137488Smckusick /* 263180Sbostic * Copyright (c) 1989, 1993 363180Sbostic * The Regents of the University of California. All rights reserved. 437488Smckusick * 544458Sbostic * %sccs.include.redist.c% 637488Smckusick * 7*65260Smckusick * @(#)vfs_subr.c 8.2 (Berkeley) 12/30/93 837488Smckusick */ 937488Smckusick 1037488Smckusick /* 1137488Smckusick * External virtual filesystem routines 1237488Smckusick */ 1337488Smckusick 1451460Sbostic #include <sys/param.h> 1553829Spendry #include <sys/systm.h> 1651460Sbostic #include <sys/proc.h> 1751460Sbostic #include <sys/mount.h> 1851460Sbostic #include <sys/time.h> 1951460Sbostic #include <sys/vnode.h> 2052415Smckusick #include <sys/stat.h> 2151460Sbostic #include <sys/namei.h> 2251460Sbostic #include <sys/ucred.h> 2351460Sbostic #include <sys/buf.h> 2451460Sbostic #include <sys/errno.h> 2551460Sbostic #include <sys/malloc.h> 2637488Smckusick 2760930Smckusick #include <vm/vm.h> 2860930Smckusick #include <sys/sysctl.h> 2960930Smckusick 3055050Spendry #include <miscfs/specfs/specdev.h> 3155050Spendry 3252415Smckusick enum vtype iftovt_tab[16] = { 3352415Smckusick VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, 3452415Smckusick VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD, 3552415Smckusick }; 3652415Smckusick int vttoif_tab[9] = { 3752415Smckusick 0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, 3852415Smckusick S_IFSOCK, S_IFIFO, S_IFMT, 3952415Smckusick }; 4052415Smckusick 4137488Smckusick /* 4256608Smckusick * Insq/Remq for the vnode usage lists. 4356608Smckusick */ 44*65260Smckusick #define NOLIST ((struct buf *)0x87654321) 45*65260Smckusick #define bufinsvn(bp, dp) LIST_INSERT_HEAD(dp, bp, b_vnbufs) 46*65260Smckusick #define bufremvn(bp) { \ 47*65260Smckusick LIST_REMOVE(bp, b_vnbufs); \ 48*65260Smckusick (bp)->b_vnbufs.le_next = NOLIST; \ 49*65260Smckusick } 5056608Smckusick 51*65260Smckusick TAILQ_HEAD(freelst, vnode) vnode_free_list; /* vnode free list */ 52*65260Smckusick struct mntlist mountlist; /* mounted filesystem list */ 53*65260Smckusick 5456608Smckusick /* 55*65260Smckusick * Initialize the vnode management data structures. 5637488Smckusick */ 57*65260Smckusick vntblinit() 5837488Smckusick { 5937488Smckusick 60*65260Smckusick TAILQ_INIT(&vnode_free_list); 61*65260Smckusick TAILQ_INIT(&mountlist); 6237488Smckusick } 6337488Smckusick 6437488Smckusick /* 6537488Smckusick * Lock a filesystem. 6637488Smckusick * Used to prevent access to it while mounting and unmounting. 6737488Smckusick */ 6837488Smckusick vfs_lock(mp) 6937488Smckusick register struct mount *mp; 7037488Smckusick { 7137488Smckusick 7241400Smckusick while(mp->mnt_flag & MNT_MLOCK) { 7341400Smckusick mp->mnt_flag |= MNT_MWAIT; 7439045Smckusick sleep((caddr_t)mp, PVFS); 7539045Smckusick } 7641400Smckusick mp->mnt_flag |= MNT_MLOCK; 7737488Smckusick return (0); 7837488Smckusick } 7937488Smckusick 8037488Smckusick /* 8137488Smckusick * Unlock a locked filesystem. 8237488Smckusick * Panic if filesystem is not locked. 8337488Smckusick */ 8437488Smckusick void 8537488Smckusick vfs_unlock(mp) 8637488Smckusick register struct mount *mp; 8737488Smckusick { 8837488Smckusick 8941400Smckusick if ((mp->mnt_flag & MNT_MLOCK) == 0) 9041300Smckusick panic("vfs_unlock: not locked"); 9141400Smckusick mp->mnt_flag &= ~MNT_MLOCK; 9241400Smckusick if (mp->mnt_flag & MNT_MWAIT) { 9341400Smckusick mp->mnt_flag &= ~MNT_MWAIT; 9437488Smckusick wakeup((caddr_t)mp); 9537488Smckusick } 9637488Smckusick } 9737488Smckusick 9837488Smckusick /* 9941300Smckusick * Mark a mount point as busy. 10041300Smckusick * Used to synchronize access and to delay unmounting. 10141300Smckusick */ 10241300Smckusick vfs_busy(mp) 10341300Smckusick register struct mount *mp; 10441300Smckusick { 10541300Smckusick 10641400Smckusick while(mp->mnt_flag & MNT_MPBUSY) { 10741400Smckusick mp->mnt_flag |= MNT_MPWANT; 10841400Smckusick sleep((caddr_t)&mp->mnt_flag, PVFS); 10941300Smckusick } 11041419Smckusick if (mp->mnt_flag & MNT_UNMOUNT) 11141419Smckusick return (1); 11241400Smckusick mp->mnt_flag |= MNT_MPBUSY; 11341300Smckusick return (0); 11441300Smckusick } 11541300Smckusick 11641300Smckusick /* 11741300Smckusick * Free a busy filesystem. 11841300Smckusick * Panic if filesystem is not busy. 11941300Smckusick */ 12041300Smckusick vfs_unbusy(mp) 12141300Smckusick register struct mount *mp; 12241300Smckusick { 12341300Smckusick 12441400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 12541300Smckusick panic("vfs_unbusy: not busy"); 12641400Smckusick mp->mnt_flag &= ~MNT_MPBUSY; 12741400Smckusick if (mp->mnt_flag & MNT_MPWANT) { 12841400Smckusick mp->mnt_flag &= ~MNT_MPWANT; 12941400Smckusick wakeup((caddr_t)&mp->mnt_flag); 13041300Smckusick } 13141300Smckusick } 13241300Smckusick 13341300Smckusick /* 13437488Smckusick * Lookup a mount point by filesystem identifier. 13537488Smckusick */ 13637488Smckusick struct mount * 13737488Smckusick getvfs(fsid) 13837488Smckusick fsid_t *fsid; 13937488Smckusick { 14037488Smckusick register struct mount *mp; 14137488Smckusick 142*65260Smckusick for (mp = mountlist.tqh_first; mp != NULL; mp = mp->mnt_list.tqe_next) { 14341400Smckusick if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] && 144*65260Smckusick mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) 14538288Smckusick return (mp); 146*65260Smckusick } 14738288Smckusick return ((struct mount *)0); 14837488Smckusick } 14937488Smckusick 15037488Smckusick /* 15153829Spendry * Get a new unique fsid 15253829Spendry */ 15353829Spendry void 15453829Spendry getnewfsid(mp, mtype) 15553829Spendry struct mount *mp; 15653829Spendry int mtype; 15753829Spendry { 15853829Spendry static u_short xxxfs_mntid; 15953829Spendry 16053829Spendry fsid_t tfsid; 16153829Spendry 16253829Spendry mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev + 11, 0); /* XXX */ 16353829Spendry mp->mnt_stat.f_fsid.val[1] = mtype; 16453829Spendry if (xxxfs_mntid == 0) 16553829Spendry ++xxxfs_mntid; 16653829Spendry tfsid.val[0] = makedev(nblkdev, xxxfs_mntid); 16753829Spendry tfsid.val[1] = mtype; 168*65260Smckusick if (mountlist.tqh_first != NULL) { 16953936Spendry while (getvfs(&tfsid)) { 17053936Spendry tfsid.val[0]++; 17153936Spendry xxxfs_mntid++; 17253936Spendry } 17353829Spendry } 17453829Spendry mp->mnt_stat.f_fsid.val[0] = tfsid.val[0]; 17553829Spendry } 17653829Spendry 17753829Spendry /* 17837488Smckusick * Set vnode attributes to VNOVAL 17937488Smckusick */ 18037488Smckusick void vattr_null(vap) 18137488Smckusick register struct vattr *vap; 18237488Smckusick { 18337488Smckusick 18437488Smckusick vap->va_type = VNON; 18552005Smckusick vap->va_size = vap->va_bytes = VNOVAL; 18637488Smckusick vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid = 18752005Smckusick vap->va_fsid = vap->va_fileid = 18852005Smckusick vap->va_blocksize = vap->va_rdev = 18954347Smckusick vap->va_atime.ts_sec = vap->va_atime.ts_nsec = 19054347Smckusick vap->va_mtime.ts_sec = vap->va_mtime.ts_nsec = 19154347Smckusick vap->va_ctime.ts_sec = vap->va_ctime.ts_nsec = 19238258Smckusick vap->va_flags = vap->va_gen = VNOVAL; 19358548Sbostic vap->va_vaflags = 0; 19437488Smckusick } 19538265Smckusick 19638265Smckusick /* 19739397Smckusick * Routines having to do with the management of the vnode table. 19839397Smckusick */ 19953547Sheideman extern int (**dead_vnodeop_p)(); 20039635Smckusick extern void vclean(); 20140883Smckusick long numvnodes; 20253493Sheideman extern struct vattr va_null; 20339397Smckusick 20439397Smckusick /* 20539397Smckusick * Return the next vnode from the free list. 20639397Smckusick */ 20739397Smckusick getnewvnode(tag, mp, vops, vpp) 20839397Smckusick enum vtagtype tag; 20939397Smckusick struct mount *mp; 21053495Sheideman int (**vops)(); 21139397Smckusick struct vnode **vpp; 21239397Smckusick { 21339397Smckusick register struct vnode *vp, *vq; 21457042Smargo int s; 21539397Smckusick 216*65260Smckusick if ((vnode_free_list.tqh_first == NULL && 217*65260Smckusick numvnodes < 2 * desiredvnodes) || 21854347Smckusick numvnodes < desiredvnodes) { 21945118Smckusick vp = (struct vnode *)malloc((u_long)sizeof *vp, 22045118Smckusick M_VNODE, M_WAITOK); 22140883Smckusick bzero((char *)vp, sizeof *vp); 222*65260Smckusick vp->v_usecount = 1; 22340883Smckusick numvnodes++; 22440883Smckusick } else { 225*65260Smckusick if ((vp = vnode_free_list.tqh_first) == NULL) { 22640883Smckusick tablefull("vnode"); 22740883Smckusick *vpp = 0; 22840883Smckusick return (ENFILE); 22940883Smckusick } 23040883Smckusick if (vp->v_usecount) 23140883Smckusick panic("free vnode isn't"); 232*65260Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 233*65260Smckusick vp->v_usecount = 1; 23452190Smckusick vp->v_lease = NULL; 23540883Smckusick if (vp->v_type != VBAD) 23640883Smckusick vgone(vp); 23757042Smargo #ifdef DIAGNOSTIC 23852006Smckusick if (vp->v_data) 23952006Smckusick panic("cleaned vnode isn't"); 24057042Smargo s = splbio(); 24157042Smargo if (vp->v_numoutput) 24257042Smargo panic("Clean vnode has pending I/O's"); 24357042Smargo splx(s); 24457042Smargo #endif 24540883Smckusick vp->v_flag = 0; 24640883Smckusick vp->v_lastr = 0; 24757042Smargo vp->v_lastw = 0; 24857042Smargo vp->v_lasta = 0; 24957042Smargo vp->v_cstart = 0; 25057042Smargo vp->v_clen = 0; 25140883Smckusick vp->v_socket = 0; 25239397Smckusick } 25357042Smargo vp->v_ralen = 1; 25439512Smckusick vp->v_type = VNON; 25539397Smckusick cache_purge(vp); 25639397Smckusick vp->v_tag = tag; 25739433Smckusick vp->v_op = vops; 25839397Smckusick insmntque(vp, mp); 25939397Smckusick *vpp = vp; 260*65260Smckusick vp->v_data = 0; 26139397Smckusick return (0); 26239397Smckusick } 26339397Smckusick /* 26439397Smckusick * Move a vnode from one mount queue to another. 26539397Smckusick */ 26639397Smckusick insmntque(vp, mp) 26739397Smckusick register struct vnode *vp; 26839397Smckusick register struct mount *mp; 26939397Smckusick { 27049973Smckusick register struct vnode *vq; 27139397Smckusick 27239397Smckusick /* 27339397Smckusick * Delete from old mount point vnode list, if on one. 27439397Smckusick */ 275*65260Smckusick if (vp->v_mount != NULL) 276*65260Smckusick LIST_REMOVE(vp, v_mntvnodes); 27739397Smckusick /* 27839397Smckusick * Insert into list of vnodes for the new mount point, if available. 27939397Smckusick */ 280*65260Smckusick if ((vp->v_mount = mp) == NULL) 28139397Smckusick return; 282*65260Smckusick LIST_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes); 28339397Smckusick } 28439397Smckusick 28539397Smckusick /* 28649232Smckusick * Update outstanding I/O count and do wakeup if requested. 28749232Smckusick */ 28849232Smckusick vwakeup(bp) 28949232Smckusick register struct buf *bp; 29049232Smckusick { 29149232Smckusick register struct vnode *vp; 29249232Smckusick 29357810Smckusick bp->b_flags &= ~B_WRITEINPROG; 29449232Smckusick if (vp = bp->b_vp) { 29549232Smckusick vp->v_numoutput--; 29657042Smargo if (vp->v_numoutput < 0) 29757042Smargo panic("vwakeup: neg numoutput"); 29849232Smckusick if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) { 29949232Smckusick if (vp->v_numoutput < 0) 30049232Smckusick panic("vwakeup: neg numoutput"); 30149232Smckusick vp->v_flag &= ~VBWAIT; 30249232Smckusick wakeup((caddr_t)&vp->v_numoutput); 30349232Smckusick } 30449232Smckusick } 30549232Smckusick } 30649232Smckusick 30749232Smckusick /* 30849232Smckusick * Flush out and invalidate all buffers associated with a vnode. 30949232Smckusick * Called with the underlying object locked. 31049232Smckusick */ 31154442Smckusick int 31257792Smckusick vinvalbuf(vp, flags, cred, p, slpflag, slptimeo) 31349232Smckusick register struct vnode *vp; 31456459Smargo int flags; 31554442Smckusick struct ucred *cred; 31654442Smckusick struct proc *p; 31757792Smckusick int slpflag, slptimeo; 31849232Smckusick { 31949232Smckusick register struct buf *bp; 32049232Smckusick struct buf *nbp, *blist; 32154442Smckusick int s, error; 32249232Smckusick 32356459Smargo if (flags & V_SAVE) { 32454442Smckusick if (error = VOP_FSYNC(vp, cred, MNT_WAIT, p)) 32554442Smckusick return (error); 326*65260Smckusick if (vp->v_dirtyblkhd.lh_first != NULL) 32754442Smckusick panic("vinvalbuf: dirty bufs"); 32854442Smckusick } 32949232Smckusick for (;;) { 330*65260Smckusick if ((blist = vp->v_cleanblkhd.lh_first) && flags & V_SAVEMETA) 33156459Smargo while (blist && blist->b_lblkno < 0) 332*65260Smckusick blist = blist->b_vnbufs.le_next; 333*65260Smckusick if (!blist && (blist = vp->v_dirtyblkhd.lh_first) && 33456608Smckusick (flags & V_SAVEMETA)) 33556459Smargo while (blist && blist->b_lblkno < 0) 336*65260Smckusick blist = blist->b_vnbufs.le_next; 33756459Smargo if (!blist) 33849232Smckusick break; 33956459Smargo 34049232Smckusick for (bp = blist; bp; bp = nbp) { 341*65260Smckusick nbp = bp->b_vnbufs.le_next; 34256459Smargo if (flags & V_SAVEMETA && bp->b_lblkno < 0) 34356459Smargo continue; 34449232Smckusick s = splbio(); 34549232Smckusick if (bp->b_flags & B_BUSY) { 34649232Smckusick bp->b_flags |= B_WANTED; 34757792Smckusick error = tsleep((caddr_t)bp, 34857792Smckusick slpflag | (PRIBIO + 1), "vinvalbuf", 34957792Smckusick slptimeo); 35049232Smckusick splx(s); 35157792Smckusick if (error) 35257792Smckusick return (error); 35349232Smckusick break; 35449232Smckusick } 35549232Smckusick bremfree(bp); 35649232Smckusick bp->b_flags |= B_BUSY; 35749232Smckusick splx(s); 35857792Smckusick /* 35957792Smckusick * XXX Since there are no node locks for NFS, I believe 36057792Smckusick * there is a slight chance that a delayed write will 36157792Smckusick * occur while sleeping just above, so check for it. 36257792Smckusick */ 36357792Smckusick if ((bp->b_flags & B_DELWRI) && (flags & V_SAVE)) { 36457792Smckusick (void) VOP_BWRITE(bp); 36557792Smckusick break; 36657792Smckusick } 36756459Smargo bp->b_flags |= B_INVAL; 36849232Smckusick brelse(bp); 36949232Smckusick } 37049232Smckusick } 37156608Smckusick if (!(flags & V_SAVEMETA) && 372*65260Smckusick (vp->v_dirtyblkhd.lh_first || vp->v_cleanblkhd.lh_first)) 37349232Smckusick panic("vinvalbuf: flush failed"); 37454442Smckusick return (0); 37549232Smckusick } 37649232Smckusick 37749232Smckusick /* 37849232Smckusick * Associate a buffer with a vnode. 37949232Smckusick */ 38049232Smckusick bgetvp(vp, bp) 38149232Smckusick register struct vnode *vp; 38249232Smckusick register struct buf *bp; 38349232Smckusick { 38449973Smckusick register struct vnode *vq; 38549232Smckusick 38649232Smckusick if (bp->b_vp) 38749232Smckusick panic("bgetvp: not free"); 38849232Smckusick VHOLD(vp); 38949232Smckusick bp->b_vp = vp; 39049232Smckusick if (vp->v_type == VBLK || vp->v_type == VCHR) 39149232Smckusick bp->b_dev = vp->v_rdev; 39249232Smckusick else 39349232Smckusick bp->b_dev = NODEV; 39449232Smckusick /* 39549232Smckusick * Insert onto list for new vnode. 39649232Smckusick */ 39756608Smckusick bufinsvn(bp, &vp->v_cleanblkhd); 39849232Smckusick } 39949232Smckusick 40049232Smckusick /* 40149232Smckusick * Disassociate a buffer from a vnode. 40249232Smckusick */ 40349232Smckusick brelvp(bp) 40449232Smckusick register struct buf *bp; 40549232Smckusick { 40649232Smckusick struct vnode *vp; 40749232Smckusick 40849232Smckusick if (bp->b_vp == (struct vnode *) 0) 40949232Smckusick panic("brelvp: NULL"); 41049232Smckusick /* 41149232Smckusick * Delete from old vnode list, if on one. 41249232Smckusick */ 413*65260Smckusick if (bp->b_vnbufs.le_next != NOLIST) 41456608Smckusick bufremvn(bp); 41549232Smckusick vp = bp->b_vp; 41649232Smckusick bp->b_vp = (struct vnode *) 0; 41749232Smckusick HOLDRELE(vp); 41849232Smckusick } 41949232Smckusick 42049232Smckusick /* 42149232Smckusick * Reassign a buffer from one vnode to another. 42249232Smckusick * Used to assign file specific control information 42349232Smckusick * (indirect blocks) to the vnode to which they belong. 42449232Smckusick */ 42549232Smckusick reassignbuf(bp, newvp) 42649232Smckusick register struct buf *bp; 42749232Smckusick register struct vnode *newvp; 42849232Smckusick { 429*65260Smckusick register struct buflists *listheadp; 43049232Smckusick 43152655Smckusick if (newvp == NULL) { 43252655Smckusick printf("reassignbuf: NULL"); 43352655Smckusick return; 43452655Smckusick } 43549232Smckusick /* 43649232Smckusick * Delete from old vnode list, if on one. 43749232Smckusick */ 438*65260Smckusick if (bp->b_vnbufs.le_next != NOLIST) 43956608Smckusick bufremvn(bp); 44049232Smckusick /* 44149232Smckusick * If dirty, put on list of dirty buffers; 44249232Smckusick * otherwise insert onto list of clean buffers. 44349232Smckusick */ 44449232Smckusick if (bp->b_flags & B_DELWRI) 44549232Smckusick listheadp = &newvp->v_dirtyblkhd; 44649232Smckusick else 44749232Smckusick listheadp = &newvp->v_cleanblkhd; 44856608Smckusick bufinsvn(bp, listheadp); 44949232Smckusick } 45049232Smckusick 45149232Smckusick /* 45239433Smckusick * Create a vnode for a block device. 45339433Smckusick * Used for root filesystem, argdev, and swap areas. 45439433Smckusick * Also used for memory file system special devices. 45539397Smckusick */ 45639433Smckusick bdevvp(dev, vpp) 45739433Smckusick dev_t dev; 45839433Smckusick struct vnode **vpp; 45939433Smckusick { 46039433Smckusick register struct vnode *vp; 46139433Smckusick struct vnode *nvp; 46239433Smckusick int error; 46339433Smckusick 46446989Smckusick if (dev == NODEV) 46546989Smckusick return (0); 46653547Sheideman error = getnewvnode(VT_NON, (struct mount *)0, spec_vnodeop_p, &nvp); 46739433Smckusick if (error) { 46839433Smckusick *vpp = 0; 46939433Smckusick return (error); 47039433Smckusick } 47139433Smckusick vp = nvp; 47239433Smckusick vp->v_type = VBLK; 47339615Smckusick if (nvp = checkalias(vp, dev, (struct mount *)0)) { 47439433Smckusick vput(vp); 47539433Smckusick vp = nvp; 47639433Smckusick } 47739433Smckusick *vpp = vp; 47839433Smckusick return (0); 47939433Smckusick } 48039433Smckusick 48139433Smckusick /* 48239433Smckusick * Check to see if the new vnode represents a special device 48339433Smckusick * for which we already have a vnode (either because of 48439433Smckusick * bdevvp() or because of a different vnode representing 48539433Smckusick * the same block device). If such an alias exists, deallocate 48639509Smckusick * the existing contents and return the aliased vnode. The 48739433Smckusick * caller is responsible for filling it with its new contents. 48839433Smckusick */ 48939433Smckusick struct vnode * 49039615Smckusick checkalias(nvp, nvp_rdev, mp) 49139433Smckusick register struct vnode *nvp; 49239615Smckusick dev_t nvp_rdev; 49339433Smckusick struct mount *mp; 49439433Smckusick { 49539433Smckusick register struct vnode *vp; 49639615Smckusick struct vnode **vpp; 49739433Smckusick 49839433Smckusick if (nvp->v_type != VBLK && nvp->v_type != VCHR) 49941400Smckusick return (NULLVP); 50039615Smckusick 50139615Smckusick vpp = &speclisth[SPECHASH(nvp_rdev)]; 50239433Smckusick loop: 50339615Smckusick for (vp = *vpp; vp; vp = vp->v_specnext) { 50439615Smckusick if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type) 50539433Smckusick continue; 50639615Smckusick /* 50739615Smckusick * Alias, but not in use, so flush it out. 50839615Smckusick */ 50939809Smckusick if (vp->v_usecount == 0) { 51039615Smckusick vgone(vp); 51139615Smckusick goto loop; 51239615Smckusick } 513*65260Smckusick if (vget(vp, 1)) 51439633Smckusick goto loop; 51539433Smckusick break; 51639433Smckusick } 51739615Smckusick if (vp == NULL || vp->v_tag != VT_NON) { 51839615Smckusick MALLOC(nvp->v_specinfo, struct specinfo *, 51939615Smckusick sizeof(struct specinfo), M_VNODE, M_WAITOK); 52039615Smckusick nvp->v_rdev = nvp_rdev; 52139809Smckusick nvp->v_hashchain = vpp; 52239615Smckusick nvp->v_specnext = *vpp; 52342152Smckusick nvp->v_specflags = 0; 52439615Smckusick *vpp = nvp; 52540640Smckusick if (vp != NULL) { 52640640Smckusick nvp->v_flag |= VALIASED; 52740640Smckusick vp->v_flag |= VALIASED; 52840640Smckusick vput(vp); 52940640Smckusick } 53041400Smckusick return (NULLVP); 53139433Smckusick } 53239484Smckusick VOP_UNLOCK(vp); 53339484Smckusick vclean(vp, 0); 53439433Smckusick vp->v_op = nvp->v_op; 53539433Smckusick vp->v_tag = nvp->v_tag; 53639433Smckusick nvp->v_type = VNON; 53739433Smckusick insmntque(vp, mp); 53839433Smckusick return (vp); 53939433Smckusick } 54039433Smckusick 54139433Smckusick /* 54239433Smckusick * Grab a particular vnode from the free list, increment its 54339433Smckusick * reference count and lock it. The vnode lock bit is set the 54439433Smckusick * vnode is being eliminated in vgone. The process is awakened 54539433Smckusick * when the transition is completed, and an error returned to 54639433Smckusick * indicate that the vnode is no longer usable (possibly having 54739433Smckusick * been changed to a new file system type). 54839433Smckusick */ 549*65260Smckusick vget(vp, lockflag) 55039397Smckusick register struct vnode *vp; 551*65260Smckusick int lockflag; 55239397Smckusick { 55339397Smckusick register struct vnode *vq; 55439397Smckusick 55539433Smckusick if (vp->v_flag & VXLOCK) { 55639433Smckusick vp->v_flag |= VXWANT; 55739433Smckusick sleep((caddr_t)vp, PINOD); 55839433Smckusick return (1); 55939433Smckusick } 560*65260Smckusick if (vp->v_usecount == 0) 561*65260Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 56259450Smckusick vp->v_usecount++; 563*65260Smckusick if (lockflag) 564*65260Smckusick VOP_LOCK(vp); 56539433Smckusick return (0); 56639397Smckusick } 56739397Smckusick 56839397Smckusick /* 56939397Smckusick * Vnode reference, just increment the count 57039397Smckusick */ 57139397Smckusick void vref(vp) 57239397Smckusick struct vnode *vp; 57339397Smckusick { 57439397Smckusick 57559450Smckusick if (vp->v_usecount <= 0) 57659450Smckusick panic("vref used where vget required"); 57739809Smckusick vp->v_usecount++; 57839397Smckusick } 57939397Smckusick 58039397Smckusick /* 58139397Smckusick * vput(), just unlock and vrele() 58239397Smckusick */ 58339397Smckusick void vput(vp) 58439397Smckusick register struct vnode *vp; 58539397Smckusick { 58652416Storek 58739397Smckusick VOP_UNLOCK(vp); 58839397Smckusick vrele(vp); 58939397Smckusick } 59039397Smckusick 59139397Smckusick /* 59239397Smckusick * Vnode release. 59339397Smckusick * If count drops to zero, call inactive routine and return to freelist. 59439397Smckusick */ 59539397Smckusick void vrele(vp) 59639397Smckusick register struct vnode *vp; 59739397Smckusick { 59839397Smckusick 59950109Smckusick #ifdef DIAGNOSTIC 60039397Smckusick if (vp == NULL) 60139433Smckusick panic("vrele: null vp"); 60250109Smckusick #endif 60339809Smckusick vp->v_usecount--; 60439809Smckusick if (vp->v_usecount > 0) 60539397Smckusick return; 60650109Smckusick #ifdef DIAGNOSTIC 60750109Smckusick if (vp->v_usecount != 0 || vp->v_writecount != 0) { 60850109Smckusick vprint("vrele: bad ref count", vp); 60950109Smckusick panic("vrele: ref cnt"); 61050109Smckusick } 61150109Smckusick #endif 61255468Smckusick /* 61355468Smckusick * insert at tail of LRU list 61455468Smckusick */ 615*65260Smckusick TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); 61654442Smckusick VOP_INACTIVE(vp); 61739397Smckusick } 61839433Smckusick 61939433Smckusick /* 62039809Smckusick * Page or buffer structure gets a reference. 62139809Smckusick */ 62253312Smckusick void vhold(vp) 62339809Smckusick register struct vnode *vp; 62439809Smckusick { 62539809Smckusick 62639809Smckusick vp->v_holdcnt++; 62739809Smckusick } 62839809Smckusick 62939809Smckusick /* 63039809Smckusick * Page or buffer structure frees a reference. 63139809Smckusick */ 63253312Smckusick void holdrele(vp) 63339809Smckusick register struct vnode *vp; 63439809Smckusick { 63539809Smckusick 63639809Smckusick if (vp->v_holdcnt <= 0) 63739809Smckusick panic("holdrele: holdcnt"); 63839809Smckusick vp->v_holdcnt--; 63939809Smckusick } 64039809Smckusick 64139809Smckusick /* 64239509Smckusick * Remove any vnodes in the vnode table belonging to mount point mp. 64339509Smckusick * 64439509Smckusick * If MNT_NOFORCE is specified, there should not be any active ones, 64539509Smckusick * return error if any are found (nb: this is a user error, not a 64639509Smckusick * system error). If MNT_FORCE is specified, detach any active vnodes 64739509Smckusick * that are found. 64839509Smckusick */ 64960930Smckusick int busyprt = 0; /* print out busy vnodes */ 65060930Smckusick struct ctldebug debug1 = { "busyprt", &busyprt }; 65139509Smckusick 65239509Smckusick vflush(mp, skipvp, flags) 65339509Smckusick struct mount *mp; 65439509Smckusick struct vnode *skipvp; 65539509Smckusick int flags; 65639509Smckusick { 65739509Smckusick register struct vnode *vp, *nvp; 65839509Smckusick int busy = 0; 65939509Smckusick 66041400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 66141300Smckusick panic("vflush: not busy"); 66241421Smckusick loop: 663*65260Smckusick for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) { 66441421Smckusick if (vp->v_mount != mp) 66541421Smckusick goto loop; 666*65260Smckusick nvp = vp->v_mntvnodes.le_next; 66739509Smckusick /* 66839509Smckusick * Skip over a selected vnode. 66939509Smckusick */ 67039509Smckusick if (vp == skipvp) 67139509Smckusick continue; 67239509Smckusick /* 67341300Smckusick * Skip over a vnodes marked VSYSTEM. 67441300Smckusick */ 67541300Smckusick if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) 67641300Smckusick continue; 67741300Smckusick /* 67857040Smckusick * If WRITECLOSE is set, only flush out regular file 67957040Smckusick * vnodes open for writing. 68057040Smckusick */ 68157040Smckusick if ((flags & WRITECLOSE) && 68257040Smckusick (vp->v_writecount == 0 || vp->v_type != VREG)) 68357040Smckusick continue; 68457040Smckusick /* 68539809Smckusick * With v_usecount == 0, all we need to do is clear 68639509Smckusick * out the vnode data structures and we are done. 68739509Smckusick */ 68839809Smckusick if (vp->v_usecount == 0) { 68939509Smckusick vgone(vp); 69039509Smckusick continue; 69139509Smckusick } 69239509Smckusick /* 69357040Smckusick * If FORCECLOSE is set, forcibly close the vnode. 69439509Smckusick * For block or character devices, revert to an 69539509Smckusick * anonymous device. For all other files, just kill them. 69639509Smckusick */ 69741300Smckusick if (flags & FORCECLOSE) { 69839509Smckusick if (vp->v_type != VBLK && vp->v_type != VCHR) { 69939509Smckusick vgone(vp); 70039509Smckusick } else { 70139509Smckusick vclean(vp, 0); 70253547Sheideman vp->v_op = spec_vnodeop_p; 70339509Smckusick insmntque(vp, (struct mount *)0); 70439509Smckusick } 70539509Smckusick continue; 70639509Smckusick } 70739509Smckusick if (busyprt) 70839667Smckusick vprint("vflush: busy vnode", vp); 70939509Smckusick busy++; 71039509Smckusick } 71139509Smckusick if (busy) 71239509Smckusick return (EBUSY); 71339509Smckusick return (0); 71439509Smckusick } 71539509Smckusick 71639509Smckusick /* 71739433Smckusick * Disassociate the underlying file system from a vnode. 71839433Smckusick */ 71954347Smckusick void 72054347Smckusick vclean(vp, flags) 72139433Smckusick register struct vnode *vp; 72245118Smckusick int flags; 72339433Smckusick { 72439484Smckusick int active; 72539433Smckusick 72639484Smckusick /* 72739484Smckusick * Check to see if the vnode is in use. 72839667Smckusick * If so we have to reference it before we clean it out 72939667Smckusick * so that its count cannot fall to zero and generate a 73039667Smckusick * race against ourselves to recycle it. 73139484Smckusick */ 73239809Smckusick if (active = vp->v_usecount) 73339484Smckusick VREF(vp); 73439484Smckusick /* 73556805Smckusick * Even if the count is zero, the VOP_INACTIVE routine may still 73656805Smckusick * have the object locked while it cleans it out. The VOP_LOCK 73756805Smckusick * ensures that the VOP_INACTIVE routine is done with its work. 73856805Smckusick * For active vnodes, it ensures that no other activity can 73956805Smckusick * occur while the underlying object is being cleaned out. 74056805Smckusick */ 74156805Smckusick VOP_LOCK(vp); 74256805Smckusick /* 74339484Smckusick * Prevent the vnode from being recycled or 74439484Smckusick * brought into use while we clean it out. 74539484Smckusick */ 74639667Smckusick if (vp->v_flag & VXLOCK) 74739667Smckusick panic("vclean: deadlock"); 74839433Smckusick vp->v_flag |= VXLOCK; 74939433Smckusick /* 75056805Smckusick * Clean out any buffers associated with the vnode. 75139667Smckusick */ 75241300Smckusick if (flags & DOCLOSE) 75357792Smckusick vinvalbuf(vp, V_SAVE, NOCRED, NULL, 0, 0); 75439667Smckusick /* 75556805Smckusick * Any other processes trying to obtain this lock must first 75656805Smckusick * wait for VXLOCK to clear, then call the new lock operation. 75739433Smckusick */ 75856805Smckusick VOP_UNLOCK(vp); 75939433Smckusick /* 76056805Smckusick * If purging an active vnode, it must be closed and 76156805Smckusick * deactivated before being reclaimed. 76239433Smckusick */ 76339484Smckusick if (active) { 76456805Smckusick if (flags & DOCLOSE) 76556805Smckusick VOP_CLOSE(vp, IO_NDELAY, NOCRED, NULL); 76656805Smckusick VOP_INACTIVE(vp); 76739433Smckusick } 76839433Smckusick /* 76939433Smckusick * Reclaim the vnode. 77039433Smckusick */ 77156805Smckusick if (VOP_RECLAIM(vp)) 77239433Smckusick panic("vclean: cannot reclaim"); 77339484Smckusick if (active) 77439484Smckusick vrele(vp); 77553580Sheideman 77639433Smckusick /* 77756805Smckusick * Done with purge, notify sleepers of the grim news. 77839433Smckusick */ 77956805Smckusick vp->v_op = dead_vnodeop_p; 78056805Smckusick vp->v_tag = VT_NON; 78139433Smckusick vp->v_flag &= ~VXLOCK; 78239433Smckusick if (vp->v_flag & VXWANT) { 78339433Smckusick vp->v_flag &= ~VXWANT; 78439433Smckusick wakeup((caddr_t)vp); 78539433Smckusick } 78639433Smckusick } 78739433Smckusick 78839433Smckusick /* 78939633Smckusick * Eliminate all activity associated with the requested vnode 79039633Smckusick * and with all vnodes aliased to the requested vnode. 79139633Smckusick */ 79239633Smckusick void vgoneall(vp) 79339633Smckusick register struct vnode *vp; 79439633Smckusick { 79539809Smckusick register struct vnode *vq; 79639633Smckusick 79740665Smckusick if (vp->v_flag & VALIASED) { 79840665Smckusick /* 79940665Smckusick * If a vgone (or vclean) is already in progress, 80040665Smckusick * wait until it is done and return. 80140665Smckusick */ 80240665Smckusick if (vp->v_flag & VXLOCK) { 80340665Smckusick vp->v_flag |= VXWANT; 80440665Smckusick sleep((caddr_t)vp, PINOD); 80540665Smckusick return; 80639633Smckusick } 80740665Smckusick /* 80840665Smckusick * Ensure that vp will not be vgone'd while we 80940665Smckusick * are eliminating its aliases. 81040665Smckusick */ 81140665Smckusick vp->v_flag |= VXLOCK; 81240665Smckusick while (vp->v_flag & VALIASED) { 81340665Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 81440665Smckusick if (vq->v_rdev != vp->v_rdev || 81540665Smckusick vq->v_type != vp->v_type || vp == vq) 81640665Smckusick continue; 81740665Smckusick vgone(vq); 81840665Smckusick break; 81940665Smckusick } 82040665Smckusick } 82140665Smckusick /* 82240665Smckusick * Remove the lock so that vgone below will 82340665Smckusick * really eliminate the vnode after which time 82440665Smckusick * vgone will awaken any sleepers. 82540665Smckusick */ 82640665Smckusick vp->v_flag &= ~VXLOCK; 82739633Smckusick } 82839633Smckusick vgone(vp); 82939633Smckusick } 83039633Smckusick 83139633Smckusick /* 83239433Smckusick * Eliminate all activity associated with a vnode 83339433Smckusick * in preparation for reuse. 83439433Smckusick */ 83539433Smckusick void vgone(vp) 83639433Smckusick register struct vnode *vp; 83739433Smckusick { 83839809Smckusick register struct vnode *vq; 83939615Smckusick struct vnode *vx; 84039433Smckusick 84139433Smckusick /* 84240548Smckusick * If a vgone (or vclean) is already in progress, 84340548Smckusick * wait until it is done and return. 84440548Smckusick */ 84540548Smckusick if (vp->v_flag & VXLOCK) { 84640548Smckusick vp->v_flag |= VXWANT; 84740548Smckusick sleep((caddr_t)vp, PINOD); 84840548Smckusick return; 84940548Smckusick } 85040548Smckusick /* 85139433Smckusick * Clean out the filesystem specific data. 85239433Smckusick */ 85341300Smckusick vclean(vp, DOCLOSE); 85439433Smckusick /* 85539433Smckusick * Delete from old mount point vnode list, if on one. 85639433Smckusick */ 857*65260Smckusick if (vp->v_mount != NULL) { 858*65260Smckusick LIST_REMOVE(vp, v_mntvnodes); 85952311Smckusick vp->v_mount = NULL; 86039433Smckusick } 86139433Smckusick /* 86239433Smckusick * If special device, remove it from special device alias list. 86339433Smckusick */ 86439433Smckusick if (vp->v_type == VBLK || vp->v_type == VCHR) { 86539809Smckusick if (*vp->v_hashchain == vp) { 86639809Smckusick *vp->v_hashchain = vp->v_specnext; 86739433Smckusick } else { 86839809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 86939615Smckusick if (vq->v_specnext != vp) 87039433Smckusick continue; 87139615Smckusick vq->v_specnext = vp->v_specnext; 87239433Smckusick break; 87339433Smckusick } 87439615Smckusick if (vq == NULL) 87539433Smckusick panic("missing bdev"); 87639433Smckusick } 87739615Smckusick if (vp->v_flag & VALIASED) { 87852416Storek vx = NULL; 87939809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 88040108Smckusick if (vq->v_rdev != vp->v_rdev || 88140108Smckusick vq->v_type != vp->v_type) 88239615Smckusick continue; 88352416Storek if (vx) 88452416Storek break; 88539615Smckusick vx = vq; 88639615Smckusick } 88752416Storek if (vx == NULL) 88839615Smckusick panic("missing alias"); 88952416Storek if (vq == NULL) 89039615Smckusick vx->v_flag &= ~VALIASED; 89139615Smckusick vp->v_flag &= ~VALIASED; 89239615Smckusick } 89339615Smckusick FREE(vp->v_specinfo, M_VNODE); 89439615Smckusick vp->v_specinfo = NULL; 89539433Smckusick } 89639433Smckusick /* 89756932Smckusick * If it is on the freelist and not already at the head, 89856932Smckusick * move it to the head of the list. 89939433Smckusick */ 900*65260Smckusick if (vp->v_usecount == 0 && vnode_free_list.tqh_first != vp) { 901*65260Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 902*65260Smckusick TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist); 90339433Smckusick } 90439484Smckusick vp->v_type = VBAD; 90539433Smckusick } 90639633Smckusick 90739633Smckusick /* 90839821Smckusick * Lookup a vnode by device number. 90939821Smckusick */ 91039821Smckusick vfinddev(dev, type, vpp) 91139821Smckusick dev_t dev; 91239821Smckusick enum vtype type; 91339821Smckusick struct vnode **vpp; 91439821Smckusick { 91539821Smckusick register struct vnode *vp; 91639821Smckusick 91739821Smckusick for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) { 91839821Smckusick if (dev != vp->v_rdev || type != vp->v_type) 91939821Smckusick continue; 92039821Smckusick *vpp = vp; 92159484Smckusick return (1); 92239821Smckusick } 92359484Smckusick return (0); 92439821Smckusick } 92539821Smckusick 92639821Smckusick /* 92739633Smckusick * Calculate the total number of references to a special device. 92839633Smckusick */ 92939633Smckusick vcount(vp) 93039633Smckusick register struct vnode *vp; 93139633Smckusick { 93239809Smckusick register struct vnode *vq; 93339633Smckusick int count; 93439633Smckusick 93539633Smckusick if ((vp->v_flag & VALIASED) == 0) 93639809Smckusick return (vp->v_usecount); 93739633Smckusick loop: 93839809Smckusick for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 93940108Smckusick if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type) 94039633Smckusick continue; 94139633Smckusick /* 94239633Smckusick * Alias, but not in use, so flush it out. 94339633Smckusick */ 94439809Smckusick if (vq->v_usecount == 0) { 94539633Smckusick vgone(vq); 94639633Smckusick goto loop; 94739633Smckusick } 94839809Smckusick count += vq->v_usecount; 94939633Smckusick } 95039633Smckusick return (count); 95139633Smckusick } 95239667Smckusick 95339667Smckusick /* 95439667Smckusick * Print out a description of a vnode. 95539667Smckusick */ 95639667Smckusick static char *typename[] = 95740286Smckusick { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" }; 95839667Smckusick 95939667Smckusick vprint(label, vp) 96039667Smckusick char *label; 96139667Smckusick register struct vnode *vp; 96239667Smckusick { 96339913Smckusick char buf[64]; 96439667Smckusick 96539667Smckusick if (label != NULL) 96639667Smckusick printf("%s: ", label); 96750109Smckusick printf("type %s, usecount %d, writecount %d, refcount %d,", 96850109Smckusick typename[vp->v_type], vp->v_usecount, vp->v_writecount, 96950109Smckusick vp->v_holdcnt); 97039913Smckusick buf[0] = '\0'; 97139913Smckusick if (vp->v_flag & VROOT) 97239913Smckusick strcat(buf, "|VROOT"); 97339913Smckusick if (vp->v_flag & VTEXT) 97439913Smckusick strcat(buf, "|VTEXT"); 97541300Smckusick if (vp->v_flag & VSYSTEM) 97641300Smckusick strcat(buf, "|VSYSTEM"); 97741300Smckusick if (vp->v_flag & VXLOCK) 97841300Smckusick strcat(buf, "|VXLOCK"); 97941300Smckusick if (vp->v_flag & VXWANT) 98041300Smckusick strcat(buf, "|VXWANT"); 98141300Smckusick if (vp->v_flag & VBWAIT) 98241300Smckusick strcat(buf, "|VBWAIT"); 98339913Smckusick if (vp->v_flag & VALIASED) 98439913Smckusick strcat(buf, "|VALIASED"); 98539913Smckusick if (buf[0] != '\0') 98639913Smckusick printf(" flags (%s)", &buf[1]); 987*65260Smckusick if (vp->v_data == NULL) { 988*65260Smckusick printf("\n"); 989*65260Smckusick } else { 990*65260Smckusick printf("\n\t"); 991*65260Smckusick VOP_PRINT(vp); 992*65260Smckusick } 99339667Smckusick } 99441110Smarc 99549691Smckusick #ifdef DEBUG 99649691Smckusick /* 99749691Smckusick * List all of the locked vnodes in the system. 99849691Smckusick * Called when debugging the kernel. 99949691Smckusick */ 100049691Smckusick printlockedvnodes() 100149691Smckusick { 100249691Smckusick register struct mount *mp; 100349691Smckusick register struct vnode *vp; 100449691Smckusick 100549691Smckusick printf("Locked vnodes\n"); 1006*65260Smckusick for (mp = mountlist.tqh_first; mp != NULL; mp = mp->mnt_list.tqe_next) { 1007*65260Smckusick for (vp = mp->mnt_vnodelist.lh_first; 1008*65260Smckusick vp != NULL; 1009*65260Smckusick vp = vp->v_mntvnodes.le_next) 101049691Smckusick if (VOP_ISLOCKED(vp)) 101149691Smckusick vprint((char *)0, vp); 1012*65260Smckusick } 101349691Smckusick } 101449691Smckusick #endif 101549691Smckusick 101641110Smarc int kinfo_vdebug = 1; 101741110Smarc int kinfo_vgetfailed; 101841110Smarc #define KINFO_VNODESLOP 10 101941110Smarc /* 102057841Smckusick * Dump vnode list (via sysctl). 102141110Smarc * Copyout address of vnode followed by vnode. 102241110Smarc */ 102345118Smckusick /* ARGSUSED */ 102457841Smckusick sysctl_vnode(where, sizep) 102541110Smarc char *where; 102658465Sbostic size_t *sizep; 102741110Smarc { 1028*65260Smckusick register struct mount *mp, *nmp; 102941110Smarc struct vnode *vp; 103041110Smarc register char *bp = where, *savebp; 103153818Smckusick char *ewhere; 103241110Smarc int error; 103341110Smarc 103441110Smarc #define VPTRSZ sizeof (struct vnode *) 103541110Smarc #define VNODESZ sizeof (struct vnode) 103641110Smarc if (where == NULL) { 103757841Smckusick *sizep = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ); 103841110Smarc return (0); 103941110Smarc } 104057841Smckusick ewhere = where + *sizep; 104141110Smarc 1042*65260Smckusick for (mp = mountlist.tqh_first; mp != NULL; mp = nmp) { 1043*65260Smckusick nmp = mp->mnt_list.tqe_next; 1044*65260Smckusick if (vfs_busy(mp)) 104541300Smckusick continue; 104641110Smarc savebp = bp; 104741110Smarc again: 1048*65260Smckusick for (vp = mp->mnt_vnodelist.lh_first; 1049*65260Smckusick vp != NULL; 1050*65260Smckusick vp = vp->v_mntvnodes.le_next) { 105141422Smckusick /* 105241422Smckusick * Check that the vp is still associated with 105341422Smckusick * this filesystem. RACE: could have been 105441422Smckusick * recycled onto the same filesystem. 105541422Smckusick */ 105641421Smckusick if (vp->v_mount != mp) { 105741421Smckusick if (kinfo_vdebug) 105841421Smckusick printf("kinfo: vp changed\n"); 105941421Smckusick bp = savebp; 106041421Smckusick goto again; 106141421Smckusick } 106257841Smckusick if (bp + VPTRSZ + VNODESZ > ewhere) { 106357841Smckusick *sizep = bp - where; 106457841Smckusick return (ENOMEM); 106557841Smckusick } 106657841Smckusick if ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) || 106757841Smckusick (error = copyout((caddr_t)vp, bp + VPTRSZ, VNODESZ))) 106841110Smarc return (error); 106941110Smarc bp += VPTRSZ + VNODESZ; 107041110Smarc } 1071*65260Smckusick vfs_unbusy(mp); 1072*65260Smckusick } 107341110Smarc 107457841Smckusick *sizep = bp - where; 107541110Smarc return (0); 107641110Smarc } 1077