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