137488Smckusick /* 237488Smckusick * Copyright (c) 1989 The Regents of the University of California. 337488Smckusick * All rights reserved. 437488Smckusick * 544458Sbostic * %sccs.include.redist.c% 637488Smckusick * 7*49761Smckusick * @(#)vfs_subr.c 7.58 (Berkeley) 05/16/91 837488Smckusick */ 937488Smckusick 1037488Smckusick /* 1137488Smckusick * External virtual filesystem routines 1237488Smckusick */ 1337488Smckusick 1437488Smckusick #include "param.h" 1548024Smckusick #include "proc.h" 1637488Smckusick #include "mount.h" 1737488Smckusick #include "time.h" 1837488Smckusick #include "vnode.h" 1940652Smckusick #include "specdev.h" 2038265Smckusick #include "namei.h" 2138265Smckusick #include "ucred.h" 2249232Smckusick #include "buf.h" 2337488Smckusick #include "errno.h" 2439433Smckusick #include "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; 14037488Smckusick vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid = 14137488Smckusick vap->va_fsid = vap->va_fileid = vap->va_size = 14240643Smckusick vap->va_size_rsv = vap->va_blocksize = vap->va_rdev = 14340643Smckusick vap->va_bytes = vap->va_bytes_rsv = 14437488Smckusick vap->va_atime.tv_sec = vap->va_atime.tv_usec = 14537488Smckusick vap->va_mtime.tv_sec = vap->va_mtime.tv_usec = 14638258Smckusick vap->va_ctime.tv_sec = vap->va_ctime.tv_usec = 14738258Smckusick vap->va_flags = vap->va_gen = VNOVAL; 14837488Smckusick } 14938265Smckusick 15038265Smckusick /* 15139397Smckusick * Routines having to do with the management of the vnode table. 15239397Smckusick */ 15339397Smckusick struct vnode *vfreeh, **vfreet; 15439447Smckusick extern struct vnodeops dead_vnodeops, spec_vnodeops; 15539635Smckusick extern void vclean(); 15640883Smckusick long numvnodes; 15741363Smckusick struct vattr va_null; 15839397Smckusick 15939397Smckusick /* 16039433Smckusick * Initialize the vnode structures and initialize each file system type. 16139397Smckusick */ 16239433Smckusick vfsinit() 16339397Smckusick { 16439433Smckusick struct vfsops **vfsp; 16539397Smckusick 16639433Smckusick /* 16739433Smckusick * Initialize the vnode name cache 16839433Smckusick */ 16939433Smckusick nchinit(); 17039433Smckusick /* 17139433Smckusick * Initialize each file system type. 17239433Smckusick */ 17341363Smckusick vattr_null(&va_null); 17439433Smckusick for (vfsp = &vfssw[0]; vfsp <= &vfssw[MOUNT_MAXTYPE]; vfsp++) { 17539433Smckusick if (*vfsp == NULL) 17639433Smckusick continue; 17739433Smckusick (*(*vfsp)->vfs_init)(); 17839433Smckusick } 17939397Smckusick } 18039397Smckusick 18139397Smckusick /* 18239397Smckusick * Return the next vnode from the free list. 18339397Smckusick */ 18439397Smckusick getnewvnode(tag, mp, vops, vpp) 18539397Smckusick enum vtagtype tag; 18639397Smckusick struct mount *mp; 18739397Smckusick struct vnodeops *vops; 18839397Smckusick struct vnode **vpp; 18939397Smckusick { 19039397Smckusick register struct vnode *vp, *vq; 19139397Smckusick 19240883Smckusick if (numvnodes < desiredvnodes) { 19345118Smckusick vp = (struct vnode *)malloc((u_long)sizeof *vp, 19445118Smckusick M_VNODE, M_WAITOK); 19540883Smckusick bzero((char *)vp, sizeof *vp); 19640883Smckusick numvnodes++; 19740883Smckusick } else { 19840883Smckusick if ((vp = vfreeh) == NULL) { 19940883Smckusick tablefull("vnode"); 20040883Smckusick *vpp = 0; 20140883Smckusick return (ENFILE); 20240883Smckusick } 20340883Smckusick if (vp->v_usecount) 20440883Smckusick panic("free vnode isn't"); 20540883Smckusick if (vq = vp->v_freef) 20640883Smckusick vq->v_freeb = &vfreeh; 20740883Smckusick else 20840883Smckusick vfreet = &vfreeh; 20940883Smckusick vfreeh = vq; 21040883Smckusick vp->v_freef = NULL; 21140883Smckusick vp->v_freeb = NULL; 21240883Smckusick if (vp->v_type != VBAD) 21340883Smckusick vgone(vp); 21440883Smckusick vp->v_flag = 0; 21540883Smckusick vp->v_lastr = 0; 21640883Smckusick vp->v_socket = 0; 21739397Smckusick } 21839512Smckusick vp->v_type = VNON; 21939397Smckusick cache_purge(vp); 22039397Smckusick vp->v_tag = tag; 22139433Smckusick vp->v_op = vops; 22239397Smckusick insmntque(vp, mp); 22339397Smckusick VREF(vp); 22439397Smckusick *vpp = vp; 22539397Smckusick return (0); 22639397Smckusick } 22739397Smckusick 22839397Smckusick /* 22939397Smckusick * Move a vnode from one mount queue to another. 23039397Smckusick */ 23139397Smckusick insmntque(vp, mp) 23239397Smckusick register struct vnode *vp; 23339397Smckusick register struct mount *mp; 23439397Smckusick { 23539397Smckusick struct vnode *vq; 23639397Smckusick 23739397Smckusick /* 23839397Smckusick * Delete from old mount point vnode list, if on one. 23939397Smckusick */ 24039397Smckusick if (vp->v_mountb) { 24139397Smckusick if (vq = vp->v_mountf) 24239397Smckusick vq->v_mountb = vp->v_mountb; 24339397Smckusick *vp->v_mountb = vq; 24439397Smckusick } 24539397Smckusick /* 24639397Smckusick * Insert into list of vnodes for the new mount point, if available. 24739397Smckusick */ 24839621Smckusick vp->v_mount = mp; 24939397Smckusick if (mp == NULL) { 25039397Smckusick vp->v_mountf = NULL; 25139397Smckusick vp->v_mountb = NULL; 25239397Smckusick return; 25339397Smckusick } 25441400Smckusick if (mp->mnt_mounth) { 25541400Smckusick vp->v_mountf = mp->mnt_mounth; 25641400Smckusick vp->v_mountb = &mp->mnt_mounth; 25741400Smckusick mp->mnt_mounth->v_mountb = &vp->v_mountf; 25841400Smckusick mp->mnt_mounth = vp; 25939397Smckusick } else { 26041400Smckusick mp->mnt_mounth = vp; 26141400Smckusick vp->v_mountb = &mp->mnt_mounth; 26239397Smckusick vp->v_mountf = NULL; 26339397Smckusick } 26439397Smckusick } 26539397Smckusick 26639397Smckusick /* 26749232Smckusick * Make sure all write-behind blocks associated 26849232Smckusick * with mount point are flushed out (from sync). 26949232Smckusick */ 27049232Smckusick mntflushbuf(mountp, flags) 27149232Smckusick struct mount *mountp; 27249232Smckusick int flags; 27349232Smckusick { 27449232Smckusick register struct vnode *vp; 27549232Smckusick 27649232Smckusick if ((mountp->mnt_flag & MNT_MPBUSY) == 0) 27749232Smckusick panic("mntflushbuf: not busy"); 27849232Smckusick loop: 27949232Smckusick for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) { 28049232Smckusick if (VOP_ISLOCKED(vp)) 28149232Smckusick continue; 28249232Smckusick if (vget(vp)) 28349232Smckusick goto loop; 28449232Smckusick vflushbuf(vp, flags); 28549232Smckusick vput(vp); 28649232Smckusick if (vp->v_mount != mountp) 28749232Smckusick goto loop; 28849232Smckusick } 28949232Smckusick } 29049232Smckusick 29149232Smckusick /* 29249232Smckusick * Flush all dirty buffers associated with a vnode. 29349232Smckusick */ 29449232Smckusick vflushbuf(vp, flags) 29549232Smckusick register struct vnode *vp; 29649232Smckusick int flags; 29749232Smckusick { 29849232Smckusick register struct buf *bp; 29949232Smckusick struct buf *nbp; 30049232Smckusick int s; 30149232Smckusick 30249232Smckusick loop: 30349232Smckusick s = splbio(); 30449232Smckusick for (bp = vp->v_dirtyblkhd; bp; bp = nbp) { 30549232Smckusick nbp = bp->b_blockf; 30649232Smckusick if ((bp->b_flags & B_BUSY)) 30749232Smckusick continue; 30849232Smckusick if ((bp->b_flags & B_DELWRI) == 0) 30949232Smckusick panic("vflushbuf: not dirty"); 31049232Smckusick bremfree(bp); 31149232Smckusick bp->b_flags |= B_BUSY; 31249232Smckusick splx(s); 31349232Smckusick /* 31449232Smckusick * Wait for I/O associated with indirect blocks to complete, 31549232Smckusick * since there is no way to quickly wait for them below. 31649232Smckusick * NB: This is really specific to ufs, but is done here 31749232Smckusick * as it is easier and quicker. 31849232Smckusick */ 31949460Smckusick if (bp->b_vp == vp || (flags & B_SYNC) == 0) 32049232Smckusick (void) bawrite(bp); 32149460Smckusick else 32249232Smckusick (void) bwrite(bp); 32349460Smckusick goto loop; 32449232Smckusick } 32549232Smckusick splx(s); 32649232Smckusick if ((flags & B_SYNC) == 0) 32749232Smckusick return; 32849232Smckusick s = splbio(); 32949232Smckusick while (vp->v_numoutput) { 33049232Smckusick vp->v_flag |= VBWAIT; 33149232Smckusick sleep((caddr_t)&vp->v_numoutput, PRIBIO + 1); 33249232Smckusick } 33349232Smckusick splx(s); 33449232Smckusick if (vp->v_dirtyblkhd) { 33549232Smckusick vprint("vflushbuf: dirty", vp); 33649232Smckusick goto loop; 33749232Smckusick } 33849232Smckusick } 33949232Smckusick 34049232Smckusick /* 34149232Smckusick * Update outstanding I/O count and do wakeup if requested. 34249232Smckusick */ 34349232Smckusick vwakeup(bp) 34449232Smckusick register struct buf *bp; 34549232Smckusick { 34649232Smckusick register struct vnode *vp; 34749232Smckusick 34849232Smckusick bp->b_dirtyoff = bp->b_dirtyend = 0; 34949232Smckusick if (vp = bp->b_vp) { 35049232Smckusick vp->v_numoutput--; 35149232Smckusick if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) { 35249232Smckusick if (vp->v_numoutput < 0) 35349232Smckusick panic("vwakeup: neg numoutput"); 35449232Smckusick vp->v_flag &= ~VBWAIT; 35549232Smckusick wakeup((caddr_t)&vp->v_numoutput); 35649232Smckusick } 35749232Smckusick } 35849232Smckusick } 35949232Smckusick 36049232Smckusick /* 36149232Smckusick * Invalidate in core blocks belonging to closed or umounted filesystem 36249232Smckusick * 36349232Smckusick * Go through the list of vnodes associated with the file system; 36449232Smckusick * for each vnode invalidate any buffers that it holds. Normally 36549232Smckusick * this routine is preceeded by a bflush call, so that on a quiescent 36649232Smckusick * filesystem there will be no dirty buffers when we are done. Binval 36749232Smckusick * returns the count of dirty buffers when it is finished. 36849232Smckusick */ 36949232Smckusick mntinvalbuf(mountp) 37049232Smckusick struct mount *mountp; 37149232Smckusick { 37249232Smckusick register struct vnode *vp; 37349232Smckusick int dirty = 0; 37449232Smckusick 37549232Smckusick if ((mountp->mnt_flag & MNT_MPBUSY) == 0) 37649232Smckusick panic("mntinvalbuf: not busy"); 37749232Smckusick loop: 37849232Smckusick for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) { 37949232Smckusick if (vget(vp)) 38049232Smckusick goto loop; 38149232Smckusick dirty += vinvalbuf(vp, 1); 38249232Smckusick vput(vp); 38349232Smckusick if (vp->v_mount != mountp) 38449232Smckusick goto loop; 38549232Smckusick } 38649232Smckusick return (dirty); 38749232Smckusick } 38849232Smckusick 38949232Smckusick /* 39049232Smckusick * Flush out and invalidate all buffers associated with a vnode. 39149232Smckusick * Called with the underlying object locked. 39249232Smckusick */ 39349232Smckusick vinvalbuf(vp, save) 39449232Smckusick register struct vnode *vp; 39549232Smckusick int save; 39649232Smckusick { 39749232Smckusick register struct buf *bp; 39849232Smckusick struct buf *nbp, *blist; 39949232Smckusick int s, dirty = 0; 40049232Smckusick 40149232Smckusick for (;;) { 40249232Smckusick if (blist = vp->v_dirtyblkhd) 40349232Smckusick /* void */; 40449232Smckusick else if (blist = vp->v_cleanblkhd) 40549232Smckusick /* void */; 40649232Smckusick else 40749232Smckusick break; 40849232Smckusick for (bp = blist; bp; bp = nbp) { 40949232Smckusick nbp = bp->b_blockf; 41049232Smckusick s = splbio(); 41149232Smckusick if (bp->b_flags & B_BUSY) { 41249232Smckusick bp->b_flags |= B_WANTED; 41349232Smckusick sleep((caddr_t)bp, PRIBIO + 1); 41449232Smckusick splx(s); 41549232Smckusick break; 41649232Smckusick } 41749232Smckusick bremfree(bp); 41849232Smckusick bp->b_flags |= B_BUSY; 41949232Smckusick splx(s); 42049232Smckusick if (save && (bp->b_flags & B_DELWRI)) { 42149232Smckusick dirty++; 42249232Smckusick (void) bwrite(bp); 42349232Smckusick break; 42449232Smckusick } 42549232Smckusick if (bp->b_vp != vp) 42649232Smckusick reassignbuf(bp, bp->b_vp); 42749232Smckusick else 42849232Smckusick bp->b_flags |= B_INVAL; 42949232Smckusick brelse(bp); 43049232Smckusick } 43149232Smckusick } 43249232Smckusick if (vp->v_dirtyblkhd || vp->v_cleanblkhd) 43349232Smckusick panic("vinvalbuf: flush failed"); 43449232Smckusick return (dirty); 43549232Smckusick } 43649232Smckusick 43749232Smckusick /* 43849232Smckusick * Associate a buffer with a vnode. 43949232Smckusick */ 44049232Smckusick bgetvp(vp, bp) 44149232Smckusick register struct vnode *vp; 44249232Smckusick register struct buf *bp; 44349232Smckusick { 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 */ 45649232Smckusick if (vp->v_cleanblkhd) { 45749232Smckusick bp->b_blockf = vp->v_cleanblkhd; 45849232Smckusick bp->b_blockb = &vp->v_cleanblkhd; 45949232Smckusick vp->v_cleanblkhd->b_blockb = &bp->b_blockf; 46049232Smckusick vp->v_cleanblkhd = bp; 46149232Smckusick } else { 46249232Smckusick vp->v_cleanblkhd = bp; 46349232Smckusick bp->b_blockb = &vp->v_cleanblkhd; 46449232Smckusick bp->b_blockf = NULL; 46549232Smckusick } 46649232Smckusick } 46749232Smckusick 46849232Smckusick /* 46949232Smckusick * Disassociate a buffer from a vnode. 47049232Smckusick */ 47149232Smckusick brelvp(bp) 47249232Smckusick register struct buf *bp; 47349232Smckusick { 47449232Smckusick struct buf *bq; 47549232Smckusick struct vnode *vp; 47649232Smckusick 47749232Smckusick if (bp->b_vp == (struct vnode *) 0) 47849232Smckusick panic("brelvp: NULL"); 47949232Smckusick /* 48049232Smckusick * Delete from old vnode list, if on one. 48149232Smckusick */ 48249232Smckusick if (bp->b_blockb) { 48349232Smckusick if (bq = bp->b_blockf) 48449232Smckusick bq->b_blockb = bp->b_blockb; 48549232Smckusick *bp->b_blockb = bq; 48649232Smckusick bp->b_blockf = NULL; 48749232Smckusick bp->b_blockb = NULL; 48849232Smckusick } 48949232Smckusick vp = bp->b_vp; 49049232Smckusick bp->b_vp = (struct vnode *) 0; 49149232Smckusick HOLDRELE(vp); 49249232Smckusick } 49349232Smckusick 49449232Smckusick /* 49549232Smckusick * Reassign a buffer from one vnode to another. 49649232Smckusick * Used to assign file specific control information 49749232Smckusick * (indirect blocks) to the vnode to which they belong. 49849232Smckusick */ 49949232Smckusick reassignbuf(bp, newvp) 50049232Smckusick register struct buf *bp; 50149232Smckusick register struct vnode *newvp; 50249232Smckusick { 50349232Smckusick register struct buf *bq, **listheadp; 50449232Smckusick 50549232Smckusick if (newvp == NULL) 50649232Smckusick panic("reassignbuf: NULL"); 50749232Smckusick /* 50849232Smckusick * Delete from old vnode list, if on one. 50949232Smckusick */ 51049232Smckusick if (bp->b_blockb) { 51149232Smckusick if (bq = bp->b_blockf) 51249232Smckusick bq->b_blockb = bp->b_blockb; 51349232Smckusick *bp->b_blockb = bq; 51449232Smckusick } 51549232Smckusick /* 51649232Smckusick * If dirty, put on list of dirty buffers; 51749232Smckusick * otherwise insert onto list of clean buffers. 51849232Smckusick */ 51949232Smckusick if (bp->b_flags & B_DELWRI) 52049232Smckusick listheadp = &newvp->v_dirtyblkhd; 52149232Smckusick else 52249232Smckusick listheadp = &newvp->v_cleanblkhd; 52349232Smckusick if (*listheadp) { 52449232Smckusick bp->b_blockf = *listheadp; 52549232Smckusick bp->b_blockb = listheadp; 52649232Smckusick bp->b_blockf->b_blockb = &bp->b_blockf; 52749232Smckusick *listheadp = bp; 52849232Smckusick } else { 52949232Smckusick *listheadp = bp; 53049232Smckusick bp->b_blockb = listheadp; 53149232Smckusick bp->b_blockf = NULL; 53249232Smckusick } 53349232Smckusick } 53449232Smckusick 53549232Smckusick /* 53639433Smckusick * Create a vnode for a block device. 53739433Smckusick * Used for root filesystem, argdev, and swap areas. 53839433Smckusick * Also used for memory file system special devices. 53939397Smckusick */ 54039433Smckusick bdevvp(dev, vpp) 54139433Smckusick dev_t dev; 54239433Smckusick struct vnode **vpp; 54339433Smckusick { 54439433Smckusick register struct vnode *vp; 54539433Smckusick struct vnode *nvp; 54639433Smckusick int error; 54739433Smckusick 54846989Smckusick if (dev == NODEV) 54946989Smckusick return (0); 55039447Smckusick error = getnewvnode(VT_NON, (struct mount *)0, &spec_vnodeops, &nvp); 55139433Smckusick if (error) { 55239433Smckusick *vpp = 0; 55339433Smckusick return (error); 55439433Smckusick } 55539433Smckusick vp = nvp; 55639433Smckusick vp->v_type = VBLK; 55739615Smckusick if (nvp = checkalias(vp, dev, (struct mount *)0)) { 55839433Smckusick vput(vp); 55939433Smckusick vp = nvp; 56039433Smckusick } 56139433Smckusick *vpp = vp; 56239433Smckusick return (0); 56339433Smckusick } 56439433Smckusick 56539433Smckusick /* 56639433Smckusick * Check to see if the new vnode represents a special device 56739433Smckusick * for which we already have a vnode (either because of 56839433Smckusick * bdevvp() or because of a different vnode representing 56939433Smckusick * the same block device). If such an alias exists, deallocate 57039509Smckusick * the existing contents and return the aliased vnode. The 57139433Smckusick * caller is responsible for filling it with its new contents. 57239433Smckusick */ 57339433Smckusick struct vnode * 57439615Smckusick checkalias(nvp, nvp_rdev, mp) 57539433Smckusick register struct vnode *nvp; 57639615Smckusick dev_t nvp_rdev; 57739433Smckusick struct mount *mp; 57839433Smckusick { 57939433Smckusick register struct vnode *vp; 58039615Smckusick struct vnode **vpp; 58139433Smckusick 58239433Smckusick if (nvp->v_type != VBLK && nvp->v_type != VCHR) 58341400Smckusick return (NULLVP); 58439615Smckusick 58539615Smckusick vpp = &speclisth[SPECHASH(nvp_rdev)]; 58639433Smckusick loop: 58739615Smckusick for (vp = *vpp; vp; vp = vp->v_specnext) { 58839615Smckusick if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type) 58939433Smckusick continue; 59039615Smckusick /* 59139615Smckusick * Alias, but not in use, so flush it out. 59239615Smckusick */ 59339809Smckusick if (vp->v_usecount == 0) { 59439615Smckusick vgone(vp); 59539615Smckusick goto loop; 59639615Smckusick } 59739633Smckusick if (vget(vp)) 59839633Smckusick goto loop; 59939433Smckusick break; 60039433Smckusick } 60139615Smckusick if (vp == NULL || vp->v_tag != VT_NON) { 60239615Smckusick MALLOC(nvp->v_specinfo, struct specinfo *, 60339615Smckusick sizeof(struct specinfo), M_VNODE, M_WAITOK); 60439615Smckusick nvp->v_rdev = nvp_rdev; 60539809Smckusick nvp->v_hashchain = vpp; 60639615Smckusick nvp->v_specnext = *vpp; 60742152Smckusick nvp->v_specflags = 0; 60839615Smckusick *vpp = nvp; 60940640Smckusick if (vp != NULL) { 61040640Smckusick nvp->v_flag |= VALIASED; 61140640Smckusick vp->v_flag |= VALIASED; 61240640Smckusick vput(vp); 61340640Smckusick } 61441400Smckusick return (NULLVP); 61539433Smckusick } 61639484Smckusick VOP_UNLOCK(vp); 61739484Smckusick vclean(vp, 0); 61839433Smckusick vp->v_op = nvp->v_op; 61939433Smckusick vp->v_tag = nvp->v_tag; 62039433Smckusick nvp->v_type = VNON; 62139433Smckusick insmntque(vp, mp); 62239433Smckusick return (vp); 62339433Smckusick } 62439433Smckusick 62539433Smckusick /* 62639433Smckusick * Grab a particular vnode from the free list, increment its 62739433Smckusick * reference count and lock it. The vnode lock bit is set the 62839433Smckusick * vnode is being eliminated in vgone. The process is awakened 62939433Smckusick * when the transition is completed, and an error returned to 63039433Smckusick * indicate that the vnode is no longer usable (possibly having 63139433Smckusick * been changed to a new file system type). 63239433Smckusick */ 63339397Smckusick vget(vp) 63439397Smckusick register struct vnode *vp; 63539397Smckusick { 63639397Smckusick register struct vnode *vq; 63739397Smckusick 63839433Smckusick if (vp->v_flag & VXLOCK) { 63939433Smckusick vp->v_flag |= VXWANT; 64039433Smckusick sleep((caddr_t)vp, PINOD); 64139433Smckusick return (1); 64239433Smckusick } 64339809Smckusick if (vp->v_usecount == 0) { 64439433Smckusick if (vq = vp->v_freef) 64539433Smckusick vq->v_freeb = vp->v_freeb; 64639433Smckusick else 64739433Smckusick vfreet = vp->v_freeb; 64839433Smckusick *vp->v_freeb = vq; 64939433Smckusick vp->v_freef = NULL; 65039433Smckusick vp->v_freeb = NULL; 65139433Smckusick } 65239397Smckusick VREF(vp); 65339433Smckusick VOP_LOCK(vp); 65439433Smckusick return (0); 65539397Smckusick } 65639397Smckusick 65739397Smckusick /* 65839397Smckusick * Vnode reference, just increment the count 65939397Smckusick */ 66039397Smckusick void vref(vp) 66139397Smckusick struct vnode *vp; 66239397Smckusick { 66339397Smckusick 66439809Smckusick vp->v_usecount++; 66539397Smckusick } 66639397Smckusick 66739397Smckusick /* 66839397Smckusick * vput(), just unlock and vrele() 66939397Smckusick */ 67039397Smckusick void vput(vp) 67139397Smckusick register struct vnode *vp; 67239397Smckusick { 67339397Smckusick VOP_UNLOCK(vp); 67439397Smckusick vrele(vp); 67539397Smckusick } 67639397Smckusick 67739397Smckusick /* 67839397Smckusick * Vnode release. 67939397Smckusick * If count drops to zero, call inactive routine and return to freelist. 68039397Smckusick */ 68139397Smckusick void vrele(vp) 68239397Smckusick register struct vnode *vp; 68339397Smckusick { 68448024Smckusick struct proc *p = curproc; /* XXX */ 68539397Smckusick 68639397Smckusick if (vp == NULL) 68739433Smckusick panic("vrele: null vp"); 68839809Smckusick vp->v_usecount--; 68939809Smckusick if (vp->v_usecount < 0) 69039667Smckusick vprint("vrele: bad ref count", vp); 69139809Smckusick if (vp->v_usecount > 0) 69239397Smckusick return; 69341400Smckusick if (vfreeh == NULLVP) { 69439397Smckusick /* 69539397Smckusick * insert into empty list 69639397Smckusick */ 69739397Smckusick vfreeh = vp; 69839397Smckusick vp->v_freeb = &vfreeh; 69939397Smckusick } else { 70039397Smckusick /* 70139397Smckusick * insert at tail of list 70239397Smckusick */ 70339397Smckusick *vfreet = vp; 70439397Smckusick vp->v_freeb = vfreet; 70539397Smckusick } 70639433Smckusick vp->v_freef = NULL; 70739433Smckusick vfreet = &vp->v_freef; 70848024Smckusick VOP_INACTIVE(vp, p); 70939397Smckusick } 71039433Smckusick 71139433Smckusick /* 71239809Smckusick * Page or buffer structure gets a reference. 71339809Smckusick */ 71439809Smckusick vhold(vp) 71539809Smckusick register struct vnode *vp; 71639809Smckusick { 71739809Smckusick 71839809Smckusick vp->v_holdcnt++; 71939809Smckusick } 72039809Smckusick 72139809Smckusick /* 72239809Smckusick * Page or buffer structure frees a reference. 72339809Smckusick */ 72439809Smckusick holdrele(vp) 72539809Smckusick register struct vnode *vp; 72639809Smckusick { 72739809Smckusick 72839809Smckusick if (vp->v_holdcnt <= 0) 72939809Smckusick panic("holdrele: holdcnt"); 73039809Smckusick vp->v_holdcnt--; 73139809Smckusick } 73239809Smckusick 73339809Smckusick /* 73439509Smckusick * Remove any vnodes in the vnode table belonging to mount point mp. 73539509Smckusick * 73639509Smckusick * If MNT_NOFORCE is specified, there should not be any active ones, 73739509Smckusick * return error if any are found (nb: this is a user error, not a 73839509Smckusick * system error). If MNT_FORCE is specified, detach any active vnodes 73939509Smckusick * that are found. 74039509Smckusick */ 74139509Smckusick int busyprt = 0; /* patch to print out busy vnodes */ 74239509Smckusick 74339509Smckusick vflush(mp, skipvp, flags) 74439509Smckusick struct mount *mp; 74539509Smckusick struct vnode *skipvp; 74639509Smckusick int flags; 74739509Smckusick { 74839509Smckusick register struct vnode *vp, *nvp; 74939509Smckusick int busy = 0; 75039509Smckusick 75141400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 75241300Smckusick panic("vflush: not busy"); 75341421Smckusick loop: 75441400Smckusick for (vp = mp->mnt_mounth; vp; vp = nvp) { 75541421Smckusick if (vp->v_mount != mp) 75641421Smckusick goto loop; 75739509Smckusick nvp = vp->v_mountf; 75839509Smckusick /* 75939509Smckusick * Skip over a selected vnode. 76039509Smckusick */ 76139509Smckusick if (vp == skipvp) 76239509Smckusick continue; 76339509Smckusick /* 76441300Smckusick * Skip over a vnodes marked VSYSTEM. 76541300Smckusick */ 76641300Smckusick if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) 76741300Smckusick continue; 76841300Smckusick /* 76939809Smckusick * With v_usecount == 0, all we need to do is clear 77039509Smckusick * out the vnode data structures and we are done. 77139509Smckusick */ 77239809Smckusick if (vp->v_usecount == 0) { 77339509Smckusick vgone(vp); 77439509Smckusick continue; 77539509Smckusick } 77639509Smckusick /* 77739509Smckusick * For block or character devices, revert to an 77839509Smckusick * anonymous device. For all other files, just kill them. 77939509Smckusick */ 78041300Smckusick if (flags & FORCECLOSE) { 78139509Smckusick if (vp->v_type != VBLK && vp->v_type != VCHR) { 78239509Smckusick vgone(vp); 78339509Smckusick } else { 78439509Smckusick vclean(vp, 0); 78539509Smckusick vp->v_op = &spec_vnodeops; 78639509Smckusick insmntque(vp, (struct mount *)0); 78739509Smckusick } 78839509Smckusick continue; 78939509Smckusick } 79039509Smckusick if (busyprt) 79139667Smckusick vprint("vflush: busy vnode", vp); 79239509Smckusick busy++; 79339509Smckusick } 79439509Smckusick if (busy) 79539509Smckusick return (EBUSY); 79639509Smckusick return (0); 79739509Smckusick } 79839509Smckusick 79939509Smckusick /* 80039433Smckusick * Disassociate the underlying file system from a vnode. 80139433Smckusick */ 80241300Smckusick void vclean(vp, flags) 80339433Smckusick register struct vnode *vp; 80445118Smckusick int flags; 80539433Smckusick { 80639433Smckusick struct vnodeops *origops; 80739484Smckusick int active; 80848024Smckusick struct proc *p = curproc; /* XXX */ 80939433Smckusick 81039484Smckusick /* 81139484Smckusick * Check to see if the vnode is in use. 81239667Smckusick * If so we have to reference it before we clean it out 81339667Smckusick * so that its count cannot fall to zero and generate a 81439667Smckusick * race against ourselves to recycle it. 81539484Smckusick */ 81639809Smckusick if (active = vp->v_usecount) 81739484Smckusick VREF(vp); 81839484Smckusick /* 81939484Smckusick * Prevent the vnode from being recycled or 82039484Smckusick * brought into use while we clean it out. 82139484Smckusick */ 82239667Smckusick if (vp->v_flag & VXLOCK) 82339667Smckusick panic("vclean: deadlock"); 82439433Smckusick vp->v_flag |= VXLOCK; 82539433Smckusick /* 82639667Smckusick * Even if the count is zero, the VOP_INACTIVE routine may still 82739667Smckusick * have the object locked while it cleans it out. The VOP_LOCK 82839667Smckusick * ensures that the VOP_INACTIVE routine is done with its work. 82939667Smckusick * For active vnodes, it ensures that no other activity can 83039667Smckusick * occur while the buffer list is being cleaned out. 83139667Smckusick */ 83239667Smckusick VOP_LOCK(vp); 83341300Smckusick if (flags & DOCLOSE) 83439667Smckusick vinvalbuf(vp, 1); 83539667Smckusick /* 83639433Smckusick * Prevent any further operations on the vnode from 83739433Smckusick * being passed through to the old file system. 83839433Smckusick */ 83939433Smckusick origops = vp->v_op; 84039433Smckusick vp->v_op = &dead_vnodeops; 84139433Smckusick vp->v_tag = VT_NON; 84239433Smckusick /* 84339484Smckusick * If purging an active vnode, it must be unlocked, closed, 84439484Smckusick * and deactivated before being reclaimed. 84539433Smckusick */ 846*49761Smckusick (*(origops->vop_unlock))(vp); 84739484Smckusick if (active) { 84841300Smckusick if (flags & DOCLOSE) 849*49761Smckusick (*(origops->vop_close))(vp, IO_NDELAY, NOCRED, p); 850*49761Smckusick (*(origops->vop_inactive))(vp, p); 85139433Smckusick } 85239433Smckusick /* 85339433Smckusick * Reclaim the vnode. 85439433Smckusick */ 855*49761Smckusick if ((*(origops->vop_reclaim))(vp)) 85639433Smckusick panic("vclean: cannot reclaim"); 85739484Smckusick if (active) 85839484Smckusick vrele(vp); 85939433Smckusick /* 86039433Smckusick * Done with purge, notify sleepers in vget of the grim news. 86139433Smckusick */ 86239433Smckusick vp->v_flag &= ~VXLOCK; 86339433Smckusick if (vp->v_flag & VXWANT) { 86439433Smckusick vp->v_flag &= ~VXWANT; 86539433Smckusick wakeup((caddr_t)vp); 86639433Smckusick } 86739433Smckusick } 86839433Smckusick 86939433Smckusick /* 87039633Smckusick * Eliminate all activity associated with the requested vnode 87139633Smckusick * and with all vnodes aliased to the requested vnode. 87239633Smckusick */ 87339633Smckusick void vgoneall(vp) 87439633Smckusick register struct vnode *vp; 87539633Smckusick { 87639809Smckusick register struct vnode *vq; 87739633Smckusick 87840665Smckusick if (vp->v_flag & VALIASED) { 87940665Smckusick /* 88040665Smckusick * If a vgone (or vclean) is already in progress, 88140665Smckusick * wait until it is done and return. 88240665Smckusick */ 88340665Smckusick if (vp->v_flag & VXLOCK) { 88440665Smckusick vp->v_flag |= VXWANT; 88540665Smckusick sleep((caddr_t)vp, PINOD); 88640665Smckusick return; 88739633Smckusick } 88840665Smckusick /* 88940665Smckusick * Ensure that vp will not be vgone'd while we 89040665Smckusick * are eliminating its aliases. 89140665Smckusick */ 89240665Smckusick vp->v_flag |= VXLOCK; 89340665Smckusick while (vp->v_flag & VALIASED) { 89440665Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 89540665Smckusick if (vq->v_rdev != vp->v_rdev || 89640665Smckusick vq->v_type != vp->v_type || vp == vq) 89740665Smckusick continue; 89840665Smckusick vgone(vq); 89940665Smckusick break; 90040665Smckusick } 90140665Smckusick } 90240665Smckusick /* 90340665Smckusick * Remove the lock so that vgone below will 90440665Smckusick * really eliminate the vnode after which time 90540665Smckusick * vgone will awaken any sleepers. 90640665Smckusick */ 90740665Smckusick vp->v_flag &= ~VXLOCK; 90839633Smckusick } 90939633Smckusick vgone(vp); 91039633Smckusick } 91139633Smckusick 91239633Smckusick /* 91339433Smckusick * Eliminate all activity associated with a vnode 91439433Smckusick * in preparation for reuse. 91539433Smckusick */ 91639433Smckusick void vgone(vp) 91739433Smckusick register struct vnode *vp; 91839433Smckusick { 91939809Smckusick register struct vnode *vq; 92039615Smckusick struct vnode *vx; 92139615Smckusick long count; 92239433Smckusick 92339433Smckusick /* 92440548Smckusick * If a vgone (or vclean) is already in progress, 92540548Smckusick * wait until it is done and return. 92640548Smckusick */ 92740548Smckusick if (vp->v_flag & VXLOCK) { 92840548Smckusick vp->v_flag |= VXWANT; 92940548Smckusick sleep((caddr_t)vp, PINOD); 93040548Smckusick return; 93140548Smckusick } 93240548Smckusick /* 93339433Smckusick * Clean out the filesystem specific data. 93439433Smckusick */ 93541300Smckusick vclean(vp, DOCLOSE); 93639433Smckusick /* 93739433Smckusick * Delete from old mount point vnode list, if on one. 93839433Smckusick */ 93939433Smckusick if (vp->v_mountb) { 94039433Smckusick if (vq = vp->v_mountf) 94139433Smckusick vq->v_mountb = vp->v_mountb; 94239433Smckusick *vp->v_mountb = vq; 94339433Smckusick vp->v_mountf = NULL; 94439433Smckusick vp->v_mountb = NULL; 94539433Smckusick } 94639433Smckusick /* 94739433Smckusick * If special device, remove it from special device alias list. 94839433Smckusick */ 94939433Smckusick if (vp->v_type == VBLK || vp->v_type == VCHR) { 95039809Smckusick if (*vp->v_hashchain == vp) { 95139809Smckusick *vp->v_hashchain = vp->v_specnext; 95239433Smckusick } else { 95339809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 95439615Smckusick if (vq->v_specnext != vp) 95539433Smckusick continue; 95639615Smckusick vq->v_specnext = vp->v_specnext; 95739433Smckusick break; 95839433Smckusick } 95939615Smckusick if (vq == NULL) 96039433Smckusick panic("missing bdev"); 96139433Smckusick } 96239615Smckusick if (vp->v_flag & VALIASED) { 96339809Smckusick count = 0; 96439809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 96540108Smckusick if (vq->v_rdev != vp->v_rdev || 96640108Smckusick vq->v_type != vp->v_type) 96739615Smckusick continue; 96839615Smckusick count++; 96939615Smckusick vx = vq; 97039615Smckusick } 97139615Smckusick if (count == 0) 97239615Smckusick panic("missing alias"); 97339615Smckusick if (count == 1) 97439615Smckusick vx->v_flag &= ~VALIASED; 97539615Smckusick vp->v_flag &= ~VALIASED; 97639615Smckusick } 97739615Smckusick FREE(vp->v_specinfo, M_VNODE); 97839615Smckusick vp->v_specinfo = NULL; 97939433Smckusick } 98039433Smckusick /* 98139433Smckusick * If it is on the freelist, move it to the head of the list. 98239433Smckusick */ 98339433Smckusick if (vp->v_freeb) { 98439433Smckusick if (vq = vp->v_freef) 98539433Smckusick vq->v_freeb = vp->v_freeb; 98639433Smckusick else 98739433Smckusick vfreet = vp->v_freeb; 98839433Smckusick *vp->v_freeb = vq; 98939433Smckusick vp->v_freef = vfreeh; 99039433Smckusick vp->v_freeb = &vfreeh; 99139433Smckusick vfreeh->v_freeb = &vp->v_freef; 99239433Smckusick vfreeh = vp; 99339433Smckusick } 99439484Smckusick vp->v_type = VBAD; 99539433Smckusick } 99639633Smckusick 99739633Smckusick /* 99839821Smckusick * Lookup a vnode by device number. 99939821Smckusick */ 100039821Smckusick vfinddev(dev, type, vpp) 100139821Smckusick dev_t dev; 100239821Smckusick enum vtype type; 100339821Smckusick struct vnode **vpp; 100439821Smckusick { 100539821Smckusick register struct vnode *vp; 100639821Smckusick 100739821Smckusick for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) { 100839821Smckusick if (dev != vp->v_rdev || type != vp->v_type) 100939821Smckusick continue; 101039821Smckusick *vpp = vp; 101139821Smckusick return (0); 101239821Smckusick } 101339821Smckusick return (1); 101439821Smckusick } 101539821Smckusick 101639821Smckusick /* 101739633Smckusick * Calculate the total number of references to a special device. 101839633Smckusick */ 101939633Smckusick vcount(vp) 102039633Smckusick register struct vnode *vp; 102139633Smckusick { 102239809Smckusick register struct vnode *vq; 102339633Smckusick int count; 102439633Smckusick 102539633Smckusick if ((vp->v_flag & VALIASED) == 0) 102639809Smckusick return (vp->v_usecount); 102739633Smckusick loop: 102839809Smckusick for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 102940108Smckusick if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type) 103039633Smckusick continue; 103139633Smckusick /* 103239633Smckusick * Alias, but not in use, so flush it out. 103339633Smckusick */ 103439809Smckusick if (vq->v_usecount == 0) { 103539633Smckusick vgone(vq); 103639633Smckusick goto loop; 103739633Smckusick } 103839809Smckusick count += vq->v_usecount; 103939633Smckusick } 104039633Smckusick return (count); 104139633Smckusick } 104239667Smckusick 104339667Smckusick /* 104439667Smckusick * Print out a description of a vnode. 104539667Smckusick */ 104639667Smckusick static char *typename[] = 104740286Smckusick { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" }; 104839667Smckusick 104939667Smckusick vprint(label, vp) 105039667Smckusick char *label; 105139667Smckusick register struct vnode *vp; 105239667Smckusick { 105339913Smckusick char buf[64]; 105439667Smckusick 105539667Smckusick if (label != NULL) 105639667Smckusick printf("%s: ", label); 105739913Smckusick printf("type %s, usecount %d, refcount %d,", typename[vp->v_type], 105839809Smckusick vp->v_usecount, vp->v_holdcnt); 105939913Smckusick buf[0] = '\0'; 106039913Smckusick if (vp->v_flag & VROOT) 106139913Smckusick strcat(buf, "|VROOT"); 106239913Smckusick if (vp->v_flag & VTEXT) 106339913Smckusick strcat(buf, "|VTEXT"); 106441300Smckusick if (vp->v_flag & VSYSTEM) 106541300Smckusick strcat(buf, "|VSYSTEM"); 106641300Smckusick if (vp->v_flag & VXLOCK) 106741300Smckusick strcat(buf, "|VXLOCK"); 106841300Smckusick if (vp->v_flag & VXWANT) 106941300Smckusick strcat(buf, "|VXWANT"); 107041300Smckusick if (vp->v_flag & VBWAIT) 107141300Smckusick strcat(buf, "|VBWAIT"); 107239913Smckusick if (vp->v_flag & VALIASED) 107339913Smckusick strcat(buf, "|VALIASED"); 107439913Smckusick if (buf[0] != '\0') 107539913Smckusick printf(" flags (%s)", &buf[1]); 107639913Smckusick printf("\n\t"); 107739667Smckusick VOP_PRINT(vp); 107839667Smckusick } 107941110Smarc 108049691Smckusick #ifdef DEBUG 108149691Smckusick /* 108249691Smckusick * List all of the locked vnodes in the system. 108349691Smckusick * Called when debugging the kernel. 108449691Smckusick */ 108549691Smckusick printlockedvnodes() 108649691Smckusick { 108749691Smckusick register struct mount *mp; 108849691Smckusick register struct vnode *vp; 108949691Smckusick 109049691Smckusick printf("Locked vnodes\n"); 109149691Smckusick mp = rootfs; 109249691Smckusick do { 109349691Smckusick for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) 109449691Smckusick if (VOP_ISLOCKED(vp)) 109549691Smckusick vprint((char *)0, vp); 109649691Smckusick mp = mp->mnt_next; 109749691Smckusick } while (mp != rootfs); 109849691Smckusick } 109949691Smckusick #endif 110049691Smckusick 110141110Smarc int kinfo_vdebug = 1; 110241110Smarc int kinfo_vgetfailed; 110341110Smarc #define KINFO_VNODESLOP 10 110441110Smarc /* 110541110Smarc * Dump vnode list (via kinfo). 110641110Smarc * Copyout address of vnode followed by vnode. 110741110Smarc */ 110845118Smckusick /* ARGSUSED */ 110941110Smarc kinfo_vnode(op, where, acopysize, arg, aneeded) 111045118Smckusick int op; 111141110Smarc char *where; 111245118Smckusick int *acopysize, arg, *aneeded; 111341110Smarc { 111441110Smarc register struct mount *mp = rootfs; 111541300Smckusick struct mount *omp; 111641110Smarc struct vnode *vp; 111741110Smarc register char *bp = where, *savebp; 111841110Smarc char *ewhere = where + *acopysize; 111941110Smarc int error; 112041110Smarc 112141110Smarc #define VPTRSZ sizeof (struct vnode *) 112241110Smarc #define VNODESZ sizeof (struct vnode) 112341110Smarc if (where == NULL) { 112441110Smarc *aneeded = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ); 112541110Smarc return (0); 112641110Smarc } 112741110Smarc 112841110Smarc do { 112941300Smckusick if (vfs_busy(mp)) { 113041400Smckusick mp = mp->mnt_next; 113141300Smckusick continue; 113241300Smckusick } 113341110Smarc savebp = bp; 113441110Smarc again: 113541421Smckusick for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) { 113641422Smckusick /* 113741422Smckusick * Check that the vp is still associated with 113841422Smckusick * this filesystem. RACE: could have been 113941422Smckusick * recycled onto the same filesystem. 114041422Smckusick */ 114141421Smckusick if (vp->v_mount != mp) { 114241421Smckusick if (kinfo_vdebug) 114341421Smckusick printf("kinfo: vp changed\n"); 114441421Smckusick bp = savebp; 114541421Smckusick goto again; 114641421Smckusick } 114741110Smarc if ((bp + VPTRSZ + VNODESZ <= ewhere) && 114841110Smarc ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) || 114941110Smarc (error = copyout((caddr_t)vp, bp + VPTRSZ, 115041422Smckusick VNODESZ)))) 115141110Smarc return (error); 115241110Smarc bp += VPTRSZ + VNODESZ; 115341110Smarc } 115441300Smckusick omp = mp; 115541400Smckusick mp = mp->mnt_next; 115641300Smckusick vfs_unbusy(omp); 115741110Smarc } while (mp != rootfs); 115841110Smarc 115941110Smarc *aneeded = bp - where; 116041110Smarc if (bp > ewhere) 116141110Smarc *acopysize = ewhere - where; 116241110Smarc else 116341110Smarc *acopysize = bp - where; 116441110Smarc return (0); 116541110Smarc } 1166