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.13 (Berkeley) 4/18/94
   39  * $FreeBSD: src/sys/kern/vfs_subr.c,v 1.64.2.6 1999/09/05 08:15:44 peter Exp $
   40  */
   41 
   42 /*
   43  * External virtual filesystem routines
   44  */
   45 #include "opt_ddb.h"
   46 #include "opt_devfs.h"
   47 
   48 #include <sys/param.h>
   49 #include <sys/systm.h>
   50 #include <sys/kernel.h>
   51 #include <sys/file.h>
   52 #include <sys/proc.h>
   53 #include <sys/mount.h>
   54 #include <sys/time.h>
   55 #include <sys/vnode.h>
   56 #include <sys/stat.h>
   57 #include <sys/namei.h>
   58 #include <sys/ucred.h>
   59 #include <sys/buf.h>
   60 #include <sys/errno.h>
   61 #include <sys/malloc.h>
   62 #include <sys/domain.h>
   63 #include <sys/mbuf.h>
   64 
   65 #include <vm/vm.h>
   66 #include <vm/vm_param.h>
   67 #include <vm/vm_object.h>
   68 #include <vm/vm_extern.h>
   69 #include <vm/vm_pager.h>
   70 #include <vm/vnode_pager.h>
   71 #include <sys/sysctl.h>
   72 
   73 #include <miscfs/specfs/specdev.h>
   74 
   75 #ifdef DDB
   76 extern void     printlockedvnodes __P((void));
   77 #endif
   78 extern void     vclean __P((struct vnode *vp, int flags));
   79 extern void     vfs_unmountroot __P((struct mount *rootfs));
   80 
   81 enum vtype iftovt_tab[16] = {
   82         VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
   83         VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
   84 };
   85 int vttoif_tab[9] = {
   86         0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
   87         S_IFSOCK, S_IFIFO, S_IFMT,
   88 };
   89 
   90 /*
   91  * Insq/Remq for the vnode usage lists.
   92  */
   93 #define bufinsvn(bp, dp)        LIST_INSERT_HEAD(dp, bp, b_vnbufs)
   94 #define bufremvn(bp) {  \
   95         LIST_REMOVE(bp, b_vnbufs); \
   96         (bp)->b_vnbufs.le_next = NOLIST; \
   97 }
   98 
   99 TAILQ_HEAD(freelst, vnode) vnode_free_list;     /* vnode free list */
  100 static u_long freevnodes = 0;
  101 
  102 struct mntlist mountlist;       /* mounted filesystem list */
  103 
  104 int desiredvnodes;
  105 SYSCTL_INT(_kern, KERN_MAXVNODES, maxvnodes, CTLFLAG_RW, &desiredvnodes, 0, "");
  106 
  107 static void     vfs_free_addrlist __P((struct netexport *nep));
  108 static int      vfs_free_netcred __P((struct radix_node *rn, void *w));
  109 static int      vfs_hang_addrlist __P((struct mount *mp, struct netexport *nep,
  110                                        struct export_args *argp));
  111 
  112 /*
  113  * Initialize the vnode management data structures.
  114  */
  115 void
  116 vntblinit()
  117 {
  118 
  119         desiredvnodes = maxproc + vm_object_cache_max;
  120         TAILQ_INIT(&vnode_free_list);
  121         CIRCLEQ_INIT(&mountlist);
  122 }
  123 
  124 /*
  125  * Lock a filesystem.
  126  * Used to prevent access to it while mounting and unmounting.
  127  */
  128 int
  129 vfs_lock(mp)
  130         register struct mount *mp;
  131 {
  132 
  133         while (mp->mnt_flag & MNT_MLOCK) {
  134                 mp->mnt_flag |= MNT_MWAIT;
  135                 (void) tsleep((caddr_t) mp, PVFS, "vfslck", 0);
  136         }
  137         mp->mnt_flag |= MNT_MLOCK;
  138         return (0);
  139 }
  140 
  141 /*
  142  * Unlock a locked filesystem.
  143  * Panic if filesystem is not locked.
  144  */
  145 void
  146 vfs_unlock(mp)
  147         register struct mount *mp;
  148 {
  149 
  150         if ((mp->mnt_flag & MNT_MLOCK) == 0)
  151                 panic("vfs_unlock: not locked");
  152         mp->mnt_flag &= ~MNT_MLOCK;
  153         if (mp->mnt_flag & MNT_MWAIT) {
  154                 mp->mnt_flag &= ~MNT_MWAIT;
  155                 wakeup((caddr_t) mp);
  156         }
  157 }
  158 
  159 /*
  160  * Mark a mount point as busy.
  161  * Used to synchronize access and to delay unmounting.
  162  */
  163 int
  164 vfs_busy(mp)
  165         register struct mount *mp;
  166 {
  167 
  168         while (mp->mnt_flag & MNT_MPBUSY) {
  169                 mp->mnt_flag |= MNT_MPWANT;
  170                 (void) tsleep((caddr_t) &mp->mnt_flag, PVFS, "vfsbsy", 0);
  171         }
  172         if (mp->mnt_flag & MNT_UNMOUNT)
  173                 return (1);
  174         mp->mnt_flag |= MNT_MPBUSY;
  175         return (0);
  176 }
  177 
  178 /*
  179  * Free a busy filesystem.
  180  * Panic if filesystem is not busy.
  181  */
  182 void
  183 vfs_unbusy(mp)
  184         register struct mount *mp;
  185 {
  186 
  187         if ((mp->mnt_flag & MNT_MPBUSY) == 0)
  188                 panic("vfs_unbusy: not busy");
  189         mp->mnt_flag &= ~MNT_MPBUSY;
  190         if (mp->mnt_flag & MNT_MPWANT) {
  191                 mp->mnt_flag &= ~MNT_MPWANT;
  192                 wakeup((caddr_t) &mp->mnt_flag);
  193         }
  194 }
  195 
  196 void
  197 vfs_unmountroot(struct mount *rootfs)
  198 {
  199         struct mount *mp = rootfs;
  200         int error;
  201 
  202         if (vfs_busy(mp)) {
  203                 printf("failed to unmount root\n");
  204                 return;
  205         }
  206         mp->mnt_flag |= MNT_UNMOUNT;
  207         if ((error = vfs_lock(mp))) {
  208                 printf("lock of root filesystem failed (%d)\n", error);
  209                 return;
  210         }
  211         vnode_pager_umount(mp); /* release cached vnodes */
  212         cache_purgevfs(mp);     /* remove cache entries for this file sys */
  213 
  214         if ((error = VFS_SYNC(mp, MNT_WAIT, initproc->p_ucred, initproc)))
  215                 printf("sync of root filesystem failed (%d)\n", error);
  216 
  217         if ((error = VFS_UNMOUNT(mp, MNT_FORCE, initproc))) {
  218                 printf("unmount of root filesystem failed (");
  219                 if (error == EBUSY)
  220                         printf("BUSY)\n");
  221                 else
  222                         printf("%d)\n", error);
  223         }
  224         mp->mnt_flag &= ~MNT_UNMOUNT;
  225         vfs_unbusy(mp);
  226 }
  227 
  228 /*
  229  * Unmount all filesystems.  Should only be called by halt().
  230  */
  231 void
  232 vfs_unmountall()
  233 {
  234         struct mount *mp, *nmp, *rootfs = NULL;
  235         int error;
  236 
  237         /* unmount all but rootfs */
  238         for (mp = mountlist.cqh_last; mp != (void *)&mountlist; mp = nmp) {
  239                 nmp = mp->mnt_list.cqe_prev;
  240 
  241                 if (mp->mnt_flag & MNT_ROOTFS) {
  242                         rootfs = mp;
  243                         continue;
  244                 }
  245                 error = dounmount(mp, MNT_FORCE, initproc);
  246                 if (error) {
  247                         printf("unmount of %s failed (", mp->mnt_stat.f_mntonname);
  248                         if (error == EBUSY)
  249                                 printf("BUSY)\n");
  250                         else
  251                                 printf("%d)\n", error);
  252                 }
  253         }
  254 
  255         /* and finally... */
  256         if (rootfs) {
  257                 vfs_unmountroot(rootfs);
  258         } else {
  259                 printf("no root filesystem\n");
  260         }
  261 }
  262 
  263 /*
  264  * Lookup a mount point by filesystem identifier.
  265  */
  266 struct mount *
  267 getvfs(fsid)
  268         fsid_t *fsid;
  269 {
  270         register struct mount *mp;
  271 
  272         for (mp = mountlist.cqh_first; mp != (void *)&mountlist;
  273             mp = mp->mnt_list.cqe_next) {
  274                 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
  275                     mp->mnt_stat.f_fsid.val[1] == fsid->val[1])
  276                         return (mp);
  277         }
  278         return ((struct mount *) 0);
  279 }
  280 
  281 /*
  282  * Get a new unique fsid
  283  */
  284 void
  285 getnewfsid(mp, mtype)
  286         struct mount *mp;
  287         int mtype;
  288 {
  289         static u_short xxxfs_mntid;
  290 
  291         fsid_t tfsid;
  292 
  293         mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev + mtype, 0);
  294         mp->mnt_stat.f_fsid.val[1] = mtype;
  295         if (xxxfs_mntid == 0)
  296                 ++xxxfs_mntid;
  297         tfsid.val[0] = makedev(nblkdev + mtype, xxxfs_mntid);
  298         tfsid.val[1] = mtype;
  299         if (mountlist.cqh_first != (void *)&mountlist) {
  300                 while (getvfs(&tfsid)) {
  301                         tfsid.val[0]++;
  302                         xxxfs_mntid++;
  303                 }
  304         }
  305         mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
  306 }
  307 
  308 /*
  309  * Set vnode attributes to VNOVAL
  310  */
  311 void
  312 vattr_null(vap)
  313         register struct vattr *vap;
  314 {
  315 
  316         vap->va_type = VNON;
  317         vap->va_size = VNOVAL;
  318         vap->va_bytes = VNOVAL;
  319         vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid =
  320             vap->va_fsid = vap->va_fileid =
  321             vap->va_blocksize = vap->va_rdev =
  322             vap->va_atime.tv_sec = vap->va_atime.tv_nsec =
  323             vap->va_mtime.tv_sec = vap->va_mtime.tv_nsec =
  324             vap->va_ctime.tv_sec = vap->va_ctime.tv_nsec =
  325             vap->va_flags = vap->va_gen = VNOVAL;
  326         vap->va_vaflags = 0;
  327 }
  328 
  329 /*
  330  * Routines having to do with the management of the vnode table.
  331  */
  332 extern vop_t **dead_vnodeop_p;
  333 
  334 /*
  335  * Return the next vnode from the free list.
  336  */
  337 int
  338 getnewvnode(tag, mp, vops, vpp)
  339         enum vtagtype tag;
  340         struct mount *mp;
  341         vop_t **vops;
  342         struct vnode **vpp;
  343 {
  344         register struct vnode *vp;
  345 
  346 retry:
  347         vp = vnode_free_list.tqh_first;
  348         /*
  349          * we allocate a new vnode if
  350          *      1. we don't have any free
  351          *              Pretty obvious, we actually used to panic, but that
  352          *              is a silly thing to do.
  353          *      2. we havn't filled our pool yet
  354          *              We don't want to trash the incore (VM-)vnodecache.
  355          *      3. if less that 1/4th of our vnodes are free.
  356          *              We don't want to trash the namei cache either.
  357          */
  358         if (freevnodes < (numvnodes >> 2) ||
  359             numvnodes < desiredvnodes ||
  360             vp == NULL) {
  361                 vp = (struct vnode *) malloc((u_long) sizeof *vp,
  362                     M_VNODE, M_WAITOK);
  363                 bzero((char *) vp, sizeof *vp);
  364                 numvnodes++;
  365         } else {
  366                 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
  367                 if (vp->v_usage > 0) {
  368                         --vp->v_usage;
  369                         TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
  370                         goto retry;
  371                 }
  372                 freevnodes--;
  373                 if (vp->v_usecount)
  374                         panic("free vnode isn't");
  375 
  376                 /* see comment on why 0xdeadb is set at end of vgone (below) */
  377                 vp->v_freelist.tqe_prev = (struct vnode **) 0xdeadb;
  378                 vp->v_lease = NULL;
  379                 if (vp->v_type != VBAD)
  380                         vgone(vp);
  381 
  382 #ifdef DIAGNOSTIC
  383                 {
  384                         int s;
  385 
  386                         if (vp->v_data)
  387                                 panic("cleaned vnode isn't");
  388                         s = splbio();
  389                         if (vp->v_numoutput)
  390                                 panic("Clean vnode has pending I/O's");
  391                         splx(s);
  392                 }
  393 #endif
  394                 vp->v_flag = 0;
  395                 vp->v_lastr = 0;
  396                 vp->v_ralen = 0;
  397                 vp->v_maxra = 0;
  398                 vp->v_lastw = 0;
  399                 vp->v_lasta = 0;
  400                 vp->v_cstart = 0;
  401                 vp->v_clen = 0;
  402                 vp->v_socket = 0;
  403                 vp->v_writecount = 0;   /* XXX */
  404                 vp->v_usage = 0;
  405         }
  406         vp->v_type = VNON;
  407         cache_purge(vp);
  408         vp->v_tag = tag;
  409         vp->v_op = vops;
  410         insmntque(vp, mp);
  411         *vpp = vp;
  412         vp->v_usecount = 1;
  413         vp->v_data = 0;
  414         return (0);
  415 }
  416 
  417 /*
  418  * Move a vnode from one mount queue to another.
  419  */
  420 void
  421 insmntque(vp, mp)
  422         register struct vnode *vp;
  423         register struct mount *mp;
  424 {
  425 
  426         /*
  427          * Delete from old mount point vnode list, if on one.
  428          */
  429         if (vp->v_mount != NULL)
  430                 LIST_REMOVE(vp, v_mntvnodes);
  431         /*
  432          * Insert into list of vnodes for the new mount point, if available.
  433          */
  434         if ((vp->v_mount = mp) == NULL)
  435                 return;
  436         LIST_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes);
  437 }
  438 
  439 /*
  440  * Update outstanding I/O count and do wakeup if requested.
  441  */
  442 void
  443 vwakeup(bp)
  444         register struct buf *bp;
  445 {
  446         register struct vnode *vp;
  447 
  448         bp->b_flags &= ~B_WRITEINPROG;
  449         if ((vp = bp->b_vp)) {
  450                 vp->v_numoutput--;
  451                 if (vp->v_numoutput < 0)
  452                         panic("vwakeup: neg numoutput");
  453                 if ((vp->v_numoutput == 0) && (vp->v_flag & VBWAIT)) {
  454                         vp->v_flag &= ~VBWAIT;
  455                         wakeup((caddr_t) &vp->v_numoutput);
  456                 }
  457         }
  458 }
  459 
  460 /*
  461  * Flush out and invalidate all buffers associated with a vnode.
  462  * Called with the underlying object locked.
  463  */
  464 int
  465 vinvalbuf(vp, flags, cred, p, slpflag, slptimeo)
  466         register struct vnode *vp;
  467         int flags;
  468         struct ucred *cred;
  469         struct proc *p;
  470         int slpflag, slptimeo;
  471 {
  472         register struct buf *bp;
  473         struct buf *nbp, *blist;
  474         int s, error;
  475         vm_object_t object;
  476 
  477         if (flags & V_SAVE) {
  478                 if ((error = VOP_FSYNC(vp, cred, MNT_WAIT, p)))
  479                         return (error);
  480                 if (vp->v_dirtyblkhd.lh_first != NULL)
  481                         panic("vinvalbuf: dirty bufs");
  482         }
  483 
  484         s = splbio();
  485         for (;;) {
  486                 if ((blist = vp->v_cleanblkhd.lh_first) && (flags & V_SAVEMETA))
  487                         while (blist && blist->b_lblkno < 0)
  488                                 blist = blist->b_vnbufs.le_next;
  489                 if (!blist && (blist = vp->v_dirtyblkhd.lh_first) &&
  490                     (flags & V_SAVEMETA))
  491                         while (blist && blist->b_lblkno < 0)
  492                                 blist = blist->b_vnbufs.le_next;
  493                 if (!blist)
  494                         break;
  495 
  496                 for (bp = blist; bp; bp = nbp) {
  497                         nbp = bp->b_vnbufs.le_next;
  498                         if ((flags & V_SAVEMETA) && bp->b_lblkno < 0)
  499                                 continue;
  500                         if (bp->b_flags & B_BUSY) {
  501                                 bp->b_flags |= B_WANTED;
  502                                 error = tsleep((caddr_t) bp,
  503                                     slpflag | (PRIBIO + 1), "vinvalbuf",
  504                                     slptimeo);
  505                                 if (error) {
  506                                         splx(s);
  507                                         return (error);
  508                                 }
  509                                 break;
  510                         }
  511                         bremfree(bp);
  512                         bp->b_flags |= B_BUSY;
  513                         /*
  514                          * XXX Since there are no node locks for NFS, I
  515                          * believe there is a slight chance that a delayed
  516                          * write will occur while sleeping just above, so
  517                          * check for it.
  518                          */
  519                         if ((bp->b_flags & B_DELWRI) && (flags & V_SAVE)) {
  520                                 (void) VOP_BWRITE(bp);
  521                                 break;
  522                         }
  523                         bp->b_flags |= (B_INVAL|B_NOCACHE|B_RELBUF);
  524                         brelse(bp);
  525                 }
  526         }
  527 
  528         while (vp->v_numoutput > 0) {
  529                 vp->v_flag |= VBWAIT;
  530                 tsleep(&vp->v_numoutput, PVM, "vnvlbv", 0);
  531         }
  532 
  533         splx(s);
  534 
  535         /*
  536          * Destroy the copy in the VM cache, too.
  537          */
  538         object = vp->v_object;
  539         if (object != NULL) {
  540                 vm_object_page_remove(object, 0, object->size,
  541                     (flags & V_SAVE) ? TRUE : FALSE);
  542         }
  543         if (!(flags & V_SAVEMETA) &&
  544             (vp->v_dirtyblkhd.lh_first || vp->v_cleanblkhd.lh_first))
  545                 panic("vinvalbuf: flush failed");
  546         return (0);
  547 }
  548 
  549 /*
  550  * Associate a buffer with a vnode.
  551  */
  552 void
  553 bgetvp(vp, bp)
  554         register struct vnode *vp;
  555         register struct buf *bp;
  556 {
  557         int s;
  558 
  559         if (bp->b_vp)
  560                 panic("bgetvp: not free");
  561         VHOLD(vp);
  562         bp->b_vp = vp;
  563         if (vp->v_type == VBLK || vp->v_type == VCHR)
  564                 bp->b_dev = vp->v_rdev;
  565         else
  566                 bp->b_dev = NODEV;
  567         /*
  568          * Insert onto list for new vnode.
  569          */
  570         s = splbio();
  571         bufinsvn(bp, &vp->v_cleanblkhd);
  572         splx(s);
  573 }
  574 
  575 /*
  576  * Disassociate a buffer from a vnode.
  577  */
  578 void
  579 brelvp(bp)
  580         register struct buf *bp;
  581 {
  582         struct vnode *vp;
  583         int s;
  584 
  585         if (bp->b_vp == (struct vnode *) 0)
  586                 panic("brelvp: NULL");
  587         /*
  588          * Delete from old vnode list, if on one.
  589          */
  590         s = splbio();
  591         if (bp->b_vnbufs.le_next != NOLIST)
  592                 bufremvn(bp);
  593         splx(s);
  594 
  595         vp = bp->b_vp;
  596         bp->b_vp = (struct vnode *) 0;
  597         HOLDRELE(vp);
  598 }
  599 
  600 /*
  601  * Associate a p-buffer with a vnode.
  602  */
  603 void
  604 pbgetvp(vp, bp)
  605         register struct vnode *vp;
  606         register struct buf *bp;
  607 {
  608         if (bp->b_vp)
  609                 panic("pbgetvp: not free");
  610         VHOLD(vp);
  611         bp->b_vp = vp;
  612         if (vp->v_type == VBLK || vp->v_type == VCHR)
  613                 bp->b_dev = vp->v_rdev;
  614         else
  615                 bp->b_dev = NODEV;
  616 }
  617 
  618 /*
  619  * Disassociate a p-buffer from a vnode.
  620  */
  621 void
  622 pbrelvp(bp)
  623         register struct buf *bp;
  624 {
  625         struct vnode *vp;
  626 
  627         if (bp->b_vp == (struct vnode *) 0)
  628                 panic("brelvp: NULL");
  629 
  630         vp = bp->b_vp;
  631         bp->b_vp = (struct vnode *) 0;
  632         HOLDRELE(vp);
  633 }
  634 
  635 /*
  636  * Reassign a buffer from one vnode to another.
  637  * Used to assign file specific control information
  638  * (indirect blocks) to the vnode to which they belong.
  639  */
  640 void
  641 reassignbuf(bp, newvp)
  642         register struct buf *bp;
  643         register struct vnode *newvp;
  644 {
  645         int s;
  646 
  647         if (newvp == NULL) {
  648                 printf("reassignbuf: NULL");
  649                 return;
  650         }
  651 
  652         s = splbio();
  653         /*
  654          * Delete from old vnode list, if on one.
  655          */
  656         if (bp->b_vnbufs.le_next != NOLIST)
  657                 bufremvn(bp);
  658         /*
  659          * If dirty, put on list of dirty buffers; otherwise insert onto list
  660          * of clean buffers.
  661          */
  662         if (bp->b_flags & B_DELWRI) {
  663                 struct buf *tbp;
  664 
  665                 tbp = newvp->v_dirtyblkhd.lh_first;
  666                 if (!tbp || (tbp->b_lblkno > bp->b_lblkno)) {
  667                         bufinsvn(bp, &newvp->v_dirtyblkhd);
  668                 } else {
  669                         while (tbp->b_vnbufs.le_next &&
  670                                 (tbp->b_vnbufs.le_next->b_lblkno < bp->b_lblkno)) {
  671                                 tbp = tbp->b_vnbufs.le_next;
  672                         }
  673                         LIST_INSERT_AFTER(tbp, bp, b_vnbufs);
  674                 }
  675         } else {
  676                 bufinsvn(bp, &newvp->v_cleanblkhd);
  677         }
  678         splx(s);
  679 }
  680 
  681 #ifndef DEVFS_ROOT
  682 /*
  683  * Create a vnode for a block device.
  684  * Used for root filesystem, argdev, and swap areas.
  685  * Also used for memory file system special devices.
  686  */
  687 int
  688 bdevvp(dev, vpp)
  689         dev_t dev;
  690         struct vnode **vpp;
  691 {
  692         register struct vnode *vp;
  693         struct vnode *nvp;
  694         int error;
  695 
  696         if (dev == NODEV)
  697                 return (0);
  698         error = getnewvnode(VT_NON, (struct mount *) 0, spec_vnodeop_p, &nvp);
  699         if (error) {
  700                 *vpp = 0;
  701                 return (error);
  702         }
  703         vp = nvp;
  704         vp->v_type = VBLK;
  705         if ((nvp = checkalias(vp, dev, (struct mount *) 0))) {
  706                 vput(vp);
  707                 vp = nvp;
  708         }
  709         *vpp = vp;
  710         return (0);
  711 }
  712 #endif /* !DEVFS_ROOT */
  713 
  714 /*
  715  * Check to see if the new vnode represents a special device
  716  * for which we already have a vnode (either because of
  717  * bdevvp() or because of a different vnode representing
  718  * the same block device). If such an alias exists, deallocate
  719  * the existing contents and return the aliased vnode. The
  720  * caller is responsible for filling it with its new contents.
  721  */
  722 struct vnode *
  723 checkalias(nvp, nvp_rdev, mp)
  724         register struct vnode *nvp;
  725         dev_t nvp_rdev;
  726         struct mount *mp;
  727 {
  728         register struct vnode *vp;
  729         struct vnode **vpp;
  730 
  731         if (nvp->v_type != VBLK && nvp->v_type != VCHR)
  732                 return (NULLVP);
  733 
  734         vpp = &speclisth[SPECHASH(nvp_rdev)];
  735 loop:
  736         for (vp = *vpp; vp; vp = vp->v_specnext) {
  737                 if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type)
  738                         continue;
  739                 /*
  740                  * Alias, but not in use, so flush it out.
  741                  */
  742                 if (vp->v_usecount == 0) {
  743                         vgone(vp);
  744                         goto loop;
  745                 }
  746                 if (vget(vp, 1))
  747                         goto loop;
  748                 break;
  749         }
  750 
  751         if (vp == NULL || vp->v_tag != VT_NON) {
  752                 MALLOC(nvp->v_specinfo, struct specinfo *,
  753                     sizeof(struct specinfo), M_VNODE, M_WAITOK);
  754                 nvp->v_rdev = nvp_rdev;
  755                 nvp->v_hashchain = vpp;
  756                 nvp->v_specnext = *vpp;
  757                 nvp->v_specflags = 0;
  758                 *vpp = nvp;
  759                 if (vp != NULL) {
  760                         nvp->v_flag |= VALIASED;
  761                         vp->v_flag |= VALIASED;
  762                         vput(vp);
  763                 }
  764                 return (NULLVP);
  765         }
  766         VOP_UNLOCK(vp);
  767         vclean(vp, 0);
  768         vp->v_op = nvp->v_op;
  769         vp->v_tag = nvp->v_tag;
  770         nvp->v_type = VNON;
  771         insmntque(vp, mp);
  772         return (vp);
  773 }
  774 
  775 /*
  776  * Grab a particular vnode from the free list, increment its
  777  * reference count and lock it. The vnode lock bit is set the
  778  * vnode is being eliminated in vgone. The process is awakened
  779  * when the transition is completed, and an error returned to
  780  * indicate that the vnode is no longer usable (possibly having
  781  * been changed to a new file system type).
  782  */
  783 int
  784 vget(vp, lockflag)
  785         register struct vnode *vp;
  786         int lockflag;
  787 {
  788 
  789         /*
  790          * If the vnode is in the process of being cleaned out for another
  791          * use, we wait for the cleaning to finish and then return failure.
  792          * Cleaning is determined either by checking that the VXLOCK flag is
  793          * set, or that the use count is zero with the back pointer set to
  794          * show that it has been removed from the free list by getnewvnode.
  795          * The VXLOCK flag may not have been set yet because vclean is blocked
  796          * in the VOP_LOCK call waiting for the VOP_INACTIVE to complete.
  797          */
  798         if ((vp->v_flag & VXLOCK) ||
  799             (vp->v_usecount == 0 &&
  800                 vp->v_freelist.tqe_prev == (struct vnode **) 0xdeadb)) {
  801                 vp->v_flag |= VXWANT;
  802                 (void) tsleep((caddr_t) vp, PINOD, "vget", 0);
  803                 return (1);
  804         }
  805         if (vp->v_usecount == 0) {
  806                 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
  807                 freevnodes--;
  808         }
  809         vp->v_usecount++;
  810 
  811         /*
  812          * Create the VM object, if needed
  813          */
  814         if ((vp->v_type == VREG) &&
  815                 ((vp->v_object == NULL) ||
  816                         (vp->v_object->flags & OBJ_VFS_REF) == 0)) {
  817                 vfs_object_create(vp, curproc, curproc->p_ucred, 0);
  818         }
  819         if (lockflag)
  820                 VOP_LOCK(vp);
  821 
  822         return (0);
  823 }
  824 
  825 /*
  826  * Vnode reference, just increment the count
  827  */
  828 void
  829 vref(vp)
  830         struct vnode *vp;
  831 {
  832         if (vp->v_usecount <= 0)
  833                 panic("vref used where vget required");
  834 
  835         vp->v_usecount++;
  836 
  837         if ((vp->v_type == VREG) &&
  838                 ((vp->v_object == NULL) ||
  839                         ((vp->v_object->flags & OBJ_VFS_REF) == 0)) ) {
  840                 /*
  841                  * We need to lock to VP during the time that
  842                  * the object is created.  This is necessary to
  843                  * keep the system from re-entrantly doing it
  844                  * multiple times.
  845                  */
  846                 vfs_object_create(vp, curproc, curproc->p_ucred, 0);
  847         }
  848 }
  849 
  850 /*
  851  * vput(), just unlock and vrele()
  852  */
  853 void
  854 vput(vp)
  855         register struct vnode *vp;
  856 {
  857         VOP_UNLOCK(vp);
  858         vrele(vp);
  859 }
  860 
  861 /*
  862  * Vnode release.
  863  * If count drops to zero, call inactive routine and return to freelist.
  864  */
  865 void
  866 vrele(vp)
  867         register struct vnode *vp;
  868 {
  869 
  870 #ifdef DIAGNOSTIC
  871         if (vp == NULL)
  872                 panic("vrele: null vp");
  873 #endif
  874 
  875         vp->v_usecount--;
  876 
  877         if ((vp->v_usecount == 1) &&
  878                 vp->v_object &&
  879                 (vp->v_object->flags & OBJ_VFS_REF)) {
  880                 vp->v_object->flags &= ~OBJ_VFS_REF;
  881                 vm_object_deallocate(vp->v_object);
  882                 return;
  883         }
  884 
  885         if (vp->v_usecount > 0)
  886                 return;
  887 
  888         if (vp->v_usecount < 0) {
  889 #ifdef DIAGNOSTIC
  890                 vprint("vrele: negative ref count", vp);
  891 #endif
  892                 panic("vrele: negative reference cnt");
  893         }
  894         if (vp->v_flag & VAGE) {
  895                 if(vp->v_tag != VT_TFS)
  896                         TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
  897                 vp->v_flag &= ~VAGE;
  898                 vp->v_usage = 0;
  899         } else {
  900                 if(vp->v_tag != VT_TFS)
  901                         TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
  902         }
  903         freevnodes++;
  904 
  905         VOP_INACTIVE(vp);
  906 }
  907 
  908 #ifdef DIAGNOSTIC
  909 /*
  910  * Page or buffer structure gets a reference.
  911  */
  912 void
  913 vhold(vp)
  914         register struct vnode *vp;
  915 {
  916 
  917         vp->v_holdcnt++;
  918 }
  919 
  920 /*
  921  * Page or buffer structure frees a reference.
  922  */
  923 void
  924 holdrele(vp)
  925         register struct vnode *vp;
  926 {
  927 
  928         if (vp->v_holdcnt <= 0)
  929                 panic("holdrele: holdcnt");
  930         vp->v_holdcnt--;
  931 }
  932 #endif /* DIAGNOSTIC */
  933 
  934 /*
  935  * Remove any vnodes in the vnode table belonging to mount point mp.
  936  *
  937  * If MNT_NOFORCE is specified, there should not be any active ones,
  938  * return error if any are found (nb: this is a user error, not a
  939  * system error). If MNT_FORCE is specified, detach any active vnodes
  940  * that are found.
  941  */
  942 #ifdef DIAGNOSTIC
  943 static int busyprt = 0;         /* print out busy vnodes */
  944 SYSCTL_INT(_debug, 1, busyprt, CTLFLAG_RW, &busyprt, 0, "");
  945 #endif
  946 
  947 int
  948 vflush(mp, skipvp, flags)
  949         struct mount *mp;
  950         struct vnode *skipvp;
  951         int flags;
  952 {
  953         register struct vnode *vp, *nvp;
  954         int busy = 0;
  955 
  956         if ((mp->mnt_flag & MNT_MPBUSY) == 0)
  957                 panic("vflush: not busy");
  958 loop:
  959         for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) {
  960                 /*
  961                  * Make sure this vnode wasn't reclaimed in getnewvnode().
  962                  * Start over if it has (it won't be on the list anymore).
  963                  */
  964                 if (vp->v_mount != mp)
  965                         goto loop;
  966                 nvp = vp->v_mntvnodes.le_next;
  967                 /*
  968                  * Skip over a selected vnode.
  969                  */
  970                 if (vp == skipvp)
  971                         continue;
  972                 /*
  973                  * Skip over a vnodes marked VSYSTEM.
  974                  */
  975                 if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM))
  976                         continue;
  977                 /*
  978                  * If WRITECLOSE is set, only flush out regular file vnodes
  979                  * open for writing.
  980                  */
  981                 if ((flags & WRITECLOSE) &&
  982                     (vp->v_writecount == 0 || vp->v_type != VREG))
  983                         continue;
  984 
  985                 if (vp->v_object && (vp->v_object->flags & OBJ_VFS_REF)) {
  986                         vm_object_reference(vp->v_object);
  987                         pager_cache(vp->v_object, FALSE);
  988                         vp->v_object->flags &= ~OBJ_VFS_REF;
  989                         vm_object_deallocate(vp->v_object);
  990                 }
  991 
  992                 /*
  993                  * With v_usecount == 0, all we need to do is clear out the
  994                  * vnode data structures and we are done.
  995                  */
  996                 if (vp->v_usecount == 0) {
  997                         vgone(vp);
  998                         continue;
  999                 }
 1000 
 1001                 /*
 1002                  * If FORCECLOSE is set, forcibly close the vnode. For block
 1003                  * or character devices, revert to an anonymous device. For
 1004                  * all other files, just kill them.
 1005                  */
 1006                 if (flags & FORCECLOSE) {
 1007                         if (vp->v_type != VBLK && vp->v_type != VCHR) {
 1008                                 vgone(vp);
 1009                         } else {
 1010                                 vclean(vp, 0);
 1011                                 vp->v_op = spec_vnodeop_p;
 1012                                 insmntque(vp, (struct mount *) 0);
 1013                         }
 1014                         continue;
 1015                 }
 1016 #ifdef DIAGNOSTIC
 1017                 if (busyprt)
 1018                         vprint("vflush: busy vnode", vp);
 1019 #endif
 1020                 busy++;
 1021         }
 1022         if (busy)
 1023                 return (EBUSY);
 1024         return (0);
 1025 }
 1026 
 1027 /*
 1028  * Disassociate the underlying file system from a vnode.
 1029  */
 1030 void
 1031 vclean(struct vnode *vp, int flags)
 1032 {
 1033         int active;
 1034 
 1035         /*
 1036          * Check to see if the vnode is in use. If so we have to reference it
 1037          * before we clean it out so that its count cannot fall to zero and
 1038          * generate a race against ourselves to recycle it.
 1039          */
 1040         if ((active = vp->v_usecount))
 1041                 VREF(vp);
 1042         /*
 1043          * Even if the count is zero, the VOP_INACTIVE routine may still have
 1044          * the object locked while it cleans it out. The VOP_LOCK ensures that
 1045          * the VOP_INACTIVE routine is done with its work. For active vnodes,
 1046          * it ensures that no other activity can occur while the underlying
 1047          * object is being cleaned out.
 1048          */
 1049         VOP_LOCK(vp);
 1050         /*
 1051          * Prevent the vnode from being recycled or brought into use while we
 1052          * clean it out.
 1053          */
 1054         if (vp->v_flag & VXLOCK)
 1055                 panic("vclean: deadlock");
 1056         vp->v_flag |= VXLOCK;
 1057         /*
 1058          * Clean out any buffers associated with the vnode.
 1059          */
 1060         if (flags & DOCLOSE)
 1061                 vinvalbuf(vp, V_SAVE, NOCRED, NULL, 0, 0);
 1062         /*
 1063          * Any other processes trying to obtain this lock must first wait for
 1064          * VXLOCK to clear, then call the new lock operation.
 1065          */
 1066         VOP_UNLOCK(vp);
 1067         /*
 1068          * If purging an active vnode, it must be closed and deactivated
 1069          * before being reclaimed.
 1070          */
 1071         if (active) {
 1072                 if (flags & DOCLOSE)
 1073                         VOP_CLOSE(vp, FNONBLOCK, NOCRED, NULL);
 1074                 VOP_INACTIVE(vp);
 1075         }
 1076         /*
 1077          * Reclaim the vnode.
 1078          */
 1079         if (VOP_RECLAIM(vp))
 1080                 panic("vclean: cannot reclaim");
 1081         if (active)
 1082                 vrele(vp);
 1083 
 1084         /*
 1085          * Done with purge, notify sleepers of the grim news.
 1086          */
 1087         vp->v_op = dead_vnodeop_p;
 1088         vp->v_tag = VT_NON;
 1089         vp->v_flag &= ~VXLOCK;
 1090         if (vp->v_flag & VXWANT) {
 1091                 vp->v_flag &= ~VXWANT;
 1092                 wakeup((caddr_t) vp);
 1093         }
 1094 }
 1095 
 1096 /*
 1097  * Eliminate all activity associated with  the requested vnode
 1098  * and with all vnodes aliased to the requested vnode.
 1099  */
 1100 void
 1101 vgoneall(vp)
 1102         register struct vnode *vp;
 1103 {
 1104         register struct vnode *vq;
 1105 
 1106         if (vp->v_flag & VALIASED) {
 1107                 /*
 1108                  * If a vgone (or vclean) is already in progress, wait until
 1109                  * it is done and return.
 1110                  */
 1111                 if (vp->v_flag & VXLOCK) {
 1112                         vp->v_flag |= VXWANT;
 1113                         (void) tsleep((caddr_t) vp, PINOD, "vgall", 0);
 1114                         return;
 1115                 }
 1116                 /*
 1117                  * Ensure that vp will not be vgone'd while we are eliminating
 1118                  * its aliases.
 1119                  */
 1120                 vp->v_flag |= VXLOCK;
 1121                 while (vp->v_flag & VALIASED) {
 1122                         for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
 1123                                 if (vq->v_rdev != vp->v_rdev ||
 1124                                     vq->v_type != vp->v_type || vp == vq)
 1125                                         continue;
 1126                                 vgone(vq);
 1127                                 break;
 1128                         }
 1129                 }
 1130                 /*
 1131                  * Remove the lock so that vgone below will really eliminate
 1132                  * the vnode after which time vgone will awaken any sleepers.
 1133                  */
 1134                 vp->v_flag &= ~VXLOCK;
 1135         }
 1136         vgone(vp);
 1137 }
 1138 
 1139 /*
 1140  * Eliminate all activity associated with a vnode
 1141  * in preparation for reuse.
 1142  */
 1143 void
 1144 vgone(vp)
 1145         register struct vnode *vp;
 1146 {
 1147         register struct vnode *vq;
 1148         struct vnode *vx;
 1149 
 1150         /*
 1151          * If a vgone (or vclean) is already in progress, wait until it is
 1152          * done and return.
 1153          */
 1154         if (vp->v_flag & VXLOCK) {
 1155                 vp->v_flag |= VXWANT;
 1156                 (void) tsleep((caddr_t) vp, PINOD, "vgone", 0);
 1157                 return;
 1158         }
 1159 
 1160         if (vp->v_object) {
 1161                 vp->v_object->flags |= OBJ_VNODE_GONE;
 1162         }
 1163 
 1164         /*
 1165          * Clean out the filesystem specific data.
 1166          */
 1167         vclean(vp, DOCLOSE);
 1168         /*
 1169          * Delete from old mount point vnode list, if on one.
 1170          */
 1171         if (vp->v_mount != NULL) {
 1172                 LIST_REMOVE(vp, v_mntvnodes);
 1173                 vp->v_mount = NULL;
 1174         }
 1175         /*
 1176          * If special device, remove it from special device alias list.
 1177          */
 1178         if (vp->v_type == VBLK || vp->v_type == VCHR) {
 1179                 if (*vp->v_hashchain == vp) {
 1180                         *vp->v_hashchain = vp->v_specnext;
 1181                 } else {
 1182                         for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
 1183                                 if (vq->v_specnext != vp)
 1184                                         continue;
 1185                                 vq->v_specnext = vp->v_specnext;
 1186                                 break;
 1187                         }
 1188                         if (vq == NULL)
 1189                                 panic("missing bdev");
 1190                 }
 1191                 if (vp->v_flag & VALIASED) {
 1192                         vx = NULL;
 1193                         for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
 1194                                 if (vq->v_rdev != vp->v_rdev ||
 1195                                     vq->v_type != vp->v_type)
 1196                                         continue;
 1197                                 if (vx)
 1198                                         break;
 1199                                 vx = vq;
 1200                         }
 1201                         if (vx == NULL)
 1202                                 panic("missing alias");
 1203                         if (vq == NULL)
 1204                                 vx->v_flag &= ~VALIASED;
 1205                         vp->v_flag &= ~VALIASED;
 1206                 }
 1207                 FREE(vp->v_specinfo, M_VNODE);
 1208                 vp->v_specinfo = NULL;
 1209         }
 1210         /*
 1211          * If it is on the freelist and not already at the head, move it to
 1212          * the head of the list. The test of the back pointer and the
 1213          * reference count of zero is because it will be removed from the free
 1214          * list by getnewvnode, but will not have its reference count
 1215          * incremented until after calling vgone. If the reference count were
 1216          * incremented first, vgone would (incorrectly) try to close the
 1217          * previous instance of the underlying object. So, the back pointer is
 1218          * explicitly set to `0xdeadb' in getnewvnode after removing it from
 1219          * the freelist to ensure that we do not try to move it here.
 1220          */
 1221         if (vp->v_usecount == 0 &&
 1222             vp->v_freelist.tqe_prev != (struct vnode **) 0xdeadb &&
 1223             vnode_free_list.tqh_first != vp) {
 1224                 if(vp->v_tag != VT_TFS) {
 1225                         TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
 1226                         TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
 1227                 }
 1228         }
 1229         vp->v_type = VBAD;
 1230 }
 1231 
 1232 /*
 1233  * Lookup a vnode by device number.
 1234  */
 1235 int
 1236 vfinddev(dev, type, vpp)
 1237         dev_t dev;
 1238         enum vtype type;
 1239         struct vnode **vpp;
 1240 {
 1241         register struct vnode *vp;
 1242 
 1243         for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) {
 1244                 if (dev != vp->v_rdev || type != vp->v_type)
 1245                         continue;
 1246                 *vpp = vp;
 1247                 return (1);
 1248         }
 1249         return (0);
 1250 }
 1251 
 1252 /*
 1253  * Calculate the total number of references to a special device.
 1254  */
 1255 int
 1256 vcount(vp)
 1257         register struct vnode *vp;
 1258 {
 1259         register struct vnode *vq, *vnext;
 1260         int count;
 1261 
 1262 loop:
 1263         if ((vp->v_flag & VALIASED) == 0)
 1264                 return (vp->v_usecount);
 1265         for (count = 0, vq = *vp->v_hashchain; vq; vq = vnext) {
 1266                 vnext = vq->v_specnext;
 1267                 if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type)
 1268                         continue;
 1269                 /*
 1270                  * Alias, but not in use, so flush it out.
 1271                  */
 1272                 if (vq->v_usecount == 0 && vq != vp) {
 1273                         vgone(vq);
 1274                         goto loop;
 1275                 }
 1276                 count += vq->v_usecount;
 1277         }
 1278         return (count);
 1279 }
 1280 
 1281 /*
 1282  * Print out a description of a vnode.
 1283  */
 1284 static char *typename[] =
 1285 {"VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD"};
 1286 
 1287 void
 1288 vprint(label, vp)
 1289         char *label;
 1290         register struct vnode *vp;
 1291 {
 1292         char buf[64];
 1293 
 1294         if (label != NULL)
 1295                 printf("%s: ", label);
 1296         printf("type %s, usecount %d, writecount %d, refcount %ld,",
 1297             typename[vp->v_type], vp->v_usecount, vp->v_writecount,
 1298             vp->v_holdcnt);
 1299         buf[0] = '\0';
 1300         if (vp->v_flag & VROOT)
 1301                 strcat(buf, "|VROOT");
 1302         if (vp->v_flag & VTEXT)
 1303                 strcat(buf, "|VTEXT");
 1304         if (vp->v_flag & VSYSTEM)
 1305                 strcat(buf, "|VSYSTEM");
 1306         if (vp->v_flag & VXLOCK)
 1307                 strcat(buf, "|VXLOCK");
 1308         if (vp->v_flag & VXWANT)
 1309                 strcat(buf, "|VXWANT");
 1310         if (vp->v_flag & VBWAIT)
 1311                 strcat(buf, "|VBWAIT");
 1312         if (vp->v_flag & VALIASED)
 1313                 strcat(buf, "|VALIASED");
 1314         if (buf[0] != '\0')
 1315                 printf(" flags (%s)", &buf[1]);
 1316         if (vp->v_data == NULL) {
 1317                 printf("\n");
 1318         } else {
 1319                 printf("\n\t");
 1320                 VOP_PRINT(vp);
 1321         }
 1322 }
 1323 
 1324 #ifdef DDB
 1325 /*
 1326  * List all of the locked vnodes in the system.
 1327  * Called when debugging the kernel.
 1328  */
 1329 void
 1330 printlockedvnodes(void)
 1331 {
 1332         register struct mount *mp;
 1333         register struct vnode *vp;
 1334 
 1335         printf("Locked vnodes\n");
 1336         for (mp = mountlist.cqh_first; mp != (void *)&mountlist;
 1337             mp = mp->mnt_list.cqe_next) {
 1338                 for (vp = mp->mnt_vnodelist.lh_first;
 1339                     vp != NULL;
 1340                     vp = vp->v_mntvnodes.le_next)
 1341                         if (VOP_ISLOCKED(vp))
 1342                                 vprint((char *) 0, vp);
 1343         }
 1344 }
 1345 #endif
 1346 
 1347 int kinfo_vdebug = 1;
 1348 int kinfo_vgetfailed;
 1349 
 1350 #define KINFO_VNODESLOP 10
 1351 /*
 1352  * Dump vnode list (via sysctl).
 1353  * Copyout address of vnode followed by vnode.
 1354  */
 1355 /* ARGSUSED */
 1356 static int
 1357 sysctl_vnode SYSCTL_HANDLER_ARGS
 1358 {
 1359         register struct mount *mp, *nmp;
 1360         struct vnode *vp;
 1361         int error;
 1362 
 1363 #define VPTRSZ  sizeof (struct vnode *)
 1364 #define VNODESZ sizeof (struct vnode)
 1365 
 1366         req->lock = 0;
 1367         if (!req->oldptr) /* Make an estimate */
 1368                 return (SYSCTL_OUT(req, 0,
 1369                         (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ)));
 1370 
 1371         for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
 1372                 nmp = mp->mnt_list.cqe_next;
 1373                 if (vfs_busy(mp))
 1374                         continue;
 1375 again:
 1376                 for (vp = mp->mnt_vnodelist.lh_first;
 1377                     vp != NULL;
 1378                     vp = vp->v_mntvnodes.le_next) {
 1379                         /*
 1380                          * Check that the vp is still associated with this
 1381                          * filesystem.  RACE: could have been recycled onto
 1382                          * the same filesystem.
 1383                          */
 1384                         if (vp->v_mount != mp) {
 1385                                 if (kinfo_vdebug)
 1386                                         printf("kinfo: vp changed\n");
 1387                                 goto again;
 1388                         }
 1389                         if ((error = SYSCTL_OUT(req, &vp, VPTRSZ)) ||
 1390                             (error = SYSCTL_OUT(req, vp, VNODESZ))) {
 1391                                 vfs_unbusy(mp);
 1392                                 return (error);
 1393                         }
 1394                 }
 1395                 vfs_unbusy(mp);
 1396         }
 1397 
 1398         return (0);
 1399 }
 1400 
 1401 /*
 1402  * XXX
 1403  * Exporting the vnode list on large systems causes them to crash.
 1404  * Exporting the vnode list on medium systems causes sysctl to coredump.
 1405  */
 1406 #if 0
 1407 SYSCTL_PROC(_kern, KERN_VNODE, vnode, CTLTYPE_OPAQUE|CTLFLAG_RD,
 1408         0, 0, sysctl_vnode, "S,vnode", "");
 1409 #endif
 1410 
 1411 /*
 1412  * Check to see if a filesystem is mounted on a block device.
 1413  */
 1414 int
 1415 vfs_mountedon(vp)
 1416         register struct vnode *vp;
 1417 {
 1418         register struct vnode *vq;
 1419 
 1420         if (vp->v_specflags & SI_MOUNTEDON)
 1421                 return (EBUSY);
 1422         if (vp->v_flag & VALIASED) {
 1423                 for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
 1424                         if (vq->v_rdev != vp->v_rdev ||
 1425                             vq->v_type != vp->v_type)
 1426                                 continue;
 1427                         if (vq->v_specflags & SI_MOUNTEDON)
 1428                                 return (EBUSY);
 1429                 }
 1430         }
 1431         return (0);
 1432 }
 1433 
 1434 /*
 1435  * Build hash lists of net addresses and hang them off the mount point.
 1436  * Called by ufs_mount() to set up the lists of export addresses.
 1437  */
 1438 static int
 1439 vfs_hang_addrlist(struct mount *mp, struct netexport *nep, 
 1440         struct export_args *argp)
 1441 {
 1442         register struct netcred *np;
 1443         register struct radix_node_head *rnh;
 1444         register int i;
 1445         struct radix_node *rn;
 1446         struct sockaddr *saddr, *smask = 0;
 1447         struct domain *dom;
 1448         int error;
 1449 
 1450         if (argp->ex_addrlen == 0) {
 1451                 if (mp->mnt_flag & MNT_DEFEXPORTED)
 1452                         return (EPERM);
 1453                 np = &nep->ne_defexported;
 1454                 np->netc_exflags = argp->ex_flags;
 1455                 np->netc_anon = argp->ex_anon;
 1456                 np->netc_anon.cr_ref = 1;
 1457                 mp->mnt_flag |= MNT_DEFEXPORTED;
 1458                 return (0);
 1459         }
 1460         i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen;
 1461         np = (struct netcred *) malloc(i, M_NETADDR, M_WAITOK);
 1462         bzero((caddr_t) np, i);
 1463         saddr = (struct sockaddr *) (np + 1);
 1464         if ((error = copyin(argp->ex_addr, (caddr_t) saddr, argp->ex_addrlen)))
 1465                 goto out;
 1466         if (saddr->sa_len > argp->ex_addrlen)
 1467                 saddr->sa_len = argp->ex_addrlen;
 1468         if (argp->ex_masklen) {
 1469                 smask = (struct sockaddr *) ((caddr_t) saddr + argp->ex_addrlen);
 1470                 error = copyin(argp->ex_mask, (caddr_t) smask, argp->ex_masklen);
 1471                 if (error)
 1472                         goto out;
 1473                 if (smask->sa_len > argp->ex_masklen)
 1474                         smask->sa_len = argp->ex_masklen;
 1475         }
 1476         i = saddr->sa_family;
 1477         if ((rnh = nep->ne_rtable[i]) == 0) {
 1478                 /*
 1479                  * Seems silly to initialize every AF when most are not used,
 1480                  * do so on demand here
 1481                  */
 1482                 for (dom = domains; dom; dom = dom->dom_next)
 1483                         if (dom->dom_family == i && dom->dom_rtattach) {
 1484                                 dom->dom_rtattach((void **) &nep->ne_rtable[i],
 1485                                     dom->dom_rtoffset);
 1486                                 break;
 1487                         }
 1488                 if ((rnh = nep->ne_rtable[i]) == 0) {
 1489                         error = ENOBUFS;
 1490                         goto out;
 1491                 }
 1492         }
 1493         rn = (*rnh->rnh_addaddr) ((caddr_t) saddr, (caddr_t) smask, rnh,
 1494             np->netc_rnodes);
 1495         if (rn == 0 || np != (struct netcred *) rn) {   /* already exists */
 1496                 error = EPERM;
 1497                 goto out;
 1498         }
 1499         np->netc_exflags = argp->ex_flags;
 1500         np->netc_anon = argp->ex_anon;
 1501         np->netc_anon.cr_ref = 1;
 1502         return (0);
 1503 out:
 1504         free(np, M_NETADDR);
 1505         return (error);
 1506 }
 1507 
 1508 /* ARGSUSED */
 1509 static int
 1510 vfs_free_netcred(struct radix_node *rn, void *w)
 1511 {
 1512         register struct radix_node_head *rnh = (struct radix_node_head *) w;
 1513 
 1514         (*rnh->rnh_deladdr) (rn->rn_key, rn->rn_mask, rnh);
 1515         free((caddr_t) rn, M_NETADDR);
 1516         return (0);
 1517 }
 1518 
 1519 /*
 1520  * Free the net address hash lists that are hanging off the mount points.
 1521  */
 1522 static void
 1523 vfs_free_addrlist(struct netexport *nep)
 1524 {
 1525         register int i;
 1526         register struct radix_node_head *rnh;
 1527 
 1528         for (i = 0; i <= AF_MAX; i++)
 1529                 if ((rnh = nep->ne_rtable[i])) {
 1530                         (*rnh->rnh_walktree) (rnh, vfs_free_netcred,
 1531                             (caddr_t) rnh);
 1532                         free((caddr_t) rnh, M_RTABLE);
 1533                         nep->ne_rtable[i] = 0;
 1534                 }
 1535 }
 1536 
 1537 int
 1538 vfs_export(mp, nep, argp)
 1539         struct mount *mp;
 1540         struct netexport *nep;
 1541         struct export_args *argp;
 1542 {
 1543         int error;
 1544 
 1545         if (argp->ex_flags & MNT_DELEXPORT) {
 1546                 vfs_free_addrlist(nep);
 1547                 mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED);
 1548         }
 1549         if (argp->ex_flags & MNT_EXPORTED) {
 1550                 if ((error = vfs_hang_addrlist(mp, nep, argp)))
 1551                         return (error);
 1552                 mp->mnt_flag |= MNT_EXPORTED;
 1553         }
 1554         return (0);
 1555 }
 1556 
 1557 struct netcred *
 1558 vfs_export_lookup(mp, nep, nam)
 1559         register struct mount *mp;
 1560         struct netexport *nep;
 1561         struct mbuf *nam;
 1562 {
 1563         register struct netcred *np;
 1564         register struct radix_node_head *rnh;
 1565         struct sockaddr *saddr;
 1566 
 1567         np = NULL;
 1568         if (mp->mnt_flag & MNT_EXPORTED) {
 1569                 /*
 1570                  * Lookup in the export list first.
 1571                  */
 1572                 if (nam != NULL) {
 1573                         saddr = mtod(nam, struct sockaddr *);
 1574                         rnh = nep->ne_rtable[saddr->sa_family];
 1575                         if (rnh != NULL) {
 1576                                 np = (struct netcred *)
 1577                                     (*rnh->rnh_matchaddr) ((caddr_t) saddr,
 1578                                     rnh);
 1579                                 if (np && np->netc_rnodes->rn_flags & RNF_ROOT)
 1580                                         np = NULL;
 1581                         }
 1582                 }
 1583                 /*
 1584                  * If no address match, use the default if it exists.
 1585                  */
 1586                 if (np == NULL && mp->mnt_flag & MNT_DEFEXPORTED)
 1587                         np = &nep->ne_defexported;
 1588         }
 1589         return (np);
 1590 }
 1591 
 1592 
 1593 /*
 1594  * perform msync on all vnodes under a mount point
 1595  * the mount point must be locked.
 1596  */
 1597 void
 1598 vfs_msync(struct mount *mp, int flags) {
 1599         struct vnode *vp, *nvp;
 1600 loop:
 1601         for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
 1602 
 1603                 if (vp->v_mount != mp)
 1604                         goto loop;
 1605                 nvp = vp->v_mntvnodes.le_next;
 1606                 if (VOP_ISLOCKED(vp) && (flags != MNT_WAIT))
 1607                         continue;
 1608                 if (vp->v_object &&
 1609                    (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
 1610                         vm_object_page_clean(vp->v_object, 0, 0, TRUE, TRUE);
 1611                 }
 1612         }
 1613 }
 1614 
 1615 /*
 1616  * Create the VM object needed for VMIO and mmap support.  This
 1617  * is done for all VREG files in the system.  Some filesystems might
 1618  * afford the additional metadata buffering capability of the
 1619  * VMIO code by making the device node be VMIO mode also.
 1620  */
 1621 int
 1622 vfs_object_create(vp, p, cred, waslocked)
 1623         struct vnode *vp;
 1624         struct proc *p;
 1625         struct ucred *cred;
 1626         int waslocked;
 1627 {
 1628         struct vattr vat;
 1629         vm_object_t object;
 1630         int error = 0;
 1631 
 1632 retry:
 1633         if ((object = vp->v_object) == NULL) {
 1634                 if (vp->v_type == VREG) {
 1635                         if ((error = VOP_GETATTR(vp, &vat, cred, p)) != 0)
 1636                                 goto retn;
 1637                         (void) vnode_pager_alloc(vp,
 1638                                 OFF_TO_IDX(round_page(vat.va_size)), 0, 0);
 1639                 } else {
 1640                         /*
 1641                          * This simply allocates the biggest object possible
 1642                          * for a VBLK vnode.  This should be fixed, but doesn't
 1643                          * cause any problems (yet).
 1644                          */
 1645                         (void) vnode_pager_alloc(vp, INT_MAX, 0, 0);
 1646                 }
 1647                 vp->v_object->flags |= OBJ_VFS_REF;
 1648         } else {
 1649                 if (object->flags & OBJ_DEAD) {
 1650                         if (waslocked)
 1651                                 VOP_UNLOCK(vp);
 1652                         tsleep(object, PVM, "vodead", 0);
 1653                         if (waslocked)
 1654                                 VOP_LOCK(vp);
 1655                         goto retry;
 1656                 }
 1657                 if ((object->flags & OBJ_VFS_REF) == 0) {
 1658                         object->flags |= OBJ_VFS_REF;
 1659                         vm_object_reference(object);
 1660                 }
 1661         }
 1662         if (vp->v_object)
 1663                 vp->v_flag |= VVMIO;
 1664 
 1665 retn:
 1666         return error;
 1667 }

Cache object: 7abdc223ebacc917814e3e613fd936c3


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