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