xref: /csrg-svn/sys/kern/vfs_subr.c (revision 63180)
137488Smckusick /*
2*63180Sbostic  * Copyright (c) 1989, 1993
3*63180Sbostic  *	The Regents of the University of California.  All rights reserved.
437488Smckusick  *
544458Sbostic  * %sccs.include.redist.c%
637488Smckusick  *
7*63180Sbostic  *	@(#)vfs_subr.c	8.1 (Berkeley) 06/10/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  */
4456608Smckusick #define	bufinsvn(bp, dp)	list_enter_head(dp, bp, struct buf *, b_vnbufs)
4556608Smckusick #define	bufremvn(bp)		list_remove(bp, struct buf *, b_vnbufs)
4656608Smckusick 
4756608Smckusick /*
4837488Smckusick  * Remove a mount point from the list of mounted filesystems.
4937488Smckusick  * Unmount of the root is illegal.
5037488Smckusick  */
5137488Smckusick void
5237488Smckusick vfs_remove(mp)
5337488Smckusick 	register struct mount *mp;
5437488Smckusick {
5537488Smckusick 
5637488Smckusick 	if (mp == rootfs)
5737488Smckusick 		panic("vfs_remove: unmounting root");
5841400Smckusick 	mp->mnt_prev->mnt_next = mp->mnt_next;
5941400Smckusick 	mp->mnt_next->mnt_prev = mp->mnt_prev;
6041400Smckusick 	mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
6137488Smckusick 	vfs_unlock(mp);
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 
14238288Smckusick 	mp = rootfs;
14338288Smckusick 	do {
14441400Smckusick 		if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
14541400Smckusick 		    mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
14638288Smckusick 			return (mp);
14737488Smckusick 		}
14841400Smckusick 		mp = mp->mnt_next;
14938288Smckusick 	} while (mp != rootfs);
15038288Smckusick 	return ((struct mount *)0);
15137488Smckusick }
15237488Smckusick 
15337488Smckusick /*
15453829Spendry  * Get a new unique fsid
15553829Spendry  */
15653829Spendry void
15753829Spendry getnewfsid(mp, mtype)
15853829Spendry 	struct mount *mp;
15953829Spendry 	int mtype;
16053829Spendry {
16153829Spendry static u_short xxxfs_mntid;
16253829Spendry 
16353829Spendry 	fsid_t tfsid;
16453829Spendry 
16553829Spendry 	mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev + 11, 0);	/* XXX */
16653829Spendry 	mp->mnt_stat.f_fsid.val[1] = mtype;
16753829Spendry 	if (xxxfs_mntid == 0)
16853829Spendry 		++xxxfs_mntid;
16953829Spendry 	tfsid.val[0] = makedev(nblkdev, xxxfs_mntid);
17053829Spendry 	tfsid.val[1] = mtype;
17153936Spendry 	if (rootfs) {
17253936Spendry 		while (getvfs(&tfsid)) {
17353936Spendry 			tfsid.val[0]++;
17453936Spendry 			xxxfs_mntid++;
17553936Spendry 		}
17653829Spendry 	}
17753829Spendry 	mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
17853829Spendry }
17953829Spendry 
18053829Spendry /*
18137488Smckusick  * Set vnode attributes to VNOVAL
18237488Smckusick  */
18337488Smckusick void vattr_null(vap)
18437488Smckusick 	register struct vattr *vap;
18537488Smckusick {
18637488Smckusick 
18737488Smckusick 	vap->va_type = VNON;
18852005Smckusick 	vap->va_size = vap->va_bytes = VNOVAL;
18937488Smckusick 	vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid =
19052005Smckusick 		vap->va_fsid = vap->va_fileid =
19152005Smckusick 		vap->va_blocksize = vap->va_rdev =
19254347Smckusick 		vap->va_atime.ts_sec = vap->va_atime.ts_nsec =
19354347Smckusick 		vap->va_mtime.ts_sec = vap->va_mtime.ts_nsec =
19454347Smckusick 		vap->va_ctime.ts_sec = vap->va_ctime.ts_nsec =
19538258Smckusick 		vap->va_flags = vap->va_gen = VNOVAL;
19658548Sbostic 	vap->va_vaflags = 0;
19737488Smckusick }
19838265Smckusick 
19938265Smckusick /*
20039397Smckusick  * Routines having to do with the management of the vnode table.
20139397Smckusick  */
20255468Smckusick struct vnode *vfreeh, **vfreet = &vfreeh;
20353547Sheideman extern int (**dead_vnodeop_p)();
20439635Smckusick extern void vclean();
20540883Smckusick long numvnodes;
20653493Sheideman extern struct vattr va_null;
20739397Smckusick 
20857042Smargo 
20939397Smckusick /*
21039397Smckusick  * Return the next vnode from the free list.
21139397Smckusick  */
21239397Smckusick getnewvnode(tag, mp, vops, vpp)
21339397Smckusick 	enum vtagtype tag;
21439397Smckusick 	struct mount *mp;
21553495Sheideman 	int (**vops)();
21639397Smckusick 	struct vnode **vpp;
21739397Smckusick {
21839397Smckusick 	register struct vnode *vp, *vq;
21957042Smargo 	int s;
22039397Smckusick 
22154347Smckusick 	if ((vfreeh == NULL && numvnodes < 2 * desiredvnodes) ||
22254347Smckusick 	    numvnodes < desiredvnodes) {
22345118Smckusick 		vp = (struct vnode *)malloc((u_long)sizeof *vp,
22445118Smckusick 		    M_VNODE, M_WAITOK);
22540883Smckusick 		bzero((char *)vp, sizeof *vp);
22640883Smckusick 		numvnodes++;
22740883Smckusick 	} else {
22840883Smckusick 		if ((vp = vfreeh) == NULL) {
22940883Smckusick 			tablefull("vnode");
23040883Smckusick 			*vpp = 0;
23140883Smckusick 			return (ENFILE);
23240883Smckusick 		}
23340883Smckusick 		if (vp->v_usecount)
23440883Smckusick 			panic("free vnode isn't");
23540883Smckusick 		if (vq = vp->v_freef)
23640883Smckusick 			vq->v_freeb = &vfreeh;
23740883Smckusick 		else
23840883Smckusick 			vfreet = &vfreeh;
23940883Smckusick 		vfreeh = vq;
24040883Smckusick 		vp->v_freef = NULL;
24140883Smckusick 		vp->v_freeb = NULL;
24252190Smckusick 		vp->v_lease = NULL;
24340883Smckusick 		if (vp->v_type != VBAD)
24440883Smckusick 			vgone(vp);
24557042Smargo #ifdef DIAGNOSTIC
24652006Smckusick 		if (vp->v_data)
24752006Smckusick 			panic("cleaned vnode isn't");
24857042Smargo 		s = splbio();
24957042Smargo 		if (vp->v_numoutput)
25057042Smargo 			panic("Clean vnode has pending I/O's");
25157042Smargo 		splx(s);
25257042Smargo #endif
25340883Smckusick 		vp->v_flag = 0;
25440883Smckusick 		vp->v_lastr = 0;
25557042Smargo 		vp->v_lastw = 0;
25657042Smargo 		vp->v_lasta = 0;
25757042Smargo 		vp->v_cstart = 0;
25857042Smargo 		vp->v_clen = 0;
25940883Smckusick 		vp->v_socket = 0;
26039397Smckusick 	}
26157042Smargo 	vp->v_ralen = 1;
26239512Smckusick 	vp->v_type = VNON;
26339397Smckusick 	cache_purge(vp);
26439397Smckusick 	vp->v_tag = tag;
26539433Smckusick 	vp->v_op = vops;
26639397Smckusick 	insmntque(vp, mp);
26759450Smckusick 	vp->v_usecount++;
26839397Smckusick 	*vpp = vp;
26939397Smckusick 	return (0);
27039397Smckusick }
27139397Smckusick /*
27239397Smckusick  * Move a vnode from one mount queue to another.
27339397Smckusick  */
27439397Smckusick insmntque(vp, mp)
27539397Smckusick 	register struct vnode *vp;
27639397Smckusick 	register struct mount *mp;
27739397Smckusick {
27849973Smckusick 	register struct vnode *vq;
27939397Smckusick 
28039397Smckusick 	/*
28139397Smckusick 	 * Delete from old mount point vnode list, if on one.
28239397Smckusick 	 */
28339397Smckusick 	if (vp->v_mountb) {
28439397Smckusick 		if (vq = vp->v_mountf)
28539397Smckusick 			vq->v_mountb = vp->v_mountb;
28639397Smckusick 		*vp->v_mountb = vq;
28739397Smckusick 	}
28839397Smckusick 	/*
28939397Smckusick 	 * Insert into list of vnodes for the new mount point, if available.
29039397Smckusick 	 */
29139621Smckusick 	vp->v_mount = mp;
29239397Smckusick 	if (mp == NULL) {
29339397Smckusick 		vp->v_mountf = NULL;
29439397Smckusick 		vp->v_mountb = NULL;
29539397Smckusick 		return;
29639397Smckusick 	}
29749973Smckusick 	if (vq = mp->mnt_mounth)
29849973Smckusick 		vq->v_mountb = &vp->v_mountf;
29949973Smckusick 	vp->v_mountf = vq;
30049973Smckusick 	vp->v_mountb = &mp->mnt_mounth;
30149973Smckusick 	mp->mnt_mounth = vp;
30239397Smckusick }
30339397Smckusick 
30439397Smckusick /*
30549232Smckusick  * Update outstanding I/O count and do wakeup if requested.
30649232Smckusick  */
30749232Smckusick vwakeup(bp)
30849232Smckusick 	register struct buf *bp;
30949232Smckusick {
31049232Smckusick 	register struct vnode *vp;
31149232Smckusick 
31257810Smckusick 	bp->b_flags &= ~B_WRITEINPROG;
31349232Smckusick 	if (vp = bp->b_vp) {
31449232Smckusick 		vp->v_numoutput--;
31557042Smargo 		if (vp->v_numoutput < 0)
31657042Smargo 			panic("vwakeup: neg numoutput");
31749232Smckusick 		if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) {
31849232Smckusick 			if (vp->v_numoutput < 0)
31949232Smckusick 				panic("vwakeup: neg numoutput");
32049232Smckusick 			vp->v_flag &= ~VBWAIT;
32149232Smckusick 			wakeup((caddr_t)&vp->v_numoutput);
32249232Smckusick 		}
32349232Smckusick 	}
32449232Smckusick }
32549232Smckusick 
32649232Smckusick /*
32749232Smckusick  * Flush out and invalidate all buffers associated with a vnode.
32849232Smckusick  * Called with the underlying object locked.
32949232Smckusick  */
33054442Smckusick int
33157792Smckusick vinvalbuf(vp, flags, cred, p, slpflag, slptimeo)
33249232Smckusick 	register struct vnode *vp;
33356459Smargo 	int flags;
33454442Smckusick 	struct ucred *cred;
33554442Smckusick 	struct proc *p;
33657792Smckusick 	int slpflag, slptimeo;
33749232Smckusick {
33849232Smckusick 	register struct buf *bp;
33949232Smckusick 	struct buf *nbp, *blist;
34054442Smckusick 	int s, error;
34149232Smckusick 
34256459Smargo 	if (flags & V_SAVE) {
34354442Smckusick 		if (error = VOP_FSYNC(vp, cred, MNT_WAIT, p))
34454442Smckusick 			return (error);
34556608Smckusick 		if (vp->v_dirtyblkhd.le_next != NULL)
34654442Smckusick 			panic("vinvalbuf: dirty bufs");
34754442Smckusick 	}
34849232Smckusick 	for (;;) {
34956608Smckusick 		if ((blist = vp->v_cleanblkhd.le_next) && flags & V_SAVEMETA)
35056459Smargo 			while (blist && blist->b_lblkno < 0)
35156608Smckusick 				blist = blist->b_vnbufs.qe_next;
35256608Smckusick 		if (!blist && (blist = vp->v_dirtyblkhd.le_next) &&
35356608Smckusick 		    (flags & V_SAVEMETA))
35456459Smargo 			while (blist && blist->b_lblkno < 0)
35556608Smckusick 				blist = blist->b_vnbufs.qe_next;
35656459Smargo 		if (!blist)
35749232Smckusick 			break;
35856459Smargo 
35949232Smckusick 		for (bp = blist; bp; bp = nbp) {
36056608Smckusick 			nbp = bp->b_vnbufs.qe_next;
36156459Smargo 			if (flags & V_SAVEMETA && bp->b_lblkno < 0)
36256459Smargo 				continue;
36349232Smckusick 			s = splbio();
36449232Smckusick 			if (bp->b_flags & B_BUSY) {
36549232Smckusick 				bp->b_flags |= B_WANTED;
36657792Smckusick 				error = tsleep((caddr_t)bp,
36757792Smckusick 					slpflag | (PRIBIO + 1), "vinvalbuf",
36857792Smckusick 					slptimeo);
36949232Smckusick 				splx(s);
37057792Smckusick 				if (error)
37157792Smckusick 					return (error);
37249232Smckusick 				break;
37349232Smckusick 			}
37449232Smckusick 			bremfree(bp);
37549232Smckusick 			bp->b_flags |= B_BUSY;
37649232Smckusick 			splx(s);
37757792Smckusick 			/*
37857792Smckusick 			 * XXX Since there are no node locks for NFS, I believe
37957792Smckusick 			 * there is a slight chance that a delayed write will
38057792Smckusick 			 * occur while sleeping just above, so check for it.
38157792Smckusick 			 */
38257792Smckusick 			if ((bp->b_flags & B_DELWRI) && (flags & V_SAVE)) {
38357792Smckusick 				(void) VOP_BWRITE(bp);
38457792Smckusick 				break;
38557792Smckusick 			}
38656459Smargo 			bp->b_flags |= B_INVAL;
38749232Smckusick 			brelse(bp);
38849232Smckusick 		}
38949232Smckusick 	}
39056608Smckusick 	if (!(flags & V_SAVEMETA) &&
39156608Smckusick 	    (vp->v_dirtyblkhd.le_next || vp->v_cleanblkhd.le_next))
39249232Smckusick 		panic("vinvalbuf: flush failed");
39354442Smckusick 	return (0);
39449232Smckusick }
39549232Smckusick 
39649232Smckusick /*
39749232Smckusick  * Associate a buffer with a vnode.
39849232Smckusick  */
39949232Smckusick bgetvp(vp, bp)
40049232Smckusick 	register struct vnode *vp;
40149232Smckusick 	register struct buf *bp;
40249232Smckusick {
40349973Smckusick 	register struct vnode *vq;
40449232Smckusick 
40549232Smckusick 	if (bp->b_vp)
40649232Smckusick 		panic("bgetvp: not free");
40749232Smckusick 	VHOLD(vp);
40849232Smckusick 	bp->b_vp = vp;
40949232Smckusick 	if (vp->v_type == VBLK || vp->v_type == VCHR)
41049232Smckusick 		bp->b_dev = vp->v_rdev;
41149232Smckusick 	else
41249232Smckusick 		bp->b_dev = NODEV;
41349232Smckusick 	/*
41449232Smckusick 	 * Insert onto list for new vnode.
41549232Smckusick 	 */
41656608Smckusick 	bufinsvn(bp, &vp->v_cleanblkhd);
41749232Smckusick }
41849232Smckusick 
41949232Smckusick /*
42049232Smckusick  * Disassociate a buffer from a vnode.
42149232Smckusick  */
42249232Smckusick brelvp(bp)
42349232Smckusick 	register struct buf *bp;
42449232Smckusick {
42549232Smckusick 	struct vnode *vp;
42649232Smckusick 
42749232Smckusick 	if (bp->b_vp == (struct vnode *) 0)
42849232Smckusick 		panic("brelvp: NULL");
42949232Smckusick 	/*
43049232Smckusick 	 * Delete from old vnode list, if on one.
43149232Smckusick 	 */
43256608Smckusick 	if (bp->b_vnbufs.qe_next != NOLIST)
43356608Smckusick 		bufremvn(bp);
43449232Smckusick 	vp = bp->b_vp;
43549232Smckusick 	bp->b_vp = (struct vnode *) 0;
43649232Smckusick 	HOLDRELE(vp);
43749232Smckusick }
43849232Smckusick 
43949232Smckusick /*
44049232Smckusick  * Reassign a buffer from one vnode to another.
44149232Smckusick  * Used to assign file specific control information
44249232Smckusick  * (indirect blocks) to the vnode to which they belong.
44349232Smckusick  */
44449232Smckusick reassignbuf(bp, newvp)
44549232Smckusick 	register struct buf *bp;
44649232Smckusick 	register struct vnode *newvp;
44749232Smckusick {
44856608Smckusick 	register struct list_entry *listheadp;
44949232Smckusick 
45052655Smckusick 	if (newvp == NULL) {
45152655Smckusick 		printf("reassignbuf: NULL");
45252655Smckusick 		return;
45352655Smckusick 	}
45449232Smckusick 	/*
45549232Smckusick 	 * Delete from old vnode list, if on one.
45649232Smckusick 	 */
45756608Smckusick 	if (bp->b_vnbufs.qe_next != NOLIST)
45856608Smckusick 		bufremvn(bp);
45949232Smckusick 	/*
46049232Smckusick 	 * If dirty, put on list of dirty buffers;
46149232Smckusick 	 * otherwise insert onto list of clean buffers.
46249232Smckusick 	 */
46349232Smckusick 	if (bp->b_flags & B_DELWRI)
46449232Smckusick 		listheadp = &newvp->v_dirtyblkhd;
46549232Smckusick 	else
46649232Smckusick 		listheadp = &newvp->v_cleanblkhd;
46756608Smckusick 	bufinsvn(bp, listheadp);
46849232Smckusick }
46949232Smckusick 
47049232Smckusick /*
47139433Smckusick  * Create a vnode for a block device.
47239433Smckusick  * Used for root filesystem, argdev, and swap areas.
47339433Smckusick  * Also used for memory file system special devices.
47439397Smckusick  */
47539433Smckusick bdevvp(dev, vpp)
47639433Smckusick 	dev_t dev;
47739433Smckusick 	struct vnode **vpp;
47839433Smckusick {
47939433Smckusick 	register struct vnode *vp;
48039433Smckusick 	struct vnode *nvp;
48139433Smckusick 	int error;
48239433Smckusick 
48346989Smckusick 	if (dev == NODEV)
48446989Smckusick 		return (0);
48553547Sheideman 	error = getnewvnode(VT_NON, (struct mount *)0, spec_vnodeop_p, &nvp);
48639433Smckusick 	if (error) {
48739433Smckusick 		*vpp = 0;
48839433Smckusick 		return (error);
48939433Smckusick 	}
49039433Smckusick 	vp = nvp;
49139433Smckusick 	vp->v_type = VBLK;
49239615Smckusick 	if (nvp = checkalias(vp, dev, (struct mount *)0)) {
49339433Smckusick 		vput(vp);
49439433Smckusick 		vp = nvp;
49539433Smckusick 	}
49639433Smckusick 	*vpp = vp;
49739433Smckusick 	return (0);
49839433Smckusick }
49939433Smckusick 
50039433Smckusick /*
50139433Smckusick  * Check to see if the new vnode represents a special device
50239433Smckusick  * for which we already have a vnode (either because of
50339433Smckusick  * bdevvp() or because of a different vnode representing
50439433Smckusick  * the same block device). If such an alias exists, deallocate
50539509Smckusick  * the existing contents and return the aliased vnode. The
50639433Smckusick  * caller is responsible for filling it with its new contents.
50739433Smckusick  */
50839433Smckusick struct vnode *
50939615Smckusick checkalias(nvp, nvp_rdev, mp)
51039433Smckusick 	register struct vnode *nvp;
51139615Smckusick 	dev_t nvp_rdev;
51239433Smckusick 	struct mount *mp;
51339433Smckusick {
51439433Smckusick 	register struct vnode *vp;
51539615Smckusick 	struct vnode **vpp;
51639433Smckusick 
51739433Smckusick 	if (nvp->v_type != VBLK && nvp->v_type != VCHR)
51841400Smckusick 		return (NULLVP);
51939615Smckusick 
52039615Smckusick 	vpp = &speclisth[SPECHASH(nvp_rdev)];
52139433Smckusick loop:
52239615Smckusick 	for (vp = *vpp; vp; vp = vp->v_specnext) {
52339615Smckusick 		if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type)
52439433Smckusick 			continue;
52539615Smckusick 		/*
52639615Smckusick 		 * Alias, but not in use, so flush it out.
52739615Smckusick 		 */
52839809Smckusick 		if (vp->v_usecount == 0) {
52939615Smckusick 			vgone(vp);
53039615Smckusick 			goto loop;
53139615Smckusick 		}
53239633Smckusick 		if (vget(vp))
53339633Smckusick 			goto loop;
53439433Smckusick 		break;
53539433Smckusick 	}
53639615Smckusick 	if (vp == NULL || vp->v_tag != VT_NON) {
53739615Smckusick 		MALLOC(nvp->v_specinfo, struct specinfo *,
53839615Smckusick 			sizeof(struct specinfo), M_VNODE, M_WAITOK);
53939615Smckusick 		nvp->v_rdev = nvp_rdev;
54039809Smckusick 		nvp->v_hashchain = vpp;
54139615Smckusick 		nvp->v_specnext = *vpp;
54242152Smckusick 		nvp->v_specflags = 0;
54339615Smckusick 		*vpp = nvp;
54440640Smckusick 		if (vp != NULL) {
54540640Smckusick 			nvp->v_flag |= VALIASED;
54640640Smckusick 			vp->v_flag |= VALIASED;
54740640Smckusick 			vput(vp);
54840640Smckusick 		}
54941400Smckusick 		return (NULLVP);
55039433Smckusick 	}
55139484Smckusick 	VOP_UNLOCK(vp);
55239484Smckusick 	vclean(vp, 0);
55339433Smckusick 	vp->v_op = nvp->v_op;
55439433Smckusick 	vp->v_tag = nvp->v_tag;
55539433Smckusick 	nvp->v_type = VNON;
55639433Smckusick 	insmntque(vp, mp);
55739433Smckusick 	return (vp);
55839433Smckusick }
55939433Smckusick 
56039433Smckusick /*
56139433Smckusick  * Grab a particular vnode from the free list, increment its
56239433Smckusick  * reference count and lock it. The vnode lock bit is set the
56339433Smckusick  * vnode is being eliminated in vgone. The process is awakened
56439433Smckusick  * when the transition is completed, and an error returned to
56539433Smckusick  * indicate that the vnode is no longer usable (possibly having
56639433Smckusick  * been changed to a new file system type).
56739433Smckusick  */
56839397Smckusick vget(vp)
56939397Smckusick 	register struct vnode *vp;
57039397Smckusick {
57139397Smckusick 	register struct vnode *vq;
57239397Smckusick 
57339433Smckusick 	if (vp->v_flag & VXLOCK) {
57439433Smckusick 		vp->v_flag |= VXWANT;
57539433Smckusick 		sleep((caddr_t)vp, PINOD);
57639433Smckusick 		return (1);
57739433Smckusick 	}
57839809Smckusick 	if (vp->v_usecount == 0) {
57939433Smckusick 		if (vq = vp->v_freef)
58039433Smckusick 			vq->v_freeb = vp->v_freeb;
58139433Smckusick 		else
58239433Smckusick 			vfreet = vp->v_freeb;
58339433Smckusick 		*vp->v_freeb = vq;
58439433Smckusick 		vp->v_freef = NULL;
58539433Smckusick 		vp->v_freeb = NULL;
58639433Smckusick 	}
58759450Smckusick 	vp->v_usecount++;
58839433Smckusick 	VOP_LOCK(vp);
58939433Smckusick 	return (0);
59039397Smckusick }
59139397Smckusick 
59239397Smckusick /*
59339397Smckusick  * Vnode reference, just increment the count
59439397Smckusick  */
59539397Smckusick void vref(vp)
59639397Smckusick 	struct vnode *vp;
59739397Smckusick {
59839397Smckusick 
59959450Smckusick 	if (vp->v_usecount <= 0)
60059450Smckusick 		panic("vref used where vget required");
60139809Smckusick 	vp->v_usecount++;
60239397Smckusick }
60339397Smckusick 
60439397Smckusick /*
60539397Smckusick  * vput(), just unlock and vrele()
60639397Smckusick  */
60739397Smckusick void vput(vp)
60839397Smckusick 	register struct vnode *vp;
60939397Smckusick {
61052416Storek 
61139397Smckusick 	VOP_UNLOCK(vp);
61239397Smckusick 	vrele(vp);
61339397Smckusick }
61439397Smckusick 
61539397Smckusick /*
61639397Smckusick  * Vnode release.
61739397Smckusick  * If count drops to zero, call inactive routine and return to freelist.
61839397Smckusick  */
61939397Smckusick void vrele(vp)
62039397Smckusick 	register struct vnode *vp;
62139397Smckusick {
62239397Smckusick 
62350109Smckusick #ifdef DIAGNOSTIC
62439397Smckusick 	if (vp == NULL)
62539433Smckusick 		panic("vrele: null vp");
62650109Smckusick #endif
62739809Smckusick 	vp->v_usecount--;
62839809Smckusick 	if (vp->v_usecount > 0)
62939397Smckusick 		return;
63050109Smckusick #ifdef DIAGNOSTIC
63150109Smckusick 	if (vp->v_usecount != 0 || vp->v_writecount != 0) {
63250109Smckusick 		vprint("vrele: bad ref count", vp);
63350109Smckusick 		panic("vrele: ref cnt");
63450109Smckusick 	}
63550109Smckusick #endif
63655468Smckusick 	/*
63755468Smckusick 	 * insert at tail of LRU list
63855468Smckusick 	 */
63955468Smckusick 	*vfreet = vp;
64055468Smckusick 	vp->v_freeb = vfreet;
64139433Smckusick 	vp->v_freef = NULL;
64239433Smckusick 	vfreet = &vp->v_freef;
64354442Smckusick 	VOP_INACTIVE(vp);
64439397Smckusick }
64539433Smckusick 
64639433Smckusick /*
64739809Smckusick  * Page or buffer structure gets a reference.
64839809Smckusick  */
64953312Smckusick void vhold(vp)
65039809Smckusick 	register struct vnode *vp;
65139809Smckusick {
65239809Smckusick 
65339809Smckusick 	vp->v_holdcnt++;
65439809Smckusick }
65539809Smckusick 
65639809Smckusick /*
65739809Smckusick  * Page or buffer structure frees a reference.
65839809Smckusick  */
65953312Smckusick void holdrele(vp)
66039809Smckusick 	register struct vnode *vp;
66139809Smckusick {
66239809Smckusick 
66339809Smckusick 	if (vp->v_holdcnt <= 0)
66439809Smckusick 		panic("holdrele: holdcnt");
66539809Smckusick 	vp->v_holdcnt--;
66639809Smckusick }
66739809Smckusick 
66839809Smckusick /*
66939509Smckusick  * Remove any vnodes in the vnode table belonging to mount point mp.
67039509Smckusick  *
67139509Smckusick  * If MNT_NOFORCE is specified, there should not be any active ones,
67239509Smckusick  * return error if any are found (nb: this is a user error, not a
67339509Smckusick  * system error). If MNT_FORCE is specified, detach any active vnodes
67439509Smckusick  * that are found.
67539509Smckusick  */
67660930Smckusick int busyprt = 0;	/* print out busy vnodes */
67760930Smckusick struct ctldebug debug1 = { "busyprt", &busyprt };
67839509Smckusick 
67939509Smckusick vflush(mp, skipvp, flags)
68039509Smckusick 	struct mount *mp;
68139509Smckusick 	struct vnode *skipvp;
68239509Smckusick 	int flags;
68339509Smckusick {
68439509Smckusick 	register struct vnode *vp, *nvp;
68539509Smckusick 	int busy = 0;
68639509Smckusick 
68741400Smckusick 	if ((mp->mnt_flag & MNT_MPBUSY) == 0)
68841300Smckusick 		panic("vflush: not busy");
68941421Smckusick loop:
69041400Smckusick 	for (vp = mp->mnt_mounth; vp; vp = nvp) {
69141421Smckusick 		if (vp->v_mount != mp)
69241421Smckusick 			goto loop;
69339509Smckusick 		nvp = vp->v_mountf;
69439509Smckusick 		/*
69539509Smckusick 		 * Skip over a selected vnode.
69639509Smckusick 		 */
69739509Smckusick 		if (vp == skipvp)
69839509Smckusick 			continue;
69939509Smckusick 		/*
70041300Smckusick 		 * Skip over a vnodes marked VSYSTEM.
70141300Smckusick 		 */
70241300Smckusick 		if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM))
70341300Smckusick 			continue;
70441300Smckusick 		/*
70557040Smckusick 		 * If WRITECLOSE is set, only flush out regular file
70657040Smckusick 		 * vnodes open for writing.
70757040Smckusick 		 */
70857040Smckusick 		if ((flags & WRITECLOSE) &&
70957040Smckusick 		    (vp->v_writecount == 0 || vp->v_type != VREG))
71057040Smckusick 			continue;
71157040Smckusick 		/*
71239809Smckusick 		 * With v_usecount == 0, all we need to do is clear
71339509Smckusick 		 * out the vnode data structures and we are done.
71439509Smckusick 		 */
71539809Smckusick 		if (vp->v_usecount == 0) {
71639509Smckusick 			vgone(vp);
71739509Smckusick 			continue;
71839509Smckusick 		}
71939509Smckusick 		/*
72057040Smckusick 		 * If FORCECLOSE is set, forcibly close the vnode.
72139509Smckusick 		 * For block or character devices, revert to an
72239509Smckusick 		 * anonymous device. For all other files, just kill them.
72339509Smckusick 		 */
72441300Smckusick 		if (flags & FORCECLOSE) {
72539509Smckusick 			if (vp->v_type != VBLK && vp->v_type != VCHR) {
72639509Smckusick 				vgone(vp);
72739509Smckusick 			} else {
72839509Smckusick 				vclean(vp, 0);
72953547Sheideman 				vp->v_op = spec_vnodeop_p;
73039509Smckusick 				insmntque(vp, (struct mount *)0);
73139509Smckusick 			}
73239509Smckusick 			continue;
73339509Smckusick 		}
73439509Smckusick 		if (busyprt)
73539667Smckusick 			vprint("vflush: busy vnode", vp);
73639509Smckusick 		busy++;
73739509Smckusick 	}
73839509Smckusick 	if (busy)
73939509Smckusick 		return (EBUSY);
74039509Smckusick 	return (0);
74139509Smckusick }
74239509Smckusick 
74339509Smckusick /*
74439433Smckusick  * Disassociate the underlying file system from a vnode.
74539433Smckusick  */
74654347Smckusick void
74754347Smckusick vclean(vp, flags)
74839433Smckusick 	register struct vnode *vp;
74945118Smckusick 	int flags;
75039433Smckusick {
75139484Smckusick 	int active;
75239433Smckusick 
75339484Smckusick 	/*
75439484Smckusick 	 * Check to see if the vnode is in use.
75539667Smckusick 	 * If so we have to reference it before we clean it out
75639667Smckusick 	 * so that its count cannot fall to zero and generate a
75739667Smckusick 	 * race against ourselves to recycle it.
75839484Smckusick 	 */
75939809Smckusick 	if (active = vp->v_usecount)
76039484Smckusick 		VREF(vp);
76139484Smckusick 	/*
76256805Smckusick 	 * Even if the count is zero, the VOP_INACTIVE routine may still
76356805Smckusick 	 * have the object locked while it cleans it out. The VOP_LOCK
76456805Smckusick 	 * ensures that the VOP_INACTIVE routine is done with its work.
76556805Smckusick 	 * For active vnodes, it ensures that no other activity can
76656805Smckusick 	 * occur while the underlying object is being cleaned out.
76756805Smckusick 	 */
76856805Smckusick 	VOP_LOCK(vp);
76956805Smckusick 	/*
77039484Smckusick 	 * Prevent the vnode from being recycled or
77139484Smckusick 	 * brought into use while we clean it out.
77239484Smckusick 	 */
77339667Smckusick 	if (vp->v_flag & VXLOCK)
77439667Smckusick 		panic("vclean: deadlock");
77539433Smckusick 	vp->v_flag |= VXLOCK;
77639433Smckusick 	/*
77756805Smckusick 	 * Clean out any buffers associated with the vnode.
77839667Smckusick 	 */
77941300Smckusick 	if (flags & DOCLOSE)
78057792Smckusick 		vinvalbuf(vp, V_SAVE, NOCRED, NULL, 0, 0);
78139667Smckusick 	/*
78256805Smckusick 	 * Any other processes trying to obtain this lock must first
78356805Smckusick 	 * wait for VXLOCK to clear, then call the new lock operation.
78439433Smckusick 	 */
78556805Smckusick 	VOP_UNLOCK(vp);
78639433Smckusick 	/*
78756805Smckusick 	 * If purging an active vnode, it must be closed and
78856805Smckusick 	 * deactivated before being reclaimed.
78939433Smckusick 	 */
79039484Smckusick 	if (active) {
79156805Smckusick 		if (flags & DOCLOSE)
79256805Smckusick 			VOP_CLOSE(vp, IO_NDELAY, NOCRED, NULL);
79356805Smckusick 		VOP_INACTIVE(vp);
79439433Smckusick 	}
79539433Smckusick 	/*
79639433Smckusick 	 * Reclaim the vnode.
79739433Smckusick 	 */
79856805Smckusick 	if (VOP_RECLAIM(vp))
79939433Smckusick 		panic("vclean: cannot reclaim");
80039484Smckusick 	if (active)
80139484Smckusick 		vrele(vp);
80253580Sheideman 
80339433Smckusick 	/*
80456805Smckusick 	 * Done with purge, notify sleepers of the grim news.
80539433Smckusick 	 */
80656805Smckusick 	vp->v_op = dead_vnodeop_p;
80756805Smckusick 	vp->v_tag = VT_NON;
80839433Smckusick 	vp->v_flag &= ~VXLOCK;
80939433Smckusick 	if (vp->v_flag & VXWANT) {
81039433Smckusick 		vp->v_flag &= ~VXWANT;
81139433Smckusick 		wakeup((caddr_t)vp);
81239433Smckusick 	}
81339433Smckusick }
81439433Smckusick 
81539433Smckusick /*
81639633Smckusick  * Eliminate all activity associated with  the requested vnode
81739633Smckusick  * and with all vnodes aliased to the requested vnode.
81839633Smckusick  */
81939633Smckusick void vgoneall(vp)
82039633Smckusick 	register struct vnode *vp;
82139633Smckusick {
82239809Smckusick 	register struct vnode *vq;
82339633Smckusick 
82440665Smckusick 	if (vp->v_flag & VALIASED) {
82540665Smckusick 		/*
82640665Smckusick 		 * If a vgone (or vclean) is already in progress,
82740665Smckusick 		 * wait until it is done and return.
82840665Smckusick 		 */
82940665Smckusick 		if (vp->v_flag & VXLOCK) {
83040665Smckusick 			vp->v_flag |= VXWANT;
83140665Smckusick 			sleep((caddr_t)vp, PINOD);
83240665Smckusick 			return;
83339633Smckusick 		}
83440665Smckusick 		/*
83540665Smckusick 		 * Ensure that vp will not be vgone'd while we
83640665Smckusick 		 * are eliminating its aliases.
83740665Smckusick 		 */
83840665Smckusick 		vp->v_flag |= VXLOCK;
83940665Smckusick 		while (vp->v_flag & VALIASED) {
84040665Smckusick 			for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
84140665Smckusick 				if (vq->v_rdev != vp->v_rdev ||
84240665Smckusick 				    vq->v_type != vp->v_type || vp == vq)
84340665Smckusick 					continue;
84440665Smckusick 				vgone(vq);
84540665Smckusick 				break;
84640665Smckusick 			}
84740665Smckusick 		}
84840665Smckusick 		/*
84940665Smckusick 		 * Remove the lock so that vgone below will
85040665Smckusick 		 * really eliminate the vnode after which time
85140665Smckusick 		 * vgone will awaken any sleepers.
85240665Smckusick 		 */
85340665Smckusick 		vp->v_flag &= ~VXLOCK;
85439633Smckusick 	}
85539633Smckusick 	vgone(vp);
85639633Smckusick }
85739633Smckusick 
85839633Smckusick /*
85939433Smckusick  * Eliminate all activity associated with a vnode
86039433Smckusick  * in preparation for reuse.
86139433Smckusick  */
86239433Smckusick void vgone(vp)
86339433Smckusick 	register struct vnode *vp;
86439433Smckusick {
86539809Smckusick 	register struct vnode *vq;
86639615Smckusick 	struct vnode *vx;
86739433Smckusick 
86839433Smckusick 	/*
86940548Smckusick 	 * If a vgone (or vclean) is already in progress,
87040548Smckusick 	 * wait until it is done and return.
87140548Smckusick 	 */
87240548Smckusick 	if (vp->v_flag & VXLOCK) {
87340548Smckusick 		vp->v_flag |= VXWANT;
87440548Smckusick 		sleep((caddr_t)vp, PINOD);
87540548Smckusick 		return;
87640548Smckusick 	}
87740548Smckusick 	/*
87839433Smckusick 	 * Clean out the filesystem specific data.
87939433Smckusick 	 */
88041300Smckusick 	vclean(vp, DOCLOSE);
88139433Smckusick 	/*
88239433Smckusick 	 * Delete from old mount point vnode list, if on one.
88339433Smckusick 	 */
88439433Smckusick 	if (vp->v_mountb) {
88539433Smckusick 		if (vq = vp->v_mountf)
88639433Smckusick 			vq->v_mountb = vp->v_mountb;
88739433Smckusick 		*vp->v_mountb = vq;
88839433Smckusick 		vp->v_mountf = NULL;
88939433Smckusick 		vp->v_mountb = NULL;
89052311Smckusick 		vp->v_mount = NULL;
89139433Smckusick 	}
89239433Smckusick 	/*
89339433Smckusick 	 * If special device, remove it from special device alias list.
89439433Smckusick 	 */
89539433Smckusick 	if (vp->v_type == VBLK || vp->v_type == VCHR) {
89639809Smckusick 		if (*vp->v_hashchain == vp) {
89739809Smckusick 			*vp->v_hashchain = vp->v_specnext;
89839433Smckusick 		} else {
89939809Smckusick 			for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
90039615Smckusick 				if (vq->v_specnext != vp)
90139433Smckusick 					continue;
90239615Smckusick 				vq->v_specnext = vp->v_specnext;
90339433Smckusick 				break;
90439433Smckusick 			}
90539615Smckusick 			if (vq == NULL)
90639433Smckusick 				panic("missing bdev");
90739433Smckusick 		}
90839615Smckusick 		if (vp->v_flag & VALIASED) {
90952416Storek 			vx = NULL;
91039809Smckusick 			for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
91140108Smckusick 				if (vq->v_rdev != vp->v_rdev ||
91240108Smckusick 				    vq->v_type != vp->v_type)
91339615Smckusick 					continue;
91452416Storek 				if (vx)
91552416Storek 					break;
91639615Smckusick 				vx = vq;
91739615Smckusick 			}
91852416Storek 			if (vx == NULL)
91939615Smckusick 				panic("missing alias");
92052416Storek 			if (vq == NULL)
92139615Smckusick 				vx->v_flag &= ~VALIASED;
92239615Smckusick 			vp->v_flag &= ~VALIASED;
92339615Smckusick 		}
92439615Smckusick 		FREE(vp->v_specinfo, M_VNODE);
92539615Smckusick 		vp->v_specinfo = NULL;
92639433Smckusick 	}
92739433Smckusick 	/*
92856932Smckusick 	 * If it is on the freelist and not already at the head,
92956932Smckusick 	 * move it to the head of the list.
93039433Smckusick 	 */
93156932Smckusick 	if (vp->v_freeb && vfreeh != vp) {
93239433Smckusick 		if (vq = vp->v_freef)
93339433Smckusick 			vq->v_freeb = vp->v_freeb;
93439433Smckusick 		else
93539433Smckusick 			vfreet = vp->v_freeb;
93639433Smckusick 		*vp->v_freeb = vq;
93739433Smckusick 		vp->v_freef = vfreeh;
93839433Smckusick 		vp->v_freeb = &vfreeh;
93939433Smckusick 		vfreeh->v_freeb = &vp->v_freef;
94039433Smckusick 		vfreeh = vp;
94139433Smckusick 	}
94239484Smckusick 	vp->v_type = VBAD;
94339433Smckusick }
94439633Smckusick 
94539633Smckusick /*
94639821Smckusick  * Lookup a vnode by device number.
94739821Smckusick  */
94839821Smckusick vfinddev(dev, type, vpp)
94939821Smckusick 	dev_t dev;
95039821Smckusick 	enum vtype type;
95139821Smckusick 	struct vnode **vpp;
95239821Smckusick {
95339821Smckusick 	register struct vnode *vp;
95439821Smckusick 
95539821Smckusick 	for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) {
95639821Smckusick 		if (dev != vp->v_rdev || type != vp->v_type)
95739821Smckusick 			continue;
95839821Smckusick 		*vpp = vp;
95959484Smckusick 		return (1);
96039821Smckusick 	}
96159484Smckusick 	return (0);
96239821Smckusick }
96339821Smckusick 
96439821Smckusick /*
96539633Smckusick  * Calculate the total number of references to a special device.
96639633Smckusick  */
96739633Smckusick vcount(vp)
96839633Smckusick 	register struct vnode *vp;
96939633Smckusick {
97039809Smckusick 	register struct vnode *vq;
97139633Smckusick 	int count;
97239633Smckusick 
97339633Smckusick 	if ((vp->v_flag & VALIASED) == 0)
97439809Smckusick 		return (vp->v_usecount);
97539633Smckusick loop:
97639809Smckusick 	for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
97740108Smckusick 		if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type)
97839633Smckusick 			continue;
97939633Smckusick 		/*
98039633Smckusick 		 * Alias, but not in use, so flush it out.
98139633Smckusick 		 */
98239809Smckusick 		if (vq->v_usecount == 0) {
98339633Smckusick 			vgone(vq);
98439633Smckusick 			goto loop;
98539633Smckusick 		}
98639809Smckusick 		count += vq->v_usecount;
98739633Smckusick 	}
98839633Smckusick 	return (count);
98939633Smckusick }
99039667Smckusick 
99139667Smckusick /*
99239667Smckusick  * Print out a description of a vnode.
99339667Smckusick  */
99439667Smckusick static char *typename[] =
99540286Smckusick    { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" };
99639667Smckusick 
99739667Smckusick vprint(label, vp)
99839667Smckusick 	char *label;
99939667Smckusick 	register struct vnode *vp;
100039667Smckusick {
100139913Smckusick 	char buf[64];
100239667Smckusick 
100339667Smckusick 	if (label != NULL)
100439667Smckusick 		printf("%s: ", label);
100550109Smckusick 	printf("type %s, usecount %d, writecount %d, refcount %d,",
100650109Smckusick 		typename[vp->v_type], vp->v_usecount, vp->v_writecount,
100750109Smckusick 		vp->v_holdcnt);
100839913Smckusick 	buf[0] = '\0';
100939913Smckusick 	if (vp->v_flag & VROOT)
101039913Smckusick 		strcat(buf, "|VROOT");
101139913Smckusick 	if (vp->v_flag & VTEXT)
101239913Smckusick 		strcat(buf, "|VTEXT");
101341300Smckusick 	if (vp->v_flag & VSYSTEM)
101441300Smckusick 		strcat(buf, "|VSYSTEM");
101541300Smckusick 	if (vp->v_flag & VXLOCK)
101641300Smckusick 		strcat(buf, "|VXLOCK");
101741300Smckusick 	if (vp->v_flag & VXWANT)
101841300Smckusick 		strcat(buf, "|VXWANT");
101941300Smckusick 	if (vp->v_flag & VBWAIT)
102041300Smckusick 		strcat(buf, "|VBWAIT");
102139913Smckusick 	if (vp->v_flag & VALIASED)
102239913Smckusick 		strcat(buf, "|VALIASED");
102339913Smckusick 	if (buf[0] != '\0')
102439913Smckusick 		printf(" flags (%s)", &buf[1]);
102539913Smckusick 	printf("\n\t");
102639667Smckusick 	VOP_PRINT(vp);
102739667Smckusick }
102841110Smarc 
102949691Smckusick #ifdef DEBUG
103049691Smckusick /*
103149691Smckusick  * List all of the locked vnodes in the system.
103249691Smckusick  * Called when debugging the kernel.
103349691Smckusick  */
103449691Smckusick printlockedvnodes()
103549691Smckusick {
103649691Smckusick 	register struct mount *mp;
103749691Smckusick 	register struct vnode *vp;
103849691Smckusick 
103949691Smckusick 	printf("Locked vnodes\n");
104049691Smckusick 	mp = rootfs;
104149691Smckusick 	do {
104249691Smckusick 		for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf)
104349691Smckusick 			if (VOP_ISLOCKED(vp))
104449691Smckusick 				vprint((char *)0, vp);
104549691Smckusick 		mp = mp->mnt_next;
104649691Smckusick 	} while (mp != rootfs);
104749691Smckusick }
104849691Smckusick #endif
104949691Smckusick 
105041110Smarc int kinfo_vdebug = 1;
105141110Smarc int kinfo_vgetfailed;
105241110Smarc #define KINFO_VNODESLOP	10
105341110Smarc /*
105457841Smckusick  * Dump vnode list (via sysctl).
105541110Smarc  * Copyout address of vnode followed by vnode.
105641110Smarc  */
105745118Smckusick /* ARGSUSED */
105857841Smckusick sysctl_vnode(where, sizep)
105941110Smarc 	char *where;
106058465Sbostic 	size_t *sizep;
106141110Smarc {
106241110Smarc 	register struct mount *mp = rootfs;
106341300Smckusick 	struct mount *omp;
106441110Smarc 	struct vnode *vp;
106541110Smarc 	register char *bp = where, *savebp;
106653818Smckusick 	char *ewhere;
106741110Smarc 	int error;
106841110Smarc 
106941110Smarc #define VPTRSZ	sizeof (struct vnode *)
107041110Smarc #define VNODESZ	sizeof (struct vnode)
107141110Smarc 	if (where == NULL) {
107257841Smckusick 		*sizep = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ);
107341110Smarc 		return (0);
107441110Smarc 	}
107557841Smckusick 	ewhere = where + *sizep;
107641110Smarc 
107741110Smarc 	do {
107841300Smckusick 		if (vfs_busy(mp)) {
107941400Smckusick 			mp = mp->mnt_next;
108041300Smckusick 			continue;
108141300Smckusick 		}
108241110Smarc 		savebp = bp;
108341110Smarc again:
108441421Smckusick 		for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) {
108541422Smckusick 			/*
108641422Smckusick 			 * Check that the vp is still associated with
108741422Smckusick 			 * this filesystem.  RACE: could have been
108841422Smckusick 			 * recycled onto the same filesystem.
108941422Smckusick 			 */
109041421Smckusick 			if (vp->v_mount != mp) {
109141421Smckusick 				if (kinfo_vdebug)
109241421Smckusick 					printf("kinfo: vp changed\n");
109341421Smckusick 				bp = savebp;
109441421Smckusick 				goto again;
109541421Smckusick 			}
109657841Smckusick 			if (bp + VPTRSZ + VNODESZ > ewhere) {
109757841Smckusick 				*sizep = bp - where;
109857841Smckusick 				return (ENOMEM);
109957841Smckusick 			}
110057841Smckusick 			if ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) ||
110157841Smckusick 			   (error = copyout((caddr_t)vp, bp + VPTRSZ, VNODESZ)))
110241110Smarc 				return (error);
110341110Smarc 			bp += VPTRSZ + VNODESZ;
110441110Smarc 		}
110541300Smckusick 		omp = mp;
110641400Smckusick 		mp = mp->mnt_next;
110741300Smckusick 		vfs_unbusy(omp);
110841110Smarc 	} while (mp != rootfs);
110941110Smarc 
111057841Smckusick 	*sizep = bp - where;
111141110Smarc 	return (0);
111241110Smarc }
1113