137488Smckusick /* 237488Smckusick * Copyright (c) 1989 The Regents of the University of California. 337488Smckusick * All rights reserved. 437488Smckusick * 544458Sbostic * %sccs.include.redist.c% 637488Smckusick * 7*52005Smckusick * @(#)vfs_subr.c 7.63 (Berkeley) 12/19/91 837488Smckusick */ 937488Smckusick 1037488Smckusick /* 1137488Smckusick * External virtual filesystem routines 1237488Smckusick */ 1337488Smckusick 1451460Sbostic #include <sys/param.h> 1551460Sbostic #include <sys/proc.h> 1651460Sbostic #include <sys/mount.h> 1751460Sbostic #include <sys/time.h> 1851460Sbostic #include <sys/vnode.h> 1951460Sbostic #include <sys/specdev.h> 2051460Sbostic #include <sys/namei.h> 2151460Sbostic #include <sys/ucred.h> 2251460Sbostic #include <sys/buf.h> 2351460Sbostic #include <sys/errno.h> 2451460Sbostic #include <sys/malloc.h> 2537488Smckusick 2637488Smckusick /* 2737488Smckusick * Remove a mount point from the list of mounted filesystems. 2837488Smckusick * Unmount of the root is illegal. 2937488Smckusick */ 3037488Smckusick void 3137488Smckusick vfs_remove(mp) 3237488Smckusick register struct mount *mp; 3337488Smckusick { 3437488Smckusick 3537488Smckusick if (mp == rootfs) 3637488Smckusick panic("vfs_remove: unmounting root"); 3741400Smckusick mp->mnt_prev->mnt_next = mp->mnt_next; 3841400Smckusick mp->mnt_next->mnt_prev = mp->mnt_prev; 3941400Smckusick mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0; 4037488Smckusick vfs_unlock(mp); 4137488Smckusick } 4237488Smckusick 4337488Smckusick /* 4437488Smckusick * Lock a filesystem. 4537488Smckusick * Used to prevent access to it while mounting and unmounting. 4637488Smckusick */ 4737488Smckusick vfs_lock(mp) 4837488Smckusick register struct mount *mp; 4937488Smckusick { 5037488Smckusick 5141400Smckusick while(mp->mnt_flag & MNT_MLOCK) { 5241400Smckusick mp->mnt_flag |= MNT_MWAIT; 5339045Smckusick sleep((caddr_t)mp, PVFS); 5439045Smckusick } 5541400Smckusick mp->mnt_flag |= MNT_MLOCK; 5637488Smckusick return (0); 5737488Smckusick } 5837488Smckusick 5937488Smckusick /* 6037488Smckusick * Unlock a locked filesystem. 6137488Smckusick * Panic if filesystem is not locked. 6237488Smckusick */ 6337488Smckusick void 6437488Smckusick vfs_unlock(mp) 6537488Smckusick register struct mount *mp; 6637488Smckusick { 6737488Smckusick 6841400Smckusick if ((mp->mnt_flag & MNT_MLOCK) == 0) 6941300Smckusick panic("vfs_unlock: not locked"); 7041400Smckusick mp->mnt_flag &= ~MNT_MLOCK; 7141400Smckusick if (mp->mnt_flag & MNT_MWAIT) { 7241400Smckusick mp->mnt_flag &= ~MNT_MWAIT; 7337488Smckusick wakeup((caddr_t)mp); 7437488Smckusick } 7537488Smckusick } 7637488Smckusick 7737488Smckusick /* 7841300Smckusick * Mark a mount point as busy. 7941300Smckusick * Used to synchronize access and to delay unmounting. 8041300Smckusick */ 8141300Smckusick vfs_busy(mp) 8241300Smckusick register struct mount *mp; 8341300Smckusick { 8441300Smckusick 8541400Smckusick while(mp->mnt_flag & MNT_MPBUSY) { 8641400Smckusick mp->mnt_flag |= MNT_MPWANT; 8741400Smckusick sleep((caddr_t)&mp->mnt_flag, PVFS); 8841300Smckusick } 8941419Smckusick if (mp->mnt_flag & MNT_UNMOUNT) 9041419Smckusick return (1); 9141400Smckusick mp->mnt_flag |= MNT_MPBUSY; 9241300Smckusick return (0); 9341300Smckusick } 9441300Smckusick 9541300Smckusick /* 9641300Smckusick * Free a busy filesystem. 9741300Smckusick * Panic if filesystem is not busy. 9841300Smckusick */ 9941300Smckusick vfs_unbusy(mp) 10041300Smckusick register struct mount *mp; 10141300Smckusick { 10241300Smckusick 10341400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 10441300Smckusick panic("vfs_unbusy: not busy"); 10541400Smckusick mp->mnt_flag &= ~MNT_MPBUSY; 10641400Smckusick if (mp->mnt_flag & MNT_MPWANT) { 10741400Smckusick mp->mnt_flag &= ~MNT_MPWANT; 10841400Smckusick wakeup((caddr_t)&mp->mnt_flag); 10941300Smckusick } 11041300Smckusick } 11141300Smckusick 11241300Smckusick /* 11337488Smckusick * Lookup a mount point by filesystem identifier. 11437488Smckusick */ 11537488Smckusick struct mount * 11637488Smckusick getvfs(fsid) 11737488Smckusick fsid_t *fsid; 11837488Smckusick { 11937488Smckusick register struct mount *mp; 12037488Smckusick 12138288Smckusick mp = rootfs; 12238288Smckusick do { 12341400Smckusick if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] && 12441400Smckusick mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) { 12538288Smckusick return (mp); 12637488Smckusick } 12741400Smckusick mp = mp->mnt_next; 12838288Smckusick } while (mp != rootfs); 12938288Smckusick return ((struct mount *)0); 13037488Smckusick } 13137488Smckusick 13237488Smckusick /* 13337488Smckusick * Set vnode attributes to VNOVAL 13437488Smckusick */ 13537488Smckusick void vattr_null(vap) 13637488Smckusick register struct vattr *vap; 13737488Smckusick { 13837488Smckusick 13937488Smckusick vap->va_type = VNON; 140*52005Smckusick vap->va_size = vap->va_bytes = VNOVAL; 141*52005Smckusick #ifdef _NOQUAD 142*52005Smckusick vap->va_size_rsv = vap->va_bytes_rsv = VNOVAL; 143*52005Smckusick #endif 14437488Smckusick vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid = 145*52005Smckusick vap->va_fsid = vap->va_fileid = 146*52005Smckusick vap->va_blocksize = vap->va_rdev = 14737488Smckusick vap->va_atime.tv_sec = vap->va_atime.tv_usec = 14837488Smckusick vap->va_mtime.tv_sec = vap->va_mtime.tv_usec = 14938258Smckusick vap->va_ctime.tv_sec = vap->va_ctime.tv_usec = 15038258Smckusick vap->va_flags = vap->va_gen = VNOVAL; 15137488Smckusick } 15238265Smckusick 15338265Smckusick /* 15439397Smckusick * Routines having to do with the management of the vnode table. 15539397Smckusick */ 15639397Smckusick struct vnode *vfreeh, **vfreet; 15739447Smckusick extern struct vnodeops dead_vnodeops, spec_vnodeops; 15839635Smckusick extern void vclean(); 15940883Smckusick long numvnodes; 16041363Smckusick struct vattr va_null; 16139397Smckusick 16239397Smckusick /* 16339433Smckusick * Initialize the vnode structures and initialize each file system type. 16439397Smckusick */ 16539433Smckusick vfsinit() 16639397Smckusick { 16739433Smckusick struct vfsops **vfsp; 16839397Smckusick 16939433Smckusick /* 17039433Smckusick * Initialize the vnode name cache 17139433Smckusick */ 17239433Smckusick nchinit(); 17339433Smckusick /* 17439433Smckusick * Initialize each file system type. 17539433Smckusick */ 17641363Smckusick vattr_null(&va_null); 17739433Smckusick for (vfsp = &vfssw[0]; vfsp <= &vfssw[MOUNT_MAXTYPE]; vfsp++) { 17839433Smckusick if (*vfsp == NULL) 17939433Smckusick continue; 18039433Smckusick (*(*vfsp)->vfs_init)(); 18139433Smckusick } 18239397Smckusick } 18339397Smckusick 18439397Smckusick /* 18539397Smckusick * Return the next vnode from the free list. 18639397Smckusick */ 18739397Smckusick getnewvnode(tag, mp, vops, vpp) 18839397Smckusick enum vtagtype tag; 18939397Smckusick struct mount *mp; 19039397Smckusick struct vnodeops *vops; 19139397Smckusick struct vnode **vpp; 19239397Smckusick { 19339397Smckusick register struct vnode *vp, *vq; 19439397Smckusick 19540883Smckusick if (numvnodes < desiredvnodes) { 19645118Smckusick vp = (struct vnode *)malloc((u_long)sizeof *vp, 19745118Smckusick M_VNODE, M_WAITOK); 19840883Smckusick bzero((char *)vp, sizeof *vp); 19940883Smckusick numvnodes++; 20040883Smckusick } else { 20140883Smckusick if ((vp = vfreeh) == NULL) { 20240883Smckusick tablefull("vnode"); 20340883Smckusick *vpp = 0; 20440883Smckusick return (ENFILE); 20540883Smckusick } 20640883Smckusick if (vp->v_usecount) 20740883Smckusick panic("free vnode isn't"); 20840883Smckusick if (vq = vp->v_freef) 20940883Smckusick vq->v_freeb = &vfreeh; 21040883Smckusick else 21140883Smckusick vfreet = &vfreeh; 21240883Smckusick vfreeh = vq; 21340883Smckusick vp->v_freef = NULL; 21440883Smckusick vp->v_freeb = NULL; 21540883Smckusick if (vp->v_type != VBAD) 21640883Smckusick vgone(vp); 21740883Smckusick vp->v_flag = 0; 21840883Smckusick vp->v_lastr = 0; 21940883Smckusick vp->v_socket = 0; 22039397Smckusick } 22139512Smckusick vp->v_type = VNON; 22239397Smckusick cache_purge(vp); 22339397Smckusick vp->v_tag = tag; 22439433Smckusick vp->v_op = vops; 22539397Smckusick insmntque(vp, mp); 22639397Smckusick VREF(vp); 22739397Smckusick *vpp = vp; 22839397Smckusick return (0); 22939397Smckusick } 23039397Smckusick 23139397Smckusick /* 23239397Smckusick * Move a vnode from one mount queue to another. 23339397Smckusick */ 23439397Smckusick insmntque(vp, mp) 23539397Smckusick register struct vnode *vp; 23639397Smckusick register struct mount *mp; 23739397Smckusick { 23849973Smckusick register struct vnode *vq; 23939397Smckusick 24039397Smckusick /* 24139397Smckusick * Delete from old mount point vnode list, if on one. 24239397Smckusick */ 24339397Smckusick if (vp->v_mountb) { 24439397Smckusick if (vq = vp->v_mountf) 24539397Smckusick vq->v_mountb = vp->v_mountb; 24639397Smckusick *vp->v_mountb = vq; 24739397Smckusick } 24839397Smckusick /* 24939397Smckusick * Insert into list of vnodes for the new mount point, if available. 25039397Smckusick */ 25139621Smckusick vp->v_mount = mp; 25239397Smckusick if (mp == NULL) { 25339397Smckusick vp->v_mountf = NULL; 25439397Smckusick vp->v_mountb = NULL; 25539397Smckusick return; 25639397Smckusick } 25749973Smckusick if (vq = mp->mnt_mounth) 25849973Smckusick vq->v_mountb = &vp->v_mountf; 25949973Smckusick vp->v_mountf = vq; 26049973Smckusick vp->v_mountb = &mp->mnt_mounth; 26149973Smckusick mp->mnt_mounth = vp; 26239397Smckusick } 26339397Smckusick 26439397Smckusick /* 26549232Smckusick * Make sure all write-behind blocks associated 26649232Smckusick * with mount point are flushed out (from sync). 26749232Smckusick */ 26849232Smckusick mntflushbuf(mountp, flags) 26949232Smckusick struct mount *mountp; 27049232Smckusick int flags; 27149232Smckusick { 27249232Smckusick register struct vnode *vp; 27349232Smckusick 27449232Smckusick if ((mountp->mnt_flag & MNT_MPBUSY) == 0) 27549232Smckusick panic("mntflushbuf: not busy"); 27649232Smckusick loop: 27749232Smckusick for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) { 27849232Smckusick if (VOP_ISLOCKED(vp)) 27949232Smckusick continue; 28049232Smckusick if (vget(vp)) 28149232Smckusick goto loop; 28249232Smckusick vflushbuf(vp, flags); 28349232Smckusick vput(vp); 28449232Smckusick if (vp->v_mount != mountp) 28549232Smckusick goto loop; 28649232Smckusick } 28749232Smckusick } 28849232Smckusick 28949232Smckusick /* 29049232Smckusick * Flush all dirty buffers associated with a vnode. 29149232Smckusick */ 29249232Smckusick vflushbuf(vp, flags) 29349232Smckusick register struct vnode *vp; 29449232Smckusick int flags; 29549232Smckusick { 29649232Smckusick register struct buf *bp; 29749232Smckusick struct buf *nbp; 29849232Smckusick int s; 29949232Smckusick 30049232Smckusick loop: 30149232Smckusick s = splbio(); 30249232Smckusick for (bp = vp->v_dirtyblkhd; bp; bp = nbp) { 30349232Smckusick nbp = bp->b_blockf; 30449232Smckusick if ((bp->b_flags & B_BUSY)) 30549232Smckusick continue; 30649232Smckusick if ((bp->b_flags & B_DELWRI) == 0) 30749232Smckusick panic("vflushbuf: not dirty"); 30849232Smckusick bremfree(bp); 30949232Smckusick bp->b_flags |= B_BUSY; 31049232Smckusick splx(s); 31149232Smckusick /* 31249232Smckusick * Wait for I/O associated with indirect blocks to complete, 31349232Smckusick * since there is no way to quickly wait for them below. 31449232Smckusick * NB: This is really specific to ufs, but is done here 31549232Smckusick * as it is easier and quicker. 31649232Smckusick */ 31749460Smckusick if (bp->b_vp == vp || (flags & B_SYNC) == 0) 31849232Smckusick (void) bawrite(bp); 31949460Smckusick else 32049232Smckusick (void) bwrite(bp); 32149460Smckusick goto loop; 32249232Smckusick } 32349232Smckusick splx(s); 32449232Smckusick if ((flags & B_SYNC) == 0) 32549232Smckusick return; 32649232Smckusick s = splbio(); 32749232Smckusick while (vp->v_numoutput) { 32849232Smckusick vp->v_flag |= VBWAIT; 32949232Smckusick sleep((caddr_t)&vp->v_numoutput, PRIBIO + 1); 33049232Smckusick } 33149232Smckusick splx(s); 33249232Smckusick if (vp->v_dirtyblkhd) { 33349232Smckusick vprint("vflushbuf: dirty", vp); 33449232Smckusick goto loop; 33549232Smckusick } 33649232Smckusick } 33749232Smckusick 33849232Smckusick /* 33949232Smckusick * Update outstanding I/O count and do wakeup if requested. 34049232Smckusick */ 34149232Smckusick vwakeup(bp) 34249232Smckusick register struct buf *bp; 34349232Smckusick { 34449232Smckusick register struct vnode *vp; 34549232Smckusick 34649232Smckusick bp->b_dirtyoff = bp->b_dirtyend = 0; 34749232Smckusick if (vp = bp->b_vp) { 34849232Smckusick vp->v_numoutput--; 34949232Smckusick if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) { 35049232Smckusick if (vp->v_numoutput < 0) 35149232Smckusick panic("vwakeup: neg numoutput"); 35249232Smckusick vp->v_flag &= ~VBWAIT; 35349232Smckusick wakeup((caddr_t)&vp->v_numoutput); 35449232Smckusick } 35549232Smckusick } 35649232Smckusick } 35749232Smckusick 35849232Smckusick /* 35949232Smckusick * Invalidate in core blocks belonging to closed or umounted filesystem 36049232Smckusick * 36149232Smckusick * Go through the list of vnodes associated with the file system; 36249232Smckusick * for each vnode invalidate any buffers that it holds. Normally 36349232Smckusick * this routine is preceeded by a bflush call, so that on a quiescent 36449232Smckusick * filesystem there will be no dirty buffers when we are done. Binval 36549232Smckusick * returns the count of dirty buffers when it is finished. 36649232Smckusick */ 36749232Smckusick mntinvalbuf(mountp) 36849232Smckusick struct mount *mountp; 36949232Smckusick { 37049232Smckusick register struct vnode *vp; 37149232Smckusick int dirty = 0; 37249232Smckusick 37349232Smckusick if ((mountp->mnt_flag & MNT_MPBUSY) == 0) 37449232Smckusick panic("mntinvalbuf: not busy"); 37549232Smckusick loop: 37649232Smckusick for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) { 37749232Smckusick if (vget(vp)) 37849232Smckusick goto loop; 37949232Smckusick dirty += vinvalbuf(vp, 1); 38049232Smckusick vput(vp); 38149232Smckusick if (vp->v_mount != mountp) 38249232Smckusick goto loop; 38349232Smckusick } 38449232Smckusick return (dirty); 38549232Smckusick } 38649232Smckusick 38749232Smckusick /* 38849232Smckusick * Flush out and invalidate all buffers associated with a vnode. 38949232Smckusick * Called with the underlying object locked. 39049232Smckusick */ 39149232Smckusick vinvalbuf(vp, save) 39249232Smckusick register struct vnode *vp; 39349232Smckusick int save; 39449232Smckusick { 39549232Smckusick register struct buf *bp; 39649232Smckusick struct buf *nbp, *blist; 39749232Smckusick int s, dirty = 0; 39849232Smckusick 39949232Smckusick for (;;) { 40049232Smckusick if (blist = vp->v_dirtyblkhd) 40149232Smckusick /* void */; 40249232Smckusick else if (blist = vp->v_cleanblkhd) 40349232Smckusick /* void */; 40449232Smckusick else 40549232Smckusick break; 40649232Smckusick for (bp = blist; bp; bp = nbp) { 40749232Smckusick nbp = bp->b_blockf; 40849232Smckusick s = splbio(); 40949232Smckusick if (bp->b_flags & B_BUSY) { 41049232Smckusick bp->b_flags |= B_WANTED; 41149232Smckusick sleep((caddr_t)bp, PRIBIO + 1); 41249232Smckusick splx(s); 41349232Smckusick break; 41449232Smckusick } 41549232Smckusick bremfree(bp); 41649232Smckusick bp->b_flags |= B_BUSY; 41749232Smckusick splx(s); 41849232Smckusick if (save && (bp->b_flags & B_DELWRI)) { 41951568Smckusick dirty++; 42051568Smckusick (void) VOP_BWRITE(bp); 42149232Smckusick break; 42249232Smckusick } 42349232Smckusick if (bp->b_vp != vp) 42449232Smckusick reassignbuf(bp, bp->b_vp); 42549232Smckusick else 42649232Smckusick bp->b_flags |= B_INVAL; 42749232Smckusick brelse(bp); 42849232Smckusick } 42949232Smckusick } 43049232Smckusick if (vp->v_dirtyblkhd || vp->v_cleanblkhd) 43149232Smckusick panic("vinvalbuf: flush failed"); 43249232Smckusick return (dirty); 43349232Smckusick } 43449232Smckusick 43549232Smckusick /* 43649232Smckusick * Associate a buffer with a vnode. 43749232Smckusick */ 43849232Smckusick bgetvp(vp, bp) 43949232Smckusick register struct vnode *vp; 44049232Smckusick register struct buf *bp; 44149232Smckusick { 44249973Smckusick register struct vnode *vq; 44349973Smckusick register struct buf *bq; 44449232Smckusick 44549232Smckusick if (bp->b_vp) 44649232Smckusick panic("bgetvp: not free"); 44749232Smckusick VHOLD(vp); 44849232Smckusick bp->b_vp = vp; 44949232Smckusick if (vp->v_type == VBLK || vp->v_type == VCHR) 45049232Smckusick bp->b_dev = vp->v_rdev; 45149232Smckusick else 45249232Smckusick bp->b_dev = NODEV; 45349232Smckusick /* 45449232Smckusick * Insert onto list for new vnode. 45549232Smckusick */ 45649973Smckusick if (bq = vp->v_cleanblkhd) 45749973Smckusick bq->b_blockb = &bp->b_blockf; 45849973Smckusick bp->b_blockf = bq; 45949973Smckusick bp->b_blockb = &vp->v_cleanblkhd; 46049973Smckusick vp->v_cleanblkhd = bp; 46149232Smckusick } 46249232Smckusick 46349232Smckusick /* 46449232Smckusick * Disassociate a buffer from a vnode. 46549232Smckusick */ 46649232Smckusick brelvp(bp) 46749232Smckusick register struct buf *bp; 46849232Smckusick { 46949232Smckusick struct buf *bq; 47049232Smckusick struct vnode *vp; 47149232Smckusick 47249232Smckusick if (bp->b_vp == (struct vnode *) 0) 47349232Smckusick panic("brelvp: NULL"); 47449232Smckusick /* 47549232Smckusick * Delete from old vnode list, if on one. 47649232Smckusick */ 47749232Smckusick if (bp->b_blockb) { 47849232Smckusick if (bq = bp->b_blockf) 47949232Smckusick bq->b_blockb = bp->b_blockb; 48049232Smckusick *bp->b_blockb = bq; 48149232Smckusick bp->b_blockf = NULL; 48249232Smckusick bp->b_blockb = NULL; 48349232Smckusick } 48449232Smckusick vp = bp->b_vp; 48549232Smckusick bp->b_vp = (struct vnode *) 0; 48649232Smckusick HOLDRELE(vp); 48749232Smckusick } 48849232Smckusick 48949232Smckusick /* 49049232Smckusick * Reassign a buffer from one vnode to another. 49149232Smckusick * Used to assign file specific control information 49249232Smckusick * (indirect blocks) to the vnode to which they belong. 49349232Smckusick */ 49449232Smckusick reassignbuf(bp, newvp) 49549232Smckusick register struct buf *bp; 49649232Smckusick register struct vnode *newvp; 49749232Smckusick { 49849232Smckusick register struct buf *bq, **listheadp; 49949232Smckusick 50049232Smckusick if (newvp == NULL) 50149232Smckusick panic("reassignbuf: NULL"); 50249232Smckusick /* 50349232Smckusick * Delete from old vnode list, if on one. 50449232Smckusick */ 50549232Smckusick if (bp->b_blockb) { 50649232Smckusick if (bq = bp->b_blockf) 50749232Smckusick bq->b_blockb = bp->b_blockb; 50849232Smckusick *bp->b_blockb = bq; 50949232Smckusick } 51049232Smckusick /* 51149232Smckusick * If dirty, put on list of dirty buffers; 51249232Smckusick * otherwise insert onto list of clean buffers. 51349232Smckusick */ 51449232Smckusick if (bp->b_flags & B_DELWRI) 51549232Smckusick listheadp = &newvp->v_dirtyblkhd; 51649232Smckusick else 51749232Smckusick listheadp = &newvp->v_cleanblkhd; 51849973Smckusick if (bq = *listheadp) 51949973Smckusick bq->b_blockb = &bp->b_blockf; 52049973Smckusick bp->b_blockf = bq; 52149973Smckusick bp->b_blockb = listheadp; 52249973Smckusick *listheadp = bp; 52349232Smckusick } 52449232Smckusick 52549232Smckusick /* 52639433Smckusick * Create a vnode for a block device. 52739433Smckusick * Used for root filesystem, argdev, and swap areas. 52839433Smckusick * Also used for memory file system special devices. 52939397Smckusick */ 53039433Smckusick bdevvp(dev, vpp) 53139433Smckusick dev_t dev; 53239433Smckusick struct vnode **vpp; 53339433Smckusick { 53439433Smckusick register struct vnode *vp; 53539433Smckusick struct vnode *nvp; 53639433Smckusick int error; 53739433Smckusick 53846989Smckusick if (dev == NODEV) 53946989Smckusick return (0); 54039447Smckusick error = getnewvnode(VT_NON, (struct mount *)0, &spec_vnodeops, &nvp); 54139433Smckusick if (error) { 54239433Smckusick *vpp = 0; 54339433Smckusick return (error); 54439433Smckusick } 54539433Smckusick vp = nvp; 54639433Smckusick vp->v_type = VBLK; 54739615Smckusick if (nvp = checkalias(vp, dev, (struct mount *)0)) { 54839433Smckusick vput(vp); 54939433Smckusick vp = nvp; 55039433Smckusick } 55139433Smckusick *vpp = vp; 55239433Smckusick return (0); 55339433Smckusick } 55439433Smckusick 55539433Smckusick /* 55639433Smckusick * Check to see if the new vnode represents a special device 55739433Smckusick * for which we already have a vnode (either because of 55839433Smckusick * bdevvp() or because of a different vnode representing 55939433Smckusick * the same block device). If such an alias exists, deallocate 56039509Smckusick * the existing contents and return the aliased vnode. The 56139433Smckusick * caller is responsible for filling it with its new contents. 56239433Smckusick */ 56339433Smckusick struct vnode * 56439615Smckusick checkalias(nvp, nvp_rdev, mp) 56539433Smckusick register struct vnode *nvp; 56639615Smckusick dev_t nvp_rdev; 56739433Smckusick struct mount *mp; 56839433Smckusick { 56939433Smckusick register struct vnode *vp; 57039615Smckusick struct vnode **vpp; 57139433Smckusick 57239433Smckusick if (nvp->v_type != VBLK && nvp->v_type != VCHR) 57341400Smckusick return (NULLVP); 57439615Smckusick 57539615Smckusick vpp = &speclisth[SPECHASH(nvp_rdev)]; 57639433Smckusick loop: 57739615Smckusick for (vp = *vpp; vp; vp = vp->v_specnext) { 57839615Smckusick if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type) 57939433Smckusick continue; 58039615Smckusick /* 58139615Smckusick * Alias, but not in use, so flush it out. 58239615Smckusick */ 58339809Smckusick if (vp->v_usecount == 0) { 58439615Smckusick vgone(vp); 58539615Smckusick goto loop; 58639615Smckusick } 58739633Smckusick if (vget(vp)) 58839633Smckusick goto loop; 58939433Smckusick break; 59039433Smckusick } 59139615Smckusick if (vp == NULL || vp->v_tag != VT_NON) { 59239615Smckusick MALLOC(nvp->v_specinfo, struct specinfo *, 59339615Smckusick sizeof(struct specinfo), M_VNODE, M_WAITOK); 59439615Smckusick nvp->v_rdev = nvp_rdev; 59539809Smckusick nvp->v_hashchain = vpp; 59639615Smckusick nvp->v_specnext = *vpp; 59742152Smckusick nvp->v_specflags = 0; 59839615Smckusick *vpp = nvp; 59940640Smckusick if (vp != NULL) { 60040640Smckusick nvp->v_flag |= VALIASED; 60140640Smckusick vp->v_flag |= VALIASED; 60240640Smckusick vput(vp); 60340640Smckusick } 60441400Smckusick return (NULLVP); 60539433Smckusick } 60639484Smckusick VOP_UNLOCK(vp); 60739484Smckusick vclean(vp, 0); 60839433Smckusick vp->v_op = nvp->v_op; 60939433Smckusick vp->v_tag = nvp->v_tag; 61039433Smckusick nvp->v_type = VNON; 61139433Smckusick insmntque(vp, mp); 61239433Smckusick return (vp); 61339433Smckusick } 61439433Smckusick 61539433Smckusick /* 61639433Smckusick * Grab a particular vnode from the free list, increment its 61739433Smckusick * reference count and lock it. The vnode lock bit is set the 61839433Smckusick * vnode is being eliminated in vgone. The process is awakened 61939433Smckusick * when the transition is completed, and an error returned to 62039433Smckusick * indicate that the vnode is no longer usable (possibly having 62139433Smckusick * been changed to a new file system type). 62239433Smckusick */ 62339397Smckusick vget(vp) 62439397Smckusick register struct vnode *vp; 62539397Smckusick { 62639397Smckusick register struct vnode *vq; 62739397Smckusick 62839433Smckusick if (vp->v_flag & VXLOCK) { 62939433Smckusick vp->v_flag |= VXWANT; 63039433Smckusick sleep((caddr_t)vp, PINOD); 63139433Smckusick return (1); 63239433Smckusick } 63339809Smckusick if (vp->v_usecount == 0) { 63439433Smckusick if (vq = vp->v_freef) 63539433Smckusick vq->v_freeb = vp->v_freeb; 63639433Smckusick else 63739433Smckusick vfreet = vp->v_freeb; 63839433Smckusick *vp->v_freeb = vq; 63939433Smckusick vp->v_freef = NULL; 64039433Smckusick vp->v_freeb = NULL; 64139433Smckusick } 64239397Smckusick VREF(vp); 64339433Smckusick VOP_LOCK(vp); 64439433Smckusick return (0); 64539397Smckusick } 64639397Smckusick 64739397Smckusick /* 64839397Smckusick * Vnode reference, just increment the count 64939397Smckusick */ 65039397Smckusick void vref(vp) 65139397Smckusick struct vnode *vp; 65239397Smckusick { 65339397Smckusick 65439809Smckusick vp->v_usecount++; 65539397Smckusick } 65639397Smckusick 65739397Smckusick /* 65839397Smckusick * vput(), just unlock and vrele() 65939397Smckusick */ 66039397Smckusick void vput(vp) 66139397Smckusick register struct vnode *vp; 66239397Smckusick { 66339397Smckusick VOP_UNLOCK(vp); 66439397Smckusick vrele(vp); 66539397Smckusick } 66639397Smckusick 66739397Smckusick /* 66839397Smckusick * Vnode release. 66939397Smckusick * If count drops to zero, call inactive routine and return to freelist. 67039397Smckusick */ 67139397Smckusick void vrele(vp) 67239397Smckusick register struct vnode *vp; 67339397Smckusick { 67448024Smckusick struct proc *p = curproc; /* XXX */ 67539397Smckusick 67650109Smckusick #ifdef DIAGNOSTIC 67739397Smckusick if (vp == NULL) 67839433Smckusick panic("vrele: null vp"); 67950109Smckusick #endif 68039809Smckusick vp->v_usecount--; 68139809Smckusick if (vp->v_usecount > 0) 68239397Smckusick return; 68350109Smckusick #ifdef DIAGNOSTIC 68450109Smckusick if (vp->v_usecount != 0 || vp->v_writecount != 0) { 68550109Smckusick vprint("vrele: bad ref count", vp); 68650109Smckusick panic("vrele: ref cnt"); 68750109Smckusick } 68850109Smckusick #endif 68941400Smckusick if (vfreeh == NULLVP) { 69039397Smckusick /* 69139397Smckusick * insert into empty list 69239397Smckusick */ 69339397Smckusick vfreeh = vp; 69439397Smckusick vp->v_freeb = &vfreeh; 69539397Smckusick } else { 69639397Smckusick /* 69739397Smckusick * insert at tail of list 69839397Smckusick */ 69939397Smckusick *vfreet = vp; 70039397Smckusick vp->v_freeb = vfreet; 70139397Smckusick } 70239433Smckusick vp->v_freef = NULL; 70339433Smckusick vfreet = &vp->v_freef; 70448024Smckusick VOP_INACTIVE(vp, p); 70539397Smckusick } 70639433Smckusick 70739433Smckusick /* 70839809Smckusick * Page or buffer structure gets a reference. 70939809Smckusick */ 71039809Smckusick vhold(vp) 71139809Smckusick register struct vnode *vp; 71239809Smckusick { 71339809Smckusick 71439809Smckusick vp->v_holdcnt++; 71539809Smckusick } 71639809Smckusick 71739809Smckusick /* 71839809Smckusick * Page or buffer structure frees a reference. 71939809Smckusick */ 72039809Smckusick holdrele(vp) 72139809Smckusick register struct vnode *vp; 72239809Smckusick { 72339809Smckusick 72439809Smckusick if (vp->v_holdcnt <= 0) 72539809Smckusick panic("holdrele: holdcnt"); 72639809Smckusick vp->v_holdcnt--; 72739809Smckusick } 72839809Smckusick 72939809Smckusick /* 73039509Smckusick * Remove any vnodes in the vnode table belonging to mount point mp. 73139509Smckusick * 73239509Smckusick * If MNT_NOFORCE is specified, there should not be any active ones, 73339509Smckusick * return error if any are found (nb: this is a user error, not a 73439509Smckusick * system error). If MNT_FORCE is specified, detach any active vnodes 73539509Smckusick * that are found. 73639509Smckusick */ 73739509Smckusick int busyprt = 0; /* patch to print out busy vnodes */ 73839509Smckusick 73939509Smckusick vflush(mp, skipvp, flags) 74039509Smckusick struct mount *mp; 74139509Smckusick struct vnode *skipvp; 74239509Smckusick int flags; 74339509Smckusick { 74439509Smckusick register struct vnode *vp, *nvp; 74539509Smckusick int busy = 0; 74639509Smckusick 74741400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 74841300Smckusick panic("vflush: not busy"); 74941421Smckusick loop: 75041400Smckusick for (vp = mp->mnt_mounth; vp; vp = nvp) { 75141421Smckusick if (vp->v_mount != mp) 75241421Smckusick goto loop; 75339509Smckusick nvp = vp->v_mountf; 75439509Smckusick /* 75539509Smckusick * Skip over a selected vnode. 75639509Smckusick */ 75739509Smckusick if (vp == skipvp) 75839509Smckusick continue; 75939509Smckusick /* 76041300Smckusick * Skip over a vnodes marked VSYSTEM. 76141300Smckusick */ 76241300Smckusick if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) 76341300Smckusick continue; 76441300Smckusick /* 76539809Smckusick * With v_usecount == 0, all we need to do is clear 76639509Smckusick * out the vnode data structures and we are done. 76739509Smckusick */ 76839809Smckusick if (vp->v_usecount == 0) { 76939509Smckusick vgone(vp); 77039509Smckusick continue; 77139509Smckusick } 77239509Smckusick /* 77339509Smckusick * For block or character devices, revert to an 77439509Smckusick * anonymous device. For all other files, just kill them. 77539509Smckusick */ 77641300Smckusick if (flags & FORCECLOSE) { 77739509Smckusick if (vp->v_type != VBLK && vp->v_type != VCHR) { 77839509Smckusick vgone(vp); 77939509Smckusick } else { 78039509Smckusick vclean(vp, 0); 78139509Smckusick vp->v_op = &spec_vnodeops; 78239509Smckusick insmntque(vp, (struct mount *)0); 78339509Smckusick } 78439509Smckusick continue; 78539509Smckusick } 78639509Smckusick if (busyprt) 78739667Smckusick vprint("vflush: busy vnode", vp); 78839509Smckusick busy++; 78939509Smckusick } 79039509Smckusick if (busy) 79139509Smckusick return (EBUSY); 79239509Smckusick return (0); 79339509Smckusick } 79439509Smckusick 79539509Smckusick /* 79639433Smckusick * Disassociate the underlying file system from a vnode. 79739433Smckusick */ 79841300Smckusick void vclean(vp, flags) 79939433Smckusick register struct vnode *vp; 80045118Smckusick int flags; 80139433Smckusick { 80239433Smckusick struct vnodeops *origops; 80339484Smckusick int active; 80448024Smckusick struct proc *p = curproc; /* XXX */ 80539433Smckusick 80639484Smckusick /* 80739484Smckusick * Check to see if the vnode is in use. 80839667Smckusick * If so we have to reference it before we clean it out 80939667Smckusick * so that its count cannot fall to zero and generate a 81039667Smckusick * race against ourselves to recycle it. 81139484Smckusick */ 81239809Smckusick if (active = vp->v_usecount) 81339484Smckusick VREF(vp); 81439484Smckusick /* 81539484Smckusick * Prevent the vnode from being recycled or 81639484Smckusick * brought into use while we clean it out. 81739484Smckusick */ 81839667Smckusick if (vp->v_flag & VXLOCK) 81939667Smckusick panic("vclean: deadlock"); 82039433Smckusick vp->v_flag |= VXLOCK; 82139433Smckusick /* 82239667Smckusick * Even if the count is zero, the VOP_INACTIVE routine may still 82339667Smckusick * have the object locked while it cleans it out. The VOP_LOCK 82439667Smckusick * ensures that the VOP_INACTIVE routine is done with its work. 82539667Smckusick * For active vnodes, it ensures that no other activity can 82639667Smckusick * occur while the buffer list is being cleaned out. 82739667Smckusick */ 82839667Smckusick VOP_LOCK(vp); 82941300Smckusick if (flags & DOCLOSE) 83039667Smckusick vinvalbuf(vp, 1); 83139667Smckusick /* 83239433Smckusick * Prevent any further operations on the vnode from 83339433Smckusick * being passed through to the old file system. 83439433Smckusick */ 83539433Smckusick origops = vp->v_op; 83639433Smckusick vp->v_op = &dead_vnodeops; 83739433Smckusick vp->v_tag = VT_NON; 83839433Smckusick /* 83939484Smckusick * If purging an active vnode, it must be unlocked, closed, 84039484Smckusick * and deactivated before being reclaimed. 84139433Smckusick */ 84249761Smckusick (*(origops->vop_unlock))(vp); 84339484Smckusick if (active) { 84441300Smckusick if (flags & DOCLOSE) 84549761Smckusick (*(origops->vop_close))(vp, IO_NDELAY, NOCRED, p); 84649761Smckusick (*(origops->vop_inactive))(vp, p); 84739433Smckusick } 84839433Smckusick /* 84939433Smckusick * Reclaim the vnode. 85039433Smckusick */ 85149761Smckusick if ((*(origops->vop_reclaim))(vp)) 85239433Smckusick panic("vclean: cannot reclaim"); 85339484Smckusick if (active) 85439484Smckusick vrele(vp); 85539433Smckusick /* 85639433Smckusick * Done with purge, notify sleepers in vget of the grim news. 85739433Smckusick */ 85839433Smckusick vp->v_flag &= ~VXLOCK; 85939433Smckusick if (vp->v_flag & VXWANT) { 86039433Smckusick vp->v_flag &= ~VXWANT; 86139433Smckusick wakeup((caddr_t)vp); 86239433Smckusick } 86339433Smckusick } 86439433Smckusick 86539433Smckusick /* 86639633Smckusick * Eliminate all activity associated with the requested vnode 86739633Smckusick * and with all vnodes aliased to the requested vnode. 86839633Smckusick */ 86939633Smckusick void vgoneall(vp) 87039633Smckusick register struct vnode *vp; 87139633Smckusick { 87239809Smckusick register struct vnode *vq; 87339633Smckusick 87440665Smckusick if (vp->v_flag & VALIASED) { 87540665Smckusick /* 87640665Smckusick * If a vgone (or vclean) is already in progress, 87740665Smckusick * wait until it is done and return. 87840665Smckusick */ 87940665Smckusick if (vp->v_flag & VXLOCK) { 88040665Smckusick vp->v_flag |= VXWANT; 88140665Smckusick sleep((caddr_t)vp, PINOD); 88240665Smckusick return; 88339633Smckusick } 88440665Smckusick /* 88540665Smckusick * Ensure that vp will not be vgone'd while we 88640665Smckusick * are eliminating its aliases. 88740665Smckusick */ 88840665Smckusick vp->v_flag |= VXLOCK; 88940665Smckusick while (vp->v_flag & VALIASED) { 89040665Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 89140665Smckusick if (vq->v_rdev != vp->v_rdev || 89240665Smckusick vq->v_type != vp->v_type || vp == vq) 89340665Smckusick continue; 89440665Smckusick vgone(vq); 89540665Smckusick break; 89640665Smckusick } 89740665Smckusick } 89840665Smckusick /* 89940665Smckusick * Remove the lock so that vgone below will 90040665Smckusick * really eliminate the vnode after which time 90140665Smckusick * vgone will awaken any sleepers. 90240665Smckusick */ 90340665Smckusick vp->v_flag &= ~VXLOCK; 90439633Smckusick } 90539633Smckusick vgone(vp); 90639633Smckusick } 90739633Smckusick 90839633Smckusick /* 90939433Smckusick * Eliminate all activity associated with a vnode 91039433Smckusick * in preparation for reuse. 91139433Smckusick */ 91239433Smckusick void vgone(vp) 91339433Smckusick register struct vnode *vp; 91439433Smckusick { 91539809Smckusick register struct vnode *vq; 91639615Smckusick struct vnode *vx; 91739615Smckusick long count; 91839433Smckusick 91939433Smckusick /* 92040548Smckusick * If a vgone (or vclean) is already in progress, 92140548Smckusick * wait until it is done and return. 92240548Smckusick */ 92340548Smckusick if (vp->v_flag & VXLOCK) { 92440548Smckusick vp->v_flag |= VXWANT; 92540548Smckusick sleep((caddr_t)vp, PINOD); 92640548Smckusick return; 92740548Smckusick } 92840548Smckusick /* 92939433Smckusick * Clean out the filesystem specific data. 93039433Smckusick */ 93141300Smckusick vclean(vp, DOCLOSE); 93239433Smckusick /* 93339433Smckusick * Delete from old mount point vnode list, if on one. 93439433Smckusick */ 93539433Smckusick if (vp->v_mountb) { 93639433Smckusick if (vq = vp->v_mountf) 93739433Smckusick vq->v_mountb = vp->v_mountb; 93839433Smckusick *vp->v_mountb = vq; 93939433Smckusick vp->v_mountf = NULL; 94039433Smckusick vp->v_mountb = NULL; 94139433Smckusick } 94239433Smckusick /* 94339433Smckusick * If special device, remove it from special device alias list. 94439433Smckusick */ 94539433Smckusick if (vp->v_type == VBLK || vp->v_type == VCHR) { 94639809Smckusick if (*vp->v_hashchain == vp) { 94739809Smckusick *vp->v_hashchain = vp->v_specnext; 94839433Smckusick } else { 94939809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 95039615Smckusick if (vq->v_specnext != vp) 95139433Smckusick continue; 95239615Smckusick vq->v_specnext = vp->v_specnext; 95339433Smckusick break; 95439433Smckusick } 95539615Smckusick if (vq == NULL) 95639433Smckusick panic("missing bdev"); 95739433Smckusick } 95839615Smckusick if (vp->v_flag & VALIASED) { 95939809Smckusick count = 0; 96039809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 96140108Smckusick if (vq->v_rdev != vp->v_rdev || 96240108Smckusick vq->v_type != vp->v_type) 96339615Smckusick continue; 96439615Smckusick count++; 96539615Smckusick vx = vq; 96639615Smckusick } 96739615Smckusick if (count == 0) 96839615Smckusick panic("missing alias"); 96939615Smckusick if (count == 1) 97039615Smckusick vx->v_flag &= ~VALIASED; 97139615Smckusick vp->v_flag &= ~VALIASED; 97239615Smckusick } 97339615Smckusick FREE(vp->v_specinfo, M_VNODE); 97439615Smckusick vp->v_specinfo = NULL; 97539433Smckusick } 97639433Smckusick /* 97739433Smckusick * If it is on the freelist, move it to the head of the list. 97839433Smckusick */ 97939433Smckusick if (vp->v_freeb) { 98039433Smckusick if (vq = vp->v_freef) 98139433Smckusick vq->v_freeb = vp->v_freeb; 98239433Smckusick else 98339433Smckusick vfreet = vp->v_freeb; 98439433Smckusick *vp->v_freeb = vq; 98539433Smckusick vp->v_freef = vfreeh; 98639433Smckusick vp->v_freeb = &vfreeh; 98739433Smckusick vfreeh->v_freeb = &vp->v_freef; 98839433Smckusick vfreeh = vp; 98939433Smckusick } 99039484Smckusick vp->v_type = VBAD; 99139433Smckusick } 99239633Smckusick 99339633Smckusick /* 99439821Smckusick * Lookup a vnode by device number. 99539821Smckusick */ 99639821Smckusick vfinddev(dev, type, vpp) 99739821Smckusick dev_t dev; 99839821Smckusick enum vtype type; 99939821Smckusick struct vnode **vpp; 100039821Smckusick { 100139821Smckusick register struct vnode *vp; 100239821Smckusick 100339821Smckusick for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) { 100439821Smckusick if (dev != vp->v_rdev || type != vp->v_type) 100539821Smckusick continue; 100639821Smckusick *vpp = vp; 100739821Smckusick return (0); 100839821Smckusick } 100939821Smckusick return (1); 101039821Smckusick } 101139821Smckusick 101239821Smckusick /* 101339633Smckusick * Calculate the total number of references to a special device. 101439633Smckusick */ 101539633Smckusick vcount(vp) 101639633Smckusick register struct vnode *vp; 101739633Smckusick { 101839809Smckusick register struct vnode *vq; 101939633Smckusick int count; 102039633Smckusick 102139633Smckusick if ((vp->v_flag & VALIASED) == 0) 102239809Smckusick return (vp->v_usecount); 102339633Smckusick loop: 102439809Smckusick for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 102540108Smckusick if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type) 102639633Smckusick continue; 102739633Smckusick /* 102839633Smckusick * Alias, but not in use, so flush it out. 102939633Smckusick */ 103039809Smckusick if (vq->v_usecount == 0) { 103139633Smckusick vgone(vq); 103239633Smckusick goto loop; 103339633Smckusick } 103439809Smckusick count += vq->v_usecount; 103539633Smckusick } 103639633Smckusick return (count); 103739633Smckusick } 103839667Smckusick 103939667Smckusick /* 104039667Smckusick * Print out a description of a vnode. 104139667Smckusick */ 104239667Smckusick static char *typename[] = 104340286Smckusick { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" }; 104439667Smckusick 104539667Smckusick vprint(label, vp) 104639667Smckusick char *label; 104739667Smckusick register struct vnode *vp; 104839667Smckusick { 104939913Smckusick char buf[64]; 105039667Smckusick 105139667Smckusick if (label != NULL) 105239667Smckusick printf("%s: ", label); 105350109Smckusick printf("type %s, usecount %d, writecount %d, refcount %d,", 105450109Smckusick typename[vp->v_type], vp->v_usecount, vp->v_writecount, 105550109Smckusick vp->v_holdcnt); 105639913Smckusick buf[0] = '\0'; 105739913Smckusick if (vp->v_flag & VROOT) 105839913Smckusick strcat(buf, "|VROOT"); 105939913Smckusick if (vp->v_flag & VTEXT) 106039913Smckusick strcat(buf, "|VTEXT"); 106141300Smckusick if (vp->v_flag & VSYSTEM) 106241300Smckusick strcat(buf, "|VSYSTEM"); 106341300Smckusick if (vp->v_flag & VXLOCK) 106441300Smckusick strcat(buf, "|VXLOCK"); 106541300Smckusick if (vp->v_flag & VXWANT) 106641300Smckusick strcat(buf, "|VXWANT"); 106741300Smckusick if (vp->v_flag & VBWAIT) 106841300Smckusick strcat(buf, "|VBWAIT"); 106939913Smckusick if (vp->v_flag & VALIASED) 107039913Smckusick strcat(buf, "|VALIASED"); 107139913Smckusick if (buf[0] != '\0') 107239913Smckusick printf(" flags (%s)", &buf[1]); 107339913Smckusick printf("\n\t"); 107439667Smckusick VOP_PRINT(vp); 107539667Smckusick } 107641110Smarc 107749691Smckusick #ifdef DEBUG 107849691Smckusick /* 107949691Smckusick * List all of the locked vnodes in the system. 108049691Smckusick * Called when debugging the kernel. 108149691Smckusick */ 108249691Smckusick printlockedvnodes() 108349691Smckusick { 108449691Smckusick register struct mount *mp; 108549691Smckusick register struct vnode *vp; 108649691Smckusick 108749691Smckusick printf("Locked vnodes\n"); 108849691Smckusick mp = rootfs; 108949691Smckusick do { 109049691Smckusick for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) 109149691Smckusick if (VOP_ISLOCKED(vp)) 109249691Smckusick vprint((char *)0, vp); 109349691Smckusick mp = mp->mnt_next; 109449691Smckusick } while (mp != rootfs); 109549691Smckusick } 109649691Smckusick #endif 109749691Smckusick 109841110Smarc int kinfo_vdebug = 1; 109941110Smarc int kinfo_vgetfailed; 110041110Smarc #define KINFO_VNODESLOP 10 110141110Smarc /* 110241110Smarc * Dump vnode list (via kinfo). 110341110Smarc * Copyout address of vnode followed by vnode. 110441110Smarc */ 110545118Smckusick /* ARGSUSED */ 110641110Smarc kinfo_vnode(op, where, acopysize, arg, aneeded) 110745118Smckusick int op; 110841110Smarc char *where; 110945118Smckusick int *acopysize, arg, *aneeded; 111041110Smarc { 111141110Smarc register struct mount *mp = rootfs; 111241300Smckusick struct mount *omp; 111341110Smarc struct vnode *vp; 111441110Smarc register char *bp = where, *savebp; 111541110Smarc char *ewhere = where + *acopysize; 111641110Smarc int error; 111741110Smarc 111841110Smarc #define VPTRSZ sizeof (struct vnode *) 111941110Smarc #define VNODESZ sizeof (struct vnode) 112041110Smarc if (where == NULL) { 112141110Smarc *aneeded = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ); 112241110Smarc return (0); 112341110Smarc } 112441110Smarc 112541110Smarc do { 112641300Smckusick if (vfs_busy(mp)) { 112741400Smckusick mp = mp->mnt_next; 112841300Smckusick continue; 112941300Smckusick } 113041110Smarc savebp = bp; 113141110Smarc again: 113241421Smckusick for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) { 113341422Smckusick /* 113441422Smckusick * Check that the vp is still associated with 113541422Smckusick * this filesystem. RACE: could have been 113641422Smckusick * recycled onto the same filesystem. 113741422Smckusick */ 113841421Smckusick if (vp->v_mount != mp) { 113941421Smckusick if (kinfo_vdebug) 114041421Smckusick printf("kinfo: vp changed\n"); 114141421Smckusick bp = savebp; 114241421Smckusick goto again; 114341421Smckusick } 114441110Smarc if ((bp + VPTRSZ + VNODESZ <= ewhere) && 114541110Smarc ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) || 114641110Smarc (error = copyout((caddr_t)vp, bp + VPTRSZ, 114741422Smckusick VNODESZ)))) 114841110Smarc return (error); 114941110Smarc bp += VPTRSZ + VNODESZ; 115041110Smarc } 115141300Smckusick omp = mp; 115241400Smckusick mp = mp->mnt_next; 115341300Smckusick vfs_unbusy(omp); 115441110Smarc } while (mp != rootfs); 115541110Smarc 115641110Smarc *aneeded = bp - where; 115741110Smarc if (bp > ewhere) 115841110Smarc *acopysize = ewhere - where; 115941110Smarc else 116041110Smarc *acopysize = bp - where; 116141110Smarc return (0); 116241110Smarc } 1163