xref: /csrg-svn/sys/kern/vfs_subr.c (revision 52005)
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