xref: /csrg-svn/sys/kern/vfs_subr.c (revision 69523)
137488Smckusick /*
263180Sbostic  * Copyright (c) 1989, 1993
363180Sbostic  *	The Regents of the University of California.  All rights reserved.
465771Sbostic  * (c) UNIX System Laboratories, Inc.
565771Sbostic  * All or some portions of this file are derived from material licensed
665771Sbostic  * to the University of California by American Telephone and Telegraph
765771Sbostic  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
865771Sbostic  * the permission of UNIX System Laboratories, Inc.
937488Smckusick  *
1044458Sbostic  * %sccs.include.redist.c%
1137488Smckusick  *
12*69523Spendry  *	@(#)vfs_subr.c	8.25 (Berkeley) 05/17/95
1337488Smckusick  */
1437488Smckusick 
1537488Smckusick /*
1637488Smckusick  * External virtual filesystem routines
1737488Smckusick  */
1837488Smckusick 
1951460Sbostic #include <sys/param.h>
2053829Spendry #include <sys/systm.h>
2151460Sbostic #include <sys/proc.h>
2251460Sbostic #include <sys/mount.h>
2351460Sbostic #include <sys/time.h>
2451460Sbostic #include <sys/vnode.h>
2552415Smckusick #include <sys/stat.h>
2651460Sbostic #include <sys/namei.h>
2751460Sbostic #include <sys/ucred.h>
2851460Sbostic #include <sys/buf.h>
2951460Sbostic #include <sys/errno.h>
3051460Sbostic #include <sys/malloc.h>
3165679Shibler #include <sys/domain.h>
3265679Shibler #include <sys/mbuf.h>
3337488Smckusick 
3460930Smckusick #include <vm/vm.h>
3560930Smckusick #include <sys/sysctl.h>
3660930Smckusick 
3755050Spendry #include <miscfs/specfs/specdev.h>
3855050Spendry 
3952415Smckusick enum vtype iftovt_tab[16] = {
4052415Smckusick 	VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
4152415Smckusick 	VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
4252415Smckusick };
4352415Smckusick int	vttoif_tab[9] = {
4452415Smckusick 	0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
4552415Smckusick 	S_IFSOCK, S_IFIFO, S_IFMT,
4652415Smckusick };
4752415Smckusick 
4837488Smckusick /*
4956608Smckusick  * Insq/Remq for the vnode usage lists.
5056608Smckusick  */
5165260Smckusick #define	bufinsvn(bp, dp)	LIST_INSERT_HEAD(dp, bp, b_vnbufs)
5268319Scgd #define	bufremvn(bp) {							\
5368319Scgd 	LIST_REMOVE(bp, b_vnbufs);					\
5468319Scgd 	(bp)->b_vnbufs.le_next = NOLIST;				\
5565260Smckusick }
5665260Smckusick TAILQ_HEAD(freelst, vnode) vnode_free_list;	/* vnode free list */
5765260Smckusick struct mntlist mountlist;			/* mounted filesystem list */
5869408Smckusick static struct simplelock mntid_slock;
5969408Smckusick struct simplelock mntvnode_slock;
6069408Smckusick static struct simplelock spechash_slock;
6169408Smckusick static struct simplelock vnode_free_list_slock;
6265260Smckusick 
6356608Smckusick /*
6465260Smckusick  * Initialize the vnode management data structures.
6537488Smckusick  */
6668319Scgd void
6765260Smckusick vntblinit()
6837488Smckusick {
6937488Smckusick 
7069408Smckusick 	simple_lock_init(&mntvnode_slock);
7169408Smckusick 	simple_lock_init(&mntid_slock);
7269408Smckusick 	simple_lock_init(&spechash_slock);
7365260Smckusick 	TAILQ_INIT(&vnode_free_list);
7469408Smckusick 	simple_lock_init(&vnode_free_list_slock);
7569325Smckusick 	CIRCLEQ_INIT(&mountlist);
7637488Smckusick }
7737488Smckusick 
7837488Smckusick /*
7937488Smckusick  * Lock a filesystem.
8037488Smckusick  * Used to prevent access to it while mounting and unmounting.
8137488Smckusick  */
8268319Scgd int
8337488Smckusick vfs_lock(mp)
8437488Smckusick 	register struct mount *mp;
8537488Smckusick {
8637488Smckusick 
8768319Scgd 	while (mp->mnt_flag & MNT_MLOCK) {
8841400Smckusick 		mp->mnt_flag |= MNT_MWAIT;
8968319Scgd 		tsleep((caddr_t)mp, PVFS, "vfslock", 0);
9039045Smckusick 	}
9141400Smckusick 	mp->mnt_flag |= MNT_MLOCK;
9237488Smckusick 	return (0);
9337488Smckusick }
9437488Smckusick 
9537488Smckusick /*
9637488Smckusick  * Unlock a locked filesystem.
9737488Smckusick  * Panic if filesystem is not locked.
9837488Smckusick  */
9937488Smckusick void
10037488Smckusick vfs_unlock(mp)
10137488Smckusick 	register struct mount *mp;
10237488Smckusick {
10337488Smckusick 
10441400Smckusick 	if ((mp->mnt_flag & MNT_MLOCK) == 0)
10541300Smckusick 		panic("vfs_unlock: not locked");
10641400Smckusick 	mp->mnt_flag &= ~MNT_MLOCK;
10741400Smckusick 	if (mp->mnt_flag & MNT_MWAIT) {
10841400Smckusick 		mp->mnt_flag &= ~MNT_MWAIT;
10937488Smckusick 		wakeup((caddr_t)mp);
11037488Smckusick 	}
11137488Smckusick }
11237488Smckusick 
11337488Smckusick /*
11441300Smckusick  * Mark a mount point as busy.
11541300Smckusick  * Used to synchronize access and to delay unmounting.
11641300Smckusick  */
11768319Scgd int
11841300Smckusick vfs_busy(mp)
11941300Smckusick 	register struct mount *mp;
12041300Smckusick {
12141300Smckusick 
12268319Scgd 	while (mp->mnt_flag & MNT_MPBUSY) {
12341400Smckusick 		mp->mnt_flag |= MNT_MPWANT;
12468319Scgd 		tsleep((caddr_t)&mp->mnt_flag, PVFS, "vfsbusy", 0);
12541300Smckusick 	}
12641419Smckusick 	if (mp->mnt_flag & MNT_UNMOUNT)
12741419Smckusick 		return (1);
12841400Smckusick 	mp->mnt_flag |= MNT_MPBUSY;
12941300Smckusick 	return (0);
13041300Smckusick }
13141300Smckusick 
13241300Smckusick /*
13341300Smckusick  * Free a busy filesystem.
13441300Smckusick  * Panic if filesystem is not busy.
13541300Smckusick  */
13668319Scgd void
13741300Smckusick vfs_unbusy(mp)
13841300Smckusick 	register struct mount *mp;
13941300Smckusick {
14041300Smckusick 
14141400Smckusick 	if ((mp->mnt_flag & MNT_MPBUSY) == 0)
14241300Smckusick 		panic("vfs_unbusy: not busy");
14341400Smckusick 	mp->mnt_flag &= ~MNT_MPBUSY;
14441400Smckusick 	if (mp->mnt_flag & MNT_MPWANT) {
14541400Smckusick 		mp->mnt_flag &= ~MNT_MPWANT;
14641400Smckusick 		wakeup((caddr_t)&mp->mnt_flag);
14741300Smckusick 	}
14841300Smckusick }
14941300Smckusick 
15041300Smckusick /*
15169378Smckusick  * Lookup a filesystem type, and if found allocate and initialize
15269378Smckusick  * a mount structure for it.
15369378Smckusick  *
15469378Smckusick  * Devname is usually updated by mount(8) after booting.
15569378Smckusick  */
15669378Smckusick int
15769378Smckusick vfs_rootmountalloc(fstypename, devname, mpp)
15869378Smckusick 	char *fstypename;
15969378Smckusick 	char *devname;
16069378Smckusick 	struct mount **mpp;
16169378Smckusick {
16269378Smckusick 	struct vfsconf *vfsp;
16369378Smckusick 	struct mount *mp;
16469378Smckusick 
16569378Smckusick 	for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
16669378Smckusick 		if (!strcmp(vfsp->vfc_name, fstypename))
16769378Smckusick 			break;
16869378Smckusick 	if (vfsp == NULL)
16969378Smckusick 		return (ENODEV);
17069378Smckusick 	mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK);
17169378Smckusick 	bzero((char *)mp, (u_long)sizeof(struct mount));
17269378Smckusick 	LIST_INIT(&mp->mnt_vnodelist);
17369378Smckusick 	mp->mnt_vfc = vfsp;
17469378Smckusick 	mp->mnt_op = vfsp->vfc_vfsops;
17569378Smckusick 	mp->mnt_flag = MNT_RDONLY;
17669378Smckusick 	mp->mnt_vnodecovered = NULLVP;
17769378Smckusick 	vfsp->vfc_refcount++;
17869378Smckusick 	mp->mnt_stat.f_type = vfsp->vfc_typenum;
17969378Smckusick 	mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
18069378Smckusick 	strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
18169378Smckusick 	mp->mnt_stat.f_mntonname[0] = '/';
18269378Smckusick 	(void) copystr(devname, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 0);
18369378Smckusick 	*mpp = mp;
18469378Smckusick 	return (0);
18569378Smckusick }
18669378Smckusick 
18769378Smckusick /*
18869378Smckusick  * Find an appropriate filesystem to use for the root. If a filesystem
18969378Smckusick  * has not been preselected, walk through the list of known filesystems
19069378Smckusick  * trying those that have mountroot routines, and try them until one
19169378Smckusick  * works or we have tried them all.
19269378Smckusick  */
19369378Smckusick int
19469378Smckusick vfs_mountroot()
19569378Smckusick {
19669378Smckusick 	struct vfsconf *vfsp;
19769378Smckusick 	extern int (*mountroot)(void);
19869378Smckusick 	int error;
19969378Smckusick 
20069378Smckusick 	if (mountroot != NULL)
20169378Smckusick 		return ((*vfsp->vfc_mountroot)());
20269378Smckusick 	for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
20369378Smckusick 		if (vfsp->vfc_mountroot == NULL)
20469378Smckusick 			continue;
20569378Smckusick 		if ((error = (*vfsp->vfc_mountroot)()) == 0)
20669378Smckusick 			return (0);
20769378Smckusick 		printf("%s_mountroot failed: %d\n", vfsp->vfc_name, error);
20869378Smckusick 	}
20969378Smckusick 	return (ENODEV);
21069378Smckusick }
21169378Smckusick 
21269378Smckusick /*
21337488Smckusick  * Lookup a mount point by filesystem identifier.
21437488Smckusick  */
21537488Smckusick struct mount *
21668659Smckusick vfs_getvfs(fsid)
21737488Smckusick 	fsid_t *fsid;
21837488Smckusick {
21937488Smckusick 	register struct mount *mp;
22037488Smckusick 
22169325Smckusick 	for (mp = mountlist.cqh_first; mp != (void *)&mountlist;
22269325Smckusick 	     mp = mp->mnt_list.cqe_next) {
22341400Smckusick 		if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
22465260Smckusick 		    mp->mnt_stat.f_fsid.val[1] == fsid->val[1])
22538288Smckusick 			return (mp);
22665260Smckusick 	}
22738288Smckusick 	return ((struct mount *)0);
22837488Smckusick }
22937488Smckusick 
23037488Smckusick /*
23153829Spendry  * Get a new unique fsid
23253829Spendry  */
23353829Spendry void
23468659Smckusick vfs_getnewfsid(mp)
23553829Spendry 	struct mount *mp;
23653829Spendry {
23753829Spendry static u_short xxxfs_mntid;
23853829Spendry 
23953829Spendry 	fsid_t tfsid;
24068659Smckusick 	int mtype;
24153829Spendry 
24269408Smckusick 	simple_lock(&mntid_slock);
24368659Smckusick 	mtype = mp->mnt_vfc->vfc_typenum;
24465507Spendry 	mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev + mtype, 0);
24553829Spendry 	mp->mnt_stat.f_fsid.val[1] = mtype;
24653829Spendry 	if (xxxfs_mntid == 0)
24753829Spendry 		++xxxfs_mntid;
24865507Spendry 	tfsid.val[0] = makedev(nblkdev + mtype, xxxfs_mntid);
24953829Spendry 	tfsid.val[1] = mtype;
25069325Smckusick 	if (mountlist.cqh_first != (void *)&mountlist) {
25168659Smckusick 		while (vfs_getvfs(&tfsid)) {
25253936Spendry 			tfsid.val[0]++;
25353936Spendry 			xxxfs_mntid++;
25453936Spendry 		}
25553829Spendry 	}
25653829Spendry 	mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
25769408Smckusick 	simple_unlock(&mntid_slock);
25853829Spendry }
25953829Spendry 
26053829Spendry /*
26137488Smckusick  * Set vnode attributes to VNOVAL
26237488Smckusick  */
26368319Scgd void
26468319Scgd vattr_null(vap)
26537488Smckusick 	register struct vattr *vap;
26637488Smckusick {
26737488Smckusick 
26837488Smckusick 	vap->va_type = VNON;
26952005Smckusick 	vap->va_size = vap->va_bytes = VNOVAL;
27037488Smckusick 	vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid =
27152005Smckusick 		vap->va_fsid = vap->va_fileid =
27252005Smckusick 		vap->va_blocksize = vap->va_rdev =
27354347Smckusick 		vap->va_atime.ts_sec = vap->va_atime.ts_nsec =
27454347Smckusick 		vap->va_mtime.ts_sec = vap->va_mtime.ts_nsec =
27554347Smckusick 		vap->va_ctime.ts_sec = vap->va_ctime.ts_nsec =
27638258Smckusick 		vap->va_flags = vap->va_gen = VNOVAL;
27758548Sbostic 	vap->va_vaflags = 0;
27837488Smckusick }
27938265Smckusick 
28038265Smckusick /*
28139397Smckusick  * Routines having to do with the management of the vnode table.
28239397Smckusick  */
28353547Sheideman extern int (**dead_vnodeop_p)();
28469408Smckusick static void vclean __P((struct vnode *vp, int flag, struct proc *p));
28569408Smckusick extern void vgonel __P((struct vnode *vp, struct proc *p));
28640883Smckusick long numvnodes;
28753493Sheideman extern struct vattr va_null;
28839397Smckusick 
28939397Smckusick /*
29039397Smckusick  * Return the next vnode from the free list.
29139397Smckusick  */
29268319Scgd int
29339397Smckusick getnewvnode(tag, mp, vops, vpp)
29439397Smckusick 	enum vtagtype tag;
29539397Smckusick 	struct mount *mp;
29653495Sheideman 	int (**vops)();
29739397Smckusick 	struct vnode **vpp;
29839397Smckusick {
29969408Smckusick 	struct proc *p = curproc;	/* XXX */
30069408Smckusick 	struct vnode *vp;
30157042Smargo 	int s;
30269408Smckusick 	int cnt;
30339397Smckusick 
30469408Smckusick top:
30569408Smckusick 	simple_lock(&vnode_free_list_slock);
30665260Smckusick 	if ((vnode_free_list.tqh_first == NULL &&
30765260Smckusick 	     numvnodes < 2 * desiredvnodes) ||
30854347Smckusick 	    numvnodes < desiredvnodes) {
30969408Smckusick 		simple_unlock(&vnode_free_list_slock);
31045118Smckusick 		vp = (struct vnode *)malloc((u_long)sizeof *vp,
31145118Smckusick 		    M_VNODE, M_WAITOK);
31240883Smckusick 		bzero((char *)vp, sizeof *vp);
31340883Smckusick 		numvnodes++;
31440883Smckusick 	} else {
31569408Smckusick 		for (vp = vnode_free_list.tqh_first;
31669408Smckusick 				vp != NULLVP; vp = vp->v_freelist.tqe_next) {
31769408Smckusick 			if (simple_lock_try(&vp->v_interlock))
31869408Smckusick 				break;
31969408Smckusick 		}
32069408Smckusick 		/*
32169408Smckusick 		 * Unless this is a bad time of the month, at most
32269408Smckusick 		 * the first NCPUS items on the free list are
32369408Smckusick 		 * locked, so this is close enough to being empty.
32469408Smckusick 		 */
32569408Smckusick 		if (vp == NULLVP) {
32669408Smckusick 			simple_unlock(&vnode_free_list_slock);
32740883Smckusick 			tablefull("vnode");
32840883Smckusick 			*vpp = 0;
32940883Smckusick 			return (ENFILE);
33040883Smckusick 		}
33140883Smckusick 		if (vp->v_usecount)
33240883Smckusick 			panic("free vnode isn't");
33365260Smckusick 		TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
33465505Smckusick 		/* see comment on why 0xdeadb is set at end of vgone (below) */
33565505Smckusick 		vp->v_freelist.tqe_prev = (struct vnode **)0xdeadb;
33669408Smckusick 		simple_unlock(&vnode_free_list_slock);
33752190Smckusick 		vp->v_lease = NULL;
33840883Smckusick 		if (vp->v_type != VBAD)
33969408Smckusick 			vgonel(vp, p);
34069408Smckusick 		else
34169408Smckusick 			simple_unlock(&vp->v_interlock);
34257042Smargo #ifdef DIAGNOSTIC
34352006Smckusick 		if (vp->v_data)
34452006Smckusick 			panic("cleaned vnode isn't");
34557042Smargo 		s = splbio();
34657042Smargo 		if (vp->v_numoutput)
34757042Smargo 			panic("Clean vnode has pending I/O's");
34857042Smargo 		splx(s);
34957042Smargo #endif
35040883Smckusick 		vp->v_flag = 0;
35140883Smckusick 		vp->v_lastr = 0;
35265745Shibler 		vp->v_ralen = 0;
35365745Shibler 		vp->v_maxra = 0;
35457042Smargo 		vp->v_lastw = 0;
35557042Smargo 		vp->v_lasta = 0;
35657042Smargo 		vp->v_cstart = 0;
35757042Smargo 		vp->v_clen = 0;
35840883Smckusick 		vp->v_socket = 0;
35939397Smckusick 	}
36039512Smckusick 	vp->v_type = VNON;
36139397Smckusick 	cache_purge(vp);
36239397Smckusick 	vp->v_tag = tag;
36339433Smckusick 	vp->v_op = vops;
36439397Smckusick 	insmntque(vp, mp);
36539397Smckusick 	*vpp = vp;
36665505Smckusick 	vp->v_usecount = 1;
36765260Smckusick 	vp->v_data = 0;
36839397Smckusick 	return (0);
36939397Smckusick }
37065679Shibler 
37139397Smckusick /*
37239397Smckusick  * Move a vnode from one mount queue to another.
37339397Smckusick  */
37468319Scgd void
37539397Smckusick insmntque(vp, mp)
37669408Smckusick 	struct vnode *vp;
37769408Smckusick 	struct mount *mp;
37839397Smckusick {
37939397Smckusick 
38069408Smckusick 	simple_lock(&mntvnode_slock);
38139397Smckusick 	/*
38239397Smckusick 	 * Delete from old mount point vnode list, if on one.
38339397Smckusick 	 */
38465679Shibler 	if (vp->v_mount != NULL)
38565260Smckusick 		LIST_REMOVE(vp, v_mntvnodes);
38639397Smckusick 	/*
38739397Smckusick 	 * Insert into list of vnodes for the new mount point, if available.
38839397Smckusick 	 */
38969408Smckusick 	if ((vp->v_mount = mp) != NULL)
39069408Smckusick 		LIST_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes);
39169408Smckusick 	simple_unlock(&mntvnode_slock);
39239397Smckusick }
39339397Smckusick 
39439397Smckusick /*
39549232Smckusick  * Update outstanding I/O count and do wakeup if requested.
39649232Smckusick  */
39768319Scgd void
39849232Smckusick vwakeup(bp)
39949232Smckusick 	register struct buf *bp;
40049232Smckusick {
40149232Smckusick 	register struct vnode *vp;
40249232Smckusick 
40357810Smckusick 	bp->b_flags &= ~B_WRITEINPROG;
40449232Smckusick 	if (vp = bp->b_vp) {
40568319Scgd 		if (--vp->v_numoutput < 0)
40657042Smargo 			panic("vwakeup: neg numoutput");
40749232Smckusick 		if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) {
40849232Smckusick 			if (vp->v_numoutput < 0)
40968319Scgd 				panic("vwakeup: neg numoutput 2");
41049232Smckusick 			vp->v_flag &= ~VBWAIT;
41149232Smckusick 			wakeup((caddr_t)&vp->v_numoutput);
41249232Smckusick 		}
41349232Smckusick 	}
41449232Smckusick }
41549232Smckusick 
41649232Smckusick /*
41749232Smckusick  * Flush out and invalidate all buffers associated with a vnode.
41849232Smckusick  * Called with the underlying object locked.
41949232Smckusick  */
42054442Smckusick int
42157792Smckusick vinvalbuf(vp, flags, cred, p, slpflag, slptimeo)
42249232Smckusick 	register struct vnode *vp;
42356459Smargo 	int flags;
42454442Smckusick 	struct ucred *cred;
42554442Smckusick 	struct proc *p;
42657792Smckusick 	int slpflag, slptimeo;
42749232Smckusick {
42849232Smckusick 	register struct buf *bp;
42949232Smckusick 	struct buf *nbp, *blist;
43054442Smckusick 	int s, error;
43149232Smckusick 
43256459Smargo 	if (flags & V_SAVE) {
43354442Smckusick 		if (error = VOP_FSYNC(vp, cred, MNT_WAIT, p))
43454442Smckusick 			return (error);
43565260Smckusick 		if (vp->v_dirtyblkhd.lh_first != NULL)
43654442Smckusick 			panic("vinvalbuf: dirty bufs");
43754442Smckusick 	}
43849232Smckusick 	for (;;) {
43965260Smckusick 		if ((blist = vp->v_cleanblkhd.lh_first) && flags & V_SAVEMETA)
44056459Smargo 			while (blist && blist->b_lblkno < 0)
44165260Smckusick 				blist = blist->b_vnbufs.le_next;
44268319Scgd 		if (!blist && (blist = vp->v_dirtyblkhd.lh_first) &&
44356608Smckusick 		    (flags & V_SAVEMETA))
44456459Smargo 			while (blist && blist->b_lblkno < 0)
44565260Smckusick 				blist = blist->b_vnbufs.le_next;
44656459Smargo 		if (!blist)
44749232Smckusick 			break;
44856459Smargo 
44949232Smckusick 		for (bp = blist; bp; bp = nbp) {
45065260Smckusick 			nbp = bp->b_vnbufs.le_next;
45156459Smargo 			if (flags & V_SAVEMETA && bp->b_lblkno < 0)
45256459Smargo 				continue;
45349232Smckusick 			s = splbio();
45449232Smckusick 			if (bp->b_flags & B_BUSY) {
45549232Smckusick 				bp->b_flags |= B_WANTED;
45657792Smckusick 				error = tsleep((caddr_t)bp,
45757792Smckusick 					slpflag | (PRIBIO + 1), "vinvalbuf",
45857792Smckusick 					slptimeo);
45949232Smckusick 				splx(s);
46057792Smckusick 				if (error)
46157792Smckusick 					return (error);
46249232Smckusick 				break;
46349232Smckusick 			}
46449232Smckusick 			bremfree(bp);
46549232Smckusick 			bp->b_flags |= B_BUSY;
46649232Smckusick 			splx(s);
46757792Smckusick 			/*
46857792Smckusick 			 * XXX Since there are no node locks for NFS, I believe
46957792Smckusick 			 * there is a slight chance that a delayed write will
47057792Smckusick 			 * occur while sleeping just above, so check for it.
47157792Smckusick 			 */
47257792Smckusick 			if ((bp->b_flags & B_DELWRI) && (flags & V_SAVE)) {
47357792Smckusick 				(void) VOP_BWRITE(bp);
47457792Smckusick 				break;
47557792Smckusick 			}
47656459Smargo 			bp->b_flags |= B_INVAL;
47749232Smckusick 			brelse(bp);
47849232Smckusick 		}
47949232Smckusick 	}
48056608Smckusick 	if (!(flags & V_SAVEMETA) &&
48165260Smckusick 	    (vp->v_dirtyblkhd.lh_first || vp->v_cleanblkhd.lh_first))
48249232Smckusick 		panic("vinvalbuf: flush failed");
48354442Smckusick 	return (0);
48449232Smckusick }
48549232Smckusick 
48649232Smckusick /*
48749232Smckusick  * Associate a buffer with a vnode.
48849232Smckusick  */
48968319Scgd void
49049232Smckusick bgetvp(vp, bp)
49149232Smckusick 	register struct vnode *vp;
49249232Smckusick 	register struct buf *bp;
49349232Smckusick {
49449232Smckusick 
49549232Smckusick 	if (bp->b_vp)
49649232Smckusick 		panic("bgetvp: not free");
49749232Smckusick 	VHOLD(vp);
49849232Smckusick 	bp->b_vp = vp;
49949232Smckusick 	if (vp->v_type == VBLK || vp->v_type == VCHR)
50049232Smckusick 		bp->b_dev = vp->v_rdev;
50149232Smckusick 	else
50249232Smckusick 		bp->b_dev = NODEV;
50349232Smckusick 	/*
50449232Smckusick 	 * Insert onto list for new vnode.
50549232Smckusick 	 */
50656608Smckusick 	bufinsvn(bp, &vp->v_cleanblkhd);
50749232Smckusick }
50849232Smckusick 
50949232Smckusick /*
51049232Smckusick  * Disassociate a buffer from a vnode.
51149232Smckusick  */
51268319Scgd void
51349232Smckusick brelvp(bp)
51449232Smckusick 	register struct buf *bp;
51549232Smckusick {
51649232Smckusick 	struct vnode *vp;
51749232Smckusick 
51849232Smckusick 	if (bp->b_vp == (struct vnode *) 0)
51949232Smckusick 		panic("brelvp: NULL");
52049232Smckusick 	/*
52149232Smckusick 	 * Delete from old vnode list, if on one.
52249232Smckusick 	 */
52365260Smckusick 	if (bp->b_vnbufs.le_next != NOLIST)
52456608Smckusick 		bufremvn(bp);
52549232Smckusick 	vp = bp->b_vp;
52649232Smckusick 	bp->b_vp = (struct vnode *) 0;
52749232Smckusick 	HOLDRELE(vp);
52849232Smckusick }
52949232Smckusick 
53049232Smckusick /*
53149232Smckusick  * Reassign a buffer from one vnode to another.
53249232Smckusick  * Used to assign file specific control information
53349232Smckusick  * (indirect blocks) to the vnode to which they belong.
53449232Smckusick  */
53568319Scgd void
53649232Smckusick reassignbuf(bp, newvp)
53749232Smckusick 	register struct buf *bp;
53849232Smckusick 	register struct vnode *newvp;
53949232Smckusick {
54065260Smckusick 	register struct buflists *listheadp;
54149232Smckusick 
54252655Smckusick 	if (newvp == NULL) {
54352655Smckusick 		printf("reassignbuf: NULL");
54452655Smckusick 		return;
54552655Smckusick 	}
54649232Smckusick 	/*
54749232Smckusick 	 * Delete from old vnode list, if on one.
54849232Smckusick 	 */
54965260Smckusick 	if (bp->b_vnbufs.le_next != NOLIST)
55056608Smckusick 		bufremvn(bp);
55149232Smckusick 	/*
55249232Smckusick 	 * If dirty, put on list of dirty buffers;
55349232Smckusick 	 * otherwise insert onto list of clean buffers.
55449232Smckusick 	 */
55549232Smckusick 	if (bp->b_flags & B_DELWRI)
55649232Smckusick 		listheadp = &newvp->v_dirtyblkhd;
55749232Smckusick 	else
55849232Smckusick 		listheadp = &newvp->v_cleanblkhd;
55956608Smckusick 	bufinsvn(bp, listheadp);
56049232Smckusick }
56149232Smckusick 
56249232Smckusick /*
56339433Smckusick  * Create a vnode for a block device.
56439433Smckusick  * Used for root filesystem, argdev, and swap areas.
56539433Smckusick  * Also used for memory file system special devices.
56639397Smckusick  */
56768319Scgd int
56839433Smckusick bdevvp(dev, vpp)
56939433Smckusick 	dev_t dev;
57039433Smckusick 	struct vnode **vpp;
57139433Smckusick {
57239433Smckusick 	register struct vnode *vp;
57339433Smckusick 	struct vnode *nvp;
57439433Smckusick 	int error;
57539433Smckusick 
57669378Smckusick 	if (dev == NODEV) {
57769378Smckusick 		*vpp = NULLVP;
57869378Smckusick 		return (ENODEV);
57969378Smckusick 	}
58053547Sheideman 	error = getnewvnode(VT_NON, (struct mount *)0, spec_vnodeop_p, &nvp);
58139433Smckusick 	if (error) {
58268319Scgd 		*vpp = NULLVP;
58339433Smckusick 		return (error);
58439433Smckusick 	}
58539433Smckusick 	vp = nvp;
58639433Smckusick 	vp->v_type = VBLK;
58739615Smckusick 	if (nvp = checkalias(vp, dev, (struct mount *)0)) {
58839433Smckusick 		vput(vp);
58939433Smckusick 		vp = nvp;
59039433Smckusick 	}
59139433Smckusick 	*vpp = vp;
59239433Smckusick 	return (0);
59339433Smckusick }
59439433Smckusick 
59539433Smckusick /*
59639433Smckusick  * Check to see if the new vnode represents a special device
59739433Smckusick  * for which we already have a vnode (either because of
59839433Smckusick  * bdevvp() or because of a different vnode representing
59939433Smckusick  * the same block device). If such an alias exists, deallocate
60039509Smckusick  * the existing contents and return the aliased vnode. The
60139433Smckusick  * caller is responsible for filling it with its new contents.
60239433Smckusick  */
60339433Smckusick struct vnode *
60439615Smckusick checkalias(nvp, nvp_rdev, mp)
60539433Smckusick 	register struct vnode *nvp;
60639615Smckusick 	dev_t nvp_rdev;
60739433Smckusick 	struct mount *mp;
60839433Smckusick {
60969408Smckusick 	struct proc *p = curproc;	/* XXX */
61069408Smckusick 	struct vnode *vp;
61139615Smckusick 	struct vnode **vpp;
61239433Smckusick 
61339433Smckusick 	if (nvp->v_type != VBLK && nvp->v_type != VCHR)
61441400Smckusick 		return (NULLVP);
61539615Smckusick 
61639615Smckusick 	vpp = &speclisth[SPECHASH(nvp_rdev)];
61739433Smckusick loop:
61869408Smckusick 	simple_lock(&spechash_slock);
61939615Smckusick 	for (vp = *vpp; vp; vp = vp->v_specnext) {
62039615Smckusick 		if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type)
62139433Smckusick 			continue;
62239615Smckusick 		/*
62339615Smckusick 		 * Alias, but not in use, so flush it out.
62439615Smckusick 		 */
62569408Smckusick 		simple_lock(&vp->v_interlock);
62639809Smckusick 		if (vp->v_usecount == 0) {
62769408Smckusick 			simple_unlock(&spechash_slock);
62869408Smckusick 			vgonel(vp, p);
62939615Smckusick 			goto loop;
63039615Smckusick 		}
63169408Smckusick 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) {
63269408Smckusick 			simple_unlock(&spechash_slock);
63339633Smckusick 			goto loop;
63469408Smckusick 		}
63539433Smckusick 		break;
63639433Smckusick 	}
63739615Smckusick 	if (vp == NULL || vp->v_tag != VT_NON) {
63839615Smckusick 		MALLOC(nvp->v_specinfo, struct specinfo *,
63939615Smckusick 			sizeof(struct specinfo), M_VNODE, M_WAITOK);
64039615Smckusick 		nvp->v_rdev = nvp_rdev;
64139809Smckusick 		nvp->v_hashchain = vpp;
64239615Smckusick 		nvp->v_specnext = *vpp;
64342152Smckusick 		nvp->v_specflags = 0;
64469408Smckusick 		simple_unlock(&spechash_slock);
64539615Smckusick 		*vpp = nvp;
64669408Smckusick 		if (vp != NULLVP) {
64740640Smckusick 			nvp->v_flag |= VALIASED;
64840640Smckusick 			vp->v_flag |= VALIASED;
64940640Smckusick 			vput(vp);
65040640Smckusick 		}
65141400Smckusick 		return (NULLVP);
65239433Smckusick 	}
65369408Smckusick 	simple_unlock(&spechash_slock);
65469408Smckusick 	VOP_UNLOCK(vp, 0, p);
65569408Smckusick 	simple_lock(&vp->v_interlock);
65669408Smckusick 	vclean(vp, 0, p);
65739433Smckusick 	vp->v_op = nvp->v_op;
65839433Smckusick 	vp->v_tag = nvp->v_tag;
65939433Smckusick 	nvp->v_type = VNON;
66039433Smckusick 	insmntque(vp, mp);
66139433Smckusick 	return (vp);
66239433Smckusick }
66339433Smckusick 
66439433Smckusick /*
66539433Smckusick  * Grab a particular vnode from the free list, increment its
66639433Smckusick  * reference count and lock it. The vnode lock bit is set the
66739433Smckusick  * vnode is being eliminated in vgone. The process is awakened
66839433Smckusick  * when the transition is completed, and an error returned to
66939433Smckusick  * indicate that the vnode is no longer usable (possibly having
67039433Smckusick  * been changed to a new file system type).
67139433Smckusick  */
67268319Scgd int
67369408Smckusick vget(vp, flags, p)
67469408Smckusick 	struct vnode *vp;
67569408Smckusick 	int flags;
67669408Smckusick 	struct proc *p;
67739397Smckusick {
67839397Smckusick 
67966897Smckusick 	/*
68066897Smckusick 	 * If the vnode is in the process of being cleaned out for
68166897Smckusick 	 * another use, we wait for the cleaning to finish and then
68269408Smckusick 	 * return failure. Cleaning is determined by checking that
68369408Smckusick 	 * the VXLOCK flag is set.
68466897Smckusick 	 */
68569408Smckusick 	if ((flags & LK_INTERLOCK) == 0)
68669408Smckusick 		simple_lock(&vp->v_interlock);
68769408Smckusick 	if (vp->v_flag & VXLOCK) {
68839433Smckusick 		vp->v_flag |= VXWANT;
68969408Smckusick 		simple_unlock(&vp->v_interlock);
69068319Scgd 		tsleep((caddr_t)vp, PINOD, "vget", 0);
69169408Smckusick 		return (ENOENT);
69239433Smckusick 	}
69369408Smckusick 	if (vp->v_usecount == 0) {
69469408Smckusick 		simple_lock(&vnode_free_list_slock);
69565260Smckusick 		TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
69669408Smckusick 		simple_unlock(&vnode_free_list_slock);
69769408Smckusick 	}
69859450Smckusick 	vp->v_usecount++;
69969408Smckusick 	if (flags & LK_TYPE_MASK)
70069408Smckusick 		return (vn_lock(vp, flags | LK_INTERLOCK, p));
70169408Smckusick 	simple_unlock(&vp->v_interlock);
70239433Smckusick 	return (0);
70339397Smckusick }
70439397Smckusick 
70539397Smckusick /*
70669408Smckusick  * Stubs to use when there is no locking to be done on the underlying object.
70769408Smckusick  *
70869408Smckusick  * Getting a lock just clears the interlock if necessary.
70939397Smckusick  */
71069408Smckusick int
71169408Smckusick vop_nolock(ap)
71269408Smckusick 	struct vop_lock_args /* {
71369408Smckusick 		struct vnode *a_vp;
71469408Smckusick 		int a_flags;
71569408Smckusick 		struct proc *a_p;
71669408Smckusick 	} */ *ap;
71769408Smckusick {
71869408Smckusick 	struct vnode *vp = ap->a_vp;
71969408Smckusick 
72069408Smckusick 	/*
72169408Smckusick 	 * Since we are not using the lock manager, we must clear
72269408Smckusick 	 * the interlock here.
72369408Smckusick 	 */
72469408Smckusick 	if (ap->a_flags & LK_INTERLOCK)
72569408Smckusick 		simple_unlock(&vp->v_interlock);
72669408Smckusick 	return (0);
72769408Smckusick }
72869408Smckusick 
72969408Smckusick /*
73069408Smckusick  * Unlock has nothing to do.
73169408Smckusick  */
73269408Smckusick int
73369408Smckusick vop_nounlock(ap)
73469408Smckusick 	struct vop_unlock_args /* {
73569408Smckusick 		struct vnode *a_vp;
73669408Smckusick 		int a_flags;
73769408Smckusick 		struct proc *a_p;
73869408Smckusick 	} */ *ap;
73969408Smckusick {
74069408Smckusick 
74169408Smckusick 	return (0);
74269408Smckusick }
74369408Smckusick 
74469408Smckusick /*
74569408Smckusick  * Nothing is ever locked.
74669408Smckusick  */
74769408Smckusick int
74869408Smckusick vop_noislocked(ap)
74969408Smckusick 	struct vop_islocked_args /* {
75069408Smckusick 		struct vnode *a_vp;
75169408Smckusick 	} */ *ap;
75269408Smckusick {
75369408Smckusick 
75469408Smckusick 	return (0);
75569408Smckusick }
75669408Smckusick 
75769408Smckusick /*
75869408Smckusick  * Vnode reference.
75969408Smckusick  */
76068319Scgd void
76168319Scgd vref(vp)
76239397Smckusick 	struct vnode *vp;
76339397Smckusick {
76439397Smckusick 
76569408Smckusick 	simple_lock(&vp->v_interlock);
76659450Smckusick 	if (vp->v_usecount <= 0)
76759450Smckusick 		panic("vref used where vget required");
76839809Smckusick 	vp->v_usecount++;
76969408Smckusick 	simple_unlock(&vp->v_interlock);
77039397Smckusick }
77139397Smckusick 
77239397Smckusick /*
77339397Smckusick  * vput(), just unlock and vrele()
77439397Smckusick  */
77568319Scgd void
77668319Scgd vput(vp)
77769408Smckusick 	struct vnode *vp;
77839397Smckusick {
77969408Smckusick 	struct proc *p = curproc;	/* XXX */
78052416Storek 
781*69523Spendry #ifdef DIGANOSTIC
782*69523Spendry 	if (vp == NULL)
783*69523Spendry 		panic("vput: null vp");
784*69523Spendry #endif
785*69523Spendry 	simple_lock(&vp->v_interlock);
786*69523Spendry 	vp->v_usecount--;
787*69523Spendry 	if (vp->v_usecount > 0) {
788*69523Spendry 		simple_unlock(&vp->v_interlock);
789*69523Spendry 		VOP_UNLOCK(vp, 0, p);
790*69523Spendry 		return;
791*69523Spendry 	}
792*69523Spendry #ifdef DIAGNOSTIC
793*69523Spendry 	if (vp->v_usecount < 0 || vp->v_writecount != 0) {
794*69523Spendry 		vprint("vput: bad ref count", vp);
795*69523Spendry 		panic("vput: ref cnt");
796*69523Spendry 	}
797*69523Spendry #endif
798*69523Spendry 	/*
799*69523Spendry 	 * insert at tail of LRU list
800*69523Spendry 	 */
801*69523Spendry 	simple_lock(&vnode_free_list_slock);
802*69523Spendry 	TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
803*69523Spendry 	simple_unlock(&vnode_free_list_slock);
804*69523Spendry 	simple_unlock(&vp->v_interlock);
805*69523Spendry 	VOP_INACTIVE(vp, p);
80639397Smckusick }
80739397Smckusick 
80839397Smckusick /*
80939397Smckusick  * Vnode release.
81039397Smckusick  * If count drops to zero, call inactive routine and return to freelist.
81139397Smckusick  */
81268319Scgd void
81368319Scgd vrele(vp)
81469408Smckusick 	struct vnode *vp;
81539397Smckusick {
81669408Smckusick 	struct proc *p = curproc;	/* XXX */
81739397Smckusick 
81850109Smckusick #ifdef DIAGNOSTIC
81939397Smckusick 	if (vp == NULL)
82039433Smckusick 		panic("vrele: null vp");
82150109Smckusick #endif
82269408Smckusick 	simple_lock(&vp->v_interlock);
82339809Smckusick 	vp->v_usecount--;
82469408Smckusick 	if (vp->v_usecount > 0) {
82569408Smckusick 		simple_unlock(&vp->v_interlock);
82639397Smckusick 		return;
82769408Smckusick 	}
82850109Smckusick #ifdef DIAGNOSTIC
82969408Smckusick 	if (vp->v_usecount < 0 || vp->v_writecount != 0) {
83050109Smckusick 		vprint("vrele: bad ref count", vp);
83150109Smckusick 		panic("vrele: ref cnt");
83250109Smckusick 	}
83350109Smckusick #endif
83455468Smckusick 	/*
83555468Smckusick 	 * insert at tail of LRU list
83655468Smckusick 	 */
83769408Smckusick 	simple_lock(&vnode_free_list_slock);
83865260Smckusick 	TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
83969408Smckusick 	simple_unlock(&vnode_free_list_slock);
84069408Smckusick 	if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, p) == 0)
84169408Smckusick 		VOP_INACTIVE(vp, p);
84239397Smckusick }
84339433Smckusick 
84469408Smckusick #ifdef DIAGNOSTIC
84539433Smckusick /*
84639809Smckusick  * Page or buffer structure gets a reference.
84739809Smckusick  */
84868319Scgd void
84968319Scgd vhold(vp)
85039809Smckusick 	register struct vnode *vp;
85139809Smckusick {
85239809Smckusick 
85369408Smckusick 	simple_lock(&vp->v_interlock);
85439809Smckusick 	vp->v_holdcnt++;
85569408Smckusick 	simple_unlock(&vp->v_interlock);
85639809Smckusick }
85739809Smckusick 
85839809Smckusick /*
85939809Smckusick  * Page or buffer structure frees a reference.
86039809Smckusick  */
86168319Scgd void
86268319Scgd holdrele(vp)
86339809Smckusick 	register struct vnode *vp;
86439809Smckusick {
86539809Smckusick 
86669408Smckusick 	simple_lock(&vp->v_interlock);
86739809Smckusick 	if (vp->v_holdcnt <= 0)
86839809Smckusick 		panic("holdrele: holdcnt");
86939809Smckusick 	vp->v_holdcnt--;
87069408Smckusick 	simple_unlock(&vp->v_interlock);
87139809Smckusick }
87269408Smckusick #endif /* DIAGNOSTIC */
87339809Smckusick 
87439809Smckusick /*
87539509Smckusick  * Remove any vnodes in the vnode table belonging to mount point mp.
87639509Smckusick  *
87739509Smckusick  * If MNT_NOFORCE is specified, there should not be any active ones,
87839509Smckusick  * return error if any are found (nb: this is a user error, not a
87939509Smckusick  * system error). If MNT_FORCE is specified, detach any active vnodes
88039509Smckusick  * that are found.
88139509Smckusick  */
88265679Shibler #ifdef DIAGNOSTIC
88360930Smckusick int busyprt = 0;	/* print out busy vnodes */
88460930Smckusick struct ctldebug debug1 = { "busyprt", &busyprt };
88565679Shibler #endif
88639509Smckusick 
88768319Scgd int
88839509Smckusick vflush(mp, skipvp, flags)
88939509Smckusick 	struct mount *mp;
89039509Smckusick 	struct vnode *skipvp;
89139509Smckusick 	int flags;
89239509Smckusick {
89369408Smckusick 	struct proc *p = curproc;	/* XXX */
89469408Smckusick 	struct vnode *vp, *nvp;
89539509Smckusick 	int busy = 0;
89639509Smckusick 
89769408Smckusick #ifdef DIAGNOSTIC
89841400Smckusick 	if ((mp->mnt_flag & MNT_MPBUSY) == 0)
89941300Smckusick 		panic("vflush: not busy");
90069408Smckusick #endif
90169408Smckusick 
90269408Smckusick 	simple_lock(&mntvnode_slock);
90341421Smckusick loop:
90465260Smckusick 	for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) {
90541421Smckusick 		if (vp->v_mount != mp)
90641421Smckusick 			goto loop;
90765260Smckusick 		nvp = vp->v_mntvnodes.le_next;
90839509Smckusick 		/*
90939509Smckusick 		 * Skip over a selected vnode.
91039509Smckusick 		 */
91139509Smckusick 		if (vp == skipvp)
91239509Smckusick 			continue;
91369408Smckusick 
91469408Smckusick 		simple_lock(&vp->v_interlock);
91539509Smckusick 		/*
91641300Smckusick 		 * Skip over a vnodes marked VSYSTEM.
91741300Smckusick 		 */
91869408Smckusick 		if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) {
91969408Smckusick 			simple_unlock(&vp->v_interlock);
92041300Smckusick 			continue;
92169408Smckusick 		}
92241300Smckusick 		/*
92357040Smckusick 		 * If WRITECLOSE is set, only flush out regular file
92457040Smckusick 		 * vnodes open for writing.
92557040Smckusick 		 */
92657040Smckusick 		if ((flags & WRITECLOSE) &&
92769408Smckusick 		    (vp->v_writecount == 0 || vp->v_type != VREG)) {
92869408Smckusick 			simple_unlock(&vp->v_interlock);
92957040Smckusick 			continue;
93069408Smckusick 		}
93157040Smckusick 		/*
93239809Smckusick 		 * With v_usecount == 0, all we need to do is clear
93339509Smckusick 		 * out the vnode data structures and we are done.
93439509Smckusick 		 */
93539809Smckusick 		if (vp->v_usecount == 0) {
93669408Smckusick 			simple_unlock(&mntvnode_slock);
93769408Smckusick 			vgonel(vp, p);
93869408Smckusick 			simple_lock(&mntvnode_slock);
93939509Smckusick 			continue;
94039509Smckusick 		}
94139509Smckusick 		/*
94257040Smckusick 		 * If FORCECLOSE is set, forcibly close the vnode.
94339509Smckusick 		 * For block or character devices, revert to an
94439509Smckusick 		 * anonymous device. For all other files, just kill them.
94539509Smckusick 		 */
94641300Smckusick 		if (flags & FORCECLOSE) {
94769408Smckusick 			simple_unlock(&mntvnode_slock);
94839509Smckusick 			if (vp->v_type != VBLK && vp->v_type != VCHR) {
94969408Smckusick 				vgonel(vp, p);
95039509Smckusick 			} else {
95169408Smckusick 				vclean(vp, 0, p);
95253547Sheideman 				vp->v_op = spec_vnodeop_p;
95339509Smckusick 				insmntque(vp, (struct mount *)0);
95439509Smckusick 			}
95569408Smckusick 			simple_lock(&mntvnode_slock);
95639509Smckusick 			continue;
95739509Smckusick 		}
95865679Shibler #ifdef DIAGNOSTIC
95939509Smckusick 		if (busyprt)
96039667Smckusick 			vprint("vflush: busy vnode", vp);
96165679Shibler #endif
96269408Smckusick 		simple_unlock(&vp->v_interlock);
96339509Smckusick 		busy++;
96439509Smckusick 	}
96569408Smckusick 	simple_unlock(&mntvnode_slock);
96639509Smckusick 	if (busy)
96739509Smckusick 		return (EBUSY);
96839509Smckusick 	return (0);
96939509Smckusick }
97039509Smckusick 
97139509Smckusick /*
97239433Smckusick  * Disassociate the underlying file system from a vnode.
97369408Smckusick  * The vnode interlock is held on entry.
97439433Smckusick  */
97569408Smckusick static void
97669408Smckusick vclean(vp, flags, p)
97769408Smckusick 	struct vnode *vp;
97845118Smckusick 	int flags;
97969408Smckusick 	struct proc *p;
98039433Smckusick {
98139484Smckusick 	int active;
98239433Smckusick 
98339484Smckusick 	/*
98439484Smckusick 	 * Check to see if the vnode is in use.
98539667Smckusick 	 * If so we have to reference it before we clean it out
98639667Smckusick 	 * so that its count cannot fall to zero and generate a
98739667Smckusick 	 * race against ourselves to recycle it.
98839484Smckusick 	 */
98939809Smckusick 	if (active = vp->v_usecount)
99069408Smckusick 		vp->v_usecount++;
99139484Smckusick 	/*
99269408Smckusick 	 * Prevent the vnode from being recycled or
99369408Smckusick 	 * brought into use while we clean it out.
99469408Smckusick 	 */
99569408Smckusick 	if (vp->v_flag & VXLOCK)
99669408Smckusick 		panic("vclean: deadlock");
99769408Smckusick 	vp->v_flag |= VXLOCK;
99869408Smckusick 	/*
99956805Smckusick 	 * Even if the count is zero, the VOP_INACTIVE routine may still
100056805Smckusick 	 * have the object locked while it cleans it out. The VOP_LOCK
100156805Smckusick 	 * ensures that the VOP_INACTIVE routine is done with its work.
100256805Smckusick 	 * For active vnodes, it ensures that no other activity can
100356805Smckusick 	 * occur while the underlying object is being cleaned out.
100456805Smckusick 	 */
100569408Smckusick 	VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, p);
100656805Smckusick 	/*
100756805Smckusick 	 * Clean out any buffers associated with the vnode.
100839667Smckusick 	 */
100941300Smckusick 	if (flags & DOCLOSE)
101057792Smckusick 		vinvalbuf(vp, V_SAVE, NOCRED, NULL, 0, 0);
101139667Smckusick 	/*
101256805Smckusick 	 * If purging an active vnode, it must be closed and
101369408Smckusick 	 * deactivated before being reclaimed. Note that the
101469408Smckusick 	 * VOP_INACTIVE will unlock the vnode.
101539433Smckusick 	 */
101639484Smckusick 	if (active) {
101756805Smckusick 		if (flags & DOCLOSE)
101869408Smckusick 			VOP_CLOSE(vp, IO_NDELAY, NOCRED, p);
101969408Smckusick 		VOP_INACTIVE(vp, p);
102069408Smckusick 	} else {
102169408Smckusick 		/*
102269408Smckusick 		 * Any other processes trying to obtain this lock must first
102369408Smckusick 		 * wait for VXLOCK to clear, then call the new lock operation.
102469408Smckusick 		 */
102569408Smckusick 		VOP_UNLOCK(vp, 0, p);
102639433Smckusick 	}
102739433Smckusick 	/*
102839433Smckusick 	 * Reclaim the vnode.
102939433Smckusick 	 */
103069408Smckusick 	if (VOP_RECLAIM(vp, p))
103139433Smckusick 		panic("vclean: cannot reclaim");
103239484Smckusick 	if (active)
103339484Smckusick 		vrele(vp);
103468784Smckusick 	cache_purge(vp);
103553580Sheideman 
103639433Smckusick 	/*
103756805Smckusick 	 * Done with purge, notify sleepers of the grim news.
103839433Smckusick 	 */
103956805Smckusick 	vp->v_op = dead_vnodeop_p;
104056805Smckusick 	vp->v_tag = VT_NON;
104139433Smckusick 	vp->v_flag &= ~VXLOCK;
104239433Smckusick 	if (vp->v_flag & VXWANT) {
104339433Smckusick 		vp->v_flag &= ~VXWANT;
104439433Smckusick 		wakeup((caddr_t)vp);
104539433Smckusick 	}
104639433Smckusick }
104739433Smckusick 
104839433Smckusick /*
104939633Smckusick  * Eliminate all activity associated with  the requested vnode
105039633Smckusick  * and with all vnodes aliased to the requested vnode.
105139633Smckusick  */
105268424Smckusick int
105368424Smckusick vop_revoke(ap)
105468424Smckusick 	struct vop_revoke_args /* {
105568424Smckusick 		struct vnode *a_vp;
105668424Smckusick 		int a_flags;
105768424Smckusick 	} */ *ap;
105839633Smckusick {
105969408Smckusick 	struct vnode *vp, *vq;
106069408Smckusick 	struct proc *p = curproc;	/* XXX */
106139633Smckusick 
106269408Smckusick #ifdef DIAGNOSTIC
106369408Smckusick 	if ((ap->a_flags & REVOKEALL) == 0)
106469408Smckusick 		panic("vop_revoke");
106569408Smckusick #endif
106669408Smckusick 
106768424Smckusick 	vp = ap->a_vp;
106869408Smckusick 	simple_lock(&vp->v_interlock);
106969408Smckusick 
107069408Smckusick 	if (vp->v_flag & VALIASED) {
107140665Smckusick 		/*
107240665Smckusick 		 * If a vgone (or vclean) is already in progress,
107340665Smckusick 		 * wait until it is done and return.
107440665Smckusick 		 */
107540665Smckusick 		if (vp->v_flag & VXLOCK) {
107640665Smckusick 			vp->v_flag |= VXWANT;
107769408Smckusick 			simple_unlock(&vp->v_interlock);
107868424Smckusick 			tsleep((caddr_t)vp, PINOD, "vop_revokeall", 0);
107968424Smckusick 			return (0);
108039633Smckusick 		}
108140665Smckusick 		/*
108240665Smckusick 		 * Ensure that vp will not be vgone'd while we
108340665Smckusick 		 * are eliminating its aliases.
108440665Smckusick 		 */
108540665Smckusick 		vp->v_flag |= VXLOCK;
108669408Smckusick 		simple_unlock(&vp->v_interlock);
108740665Smckusick 		while (vp->v_flag & VALIASED) {
108869408Smckusick 			simple_lock(&spechash_slock);
108940665Smckusick 			for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
109040665Smckusick 				if (vq->v_rdev != vp->v_rdev ||
109140665Smckusick 				    vq->v_type != vp->v_type || vp == vq)
109240665Smckusick 					continue;
109369408Smckusick 				simple_unlock(&spechash_slock);
109440665Smckusick 				vgone(vq);
109540665Smckusick 				break;
109640665Smckusick 			}
109769408Smckusick 			if (vq == NULLVP)
109869408Smckusick 				simple_unlock(&spechash_slock);
109940665Smckusick 		}
110040665Smckusick 		/*
110140665Smckusick 		 * Remove the lock so that vgone below will
110240665Smckusick 		 * really eliminate the vnode after which time
110340665Smckusick 		 * vgone will awaken any sleepers.
110440665Smckusick 		 */
110569408Smckusick 		simple_lock(&vp->v_interlock);
110640665Smckusick 		vp->v_flag &= ~VXLOCK;
110739633Smckusick 	}
110869408Smckusick 	vgonel(vp, p);
110968424Smckusick 	return (0);
111039633Smckusick }
111139633Smckusick 
111239633Smckusick /*
111369408Smckusick  * Recycle an unused vnode to the front of the free list.
111469408Smckusick  * Release the passed interlock if the vnode will be recycled.
111569408Smckusick  */
111669408Smckusick int
111769408Smckusick vrecycle(vp, inter_lkp, p)
111869408Smckusick 	struct vnode *vp;
111969408Smckusick 	struct simplelock *inter_lkp;
112069408Smckusick 	struct proc *p;
112169408Smckusick {
112269408Smckusick 
112369408Smckusick 	simple_lock(&vp->v_interlock);
112469408Smckusick 	if (vp->v_usecount == 0) {
112569408Smckusick 		if (inter_lkp)
112669408Smckusick 			simple_unlock(inter_lkp);
112769408Smckusick 		vgonel(vp, p);
112869408Smckusick 		return (1);
112969408Smckusick 	}
113069408Smckusick 	simple_unlock(&vp->v_interlock);
113169408Smckusick 	return (0);
113269408Smckusick }
113369408Smckusick 
113469408Smckusick /*
113539433Smckusick  * Eliminate all activity associated with a vnode
113639433Smckusick  * in preparation for reuse.
113739433Smckusick  */
113868319Scgd void
113968319Scgd vgone(vp)
114069408Smckusick 	struct vnode *vp;
114139433Smckusick {
114269408Smckusick 	struct proc *p = curproc;	/* XXX */
114369408Smckusick 
114469408Smckusick 	simple_lock(&vp->v_interlock);
114569408Smckusick 	vgonel(vp, p);
114669408Smckusick }
114769408Smckusick 
114869408Smckusick /*
114969408Smckusick  * vgone, with the vp interlock held.
115069408Smckusick  */
115169408Smckusick void
115269408Smckusick vgonel(vp, p)
115369408Smckusick 	struct vnode *vp;
115469408Smckusick 	struct proc *p;
115569408Smckusick {
115669408Smckusick 	struct vnode *vq;
115739615Smckusick 	struct vnode *vx;
115839433Smckusick 
115939433Smckusick 	/*
116040548Smckusick 	 * If a vgone (or vclean) is already in progress,
116140548Smckusick 	 * wait until it is done and return.
116240548Smckusick 	 */
116340548Smckusick 	if (vp->v_flag & VXLOCK) {
116440548Smckusick 		vp->v_flag |= VXWANT;
116569408Smckusick 		simple_unlock(&vp->v_interlock);
116668319Scgd 		tsleep((caddr_t)vp, PINOD, "vgone", 0);
116740548Smckusick 		return;
116840548Smckusick 	}
116940548Smckusick 	/*
117039433Smckusick 	 * Clean out the filesystem specific data.
117139433Smckusick 	 */
117269408Smckusick 	vclean(vp, DOCLOSE, p);
117339433Smckusick 	/*
117439433Smckusick 	 * Delete from old mount point vnode list, if on one.
117539433Smckusick 	 */
117669408Smckusick 	if (vp->v_mount != NULL)
117769408Smckusick 		insmntque(vp, (struct mount *)0);
117839433Smckusick 	/*
117968592Smckusick 	 * If special device, remove it from special device alias list
118068592Smckusick 	 * if it is on one.
118139433Smckusick 	 */
118268592Smckusick 	if ((vp->v_type == VBLK || vp->v_type == VCHR) && vp->v_specinfo != 0) {
118369408Smckusick 		simple_lock(&spechash_slock);
118439809Smckusick 		if (*vp->v_hashchain == vp) {
118539809Smckusick 			*vp->v_hashchain = vp->v_specnext;
118639433Smckusick 		} else {
118739809Smckusick 			for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
118839615Smckusick 				if (vq->v_specnext != vp)
118939433Smckusick 					continue;
119039615Smckusick 				vq->v_specnext = vp->v_specnext;
119139433Smckusick 				break;
119239433Smckusick 			}
119339615Smckusick 			if (vq == NULL)
119439433Smckusick 				panic("missing bdev");
119539433Smckusick 		}
119639615Smckusick 		if (vp->v_flag & VALIASED) {
119752416Storek 			vx = NULL;
119839809Smckusick 			for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
119940108Smckusick 				if (vq->v_rdev != vp->v_rdev ||
120040108Smckusick 				    vq->v_type != vp->v_type)
120139615Smckusick 					continue;
120252416Storek 				if (vx)
120352416Storek 					break;
120439615Smckusick 				vx = vq;
120539615Smckusick 			}
120652416Storek 			if (vx == NULL)
120739615Smckusick 				panic("missing alias");
120852416Storek 			if (vq == NULL)
120939615Smckusick 				vx->v_flag &= ~VALIASED;
121039615Smckusick 			vp->v_flag &= ~VALIASED;
121139615Smckusick 		}
121269408Smckusick 		simple_unlock(&spechash_slock);
121339615Smckusick 		FREE(vp->v_specinfo, M_VNODE);
121439615Smckusick 		vp->v_specinfo = NULL;
121539433Smckusick 	}
121639433Smckusick 	/*
121756932Smckusick 	 * If it is on the freelist and not already at the head,
121865505Smckusick 	 * move it to the head of the list. The test of the back
121965505Smckusick 	 * pointer and the reference count of zero is because
122065505Smckusick 	 * it will be removed from the free list by getnewvnode,
122165505Smckusick 	 * but will not have its reference count incremented until
122265505Smckusick 	 * after calling vgone. If the reference count were
122365505Smckusick 	 * incremented first, vgone would (incorrectly) try to
122465505Smckusick 	 * close the previous instance of the underlying object.
122565505Smckusick 	 * So, the back pointer is explicitly set to `0xdeadb' in
122665505Smckusick 	 * getnewvnode after removing it from the freelist to ensure
122765505Smckusick 	 * that we do not try to move it here.
122839433Smckusick 	 */
122969408Smckusick 	if (vp->v_usecount == 0) {
123069408Smckusick 		simple_lock(&vnode_free_list_slock);
123169408Smckusick 		if ((vp->v_freelist.tqe_prev != (struct vnode **)0xdeadb) &&
123269408Smckusick 		    vnode_free_list.tqh_first != vp) {
123369408Smckusick 			TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
123469408Smckusick 			TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
123569408Smckusick 		}
123669408Smckusick 		simple_unlock(&vnode_free_list_slock);
123739433Smckusick 	}
123839484Smckusick 	vp->v_type = VBAD;
123939433Smckusick }
124039633Smckusick 
124139633Smckusick /*
124239821Smckusick  * Lookup a vnode by device number.
124339821Smckusick  */
124468319Scgd int
124539821Smckusick vfinddev(dev, type, vpp)
124639821Smckusick 	dev_t dev;
124739821Smckusick 	enum vtype type;
124839821Smckusick 	struct vnode **vpp;
124939821Smckusick {
125069408Smckusick 	struct vnode *vp;
125169408Smckusick 	int rc = 0;
125239821Smckusick 
125369408Smckusick 	simple_lock(&spechash_slock);
125439821Smckusick 	for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) {
125539821Smckusick 		if (dev != vp->v_rdev || type != vp->v_type)
125639821Smckusick 			continue;
125739821Smckusick 		*vpp = vp;
125869408Smckusick 		rc = 1;
125969408Smckusick 		break;
126039821Smckusick 	}
126169408Smckusick 	simple_unlock(&spechash_slock);
126269408Smckusick 	return (rc);
126339821Smckusick }
126439821Smckusick 
126539821Smckusick /*
126639633Smckusick  * Calculate the total number of references to a special device.
126739633Smckusick  */
126868319Scgd int
126939633Smckusick vcount(vp)
127069408Smckusick 	struct vnode *vp;
127139633Smckusick {
127269408Smckusick 	struct vnode *vq, *vnext;
127339633Smckusick 	int count;
127439633Smckusick 
127566742Smckusick loop:
127639633Smckusick 	if ((vp->v_flag & VALIASED) == 0)
127739809Smckusick 		return (vp->v_usecount);
127869408Smckusick 	simple_lock(&spechash_slock);
127966742Smckusick 	for (count = 0, vq = *vp->v_hashchain; vq; vq = vnext) {
128066742Smckusick 		vnext = vq->v_specnext;
128140108Smckusick 		if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type)
128239633Smckusick 			continue;
128339633Smckusick 		/*
128439633Smckusick 		 * Alias, but not in use, so flush it out.
128539633Smckusick 		 */
128666742Smckusick 		if (vq->v_usecount == 0 && vq != vp) {
128769408Smckusick 			simple_unlock(&spechash_slock);
128839633Smckusick 			vgone(vq);
128939633Smckusick 			goto loop;
129039633Smckusick 		}
129139809Smckusick 		count += vq->v_usecount;
129239633Smckusick 	}
129369408Smckusick 	simple_unlock(&spechash_slock);
129439633Smckusick 	return (count);
129539633Smckusick }
129639667Smckusick 
129739667Smckusick /*
129839667Smckusick  * Print out a description of a vnode.
129939667Smckusick  */
130039667Smckusick static char *typename[] =
130140286Smckusick    { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" };
130239667Smckusick 
130368171Scgd void
130439667Smckusick vprint(label, vp)
130539667Smckusick 	char *label;
130639667Smckusick 	register struct vnode *vp;
130739667Smckusick {
130839913Smckusick 	char buf[64];
130939667Smckusick 
131039667Smckusick 	if (label != NULL)
131139667Smckusick 		printf("%s: ", label);
131250109Smckusick 	printf("type %s, usecount %d, writecount %d, refcount %d,",
131350109Smckusick 		typename[vp->v_type], vp->v_usecount, vp->v_writecount,
131450109Smckusick 		vp->v_holdcnt);
131539913Smckusick 	buf[0] = '\0';
131639913Smckusick 	if (vp->v_flag & VROOT)
131739913Smckusick 		strcat(buf, "|VROOT");
131839913Smckusick 	if (vp->v_flag & VTEXT)
131939913Smckusick 		strcat(buf, "|VTEXT");
132041300Smckusick 	if (vp->v_flag & VSYSTEM)
132141300Smckusick 		strcat(buf, "|VSYSTEM");
132241300Smckusick 	if (vp->v_flag & VXLOCK)
132341300Smckusick 		strcat(buf, "|VXLOCK");
132441300Smckusick 	if (vp->v_flag & VXWANT)
132541300Smckusick 		strcat(buf, "|VXWANT");
132641300Smckusick 	if (vp->v_flag & VBWAIT)
132741300Smckusick 		strcat(buf, "|VBWAIT");
132839913Smckusick 	if (vp->v_flag & VALIASED)
132939913Smckusick 		strcat(buf, "|VALIASED");
133039913Smckusick 	if (buf[0] != '\0')
133139913Smckusick 		printf(" flags (%s)", &buf[1]);
133265260Smckusick 	if (vp->v_data == NULL) {
133365260Smckusick 		printf("\n");
133465260Smckusick 	} else {
133565260Smckusick 		printf("\n\t");
133665260Smckusick 		VOP_PRINT(vp);
133765260Smckusick 	}
133839667Smckusick }
133941110Smarc 
134049691Smckusick #ifdef DEBUG
134149691Smckusick /*
134249691Smckusick  * List all of the locked vnodes in the system.
134349691Smckusick  * Called when debugging the kernel.
134449691Smckusick  */
134568319Scgd void
134649691Smckusick printlockedvnodes()
134749691Smckusick {
134849691Smckusick 	register struct mount *mp;
134949691Smckusick 	register struct vnode *vp;
135049691Smckusick 
135149691Smckusick 	printf("Locked vnodes\n");
135269325Smckusick 	for (mp = mountlist.cqh_first; mp != (void *)&mountlist;
135369325Smckusick 	     mp = mp->mnt_list.cqe_next) {
135465260Smckusick 		for (vp = mp->mnt_vnodelist.lh_first;
135565260Smckusick 		     vp != NULL;
135669325Smckusick 		     vp = vp->v_mntvnodes.le_next) {
135749691Smckusick 			if (VOP_ISLOCKED(vp))
135849691Smckusick 				vprint((char *)0, vp);
135969325Smckusick 		}
136065260Smckusick 	}
136149691Smckusick }
136249691Smckusick #endif
136349691Smckusick 
136468659Smckusick /*
136568659Smckusick  * Top level filesystem related information gathering.
136668659Smckusick  */
136768659Smckusick int
136868659Smckusick vfs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
136968659Smckusick 	int *name;
137068659Smckusick 	u_int namelen;
137168659Smckusick 	void *oldp;
137268659Smckusick 	size_t *oldlenp;
137368659Smckusick 	void *newp;
137468659Smckusick 	size_t newlen;
137568659Smckusick 	struct proc *p;
137668659Smckusick {
137768659Smckusick 	struct ctldebug *cdp;
137868659Smckusick 	struct vfsconf *vfsp;
137968659Smckusick 
138068659Smckusick 	/* all sysctl names at this level are at least name and field */
138168659Smckusick 	if (namelen < 2)
138268659Smckusick 		return (ENOTDIR);		/* overloaded */
138368659Smckusick 	if (name[0] != VFS_GENERIC) {
138468659Smckusick 		for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
138568659Smckusick 			if (vfsp->vfc_typenum == name[0])
138668659Smckusick 				break;
138768659Smckusick 		if (vfsp == NULL)
138868659Smckusick 			return (EOPNOTSUPP);
138968659Smckusick 		return ((*vfsp->vfc_vfsops->vfs_sysctl)(&name[1], namelen - 1,
139068659Smckusick 		    oldp, oldlenp, newp, newlen, p));
139168659Smckusick 	}
139268659Smckusick 	switch (name[1]) {
139368659Smckusick 	case VFS_MAXTYPENUM:
139468659Smckusick 		return (sysctl_rdint(oldp, oldlenp, newp, maxvfsconf));
139568659Smckusick 	case VFS_CONF:
139668659Smckusick 		if (namelen < 3)
139768659Smckusick 			return (ENOTDIR);	/* overloaded */
139868659Smckusick 		for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
139968659Smckusick 			if (vfsp->vfc_typenum == name[2])
140068659Smckusick 				break;
140168659Smckusick 		if (vfsp == NULL)
140268659Smckusick 			return (EOPNOTSUPP);
140368659Smckusick 		return (sysctl_rdstruct(oldp, oldlenp, newp, vfsp,
140468659Smckusick 		    sizeof(struct vfsconf)));
140568659Smckusick 	}
140668659Smckusick 	return (EOPNOTSUPP);
140768659Smckusick }
140868659Smckusick 
140941110Smarc int kinfo_vdebug = 1;
141041110Smarc int kinfo_vgetfailed;
141141110Smarc #define KINFO_VNODESLOP	10
141241110Smarc /*
141357841Smckusick  * Dump vnode list (via sysctl).
141441110Smarc  * Copyout address of vnode followed by vnode.
141541110Smarc  */
141645118Smckusick /* ARGSUSED */
141768319Scgd int
141857841Smckusick sysctl_vnode(where, sizep)
141941110Smarc 	char *where;
142058465Sbostic 	size_t *sizep;
142141110Smarc {
142265260Smckusick 	register struct mount *mp, *nmp;
142369408Smckusick 	struct vnode *nvp, *vp;
142441110Smarc 	register char *bp = where, *savebp;
142553818Smckusick 	char *ewhere;
142641110Smarc 	int error;
142741110Smarc 
142841110Smarc #define VPTRSZ	sizeof (struct vnode *)
142941110Smarc #define VNODESZ	sizeof (struct vnode)
143041110Smarc 	if (where == NULL) {
143157841Smckusick 		*sizep = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ);
143241110Smarc 		return (0);
143341110Smarc 	}
143457841Smckusick 	ewhere = where + *sizep;
143541110Smarc 
143669325Smckusick 	for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
143769325Smckusick 		nmp = mp->mnt_list.cqe_next;
143865260Smckusick 		if (vfs_busy(mp))
143941300Smckusick 			continue;
144041110Smarc 		savebp = bp;
144141110Smarc again:
144269408Smckusick 		simple_lock(&mntvnode_slock);
144365260Smckusick 		for (vp = mp->mnt_vnodelist.lh_first;
144465260Smckusick 		     vp != NULL;
144569408Smckusick 		     vp = nvp) {
144641422Smckusick 			/*
144741422Smckusick 			 * Check that the vp is still associated with
144841422Smckusick 			 * this filesystem.  RACE: could have been
144941422Smckusick 			 * recycled onto the same filesystem.
145041422Smckusick 			 */
145141421Smckusick 			if (vp->v_mount != mp) {
145269408Smckusick 				simple_unlock(&mntvnode_slock);
145341421Smckusick 				if (kinfo_vdebug)
145441421Smckusick 					printf("kinfo: vp changed\n");
145541421Smckusick 				bp = savebp;
145641421Smckusick 				goto again;
145741421Smckusick 			}
145869408Smckusick 			nvp = vp->v_mntvnodes.le_next;
145957841Smckusick 			if (bp + VPTRSZ + VNODESZ > ewhere) {
146069408Smckusick 				simple_unlock(&mntvnode_slock);
146157841Smckusick 				*sizep = bp - where;
146257841Smckusick 				return (ENOMEM);
146357841Smckusick 			}
146469408Smckusick 			simple_unlock(&mntvnode_slock);
146557841Smckusick 			if ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) ||
146657841Smckusick 			   (error = copyout((caddr_t)vp, bp + VPTRSZ, VNODESZ)))
146741110Smarc 				return (error);
146841110Smarc 			bp += VPTRSZ + VNODESZ;
146969408Smckusick 			simple_lock(&mntvnode_slock);
147041110Smarc 		}
147169408Smckusick 		simple_unlock(&mntvnode_slock);
147265260Smckusick 		vfs_unbusy(mp);
147365260Smckusick 	}
147441110Smarc 
147557841Smckusick 	*sizep = bp - where;
147641110Smarc 	return (0);
147741110Smarc }
147865679Shibler 
147965679Shibler /*
148065679Shibler  * Check to see if a filesystem is mounted on a block device.
148165679Shibler  */
148265679Shibler int
148365679Shibler vfs_mountedon(vp)
148469408Smckusick 	struct vnode *vp;
148565679Shibler {
148669408Smckusick 	struct vnode *vq;
148769408Smckusick 	int error = 0;
148865679Shibler 
148965679Shibler 	if (vp->v_specflags & SI_MOUNTEDON)
149065679Shibler 		return (EBUSY);
149165679Shibler 	if (vp->v_flag & VALIASED) {
149269408Smckusick 		simple_lock(&spechash_slock);
149365679Shibler 		for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
149465679Shibler 			if (vq->v_rdev != vp->v_rdev ||
149565679Shibler 			    vq->v_type != vp->v_type)
149665679Shibler 				continue;
149769408Smckusick 			if (vq->v_specflags & SI_MOUNTEDON) {
149869408Smckusick 				error = EBUSY;
149969408Smckusick 				break;
150069408Smckusick 			}
150165679Shibler 		}
150269408Smckusick 		simple_unlock(&spechash_slock);
150365679Shibler 	}
150469408Smckusick 	return (error);
150565679Shibler }
150665679Shibler 
150765679Shibler /*
150869325Smckusick  * Unmount all filesystems. The list is traversed in reverse order
150969325Smckusick  * of mounting to avoid dependencies.
151069325Smckusick  */
151169325Smckusick void
151269325Smckusick vfs_unmountall()
151369325Smckusick {
151469325Smckusick 	struct mount *mp, *nmp;
151569325Smckusick 
151669325Smckusick 	for (mp = mountlist.cqh_last; mp != (void *)&mountlist; mp = nmp) {
151769325Smckusick 		nmp = mp->mnt_list.cqe_prev;
151869325Smckusick 		(void) dounmount(mp, MNT_FORCE, &proc0);
151969325Smckusick 	}
152069325Smckusick }
152169325Smckusick 
152269325Smckusick /*
152365679Shibler  * Build hash lists of net addresses and hang them off the mount point.
152465679Shibler  * Called by ufs_mount() to set up the lists of export addresses.
152565679Shibler  */
152665679Shibler static int
152765679Shibler vfs_hang_addrlist(mp, nep, argp)
152865679Shibler 	struct mount *mp;
152965679Shibler 	struct netexport *nep;
153065679Shibler 	struct export_args *argp;
153165679Shibler {
153265679Shibler 	register struct netcred *np;
153365679Shibler 	register struct radix_node_head *rnh;
153465679Shibler 	register int i;
153565679Shibler 	struct radix_node *rn;
153665679Shibler 	struct sockaddr *saddr, *smask = 0;
153765679Shibler 	struct domain *dom;
153865679Shibler 	int error;
153965679Shibler 
154065679Shibler 	if (argp->ex_addrlen == 0) {
154165679Shibler 		if (mp->mnt_flag & MNT_DEFEXPORTED)
154265679Shibler 			return (EPERM);
154365679Shibler 		np = &nep->ne_defexported;
154465679Shibler 		np->netc_exflags = argp->ex_flags;
154565679Shibler 		np->netc_anon = argp->ex_anon;
154665679Shibler 		np->netc_anon.cr_ref = 1;
154765679Shibler 		mp->mnt_flag |= MNT_DEFEXPORTED;
154865679Shibler 		return (0);
154965679Shibler 	}
155065679Shibler 	i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen;
155165679Shibler 	np = (struct netcred *)malloc(i, M_NETADDR, M_WAITOK);
155265679Shibler 	bzero((caddr_t)np, i);
155365679Shibler 	saddr = (struct sockaddr *)(np + 1);
155465679Shibler 	if (error = copyin(argp->ex_addr, (caddr_t)saddr, argp->ex_addrlen))
155565679Shibler 		goto out;
155665679Shibler 	if (saddr->sa_len > argp->ex_addrlen)
155765679Shibler 		saddr->sa_len = argp->ex_addrlen;
155865679Shibler 	if (argp->ex_masklen) {
155965679Shibler 		smask = (struct sockaddr *)((caddr_t)saddr + argp->ex_addrlen);
156065679Shibler 		error = copyin(argp->ex_addr, (caddr_t)smask, argp->ex_masklen);
156165679Shibler 		if (error)
156265679Shibler 			goto out;
156365679Shibler 		if (smask->sa_len > argp->ex_masklen)
156465679Shibler 			smask->sa_len = argp->ex_masklen;
156565679Shibler 	}
156665679Shibler 	i = saddr->sa_family;
156765679Shibler 	if ((rnh = nep->ne_rtable[i]) == 0) {
156865679Shibler 		/*
156965679Shibler 		 * Seems silly to initialize every AF when most are not
157065679Shibler 		 * used, do so on demand here
157165679Shibler 		 */
157265679Shibler 		for (dom = domains; dom; dom = dom->dom_next)
157365679Shibler 			if (dom->dom_family == i && dom->dom_rtattach) {
157465679Shibler 				dom->dom_rtattach((void **)&nep->ne_rtable[i],
157565679Shibler 					dom->dom_rtoffset);
157665679Shibler 				break;
157765679Shibler 			}
157865679Shibler 		if ((rnh = nep->ne_rtable[i]) == 0) {
157965679Shibler 			error = ENOBUFS;
158065679Shibler 			goto out;
158165679Shibler 		}
158265679Shibler 	}
158365679Shibler 	rn = (*rnh->rnh_addaddr)((caddr_t)saddr, (caddr_t)smask, rnh,
158465679Shibler 		np->netc_rnodes);
158569140Smckusick 	if (rn == 0) {
158669140Smckusick 		/*
158769140Smckusick 		 * One of the reasons that rnh_addaddr may fail is that
158869140Smckusick 		 * the entry already exists. To check for this case, we
158969140Smckusick 		 * look up the entry to see if it is there. If so, we
159069140Smckusick 		 * do not need to make a new entry but do return success.
159169140Smckusick 		 */
159269140Smckusick 		free(np, M_NETADDR);
159369140Smckusick 		rn = (*rnh->rnh_matchaddr)((caddr_t)saddr, rnh);
159469140Smckusick 		if (rn != 0 && (rn->rn_flags & RNF_ROOT) == 0 &&
159569140Smckusick 		    ((struct netcred *)rn)->netc_exflags == argp->ex_flags &&
159669140Smckusick 		    !bcmp((caddr_t)&((struct netcred *)rn)->netc_anon,
159769140Smckusick 			    (caddr_t)&argp->ex_anon, sizeof(struct ucred)))
159869140Smckusick 			return (0);
159969140Smckusick 		return (EPERM);
160065679Shibler 	}
160165679Shibler 	np->netc_exflags = argp->ex_flags;
160265679Shibler 	np->netc_anon = argp->ex_anon;
160365679Shibler 	np->netc_anon.cr_ref = 1;
160465679Shibler 	return (0);
160565679Shibler out:
160665679Shibler 	free(np, M_NETADDR);
160765679Shibler 	return (error);
160865679Shibler }
160965679Shibler 
161065679Shibler /* ARGSUSED */
161165679Shibler static int
161265679Shibler vfs_free_netcred(rn, w)
161365679Shibler 	struct radix_node *rn;
161465679Shibler 	caddr_t w;
161565679Shibler {
161665679Shibler 	register struct radix_node_head *rnh = (struct radix_node_head *)w;
161765679Shibler 
161865679Shibler 	(*rnh->rnh_deladdr)(rn->rn_key, rn->rn_mask, rnh);
161965679Shibler 	free((caddr_t)rn, M_NETADDR);
162065679Shibler 	return (0);
162165679Shibler }
162268319Scgd 
162365679Shibler /*
162465679Shibler  * Free the net address hash lists that are hanging off the mount points.
162565679Shibler  */
162665679Shibler static void
162765679Shibler vfs_free_addrlist(nep)
162865679Shibler 	struct netexport *nep;
162965679Shibler {
163065679Shibler 	register int i;
163165679Shibler 	register struct radix_node_head *rnh;
163265679Shibler 
163365679Shibler 	for (i = 0; i <= AF_MAX; i++)
163465679Shibler 		if (rnh = nep->ne_rtable[i]) {
163565679Shibler 			(*rnh->rnh_walktree)(rnh, vfs_free_netcred,
163665679Shibler 			    (caddr_t)rnh);
163765679Shibler 			free((caddr_t)rnh, M_RTABLE);
163865679Shibler 			nep->ne_rtable[i] = 0;
163965679Shibler 		}
164065679Shibler }
164165679Shibler 
164265679Shibler int
164365679Shibler vfs_export(mp, nep, argp)
164465679Shibler 	struct mount *mp;
164565679Shibler 	struct netexport *nep;
164665679Shibler 	struct export_args *argp;
164765679Shibler {
164865679Shibler 	int error;
164965679Shibler 
165065679Shibler 	if (argp->ex_flags & MNT_DELEXPORT) {
165165679Shibler 		vfs_free_addrlist(nep);
165265679Shibler 		mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED);
165365679Shibler 	}
165465679Shibler 	if (argp->ex_flags & MNT_EXPORTED) {
165565679Shibler 		if (error = vfs_hang_addrlist(mp, nep, argp))
165665679Shibler 			return (error);
165765679Shibler 		mp->mnt_flag |= MNT_EXPORTED;
165865679Shibler 	}
165965679Shibler 	return (0);
166065679Shibler }
166165679Shibler 
166265679Shibler struct netcred *
166365679Shibler vfs_export_lookup(mp, nep, nam)
166465679Shibler 	register struct mount *mp;
166565679Shibler 	struct netexport *nep;
166665679Shibler 	struct mbuf *nam;
166765679Shibler {
166865679Shibler 	register struct netcred *np;
166965679Shibler 	register struct radix_node_head *rnh;
167065679Shibler 	struct sockaddr *saddr;
167165679Shibler 
167265679Shibler 	np = NULL;
167365679Shibler 	if (mp->mnt_flag & MNT_EXPORTED) {
167465679Shibler 		/*
167565679Shibler 		 * Lookup in the export list first.
167665679Shibler 		 */
167765679Shibler 		if (nam != NULL) {
167865679Shibler 			saddr = mtod(nam, struct sockaddr *);
167965679Shibler 			rnh = nep->ne_rtable[saddr->sa_family];
168065679Shibler 			if (rnh != NULL) {
168165679Shibler 				np = (struct netcred *)
168265679Shibler 					(*rnh->rnh_matchaddr)((caddr_t)saddr,
168365679Shibler 							      rnh);
168465679Shibler 				if (np && np->netc_rnodes->rn_flags & RNF_ROOT)
168565679Shibler 					np = NULL;
168665679Shibler 			}
168765679Shibler 		}
168865679Shibler 		/*
168965679Shibler 		 * If no address match, use the default if it exists.
169065679Shibler 		 */
169165679Shibler 		if (np == NULL && mp->mnt_flag & MNT_DEFEXPORTED)
169265679Shibler 			np = &nep->ne_defexported;
169365679Shibler 	}
169465679Shibler 	return (np);
169565679Shibler }
1696