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*68659Smckusick * @(#)vfs_subr.c 8.18 (Berkeley) 03/30/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 */ 5865260Smckusick 5956608Smckusick /* 6065260Smckusick * Initialize the vnode management data structures. 6137488Smckusick */ 6268319Scgd void 6365260Smckusick vntblinit() 6437488Smckusick { 6537488Smckusick 6665260Smckusick TAILQ_INIT(&vnode_free_list); 6765260Smckusick TAILQ_INIT(&mountlist); 6837488Smckusick } 6937488Smckusick 7037488Smckusick /* 7137488Smckusick * Lock a filesystem. 7237488Smckusick * Used to prevent access to it while mounting and unmounting. 7337488Smckusick */ 7468319Scgd int 7537488Smckusick vfs_lock(mp) 7637488Smckusick register struct mount *mp; 7737488Smckusick { 7837488Smckusick 7968319Scgd while (mp->mnt_flag & MNT_MLOCK) { 8041400Smckusick mp->mnt_flag |= MNT_MWAIT; 8168319Scgd tsleep((caddr_t)mp, PVFS, "vfslock", 0); 8239045Smckusick } 8341400Smckusick mp->mnt_flag |= MNT_MLOCK; 8437488Smckusick return (0); 8537488Smckusick } 8637488Smckusick 8737488Smckusick /* 8837488Smckusick * Unlock a locked filesystem. 8937488Smckusick * Panic if filesystem is not locked. 9037488Smckusick */ 9137488Smckusick void 9237488Smckusick vfs_unlock(mp) 9337488Smckusick register struct mount *mp; 9437488Smckusick { 9537488Smckusick 9641400Smckusick if ((mp->mnt_flag & MNT_MLOCK) == 0) 9741300Smckusick panic("vfs_unlock: not locked"); 9841400Smckusick mp->mnt_flag &= ~MNT_MLOCK; 9941400Smckusick if (mp->mnt_flag & MNT_MWAIT) { 10041400Smckusick mp->mnt_flag &= ~MNT_MWAIT; 10137488Smckusick wakeup((caddr_t)mp); 10237488Smckusick } 10337488Smckusick } 10437488Smckusick 10537488Smckusick /* 10641300Smckusick * Mark a mount point as busy. 10741300Smckusick * Used to synchronize access and to delay unmounting. 10841300Smckusick */ 10968319Scgd int 11041300Smckusick vfs_busy(mp) 11141300Smckusick register struct mount *mp; 11241300Smckusick { 11341300Smckusick 11468319Scgd while (mp->mnt_flag & MNT_MPBUSY) { 11541400Smckusick mp->mnt_flag |= MNT_MPWANT; 11668319Scgd tsleep((caddr_t)&mp->mnt_flag, PVFS, "vfsbusy", 0); 11741300Smckusick } 11841419Smckusick if (mp->mnt_flag & MNT_UNMOUNT) 11941419Smckusick return (1); 12041400Smckusick mp->mnt_flag |= MNT_MPBUSY; 12141300Smckusick return (0); 12241300Smckusick } 12341300Smckusick 12441300Smckusick /* 12541300Smckusick * Free a busy filesystem. 12641300Smckusick * Panic if filesystem is not busy. 12741300Smckusick */ 12868319Scgd void 12941300Smckusick vfs_unbusy(mp) 13041300Smckusick register struct mount *mp; 13141300Smckusick { 13241300Smckusick 13341400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 13441300Smckusick panic("vfs_unbusy: not busy"); 13541400Smckusick mp->mnt_flag &= ~MNT_MPBUSY; 13641400Smckusick if (mp->mnt_flag & MNT_MPWANT) { 13741400Smckusick mp->mnt_flag &= ~MNT_MPWANT; 13841400Smckusick wakeup((caddr_t)&mp->mnt_flag); 13941300Smckusick } 14041300Smckusick } 14141300Smckusick 14241300Smckusick /* 14337488Smckusick * Lookup a mount point by filesystem identifier. 14437488Smckusick */ 14537488Smckusick struct mount * 146*68659Smckusick vfs_getvfs(fsid) 14737488Smckusick fsid_t *fsid; 14837488Smckusick { 14937488Smckusick register struct mount *mp; 15037488Smckusick 15165260Smckusick for (mp = mountlist.tqh_first; mp != NULL; mp = mp->mnt_list.tqe_next) { 15241400Smckusick if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] && 15365260Smckusick mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) 15438288Smckusick return (mp); 15565260Smckusick } 15638288Smckusick return ((struct mount *)0); 15737488Smckusick } 15837488Smckusick 15937488Smckusick /* 16053829Spendry * Get a new unique fsid 16153829Spendry */ 16253829Spendry void 163*68659Smckusick vfs_getnewfsid(mp) 16453829Spendry struct mount *mp; 16553829Spendry { 16653829Spendry static u_short xxxfs_mntid; 16753829Spendry 16853829Spendry fsid_t tfsid; 169*68659Smckusick int mtype; 17053829Spendry 171*68659Smckusick mtype = mp->mnt_vfc->vfc_typenum; 17265507Spendry mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev + mtype, 0); 17353829Spendry mp->mnt_stat.f_fsid.val[1] = mtype; 17453829Spendry if (xxxfs_mntid == 0) 17553829Spendry ++xxxfs_mntid; 17665507Spendry tfsid.val[0] = makedev(nblkdev + mtype, xxxfs_mntid); 17753829Spendry tfsid.val[1] = mtype; 17865260Smckusick if (mountlist.tqh_first != NULL) { 179*68659Smckusick while (vfs_getvfs(&tfsid)) { 18053936Spendry tfsid.val[0]++; 18153936Spendry xxxfs_mntid++; 18253936Spendry } 18353829Spendry } 18453829Spendry mp->mnt_stat.f_fsid.val[0] = tfsid.val[0]; 18553829Spendry } 18653829Spendry 18753829Spendry /* 18837488Smckusick * Set vnode attributes to VNOVAL 18937488Smckusick */ 19068319Scgd void 19168319Scgd vattr_null(vap) 19237488Smckusick register struct vattr *vap; 19337488Smckusick { 19437488Smckusick 19537488Smckusick vap->va_type = VNON; 19652005Smckusick vap->va_size = vap->va_bytes = VNOVAL; 19737488Smckusick vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid = 19852005Smckusick vap->va_fsid = vap->va_fileid = 19952005Smckusick vap->va_blocksize = vap->va_rdev = 20054347Smckusick vap->va_atime.ts_sec = vap->va_atime.ts_nsec = 20154347Smckusick vap->va_mtime.ts_sec = vap->va_mtime.ts_nsec = 20254347Smckusick vap->va_ctime.ts_sec = vap->va_ctime.ts_nsec = 20338258Smckusick vap->va_flags = vap->va_gen = VNOVAL; 20458548Sbostic vap->va_vaflags = 0; 20537488Smckusick } 20638265Smckusick 20738265Smckusick /* 20839397Smckusick * Routines having to do with the management of the vnode table. 20939397Smckusick */ 21053547Sheideman extern int (**dead_vnodeop_p)(); 21139635Smckusick extern void vclean(); 21240883Smckusick long numvnodes; 21353493Sheideman extern struct vattr va_null; 21439397Smckusick 21539397Smckusick /* 21639397Smckusick * Return the next vnode from the free list. 21739397Smckusick */ 21868319Scgd int 21939397Smckusick getnewvnode(tag, mp, vops, vpp) 22039397Smckusick enum vtagtype tag; 22139397Smckusick struct mount *mp; 22253495Sheideman int (**vops)(); 22339397Smckusick struct vnode **vpp; 22439397Smckusick { 22565511Smckusick register struct vnode *vp; 22657042Smargo int s; 22739397Smckusick 22865260Smckusick if ((vnode_free_list.tqh_first == NULL && 22965260Smckusick numvnodes < 2 * desiredvnodes) || 23054347Smckusick numvnodes < desiredvnodes) { 23145118Smckusick vp = (struct vnode *)malloc((u_long)sizeof *vp, 23245118Smckusick M_VNODE, M_WAITOK); 23340883Smckusick bzero((char *)vp, sizeof *vp); 23440883Smckusick numvnodes++; 23540883Smckusick } else { 23665260Smckusick if ((vp = vnode_free_list.tqh_first) == NULL) { 23740883Smckusick tablefull("vnode"); 23840883Smckusick *vpp = 0; 23940883Smckusick return (ENFILE); 24040883Smckusick } 24140883Smckusick if (vp->v_usecount) 24240883Smckusick panic("free vnode isn't"); 24365260Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 24465505Smckusick /* see comment on why 0xdeadb is set at end of vgone (below) */ 24565505Smckusick vp->v_freelist.tqe_prev = (struct vnode **)0xdeadb; 24652190Smckusick vp->v_lease = NULL; 24740883Smckusick if (vp->v_type != VBAD) 24868424Smckusick VOP_REVOKE(vp, 0); 24957042Smargo #ifdef DIAGNOSTIC 25052006Smckusick if (vp->v_data) 25152006Smckusick panic("cleaned vnode isn't"); 25257042Smargo s = splbio(); 25357042Smargo if (vp->v_numoutput) 25457042Smargo panic("Clean vnode has pending I/O's"); 25557042Smargo splx(s); 25657042Smargo #endif 25740883Smckusick vp->v_flag = 0; 25840883Smckusick vp->v_lastr = 0; 25965745Shibler vp->v_ralen = 0; 26065745Shibler vp->v_maxra = 0; 26157042Smargo vp->v_lastw = 0; 26257042Smargo vp->v_lasta = 0; 26357042Smargo vp->v_cstart = 0; 26457042Smargo vp->v_clen = 0; 26540883Smckusick vp->v_socket = 0; 26639397Smckusick } 26739512Smckusick vp->v_type = VNON; 26839397Smckusick cache_purge(vp); 26939397Smckusick vp->v_tag = tag; 27039433Smckusick vp->v_op = vops; 27139397Smckusick insmntque(vp, mp); 27239397Smckusick *vpp = vp; 27365505Smckusick vp->v_usecount = 1; 27465260Smckusick vp->v_data = 0; 27539397Smckusick return (0); 27639397Smckusick } 27765679Shibler 27839397Smckusick /* 27939397Smckusick * Move a vnode from one mount queue to another. 28039397Smckusick */ 28168319Scgd void 28239397Smckusick insmntque(vp, mp) 28339397Smckusick register struct vnode *vp; 28439397Smckusick register struct mount *mp; 28539397Smckusick { 28639397Smckusick 28739397Smckusick /* 28839397Smckusick * Delete from old mount point vnode list, if on one. 28939397Smckusick */ 29065679Shibler if (vp->v_mount != NULL) 29165260Smckusick LIST_REMOVE(vp, v_mntvnodes); 29239397Smckusick /* 29339397Smckusick * Insert into list of vnodes for the new mount point, if available. 29439397Smckusick */ 29565260Smckusick if ((vp->v_mount = mp) == NULL) 29639397Smckusick return; 29765260Smckusick LIST_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes); 29839397Smckusick } 29939397Smckusick 30039397Smckusick /* 30149232Smckusick * Update outstanding I/O count and do wakeup if requested. 30249232Smckusick */ 30368319Scgd void 30449232Smckusick vwakeup(bp) 30549232Smckusick register struct buf *bp; 30649232Smckusick { 30749232Smckusick register struct vnode *vp; 30849232Smckusick 30957810Smckusick bp->b_flags &= ~B_WRITEINPROG; 31049232Smckusick if (vp = bp->b_vp) { 31168319Scgd if (--vp->v_numoutput < 0) 31257042Smargo panic("vwakeup: neg numoutput"); 31349232Smckusick if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) { 31449232Smckusick if (vp->v_numoutput < 0) 31568319Scgd panic("vwakeup: neg numoutput 2"); 31649232Smckusick vp->v_flag &= ~VBWAIT; 31749232Smckusick wakeup((caddr_t)&vp->v_numoutput); 31849232Smckusick } 31949232Smckusick } 32049232Smckusick } 32149232Smckusick 32249232Smckusick /* 32349232Smckusick * Flush out and invalidate all buffers associated with a vnode. 32449232Smckusick * Called with the underlying object locked. 32549232Smckusick */ 32654442Smckusick int 32757792Smckusick vinvalbuf(vp, flags, cred, p, slpflag, slptimeo) 32849232Smckusick register struct vnode *vp; 32956459Smargo int flags; 33054442Smckusick struct ucred *cred; 33154442Smckusick struct proc *p; 33257792Smckusick int slpflag, slptimeo; 33349232Smckusick { 33449232Smckusick register struct buf *bp; 33549232Smckusick struct buf *nbp, *blist; 33654442Smckusick int s, error; 33749232Smckusick 33856459Smargo if (flags & V_SAVE) { 33954442Smckusick if (error = VOP_FSYNC(vp, cred, MNT_WAIT, p)) 34054442Smckusick return (error); 34165260Smckusick if (vp->v_dirtyblkhd.lh_first != NULL) 34254442Smckusick panic("vinvalbuf: dirty bufs"); 34354442Smckusick } 34449232Smckusick for (;;) { 34565260Smckusick if ((blist = vp->v_cleanblkhd.lh_first) && flags & V_SAVEMETA) 34656459Smargo while (blist && blist->b_lblkno < 0) 34765260Smckusick blist = blist->b_vnbufs.le_next; 34868319Scgd if (!blist && (blist = vp->v_dirtyblkhd.lh_first) && 34956608Smckusick (flags & V_SAVEMETA)) 35056459Smargo while (blist && blist->b_lblkno < 0) 35165260Smckusick blist = blist->b_vnbufs.le_next; 35256459Smargo if (!blist) 35349232Smckusick break; 35456459Smargo 35549232Smckusick for (bp = blist; bp; bp = nbp) { 35665260Smckusick nbp = bp->b_vnbufs.le_next; 35756459Smargo if (flags & V_SAVEMETA && bp->b_lblkno < 0) 35856459Smargo continue; 35949232Smckusick s = splbio(); 36049232Smckusick if (bp->b_flags & B_BUSY) { 36149232Smckusick bp->b_flags |= B_WANTED; 36257792Smckusick error = tsleep((caddr_t)bp, 36357792Smckusick slpflag | (PRIBIO + 1), "vinvalbuf", 36457792Smckusick slptimeo); 36549232Smckusick splx(s); 36657792Smckusick if (error) 36757792Smckusick return (error); 36849232Smckusick break; 36949232Smckusick } 37049232Smckusick bremfree(bp); 37149232Smckusick bp->b_flags |= B_BUSY; 37249232Smckusick splx(s); 37357792Smckusick /* 37457792Smckusick * XXX Since there are no node locks for NFS, I believe 37557792Smckusick * there is a slight chance that a delayed write will 37657792Smckusick * occur while sleeping just above, so check for it. 37757792Smckusick */ 37857792Smckusick if ((bp->b_flags & B_DELWRI) && (flags & V_SAVE)) { 37957792Smckusick (void) VOP_BWRITE(bp); 38057792Smckusick break; 38157792Smckusick } 38256459Smargo bp->b_flags |= B_INVAL; 38349232Smckusick brelse(bp); 38449232Smckusick } 38549232Smckusick } 38656608Smckusick if (!(flags & V_SAVEMETA) && 38765260Smckusick (vp->v_dirtyblkhd.lh_first || vp->v_cleanblkhd.lh_first)) 38849232Smckusick panic("vinvalbuf: flush failed"); 38954442Smckusick return (0); 39049232Smckusick } 39149232Smckusick 39249232Smckusick /* 39349232Smckusick * Associate a buffer with a vnode. 39449232Smckusick */ 39568319Scgd void 39649232Smckusick bgetvp(vp, bp) 39749232Smckusick register struct vnode *vp; 39849232Smckusick register struct buf *bp; 39949232Smckusick { 40049232Smckusick 40149232Smckusick if (bp->b_vp) 40249232Smckusick panic("bgetvp: not free"); 40349232Smckusick VHOLD(vp); 40449232Smckusick bp->b_vp = vp; 40549232Smckusick if (vp->v_type == VBLK || vp->v_type == VCHR) 40649232Smckusick bp->b_dev = vp->v_rdev; 40749232Smckusick else 40849232Smckusick bp->b_dev = NODEV; 40949232Smckusick /* 41049232Smckusick * Insert onto list for new vnode. 41149232Smckusick */ 41256608Smckusick bufinsvn(bp, &vp->v_cleanblkhd); 41349232Smckusick } 41449232Smckusick 41549232Smckusick /* 41649232Smckusick * Disassociate a buffer from a vnode. 41749232Smckusick */ 41868319Scgd void 41949232Smckusick brelvp(bp) 42049232Smckusick register struct buf *bp; 42149232Smckusick { 42249232Smckusick struct vnode *vp; 42349232Smckusick 42449232Smckusick if (bp->b_vp == (struct vnode *) 0) 42549232Smckusick panic("brelvp: NULL"); 42649232Smckusick /* 42749232Smckusick * Delete from old vnode list, if on one. 42849232Smckusick */ 42965260Smckusick if (bp->b_vnbufs.le_next != NOLIST) 43056608Smckusick bufremvn(bp); 43149232Smckusick vp = bp->b_vp; 43249232Smckusick bp->b_vp = (struct vnode *) 0; 43349232Smckusick HOLDRELE(vp); 43449232Smckusick } 43549232Smckusick 43649232Smckusick /* 43749232Smckusick * Reassign a buffer from one vnode to another. 43849232Smckusick * Used to assign file specific control information 43949232Smckusick * (indirect blocks) to the vnode to which they belong. 44049232Smckusick */ 44168319Scgd void 44249232Smckusick reassignbuf(bp, newvp) 44349232Smckusick register struct buf *bp; 44449232Smckusick register struct vnode *newvp; 44549232Smckusick { 44665260Smckusick register struct buflists *listheadp; 44749232Smckusick 44852655Smckusick if (newvp == NULL) { 44952655Smckusick printf("reassignbuf: NULL"); 45052655Smckusick return; 45152655Smckusick } 45249232Smckusick /* 45349232Smckusick * Delete from old vnode list, if on one. 45449232Smckusick */ 45565260Smckusick if (bp->b_vnbufs.le_next != NOLIST) 45656608Smckusick bufremvn(bp); 45749232Smckusick /* 45849232Smckusick * If dirty, put on list of dirty buffers; 45949232Smckusick * otherwise insert onto list of clean buffers. 46049232Smckusick */ 46149232Smckusick if (bp->b_flags & B_DELWRI) 46249232Smckusick listheadp = &newvp->v_dirtyblkhd; 46349232Smckusick else 46449232Smckusick listheadp = &newvp->v_cleanblkhd; 46556608Smckusick bufinsvn(bp, listheadp); 46649232Smckusick } 46749232Smckusick 46849232Smckusick /* 46939433Smckusick * Create a vnode for a block device. 47039433Smckusick * Used for root filesystem, argdev, and swap areas. 47139433Smckusick * Also used for memory file system special devices. 47239397Smckusick */ 47368319Scgd int 47439433Smckusick bdevvp(dev, vpp) 47539433Smckusick dev_t dev; 47639433Smckusick struct vnode **vpp; 47739433Smckusick { 47839433Smckusick register struct vnode *vp; 47939433Smckusick struct vnode *nvp; 48039433Smckusick int error; 48139433Smckusick 48246989Smckusick if (dev == NODEV) 48346989Smckusick return (0); 48453547Sheideman error = getnewvnode(VT_NON, (struct mount *)0, spec_vnodeop_p, &nvp); 48539433Smckusick if (error) { 48668319Scgd *vpp = NULLVP; 48739433Smckusick return (error); 48839433Smckusick } 48939433Smckusick vp = nvp; 49039433Smckusick vp->v_type = VBLK; 49139615Smckusick if (nvp = checkalias(vp, dev, (struct mount *)0)) { 49239433Smckusick vput(vp); 49339433Smckusick vp = nvp; 49439433Smckusick } 49539433Smckusick *vpp = vp; 49639433Smckusick return (0); 49739433Smckusick } 49839433Smckusick 49939433Smckusick /* 50039433Smckusick * Check to see if the new vnode represents a special device 50139433Smckusick * for which we already have a vnode (either because of 50239433Smckusick * bdevvp() or because of a different vnode representing 50339433Smckusick * the same block device). If such an alias exists, deallocate 50439509Smckusick * the existing contents and return the aliased vnode. The 50539433Smckusick * caller is responsible for filling it with its new contents. 50639433Smckusick */ 50739433Smckusick struct vnode * 50839615Smckusick checkalias(nvp, nvp_rdev, mp) 50939433Smckusick register struct vnode *nvp; 51039615Smckusick dev_t nvp_rdev; 51139433Smckusick struct mount *mp; 51239433Smckusick { 51339433Smckusick register struct vnode *vp; 51439615Smckusick struct vnode **vpp; 51539433Smckusick 51639433Smckusick if (nvp->v_type != VBLK && nvp->v_type != VCHR) 51741400Smckusick return (NULLVP); 51839615Smckusick 51939615Smckusick vpp = &speclisth[SPECHASH(nvp_rdev)]; 52039433Smckusick loop: 52139615Smckusick for (vp = *vpp; vp; vp = vp->v_specnext) { 52239615Smckusick if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type) 52339433Smckusick continue; 52439615Smckusick /* 52539615Smckusick * Alias, but not in use, so flush it out. 52639615Smckusick */ 52739809Smckusick if (vp->v_usecount == 0) { 52839615Smckusick vgone(vp); 52939615Smckusick goto loop; 53039615Smckusick } 53165260Smckusick if (vget(vp, 1)) 53239633Smckusick goto loop; 53339433Smckusick break; 53439433Smckusick } 53539615Smckusick if (vp == NULL || vp->v_tag != VT_NON) { 53639615Smckusick MALLOC(nvp->v_specinfo, struct specinfo *, 53739615Smckusick sizeof(struct specinfo), M_VNODE, M_WAITOK); 53839615Smckusick nvp->v_rdev = nvp_rdev; 53939809Smckusick nvp->v_hashchain = vpp; 54039615Smckusick nvp->v_specnext = *vpp; 54142152Smckusick nvp->v_specflags = 0; 54239615Smckusick *vpp = nvp; 54340640Smckusick if (vp != NULL) { 54440640Smckusick nvp->v_flag |= VALIASED; 54540640Smckusick vp->v_flag |= VALIASED; 54640640Smckusick vput(vp); 54740640Smckusick } 54841400Smckusick return (NULLVP); 54939433Smckusick } 55039484Smckusick VOP_UNLOCK(vp); 55139484Smckusick vclean(vp, 0); 55239433Smckusick vp->v_op = nvp->v_op; 55339433Smckusick vp->v_tag = nvp->v_tag; 55439433Smckusick nvp->v_type = VNON; 55539433Smckusick insmntque(vp, mp); 55639433Smckusick return (vp); 55739433Smckusick } 55839433Smckusick 55939433Smckusick /* 56039433Smckusick * Grab a particular vnode from the free list, increment its 56139433Smckusick * reference count and lock it. The vnode lock bit is set the 56239433Smckusick * vnode is being eliminated in vgone. The process is awakened 56339433Smckusick * when the transition is completed, and an error returned to 56439433Smckusick * indicate that the vnode is no longer usable (possibly having 56539433Smckusick * been changed to a new file system type). 56639433Smckusick */ 56768319Scgd int 56865260Smckusick vget(vp, lockflag) 56939397Smckusick register struct vnode *vp; 57065260Smckusick int lockflag; 57139397Smckusick { 57239397Smckusick 57366897Smckusick /* 57466897Smckusick * If the vnode is in the process of being cleaned out for 57566897Smckusick * another use, we wait for the cleaning to finish and then 57666897Smckusick * return failure. Cleaning is determined either by checking 57766897Smckusick * that the VXLOCK flag is set, or that the use count is 57866897Smckusick * zero with the back pointer set to show that it has been 57966897Smckusick * removed from the free list by getnewvnode. The VXLOCK 58066897Smckusick * flag may not have been set yet because vclean is blocked in 58166897Smckusick * the VOP_LOCK call waiting for the VOP_INACTIVE to complete. 58266897Smckusick */ 58366897Smckusick if ((vp->v_flag & VXLOCK) || 58466897Smckusick (vp->v_usecount == 0 && 58566897Smckusick vp->v_freelist.tqe_prev == (struct vnode **)0xdeadb)) { 58639433Smckusick vp->v_flag |= VXWANT; 58768319Scgd tsleep((caddr_t)vp, PINOD, "vget", 0); 58839433Smckusick return (1); 58939433Smckusick } 59066897Smckusick if (vp->v_usecount == 0) 59165260Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 59259450Smckusick vp->v_usecount++; 59365260Smckusick if (lockflag) 59465260Smckusick VOP_LOCK(vp); 59539433Smckusick return (0); 59639397Smckusick } 59739397Smckusick 59839397Smckusick /* 59939397Smckusick * Vnode reference, just increment the count 60039397Smckusick */ 60168319Scgd void 60268319Scgd vref(vp) 60339397Smckusick struct vnode *vp; 60439397Smckusick { 60539397Smckusick 60659450Smckusick if (vp->v_usecount <= 0) 60759450Smckusick panic("vref used where vget required"); 60839809Smckusick vp->v_usecount++; 60939397Smckusick } 61039397Smckusick 61139397Smckusick /* 61239397Smckusick * vput(), just unlock and vrele() 61339397Smckusick */ 61468319Scgd void 61568319Scgd vput(vp) 61639397Smckusick register struct vnode *vp; 61739397Smckusick { 61852416Storek 61939397Smckusick VOP_UNLOCK(vp); 62039397Smckusick vrele(vp); 62139397Smckusick } 62239397Smckusick 62339397Smckusick /* 62439397Smckusick * Vnode release. 62539397Smckusick * If count drops to zero, call inactive routine and return to freelist. 62639397Smckusick */ 62768319Scgd void 62868319Scgd vrele(vp) 62939397Smckusick register struct vnode *vp; 63039397Smckusick { 63139397Smckusick 63250109Smckusick #ifdef DIAGNOSTIC 63339397Smckusick if (vp == NULL) 63439433Smckusick panic("vrele: null vp"); 63550109Smckusick #endif 63639809Smckusick vp->v_usecount--; 63739809Smckusick if (vp->v_usecount > 0) 63839397Smckusick return; 63950109Smckusick #ifdef DIAGNOSTIC 64050109Smckusick if (vp->v_usecount != 0 || vp->v_writecount != 0) { 64150109Smckusick vprint("vrele: bad ref count", vp); 64250109Smckusick panic("vrele: ref cnt"); 64350109Smckusick } 64450109Smckusick #endif 64555468Smckusick /* 64655468Smckusick * insert at tail of LRU list 64755468Smckusick */ 64865260Smckusick TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); 64954442Smckusick VOP_INACTIVE(vp); 65039397Smckusick } 65139433Smckusick 65239433Smckusick /* 65339809Smckusick * Page or buffer structure gets a reference. 65439809Smckusick */ 65568319Scgd void 65668319Scgd vhold(vp) 65739809Smckusick register struct vnode *vp; 65839809Smckusick { 65939809Smckusick 66039809Smckusick vp->v_holdcnt++; 66139809Smckusick } 66239809Smckusick 66339809Smckusick /* 66439809Smckusick * Page or buffer structure frees a reference. 66539809Smckusick */ 66668319Scgd void 66768319Scgd holdrele(vp) 66839809Smckusick register struct vnode *vp; 66939809Smckusick { 67039809Smckusick 67139809Smckusick if (vp->v_holdcnt <= 0) 67239809Smckusick panic("holdrele: holdcnt"); 67339809Smckusick vp->v_holdcnt--; 67439809Smckusick } 67539809Smckusick 67639809Smckusick /* 67739509Smckusick * Remove any vnodes in the vnode table belonging to mount point mp. 67839509Smckusick * 67939509Smckusick * If MNT_NOFORCE is specified, there should not be any active ones, 68039509Smckusick * return error if any are found (nb: this is a user error, not a 68139509Smckusick * system error). If MNT_FORCE is specified, detach any active vnodes 68239509Smckusick * that are found. 68339509Smckusick */ 68465679Shibler #ifdef DIAGNOSTIC 68560930Smckusick int busyprt = 0; /* print out busy vnodes */ 68660930Smckusick struct ctldebug debug1 = { "busyprt", &busyprt }; 68765679Shibler #endif 68839509Smckusick 68968319Scgd int 69039509Smckusick vflush(mp, skipvp, flags) 69139509Smckusick struct mount *mp; 69239509Smckusick struct vnode *skipvp; 69339509Smckusick int flags; 69439509Smckusick { 69539509Smckusick register struct vnode *vp, *nvp; 69639509Smckusick int busy = 0; 69739509Smckusick 69841400Smckusick if ((mp->mnt_flag & MNT_MPBUSY) == 0) 69941300Smckusick panic("vflush: not busy"); 70041421Smckusick loop: 70165260Smckusick for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) { 70241421Smckusick if (vp->v_mount != mp) 70341421Smckusick goto loop; 70465260Smckusick nvp = vp->v_mntvnodes.le_next; 70539509Smckusick /* 70639509Smckusick * Skip over a selected vnode. 70739509Smckusick */ 70839509Smckusick if (vp == skipvp) 70939509Smckusick continue; 71039509Smckusick /* 71141300Smckusick * Skip over a vnodes marked VSYSTEM. 71241300Smckusick */ 71341300Smckusick if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) 71441300Smckusick continue; 71541300Smckusick /* 71657040Smckusick * If WRITECLOSE is set, only flush out regular file 71757040Smckusick * vnodes open for writing. 71857040Smckusick */ 71957040Smckusick if ((flags & WRITECLOSE) && 72057040Smckusick (vp->v_writecount == 0 || vp->v_type != VREG)) 72157040Smckusick continue; 72257040Smckusick /* 72339809Smckusick * With v_usecount == 0, all we need to do is clear 72439509Smckusick * out the vnode data structures and we are done. 72539509Smckusick */ 72639809Smckusick if (vp->v_usecount == 0) { 72768424Smckusick VOP_REVOKE(vp, 0); 72839509Smckusick continue; 72939509Smckusick } 73039509Smckusick /* 73157040Smckusick * If FORCECLOSE is set, forcibly close the vnode. 73239509Smckusick * For block or character devices, revert to an 73339509Smckusick * anonymous device. For all other files, just kill them. 73439509Smckusick */ 73541300Smckusick if (flags & FORCECLOSE) { 73639509Smckusick if (vp->v_type != VBLK && vp->v_type != VCHR) { 73768424Smckusick VOP_REVOKE(vp, 0); 73839509Smckusick } else { 73939509Smckusick vclean(vp, 0); 74053547Sheideman vp->v_op = spec_vnodeop_p; 74139509Smckusick insmntque(vp, (struct mount *)0); 74239509Smckusick } 74339509Smckusick continue; 74439509Smckusick } 74565679Shibler #ifdef DIAGNOSTIC 74639509Smckusick if (busyprt) 74739667Smckusick vprint("vflush: busy vnode", vp); 74865679Shibler #endif 74939509Smckusick busy++; 75039509Smckusick } 75139509Smckusick if (busy) 75239509Smckusick return (EBUSY); 75339509Smckusick return (0); 75439509Smckusick } 75539509Smckusick 75639509Smckusick /* 75739433Smckusick * Disassociate the underlying file system from a vnode. 75839433Smckusick */ 75954347Smckusick void 76054347Smckusick vclean(vp, flags) 76139433Smckusick register struct vnode *vp; 76245118Smckusick int flags; 76339433Smckusick { 76439484Smckusick int active; 76539433Smckusick 76639484Smckusick /* 76739484Smckusick * Check to see if the vnode is in use. 76839667Smckusick * If so we have to reference it before we clean it out 76939667Smckusick * so that its count cannot fall to zero and generate a 77039667Smckusick * race against ourselves to recycle it. 77139484Smckusick */ 77239809Smckusick if (active = vp->v_usecount) 77339484Smckusick VREF(vp); 77439484Smckusick /* 77556805Smckusick * Even if the count is zero, the VOP_INACTIVE routine may still 77656805Smckusick * have the object locked while it cleans it out. The VOP_LOCK 77756805Smckusick * ensures that the VOP_INACTIVE routine is done with its work. 77856805Smckusick * For active vnodes, it ensures that no other activity can 77956805Smckusick * occur while the underlying object is being cleaned out. 78056805Smckusick */ 78156805Smckusick VOP_LOCK(vp); 78256805Smckusick /* 78339484Smckusick * Prevent the vnode from being recycled or 78439484Smckusick * brought into use while we clean it out. 78539484Smckusick */ 78639667Smckusick if (vp->v_flag & VXLOCK) 78739667Smckusick panic("vclean: deadlock"); 78839433Smckusick vp->v_flag |= VXLOCK; 78939433Smckusick /* 79056805Smckusick * Clean out any buffers associated with the vnode. 79139667Smckusick */ 79241300Smckusick if (flags & DOCLOSE) 79357792Smckusick vinvalbuf(vp, V_SAVE, NOCRED, NULL, 0, 0); 79439667Smckusick /* 79556805Smckusick * Any other processes trying to obtain this lock must first 79656805Smckusick * wait for VXLOCK to clear, then call the new lock operation. 79739433Smckusick */ 79856805Smckusick VOP_UNLOCK(vp); 79939433Smckusick /* 80056805Smckusick * If purging an active vnode, it must be closed and 80156805Smckusick * deactivated before being reclaimed. 80239433Smckusick */ 80339484Smckusick if (active) { 80456805Smckusick if (flags & DOCLOSE) 80556805Smckusick VOP_CLOSE(vp, IO_NDELAY, NOCRED, NULL); 80656805Smckusick VOP_INACTIVE(vp); 80739433Smckusick } 80839433Smckusick /* 80939433Smckusick * Reclaim the vnode. 81039433Smckusick */ 81156805Smckusick if (VOP_RECLAIM(vp)) 81239433Smckusick panic("vclean: cannot reclaim"); 81339484Smckusick if (active) 81439484Smckusick vrele(vp); 81553580Sheideman 81639433Smckusick /* 81756805Smckusick * Done with purge, notify sleepers of the grim news. 81839433Smckusick */ 81956805Smckusick vp->v_op = dead_vnodeop_p; 82056805Smckusick vp->v_tag = VT_NON; 82139433Smckusick vp->v_flag &= ~VXLOCK; 82239433Smckusick if (vp->v_flag & VXWANT) { 82339433Smckusick vp->v_flag &= ~VXWANT; 82439433Smckusick wakeup((caddr_t)vp); 82539433Smckusick } 82639433Smckusick } 82739433Smckusick 82839433Smckusick /* 82939633Smckusick * Eliminate all activity associated with the requested vnode 83039633Smckusick * and with all vnodes aliased to the requested vnode. 83139633Smckusick */ 83268424Smckusick int 83368424Smckusick vop_revoke(ap) 83468424Smckusick struct vop_revoke_args /* { 83568424Smckusick struct vnode *a_vp; 83668424Smckusick int a_flags; 83768424Smckusick } */ *ap; 83839633Smckusick { 83968424Smckusick register struct vnode *vp, *vq; 84039633Smckusick 84168424Smckusick vp = ap->a_vp; 84268424Smckusick if ((ap->a_flags & REVOKEALL) && (vp->v_flag & VALIASED)) { 84340665Smckusick /* 84440665Smckusick * If a vgone (or vclean) is already in progress, 84540665Smckusick * wait until it is done and return. 84640665Smckusick */ 84740665Smckusick if (vp->v_flag & VXLOCK) { 84840665Smckusick vp->v_flag |= VXWANT; 84968424Smckusick tsleep((caddr_t)vp, PINOD, "vop_revokeall", 0); 85068424Smckusick return (0); 85139633Smckusick } 85240665Smckusick /* 85340665Smckusick * Ensure that vp will not be vgone'd while we 85440665Smckusick * are eliminating its aliases. 85540665Smckusick */ 85640665Smckusick vp->v_flag |= VXLOCK; 85740665Smckusick while (vp->v_flag & VALIASED) { 85840665Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 85940665Smckusick if (vq->v_rdev != vp->v_rdev || 86040665Smckusick vq->v_type != vp->v_type || vp == vq) 86140665Smckusick continue; 86240665Smckusick vgone(vq); 86340665Smckusick break; 86440665Smckusick } 86540665Smckusick } 86640665Smckusick /* 86740665Smckusick * Remove the lock so that vgone below will 86840665Smckusick * really eliminate the vnode after which time 86940665Smckusick * vgone will awaken any sleepers. 87040665Smckusick */ 87140665Smckusick vp->v_flag &= ~VXLOCK; 87239633Smckusick } 87339633Smckusick vgone(vp); 87468424Smckusick return (0); 87539633Smckusick } 87639633Smckusick 87739633Smckusick /* 87839433Smckusick * Eliminate all activity associated with a vnode 87939433Smckusick * in preparation for reuse. 88039433Smckusick */ 88168319Scgd void 88268319Scgd vgone(vp) 88339433Smckusick register struct vnode *vp; 88439433Smckusick { 88539809Smckusick register struct vnode *vq; 88639615Smckusick struct vnode *vx; 88739433Smckusick 88839433Smckusick /* 88940548Smckusick * If a vgone (or vclean) is already in progress, 89040548Smckusick * wait until it is done and return. 89140548Smckusick */ 89240548Smckusick if (vp->v_flag & VXLOCK) { 89340548Smckusick vp->v_flag |= VXWANT; 89468319Scgd tsleep((caddr_t)vp, PINOD, "vgone", 0); 89540548Smckusick return; 89640548Smckusick } 89740548Smckusick /* 89839433Smckusick * Clean out the filesystem specific data. 89939433Smckusick */ 90041300Smckusick vclean(vp, DOCLOSE); 90139433Smckusick /* 90239433Smckusick * Delete from old mount point vnode list, if on one. 90339433Smckusick */ 90465260Smckusick if (vp->v_mount != NULL) { 90565260Smckusick LIST_REMOVE(vp, v_mntvnodes); 90652311Smckusick vp->v_mount = NULL; 90739433Smckusick } 90839433Smckusick /* 90968592Smckusick * If special device, remove it from special device alias list 91068592Smckusick * if it is on one. 91139433Smckusick */ 91268592Smckusick if ((vp->v_type == VBLK || vp->v_type == VCHR) && vp->v_specinfo != 0) { 91339809Smckusick if (*vp->v_hashchain == vp) { 91439809Smckusick *vp->v_hashchain = vp->v_specnext; 91539433Smckusick } else { 91639809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 91739615Smckusick if (vq->v_specnext != vp) 91839433Smckusick continue; 91939615Smckusick vq->v_specnext = vp->v_specnext; 92039433Smckusick break; 92139433Smckusick } 92239615Smckusick if (vq == NULL) 92339433Smckusick panic("missing bdev"); 92439433Smckusick } 92539615Smckusick if (vp->v_flag & VALIASED) { 92652416Storek vx = NULL; 92739809Smckusick for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 92840108Smckusick if (vq->v_rdev != vp->v_rdev || 92940108Smckusick vq->v_type != vp->v_type) 93039615Smckusick continue; 93152416Storek if (vx) 93252416Storek break; 93339615Smckusick vx = vq; 93439615Smckusick } 93552416Storek if (vx == NULL) 93639615Smckusick panic("missing alias"); 93752416Storek if (vq == NULL) 93839615Smckusick vx->v_flag &= ~VALIASED; 93939615Smckusick vp->v_flag &= ~VALIASED; 94039615Smckusick } 94139615Smckusick FREE(vp->v_specinfo, M_VNODE); 94239615Smckusick vp->v_specinfo = NULL; 94339433Smckusick } 94439433Smckusick /* 94556932Smckusick * If it is on the freelist and not already at the head, 94665505Smckusick * move it to the head of the list. The test of the back 94765505Smckusick * pointer and the reference count of zero is because 94865505Smckusick * it will be removed from the free list by getnewvnode, 94965505Smckusick * but will not have its reference count incremented until 95065505Smckusick * after calling vgone. If the reference count were 95165505Smckusick * incremented first, vgone would (incorrectly) try to 95265505Smckusick * close the previous instance of the underlying object. 95365505Smckusick * So, the back pointer is explicitly set to `0xdeadb' in 95465505Smckusick * getnewvnode after removing it from the freelist to ensure 95565505Smckusick * that we do not try to move it here. 95639433Smckusick */ 95765505Smckusick if (vp->v_usecount == 0 && 95865505Smckusick vp->v_freelist.tqe_prev != (struct vnode **)0xdeadb && 95965505Smckusick vnode_free_list.tqh_first != vp) { 96065260Smckusick TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 96165260Smckusick TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist); 96239433Smckusick } 96339484Smckusick vp->v_type = VBAD; 96439433Smckusick } 96539633Smckusick 96639633Smckusick /* 96739821Smckusick * Lookup a vnode by device number. 96839821Smckusick */ 96968319Scgd int 97039821Smckusick vfinddev(dev, type, vpp) 97139821Smckusick dev_t dev; 97239821Smckusick enum vtype type; 97339821Smckusick struct vnode **vpp; 97439821Smckusick { 97539821Smckusick register struct vnode *vp; 97639821Smckusick 97739821Smckusick for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) { 97839821Smckusick if (dev != vp->v_rdev || type != vp->v_type) 97939821Smckusick continue; 98039821Smckusick *vpp = vp; 98159484Smckusick return (1); 98239821Smckusick } 98359484Smckusick return (0); 98439821Smckusick } 98539821Smckusick 98639821Smckusick /* 98739633Smckusick * Calculate the total number of references to a special device. 98839633Smckusick */ 98968319Scgd int 99039633Smckusick vcount(vp) 99139633Smckusick register struct vnode *vp; 99239633Smckusick { 99366742Smckusick register struct vnode *vq, *vnext; 99439633Smckusick int count; 99539633Smckusick 99666742Smckusick loop: 99739633Smckusick if ((vp->v_flag & VALIASED) == 0) 99839809Smckusick return (vp->v_usecount); 99966742Smckusick for (count = 0, vq = *vp->v_hashchain; vq; vq = vnext) { 100066742Smckusick vnext = vq->v_specnext; 100140108Smckusick if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type) 100239633Smckusick continue; 100339633Smckusick /* 100439633Smckusick * Alias, but not in use, so flush it out. 100539633Smckusick */ 100666742Smckusick if (vq->v_usecount == 0 && vq != vp) { 100739633Smckusick vgone(vq); 100839633Smckusick goto loop; 100939633Smckusick } 101039809Smckusick count += vq->v_usecount; 101139633Smckusick } 101239633Smckusick return (count); 101339633Smckusick } 101439667Smckusick 101539667Smckusick /* 101639667Smckusick * Print out a description of a vnode. 101739667Smckusick */ 101839667Smckusick static char *typename[] = 101940286Smckusick { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" }; 102039667Smckusick 102168171Scgd void 102239667Smckusick vprint(label, vp) 102339667Smckusick char *label; 102439667Smckusick register struct vnode *vp; 102539667Smckusick { 102639913Smckusick char buf[64]; 102739667Smckusick 102839667Smckusick if (label != NULL) 102939667Smckusick printf("%s: ", label); 103050109Smckusick printf("type %s, usecount %d, writecount %d, refcount %d,", 103150109Smckusick typename[vp->v_type], vp->v_usecount, vp->v_writecount, 103250109Smckusick vp->v_holdcnt); 103339913Smckusick buf[0] = '\0'; 103439913Smckusick if (vp->v_flag & VROOT) 103539913Smckusick strcat(buf, "|VROOT"); 103639913Smckusick if (vp->v_flag & VTEXT) 103739913Smckusick strcat(buf, "|VTEXT"); 103841300Smckusick if (vp->v_flag & VSYSTEM) 103941300Smckusick strcat(buf, "|VSYSTEM"); 104041300Smckusick if (vp->v_flag & VXLOCK) 104141300Smckusick strcat(buf, "|VXLOCK"); 104241300Smckusick if (vp->v_flag & VXWANT) 104341300Smckusick strcat(buf, "|VXWANT"); 104441300Smckusick if (vp->v_flag & VBWAIT) 104541300Smckusick strcat(buf, "|VBWAIT"); 104639913Smckusick if (vp->v_flag & VALIASED) 104739913Smckusick strcat(buf, "|VALIASED"); 104839913Smckusick if (buf[0] != '\0') 104939913Smckusick printf(" flags (%s)", &buf[1]); 105065260Smckusick if (vp->v_data == NULL) { 105165260Smckusick printf("\n"); 105265260Smckusick } else { 105365260Smckusick printf("\n\t"); 105465260Smckusick VOP_PRINT(vp); 105565260Smckusick } 105639667Smckusick } 105741110Smarc 105849691Smckusick #ifdef DEBUG 105949691Smckusick /* 106049691Smckusick * List all of the locked vnodes in the system. 106149691Smckusick * Called when debugging the kernel. 106249691Smckusick */ 106368319Scgd void 106449691Smckusick printlockedvnodes() 106549691Smckusick { 106649691Smckusick register struct mount *mp; 106749691Smckusick register struct vnode *vp; 106849691Smckusick 106949691Smckusick printf("Locked vnodes\n"); 107065260Smckusick for (mp = mountlist.tqh_first; mp != NULL; mp = mp->mnt_list.tqe_next) { 107165260Smckusick for (vp = mp->mnt_vnodelist.lh_first; 107265260Smckusick vp != NULL; 107365260Smckusick vp = vp->v_mntvnodes.le_next) 107449691Smckusick if (VOP_ISLOCKED(vp)) 107549691Smckusick vprint((char *)0, vp); 107665260Smckusick } 107749691Smckusick } 107849691Smckusick #endif 107949691Smckusick 1080*68659Smckusick /* 1081*68659Smckusick * Top level filesystem related information gathering. 1082*68659Smckusick */ 1083*68659Smckusick int 1084*68659Smckusick vfs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 1085*68659Smckusick int *name; 1086*68659Smckusick u_int namelen; 1087*68659Smckusick void *oldp; 1088*68659Smckusick size_t *oldlenp; 1089*68659Smckusick void *newp; 1090*68659Smckusick size_t newlen; 1091*68659Smckusick struct proc *p; 1092*68659Smckusick { 1093*68659Smckusick struct ctldebug *cdp; 1094*68659Smckusick struct vfsconf *vfsp; 1095*68659Smckusick 1096*68659Smckusick /* all sysctl names at this level are at least name and field */ 1097*68659Smckusick if (namelen < 2) 1098*68659Smckusick return (ENOTDIR); /* overloaded */ 1099*68659Smckusick if (name[0] != VFS_GENERIC) { 1100*68659Smckusick for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) 1101*68659Smckusick if (vfsp->vfc_typenum == name[0]) 1102*68659Smckusick break; 1103*68659Smckusick if (vfsp == NULL) 1104*68659Smckusick return (EOPNOTSUPP); 1105*68659Smckusick return ((*vfsp->vfc_vfsops->vfs_sysctl)(&name[1], namelen - 1, 1106*68659Smckusick oldp, oldlenp, newp, newlen, p)); 1107*68659Smckusick } 1108*68659Smckusick switch (name[1]) { 1109*68659Smckusick case VFS_MAXTYPENUM: 1110*68659Smckusick return (sysctl_rdint(oldp, oldlenp, newp, maxvfsconf)); 1111*68659Smckusick case VFS_CONF: 1112*68659Smckusick if (namelen < 3) 1113*68659Smckusick return (ENOTDIR); /* overloaded */ 1114*68659Smckusick for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) 1115*68659Smckusick if (vfsp->vfc_typenum == name[2]) 1116*68659Smckusick break; 1117*68659Smckusick if (vfsp == NULL) 1118*68659Smckusick return (EOPNOTSUPP); 1119*68659Smckusick return (sysctl_rdstruct(oldp, oldlenp, newp, vfsp, 1120*68659Smckusick sizeof(struct vfsconf))); 1121*68659Smckusick } 1122*68659Smckusick return (EOPNOTSUPP); 1123*68659Smckusick } 1124*68659Smckusick 112541110Smarc int kinfo_vdebug = 1; 112641110Smarc int kinfo_vgetfailed; 112741110Smarc #define KINFO_VNODESLOP 10 112841110Smarc /* 112957841Smckusick * Dump vnode list (via sysctl). 113041110Smarc * Copyout address of vnode followed by vnode. 113141110Smarc */ 113245118Smckusick /* ARGSUSED */ 113368319Scgd int 113457841Smckusick sysctl_vnode(where, sizep) 113541110Smarc char *where; 113658465Sbostic size_t *sizep; 113741110Smarc { 113865260Smckusick register struct mount *mp, *nmp; 113941110Smarc struct vnode *vp; 114041110Smarc register char *bp = where, *savebp; 114153818Smckusick char *ewhere; 114241110Smarc int error; 114341110Smarc 114441110Smarc #define VPTRSZ sizeof (struct vnode *) 114541110Smarc #define VNODESZ sizeof (struct vnode) 114641110Smarc if (where == NULL) { 114757841Smckusick *sizep = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ); 114841110Smarc return (0); 114941110Smarc } 115057841Smckusick ewhere = where + *sizep; 115141110Smarc 115265260Smckusick for (mp = mountlist.tqh_first; mp != NULL; mp = nmp) { 115365260Smckusick nmp = mp->mnt_list.tqe_next; 115465260Smckusick if (vfs_busy(mp)) 115541300Smckusick continue; 115641110Smarc savebp = bp; 115741110Smarc again: 115865260Smckusick for (vp = mp->mnt_vnodelist.lh_first; 115965260Smckusick vp != NULL; 116065260Smckusick vp = vp->v_mntvnodes.le_next) { 116141422Smckusick /* 116241422Smckusick * Check that the vp is still associated with 116341422Smckusick * this filesystem. RACE: could have been 116441422Smckusick * recycled onto the same filesystem. 116541422Smckusick */ 116641421Smckusick if (vp->v_mount != mp) { 116741421Smckusick if (kinfo_vdebug) 116841421Smckusick printf("kinfo: vp changed\n"); 116941421Smckusick bp = savebp; 117041421Smckusick goto again; 117141421Smckusick } 117257841Smckusick if (bp + VPTRSZ + VNODESZ > ewhere) { 117357841Smckusick *sizep = bp - where; 117457841Smckusick return (ENOMEM); 117557841Smckusick } 117657841Smckusick if ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) || 117757841Smckusick (error = copyout((caddr_t)vp, bp + VPTRSZ, VNODESZ))) 117841110Smarc return (error); 117941110Smarc bp += VPTRSZ + VNODESZ; 118041110Smarc } 118165260Smckusick vfs_unbusy(mp); 118265260Smckusick } 118341110Smarc 118457841Smckusick *sizep = bp - where; 118541110Smarc return (0); 118641110Smarc } 118765679Shibler 118865679Shibler /* 118965679Shibler * Check to see if a filesystem is mounted on a block device. 119065679Shibler */ 119165679Shibler int 119265679Shibler vfs_mountedon(vp) 119365679Shibler register struct vnode *vp; 119465679Shibler { 119565679Shibler register struct vnode *vq; 119665679Shibler 119765679Shibler if (vp->v_specflags & SI_MOUNTEDON) 119865679Shibler return (EBUSY); 119965679Shibler if (vp->v_flag & VALIASED) { 120065679Shibler for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { 120165679Shibler if (vq->v_rdev != vp->v_rdev || 120265679Shibler vq->v_type != vp->v_type) 120365679Shibler continue; 120465679Shibler if (vq->v_specflags & SI_MOUNTEDON) 120565679Shibler return (EBUSY); 120665679Shibler } 120765679Shibler } 120865679Shibler return (0); 120965679Shibler } 121065679Shibler 121165679Shibler /* 121265679Shibler * Build hash lists of net addresses and hang them off the mount point. 121365679Shibler * Called by ufs_mount() to set up the lists of export addresses. 121465679Shibler */ 121565679Shibler static int 121665679Shibler vfs_hang_addrlist(mp, nep, argp) 121765679Shibler struct mount *mp; 121865679Shibler struct netexport *nep; 121965679Shibler struct export_args *argp; 122065679Shibler { 122165679Shibler register struct netcred *np; 122265679Shibler register struct radix_node_head *rnh; 122365679Shibler register int i; 122465679Shibler struct radix_node *rn; 122565679Shibler struct sockaddr *saddr, *smask = 0; 122665679Shibler struct domain *dom; 122765679Shibler int error; 122865679Shibler 122965679Shibler if (argp->ex_addrlen == 0) { 123065679Shibler if (mp->mnt_flag & MNT_DEFEXPORTED) 123165679Shibler return (EPERM); 123265679Shibler np = &nep->ne_defexported; 123365679Shibler np->netc_exflags = argp->ex_flags; 123465679Shibler np->netc_anon = argp->ex_anon; 123565679Shibler np->netc_anon.cr_ref = 1; 123665679Shibler mp->mnt_flag |= MNT_DEFEXPORTED; 123765679Shibler return (0); 123865679Shibler } 123965679Shibler i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen; 124065679Shibler np = (struct netcred *)malloc(i, M_NETADDR, M_WAITOK); 124165679Shibler bzero((caddr_t)np, i); 124265679Shibler saddr = (struct sockaddr *)(np + 1); 124365679Shibler if (error = copyin(argp->ex_addr, (caddr_t)saddr, argp->ex_addrlen)) 124465679Shibler goto out; 124565679Shibler if (saddr->sa_len > argp->ex_addrlen) 124665679Shibler saddr->sa_len = argp->ex_addrlen; 124765679Shibler if (argp->ex_masklen) { 124865679Shibler smask = (struct sockaddr *)((caddr_t)saddr + argp->ex_addrlen); 124965679Shibler error = copyin(argp->ex_addr, (caddr_t)smask, argp->ex_masklen); 125065679Shibler if (error) 125165679Shibler goto out; 125265679Shibler if (smask->sa_len > argp->ex_masklen) 125365679Shibler smask->sa_len = argp->ex_masklen; 125465679Shibler } 125565679Shibler i = saddr->sa_family; 125665679Shibler if ((rnh = nep->ne_rtable[i]) == 0) { 125765679Shibler /* 125865679Shibler * Seems silly to initialize every AF when most are not 125965679Shibler * used, do so on demand here 126065679Shibler */ 126165679Shibler for (dom = domains; dom; dom = dom->dom_next) 126265679Shibler if (dom->dom_family == i && dom->dom_rtattach) { 126365679Shibler dom->dom_rtattach((void **)&nep->ne_rtable[i], 126465679Shibler dom->dom_rtoffset); 126565679Shibler break; 126665679Shibler } 126765679Shibler if ((rnh = nep->ne_rtable[i]) == 0) { 126865679Shibler error = ENOBUFS; 126965679Shibler goto out; 127065679Shibler } 127165679Shibler } 127265679Shibler rn = (*rnh->rnh_addaddr)((caddr_t)saddr, (caddr_t)smask, rnh, 127365679Shibler np->netc_rnodes); 127465679Shibler if (rn == 0 || np != (struct netcred *)rn) { /* already exists */ 127565679Shibler error = EPERM; 127665679Shibler goto out; 127765679Shibler } 127865679Shibler np->netc_exflags = argp->ex_flags; 127965679Shibler np->netc_anon = argp->ex_anon; 128065679Shibler np->netc_anon.cr_ref = 1; 128165679Shibler return (0); 128265679Shibler out: 128365679Shibler free(np, M_NETADDR); 128465679Shibler return (error); 128565679Shibler } 128665679Shibler 128765679Shibler /* ARGSUSED */ 128865679Shibler static int 128965679Shibler vfs_free_netcred(rn, w) 129065679Shibler struct radix_node *rn; 129165679Shibler caddr_t w; 129265679Shibler { 129365679Shibler register struct radix_node_head *rnh = (struct radix_node_head *)w; 129465679Shibler 129565679Shibler (*rnh->rnh_deladdr)(rn->rn_key, rn->rn_mask, rnh); 129665679Shibler free((caddr_t)rn, M_NETADDR); 129765679Shibler return (0); 129865679Shibler } 129968319Scgd 130065679Shibler /* 130165679Shibler * Free the net address hash lists that are hanging off the mount points. 130265679Shibler */ 130365679Shibler static void 130465679Shibler vfs_free_addrlist(nep) 130565679Shibler struct netexport *nep; 130665679Shibler { 130765679Shibler register int i; 130865679Shibler register struct radix_node_head *rnh; 130965679Shibler 131065679Shibler for (i = 0; i <= AF_MAX; i++) 131165679Shibler if (rnh = nep->ne_rtable[i]) { 131265679Shibler (*rnh->rnh_walktree)(rnh, vfs_free_netcred, 131365679Shibler (caddr_t)rnh); 131465679Shibler free((caddr_t)rnh, M_RTABLE); 131565679Shibler nep->ne_rtable[i] = 0; 131665679Shibler } 131765679Shibler } 131865679Shibler 131965679Shibler int 132065679Shibler vfs_export(mp, nep, argp) 132165679Shibler struct mount *mp; 132265679Shibler struct netexport *nep; 132365679Shibler struct export_args *argp; 132465679Shibler { 132565679Shibler int error; 132665679Shibler 132765679Shibler if (argp->ex_flags & MNT_DELEXPORT) { 132865679Shibler vfs_free_addrlist(nep); 132965679Shibler mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED); 133065679Shibler } 133165679Shibler if (argp->ex_flags & MNT_EXPORTED) { 133265679Shibler if (error = vfs_hang_addrlist(mp, nep, argp)) 133365679Shibler return (error); 133465679Shibler mp->mnt_flag |= MNT_EXPORTED; 133565679Shibler } 133665679Shibler return (0); 133765679Shibler } 133865679Shibler 133965679Shibler struct netcred * 134065679Shibler vfs_export_lookup(mp, nep, nam) 134165679Shibler register struct mount *mp; 134265679Shibler struct netexport *nep; 134365679Shibler struct mbuf *nam; 134465679Shibler { 134565679Shibler register struct netcred *np; 134665679Shibler register struct radix_node_head *rnh; 134765679Shibler struct sockaddr *saddr; 134865679Shibler 134965679Shibler np = NULL; 135065679Shibler if (mp->mnt_flag & MNT_EXPORTED) { 135165679Shibler /* 135265679Shibler * Lookup in the export list first. 135365679Shibler */ 135465679Shibler if (nam != NULL) { 135565679Shibler saddr = mtod(nam, struct sockaddr *); 135665679Shibler rnh = nep->ne_rtable[saddr->sa_family]; 135765679Shibler if (rnh != NULL) { 135865679Shibler np = (struct netcred *) 135965679Shibler (*rnh->rnh_matchaddr)((caddr_t)saddr, 136065679Shibler rnh); 136165679Shibler if (np && np->netc_rnodes->rn_flags & RNF_ROOT) 136265679Shibler np = NULL; 136365679Shibler } 136465679Shibler } 136565679Shibler /* 136665679Shibler * If no address match, use the default if it exists. 136765679Shibler */ 136865679Shibler if (np == NULL && mp->mnt_flag & MNT_DEFEXPORTED) 136965679Shibler np = &nep->ne_defexported; 137065679Shibler } 137165679Shibler return (np); 137265679Shibler } 1373