X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/ef62830dd62f718b52dc5278d1485d4e8d3547d5..4c5e2e1a77d1d152f5d821ef8b399def47d963e6:/usr/src/sys/kern/vfs_subr.c diff --git a/usr/src/sys/kern/vfs_subr.c b/usr/src/sys/kern/vfs_subr.c index 72208e1a35..e2bfb327a5 100644 --- a/usr/src/sys/kern/vfs_subr.c +++ b/usr/src/sys/kern/vfs_subr.c @@ -2,33 +2,36 @@ * Copyright (c) 1989 The Regents of the University of California. * All rights reserved. * - * Redistribution and use in source and binary forms are permitted - * provided that the above copyright notice and this paragraph are - * duplicated in all such forms and that any documentation, - * advertising materials, and other materials related to such - * distribution and use acknowledge that the software was developed - * by the University of California, Berkeley. The name of the - * University may not be used to endorse or promote products derived - * from this software without specific prior written permission. - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * %sccs.include.redist.c% * - * @(#)vfs_subr.c 7.17 (Berkeley) %G% + * @(#)vfs_subr.c 7.73 (Berkeley) %G% */ /* * External virtual filesystem routines */ -#include "param.h" -#include "mount.h" -#include "time.h" -#include "vnode.h" -#include "namei.h" -#include "ucred.h" -#include "errno.h" -#include "malloc.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +enum vtype iftovt_tab[16] = { + VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, + VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD, +}; +int vttoif_tab[9] = { + 0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, + S_IFSOCK, S_IFIFO, S_IFMT, +}; /* * Remove a mount point from the list of mounted filesystems. @@ -41,9 +44,9 @@ vfs_remove(mp) if (mp == rootfs) panic("vfs_remove: unmounting root"); - mp->m_prev->m_next = mp->m_next; - mp->m_next->m_prev = mp->m_prev; - mp->m_vnodecovered->v_mountedhere = (struct mount *)0; + mp->mnt_prev->mnt_next = mp->mnt_next; + mp->mnt_next->mnt_prev = mp->mnt_prev; + mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0; vfs_unlock(mp); } @@ -55,11 +58,11 @@ vfs_lock(mp) register struct mount *mp; { - while(mp->m_flag & M_MLOCK) { - mp->m_flag |= M_MWAIT; + while(mp->mnt_flag & MNT_MLOCK) { + mp->mnt_flag |= MNT_MWAIT; sleep((caddr_t)mp, PVFS); } - mp->m_flag |= M_MLOCK; + mp->mnt_flag |= MNT_MLOCK; return (0); } @@ -72,15 +75,50 @@ vfs_unlock(mp) register struct mount *mp; { - if ((mp->m_flag & M_MLOCK) == 0) - panic("vfs_unlock: locked fs"); - mp->m_flag &= ~M_MLOCK; - if (mp->m_flag & M_MWAIT) { - mp->m_flag &= ~M_MWAIT; + if ((mp->mnt_flag & MNT_MLOCK) == 0) + panic("vfs_unlock: not locked"); + mp->mnt_flag &= ~MNT_MLOCK; + if (mp->mnt_flag & MNT_MWAIT) { + mp->mnt_flag &= ~MNT_MWAIT; wakeup((caddr_t)mp); } } +/* + * Mark a mount point as busy. + * Used to synchronize access and to delay unmounting. + */ +vfs_busy(mp) + register struct mount *mp; +{ + + while(mp->mnt_flag & MNT_MPBUSY) { + mp->mnt_flag |= MNT_MPWANT; + sleep((caddr_t)&mp->mnt_flag, PVFS); + } + if (mp->mnt_flag & MNT_UNMOUNT) + return (1); + mp->mnt_flag |= MNT_MPBUSY; + return (0); +} + +/* + * Free a busy filesystem. + * Panic if filesystem is not busy. + */ +vfs_unbusy(mp) + register struct mount *mp; +{ + + if ((mp->mnt_flag & MNT_MPBUSY) == 0) + panic("vfs_unbusy: not busy"); + mp->mnt_flag &= ~MNT_MPBUSY; + if (mp->mnt_flag & MNT_MPWANT) { + mp->mnt_flag &= ~MNT_MPWANT; + wakeup((caddr_t)&mp->mnt_flag); + } +} + /* * Lookup a mount point by filesystem identifier. */ @@ -92,11 +130,11 @@ getvfs(fsid) mp = rootfs; do { - if (mp->m_fsid.val[0] == fsid->val[0] && - mp->m_fsid.val[1] == fsid->val[1]) { + if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] && + mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) { return (mp); } - mp = mp->m_next; + mp = mp->mnt_next; } while (mp != rootfs); return ((struct mount *)0); } @@ -109,98 +147,36 @@ void vattr_null(vap) { vap->va_type = VNON; + vap->va_size = vap->va_bytes = VNOVAL; +#ifdef _NOQUAD + vap->va_size_rsv = vap->va_bytes_rsv = VNOVAL; +#endif vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid = - vap->va_fsid = vap->va_fileid = vap->va_size = - vap->va_size1 = vap->va_blocksize = vap->va_rdev = - vap->va_bytes = vap->va_bytes1 = + vap->va_fsid = vap->va_fileid = + vap->va_blocksize = vap->va_rdev = vap->va_atime.tv_sec = vap->va_atime.tv_usec = vap->va_mtime.tv_sec = vap->va_mtime.tv_usec = vap->va_ctime.tv_sec = vap->va_ctime.tv_usec = vap->va_flags = vap->va_gen = VNOVAL; } -/* - * Initialize a nameidata structure - */ -ndinit(ndp) - register struct nameidata *ndp; -{ - - bzero((caddr_t)ndp, sizeof(struct nameidata)); - ndp->ni_iov = &ndp->ni_nd.nd_iovec; - ndp->ni_iovcnt = 1; - ndp->ni_base = (caddr_t)&ndp->ni_dent; - ndp->ni_rw = UIO_WRITE; - ndp->ni_segflg = UIO_SYSSPACE; -} - -/* - * Duplicate a nameidata structure - */ -nddup(ndp, newndp) - register struct nameidata *ndp, *newndp; -{ - - ndinit(newndp); - newndp->ni_cdir = ndp->ni_cdir; - VREF(newndp->ni_cdir); - newndp->ni_rdir = ndp->ni_rdir; - if (newndp->ni_rdir) - VREF(newndp->ni_rdir); - newndp->ni_cred = ndp->ni_cred; - crhold(newndp->ni_cred); -} - -/* - * Release a nameidata structure - */ -ndrele(ndp) - register struct nameidata *ndp; -{ - - vrele(ndp->ni_cdir); - if (ndp->ni_rdir) - vrele(ndp->ni_rdir); - crfree(ndp->ni_cred); -} - /* * Routines having to do with the management of the vnode table. */ struct vnode *vfreeh, **vfreet; -extern struct vnodeops dead_vnodeops, spec_vnodeops; - -#define SPECHSZ 64 -#if ((SPECHSZ&(SPECHSZ-1)) == 0) -#define SPECHASH(rdev) (((rdev>>5)+(rdev))&(SPECHSZ-1)) -#else -#define SPECHASH(rdev) (((unsigned)((rdev>>5)+(rdev)))%SPECHSZ) -#endif -struct vnode *speclisth[SPECHSZ]; +extern struct vnodeops dead_vnodeops; +extern struct vnodeops spec_vnodeops; +extern void vclean(); +long numvnodes; +struct vattr va_null; /* * Initialize the vnode structures and initialize each file system type. */ vfsinit() { - register struct vnode *vp = vnode; struct vfsops **vfsp; - /* - * Build vnode free list. - */ - vfreeh = vp; - vfreet = &vp->v_freef; - vp->v_freeb = &vfreeh; - vp->v_op = &dead_vnodeops; - for (vp++; vp < vnodeNVNODE; vp++) { - *vfreet = vp; - vp->v_freeb = vfreet; - vfreet = &vp->v_freef; - vp->v_op = &dead_vnodeops; - } - vp--; - vp->v_freef = NULL; /* * Initialize the vnode name cache */ @@ -208,6 +184,7 @@ vfsinit() /* * Initialize each file system type. */ + vattr_null(&va_null); for (vfsp = &vfssw[0]; vfsp <= &vfssw[MOUNT_MAXTYPE]; vfsp++) { if (*vfsp == NULL) continue; @@ -226,25 +203,36 @@ getnewvnode(tag, mp, vops, vpp) { register struct vnode *vp, *vq; - if ((vp = vfreeh) == NULL) { - tablefull("vnode"); - *vpp = 0; - return (ENFILE); + if (numvnodes < desiredvnodes) { + vp = (struct vnode *)malloc((u_long)sizeof *vp, + M_VNODE, M_WAITOK); + bzero((char *)vp, sizeof *vp); + numvnodes++; + } else { + if ((vp = vfreeh) == NULL) { + tablefull("vnode"); + *vpp = 0; + return (ENFILE); + } + if (vp->v_usecount) + panic("free vnode isn't"); + if (vq = vp->v_freef) + vq->v_freeb = &vfreeh; + else + vfreet = &vfreeh; + vfreeh = vq; + vp->v_freef = NULL; + vp->v_freeb = NULL; + vp->v_lease = NULL; + if (vp->v_type != VBAD) + vgone(vp); + if (vp->v_data) + panic("cleaned vnode isn't"); + vp->v_flag = 0; + vp->v_lastr = 0; + vp->v_socket = 0; } - if (vp->v_count) - panic("free vnode isn't"); - if (vq = vp->v_freef) - vq->v_freeb = &vfreeh; - vfreeh = vq; - vp->v_freef = NULL; - vp->v_freeb = NULL; - if (vp->v_type != VNON && vp->v_type != VBAD) - vgone(vp); vp->v_type = VNON; - vp->v_flag = 0; - vp->v_shlockc = 0; - vp->v_exlockc = 0; - vp->v_socket = 0; cache_purge(vp); vp->v_tag = tag; vp->v_op = vops; @@ -261,7 +249,7 @@ insmntque(vp, mp) register struct vnode *vp; register struct mount *mp; { - struct vnode *vq; + register struct vnode *vq; /* * Delete from old mount point vnode list, if on one. @@ -280,16 +268,274 @@ insmntque(vp, mp) vp->v_mountb = NULL; return; } - if (mp->m_mounth) { - vp->v_mountf = mp->m_mounth; - vp->v_mountb = &mp->m_mounth; - mp->m_mounth->v_mountb = &vp->v_mountf; - mp->m_mounth = vp; - } else { - mp->m_mounth = vp; - vp->v_mountb = &mp->m_mounth; - vp->v_mountf = NULL; + if (vq = mp->mnt_mounth) + vq->v_mountb = &vp->v_mountf; + vp->v_mountf = vq; + vp->v_mountb = &mp->mnt_mounth; + mp->mnt_mounth = vp; +} + +/* + * Make sure all write-behind blocks associated + * with mount point are flushed out (from sync). + */ +mntflushbuf(mountp, flags) + struct mount *mountp; + int flags; +{ + register struct vnode *vp; + + if ((mountp->mnt_flag & MNT_MPBUSY) == 0) + panic("mntflushbuf: not busy"); +loop: + for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) { + if (VOP_ISLOCKED(vp)) + continue; + if (vget(vp)) + goto loop; + vflushbuf(vp, flags); + vput(vp); + if (vp->v_mount != mountp) + goto loop; + } +} + +/* + * Flush all dirty buffers associated with a vnode. + */ +vflushbuf(vp, flags) + register struct vnode *vp; + int flags; +{ + register struct buf *bp; + struct buf *nbp; + int s; + +loop: + s = splbio(); + for (bp = vp->v_dirtyblkhd; bp; bp = nbp) { + nbp = bp->b_blockf; + if ((bp->b_flags & B_BUSY)) + continue; + if ((bp->b_flags & B_DELWRI) == 0) + panic("vflushbuf: not dirty"); + bremfree(bp); + bp->b_flags |= B_BUSY; + splx(s); + /* + * Wait for I/O associated with indirect blocks to complete, + * since there is no way to quickly wait for them below. + * NB: This is really specific to ufs, but is done here + * as it is easier and quicker. + */ + if (bp->b_vp == vp || (flags & B_SYNC) == 0) + (void) bawrite(bp); + else + (void) bwrite(bp); + goto loop; + } + splx(s); + if ((flags & B_SYNC) == 0) + return; + s = splbio(); + while (vp->v_numoutput) { + vp->v_flag |= VBWAIT; + sleep((caddr_t)&vp->v_numoutput, PRIBIO + 1); + } + splx(s); + if (vp->v_dirtyblkhd) { + vprint("vflushbuf: dirty", vp); + goto loop; + } +} + +/* + * Update outstanding I/O count and do wakeup if requested. + */ +vwakeup(bp) + register struct buf *bp; +{ + register struct vnode *vp; + + bp->b_dirtyoff = bp->b_dirtyend = 0; + if (vp = bp->b_vp) { + vp->v_numoutput--; + if ((vp->v_flag & VBWAIT) && vp->v_numoutput <= 0) { + if (vp->v_numoutput < 0) + panic("vwakeup: neg numoutput"); + vp->v_flag &= ~VBWAIT; + wakeup((caddr_t)&vp->v_numoutput); + } + } +} + +/* + * Invalidate in core blocks belonging to closed or umounted filesystem + * + * Go through the list of vnodes associated with the file system; + * for each vnode invalidate any buffers that it holds. Normally + * this routine is preceeded by a bflush call, so that on a quiescent + * filesystem there will be no dirty buffers when we are done. Binval + * returns the count of dirty buffers when it is finished. + */ +mntinvalbuf(mountp) + struct mount *mountp; +{ + register struct vnode *vp; + int dirty = 0; + + if ((mountp->mnt_flag & MNT_MPBUSY) == 0) + panic("mntinvalbuf: not busy"); +loop: + for (vp = mountp->mnt_mounth; vp; vp = vp->v_mountf) { + if (vget(vp)) + goto loop; + dirty += vinvalbuf(vp, 1); + vput(vp); + if (vp->v_mount != mountp) + goto loop; + } + return (dirty); +} + +/* + * Flush out and invalidate all buffers associated with a vnode. + * Called with the underlying object locked. + */ +vinvalbuf(vp, save) + register struct vnode *vp; + int save; +{ + register struct buf *bp; + struct buf *nbp, *blist; + int s, dirty = 0; + + for (;;) { + if (blist = vp->v_dirtyblkhd) + /* void */; + else if (blist = vp->v_cleanblkhd) + /* void */; + else + break; + for (bp = blist; bp; bp = nbp) { + nbp = bp->b_blockf; + s = splbio(); + if (bp->b_flags & B_BUSY) { + bp->b_flags |= B_WANTED; + sleep((caddr_t)bp, PRIBIO + 1); + splx(s); + break; + } + bremfree(bp); + bp->b_flags |= B_BUSY; + splx(s); + if (save && (bp->b_flags & B_DELWRI)) { + dirty++; + (void) VOP_BWRITE(bp); + break; + } + if (bp->b_vp != vp) + reassignbuf(bp, bp->b_vp); + else + bp->b_flags |= B_INVAL; + brelse(bp); + } + } + if (vp->v_dirtyblkhd || vp->v_cleanblkhd) + panic("vinvalbuf: flush failed"); + return (dirty); +} + +/* + * Associate a buffer with a vnode. + */ +bgetvp(vp, bp) + register struct vnode *vp; + register struct buf *bp; +{ + register struct vnode *vq; + register struct buf *bq; + + if (bp->b_vp) + panic("bgetvp: not free"); + VHOLD(vp); + bp->b_vp = vp; + if (vp->v_type == VBLK || vp->v_type == VCHR) + bp->b_dev = vp->v_rdev; + else + bp->b_dev = NODEV; + /* + * Insert onto list for new vnode. + */ + if (bq = vp->v_cleanblkhd) + bq->b_blockb = &bp->b_blockf; + bp->b_blockf = bq; + bp->b_blockb = &vp->v_cleanblkhd; + vp->v_cleanblkhd = bp; +} + +/* + * Disassociate a buffer from a vnode. + */ +brelvp(bp) + register struct buf *bp; +{ + struct buf *bq; + struct vnode *vp; + + if (bp->b_vp == (struct vnode *) 0) + panic("brelvp: NULL"); + /* + * Delete from old vnode list, if on one. + */ + if (bp->b_blockb) { + if (bq = bp->b_blockf) + bq->b_blockb = bp->b_blockb; + *bp->b_blockb = bq; + bp->b_blockf = NULL; + bp->b_blockb = NULL; } + vp = bp->b_vp; + bp->b_vp = (struct vnode *) 0; + HOLDRELE(vp); +} + +/* + * Reassign a buffer from one vnode to another. + * Used to assign file specific control information + * (indirect blocks) to the vnode to which they belong. + */ +reassignbuf(bp, newvp) + register struct buf *bp; + register struct vnode *newvp; +{ + register struct buf *bq, **listheadp; + + if (newvp == NULL) { + printf("reassignbuf: NULL"); + return; + } + /* + * Delete from old vnode list, if on one. + */ + if (bp->b_blockb) { + if (bq = bp->b_blockf) + bq->b_blockb = bp->b_blockb; + *bp->b_blockb = bq; + } + /* + * If dirty, put on list of dirty buffers; + * otherwise insert onto list of clean buffers. + */ + if (bp->b_flags & B_DELWRI) + listheadp = &newvp->v_dirtyblkhd; + else + listheadp = &newvp->v_cleanblkhd; + if (bq = *listheadp) + bq->b_blockb = &bp->b_blockf; + bp->b_blockf = bq; + bp->b_blockb = listheadp; + *listheadp = bp; } /* @@ -305,6 +551,8 @@ bdevvp(dev, vpp) struct vnode *nvp; int error; + if (dev == NODEV) + return (0); error = getnewvnode(VT_NON, (struct mount *)0, &spec_vnodeops, &nvp); if (error) { *vpp = 0; @@ -338,7 +586,7 @@ checkalias(nvp, nvp_rdev, mp) struct vnode **vpp; if (nvp->v_type != VBLK && nvp->v_type != VCHR) - return ((struct vnode *)0); + return (NULLVP); vpp = &speclisth[SPECHASH(nvp_rdev)]; loop: @@ -348,7 +596,7 @@ loop: /* * Alias, but not in use, so flush it out. */ - if (vp->v_count == 0) { + if (vp->v_usecount == 0) { vgone(vp); goto loop; } @@ -357,19 +605,19 @@ loop: break; } if (vp == NULL || vp->v_tag != VT_NON) { - if (vp != NULL) { - nvp->v_flag |= VALIASED; - vp->v_flag |= VALIASED; - vput(vp); - } MALLOC(nvp->v_specinfo, struct specinfo *, sizeof(struct specinfo), M_VNODE, M_WAITOK); nvp->v_rdev = nvp_rdev; - nvp->v_mounton = NULL; - nvp->v_lastr = 0; + nvp->v_hashchain = vpp; nvp->v_specnext = *vpp; + nvp->v_specflags = 0; *vpp = nvp; - return ((struct vnode *)0); + if (vp != NULL) { + nvp->v_flag |= VALIASED; + vp->v_flag |= VALIASED; + vput(vp); + } + return (NULLVP); } VOP_UNLOCK(vp); vclean(vp, 0); @@ -398,7 +646,7 @@ vget(vp) sleep((caddr_t)vp, PINOD); return (1); } - if (vp->v_count == 0) { + if (vp->v_usecount == 0) { if (vq = vp->v_freef) vq->v_freeb = vp->v_freeb; else @@ -412,6 +660,8 @@ vget(vp) return (0); } +int bug_refs = 0; + /* * Vnode reference, just increment the count */ @@ -419,7 +669,11 @@ void vref(vp) struct vnode *vp; { - vp->v_count++; + vp->v_usecount++; + if (vp->v_type != VBLK && curproc) + curproc->p_spare[0]++; + if (bug_refs) + vprint("vref: "); } /* @@ -428,6 +682,7 @@ void vref(vp) void vput(vp) register struct vnode *vp; { + VOP_UNLOCK(vp); vrele(vp); } @@ -439,16 +694,26 @@ void vput(vp) void vrele(vp) register struct vnode *vp; { + struct proc *p = curproc; /* XXX */ +#ifdef DIAGNOSTIC if (vp == NULL) panic("vrele: null vp"); - vp->v_count--; - if (vp->v_count < 0) - printf("vnode bad ref count %d, type %d, tag %d\n", - vp->v_count, vp->v_type, vp->v_tag); - if (vp->v_count > 0) +#endif + vp->v_usecount--; + if (vp->v_type != VBLK && curproc) + curproc->p_spare[0]--; + if (bug_refs) + vprint("vref: "); + if (vp->v_usecount > 0) return; - if (vfreeh == (struct vnode *)0) { +#ifdef DIAGNOSTIC + if (vp->v_usecount != 0 || vp->v_writecount != 0) { + vprint("vrele: bad ref count", vp); + panic("vrele: ref cnt"); + } +#endif + if (vfreeh == NULLVP) { /* * insert into empty list */ @@ -463,7 +728,29 @@ void vrele(vp) } vp->v_freef = NULL; vfreet = &vp->v_freef; - VOP_INACTIVE(vp); + VOP_INACTIVE(vp, p); +} + +/* + * Page or buffer structure gets a reference. + */ +void vhold(vp) + register struct vnode *vp; +{ + + vp->v_holdcnt++; +} + +/* + * Page or buffer structure frees a reference. + */ +void holdrele(vp) + register struct vnode *vp; +{ + + if (vp->v_holdcnt <= 0) + panic("holdrele: holdcnt"); + vp->v_holdcnt--; } /* @@ -484,19 +771,28 @@ vflush(mp, skipvp, flags) register struct vnode *vp, *nvp; int busy = 0; - for (vp = mp->m_mounth; vp; vp = nvp) { + if ((mp->mnt_flag & MNT_MPBUSY) == 0) + panic("vflush: not busy"); +loop: + for (vp = mp->mnt_mounth; vp; vp = nvp) { + if (vp->v_mount != mp) + goto loop; nvp = vp->v_mountf; /* * Skip over a selected vnode. - * Used by ufs to skip over the quota structure inode. */ if (vp == skipvp) continue; /* - * With v_count == 0, all we need to do is clear + * Skip over a vnodes marked VSYSTEM. + */ + if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) + continue; + /* + * With v_usecount == 0, all we need to do is clear * out the vnode data structures and we are done. */ - if (vp->v_count == 0) { + if (vp->v_usecount == 0) { vgone(vp); continue; } @@ -504,7 +800,7 @@ vflush(mp, skipvp, flags) * For block or character devices, revert to an * anonymous device. For all other files, just kill them. */ - if (flags & MNT_FORCE) { + if (flags & FORCECLOSE) { if (vp->v_type != VBLK && vp->v_type != VCHR) { vgone(vp); } else { @@ -515,8 +811,7 @@ vflush(mp, skipvp, flags) continue; } if (busyprt) - printf("vflush: busy vnode count %d type %d tag %d\n", - vp->v_count, vp->v_type, vp->v_tag); + vprint("vflush: busy vnode", vp); busy++; } if (busy) @@ -527,30 +822,39 @@ vflush(mp, skipvp, flags) /* * Disassociate the underlying file system from a vnode. */ -void vclean(vp, doclose) +void vclean(vp, flags) register struct vnode *vp; - long doclose; + int flags; { struct vnodeops *origops; int active; + struct proc *p = curproc; /* XXX */ /* * Check to see if the vnode is in use. - * If so we have to lock it before we clean it out. + * If so we have to reference it before we clean it out + * so that its count cannot fall to zero and generate a + * race against ourselves to recycle it. */ - if (active = vp->v_count) { + if (active = vp->v_usecount) VREF(vp); - VOP_LOCK(vp); - } /* * Prevent the vnode from being recycled or * brought into use while we clean it out. */ - while (vp->v_flag & VXLOCK) { - vp->v_flag |= VXWANT; - sleep((caddr_t)vp, PINOD); - } + if (vp->v_flag & VXLOCK) + panic("vclean: deadlock"); vp->v_flag |= VXLOCK; + /* + * Even if the count is zero, the VOP_INACTIVE routine may still + * have the object locked while it cleans it out. The VOP_LOCK + * ensures that the VOP_INACTIVE routine is done with its work. + * For active vnodes, it ensures that no other activity can + * occur while the buffer list is being cleaned out. + */ + VOP_LOCK(vp); + if (flags & DOCLOSE) + vinvalbuf(vp, 1); /* * Prevent any further operations on the vnode from * being passed through to the old file system. @@ -562,16 +866,16 @@ void vclean(vp, doclose) * If purging an active vnode, it must be unlocked, closed, * and deactivated before being reclaimed. */ + (*(origops->vop_unlock))(vp); if (active) { - (*(origops->vn_unlock))(vp); - if (doclose) - (*(origops->vn_close))(vp, 0, NOCRED); - (*(origops->vn_inactive))(vp); + if (flags & DOCLOSE) + (*(origops->vop_close))(vp, IO_NDELAY, NOCRED, p); + (*(origops->vop_inactive))(vp, p); } /* * Reclaim the vnode. */ - if ((*(origops->vn_reclaim))(vp)) + if ((*(origops->vop_reclaim))(vp)) panic("vclean: cannot reclaim"); if (active) vrele(vp); @@ -592,17 +896,38 @@ void vclean(vp, doclose) void vgoneall(vp) register struct vnode *vp; { - register struct vnode *vq, **vpp; + register struct vnode *vq; if (vp->v_flag & VALIASED) { - vpp = &speclisth[SPECHASH(vp->v_rdev)]; - loop: - for (vq = *vpp; vq; vq = vq->v_specnext) { - if (vq->v_rdev != vp->v_rdev || vp == vq) - continue; - vgone(vq); - goto loop; + /* + * If a vgone (or vclean) is already in progress, + * wait until it is done and return. + */ + if (vp->v_flag & VXLOCK) { + vp->v_flag |= VXWANT; + sleep((caddr_t)vp, PINOD); + return; } + /* + * Ensure that vp will not be vgone'd while we + * are eliminating its aliases. + */ + vp->v_flag |= VXLOCK; + while (vp->v_flag & VALIASED) { + for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { + if (vq->v_rdev != vp->v_rdev || + vq->v_type != vp->v_type || vp == vq) + continue; + vgone(vq); + break; + } + } + /* + * Remove the lock so that vgone below will + * really eliminate the vnode after which time + * vgone will awaken any sleepers. + */ + vp->v_flag &= ~VXLOCK; } vgone(vp); } @@ -614,14 +939,22 @@ void vgoneall(vp) void vgone(vp) register struct vnode *vp; { - register struct vnode *vq, **vpp; + register struct vnode *vq; struct vnode *vx; - long count; + /* + * If a vgone (or vclean) is already in progress, + * wait until it is done and return. + */ + if (vp->v_flag & VXLOCK) { + vp->v_flag |= VXWANT; + sleep((caddr_t)vp, PINOD); + return; + } /* * Clean out the filesystem specific data. */ - vclean(vp, 1); + vclean(vp, DOCLOSE); /* * Delete from old mount point vnode list, if on one. */ @@ -631,16 +964,16 @@ void vgone(vp) *vp->v_mountb = vq; vp->v_mountf = NULL; vp->v_mountb = NULL; + vp->v_mount = NULL; } /* * If special device, remove it from special device alias list. */ if (vp->v_type == VBLK || vp->v_type == VCHR) { - vpp = &speclisth[SPECHASH(vp->v_rdev)]; - if (*vpp == vp) { - *vpp = vp->v_specnext; + if (*vp->v_hashchain == vp) { + *vp->v_hashchain = vp->v_specnext; } else { - for (vq = *vpp; vq; vq = vq->v_specnext) { + for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { if (vq->v_specnext != vp) continue; vq->v_specnext = vp->v_specnext; @@ -650,15 +983,18 @@ void vgone(vp) panic("missing bdev"); } if (vp->v_flag & VALIASED) { - for (count = 0, vq = *vpp; vq; vq = vq->v_specnext) { - if (vq->v_rdev != vp->v_rdev) + vx = NULL; + for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { + if (vq->v_rdev != vp->v_rdev || + vq->v_type != vp->v_type) continue; - count++; + if (vx) + break; vx = vq; } - if (count == 0) + if (vx == NULL) panic("missing alias"); - if (count == 1) + if (vq == NULL) vx->v_flag &= ~VALIASED; vp->v_flag &= ~VALIASED; } @@ -682,30 +1018,173 @@ void vgone(vp) vp->v_type = VBAD; } +/* + * Lookup a vnode by device number. + */ +vfinddev(dev, type, vpp) + dev_t dev; + enum vtype type; + struct vnode **vpp; +{ + register struct vnode *vp; + + for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) { + if (dev != vp->v_rdev || type != vp->v_type) + continue; + *vpp = vp; + return (0); + } + return (1); +} + /* * Calculate the total number of references to a special device. */ vcount(vp) register struct vnode *vp; { - register struct vnode *vq, **vpp; + register struct vnode *vq; int count; if ((vp->v_flag & VALIASED) == 0) - return (vp->v_count); - vpp = &speclisth[SPECHASH(vp->v_rdev)]; + return (vp->v_usecount); loop: - for (count = 0, vq = *vpp; vq; vq = vq->v_specnext) { - if (vq->v_rdev != vp->v_rdev) + for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) { + if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type) continue; /* * Alias, but not in use, so flush it out. */ - if (vq->v_count == 0) { + if (vq->v_usecount == 0) { vgone(vq); goto loop; } - count += vq->v_count; + count += vq->v_usecount; } return (count); } + +/* + * Print out a description of a vnode. + */ +static char *typename[] = + { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" }; + +vprint(label, vp) + char *label; + register struct vnode *vp; +{ + char buf[64]; + + if (label != NULL) + printf("%s: ", label); + printf("type %s, usecount %d, writecount %d, refcount %d,", + typename[vp->v_type], vp->v_usecount, vp->v_writecount, + vp->v_holdcnt); + buf[0] = '\0'; + if (vp->v_flag & VROOT) + strcat(buf, "|VROOT"); + if (vp->v_flag & VTEXT) + strcat(buf, "|VTEXT"); + if (vp->v_flag & VSYSTEM) + strcat(buf, "|VSYSTEM"); + if (vp->v_flag & VXLOCK) + strcat(buf, "|VXLOCK"); + if (vp->v_flag & VXWANT) + strcat(buf, "|VXWANT"); + if (vp->v_flag & VBWAIT) + strcat(buf, "|VBWAIT"); + if (vp->v_flag & VALIASED) + strcat(buf, "|VALIASED"); + if (buf[0] != '\0') + printf(" flags (%s)", &buf[1]); + printf("\n\t"); + VOP_PRINT(vp); +} + +#ifdef DEBUG +/* + * List all of the locked vnodes in the system. + * Called when debugging the kernel. + */ +printlockedvnodes() +{ + register struct mount *mp; + register struct vnode *vp; + + printf("Locked vnodes\n"); + mp = rootfs; + do { + for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) + if (VOP_ISLOCKED(vp)) + vprint((char *)0, vp); + mp = mp->mnt_next; + } while (mp != rootfs); +} +#endif + +int kinfo_vdebug = 1; +int kinfo_vgetfailed; +#define KINFO_VNODESLOP 10 +/* + * Dump vnode list (via kinfo). + * Copyout address of vnode followed by vnode. + */ +/* ARGSUSED */ +kinfo_vnode(op, where, acopysize, arg, aneeded) + int op; + char *where; + int *acopysize, arg, *aneeded; +{ + register struct mount *mp = rootfs; + struct mount *omp; + struct vnode *vp; + register char *bp = where, *savebp; + char *ewhere = where + *acopysize; + int error; + +#define VPTRSZ sizeof (struct vnode *) +#define VNODESZ sizeof (struct vnode) + if (where == NULL) { + *aneeded = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ); + return (0); + } + + do { + if (vfs_busy(mp)) { + mp = mp->mnt_next; + continue; + } + savebp = bp; +again: + for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) { + /* + * Check that the vp is still associated with + * this filesystem. RACE: could have been + * recycled onto the same filesystem. + */ + if (vp->v_mount != mp) { + if (kinfo_vdebug) + printf("kinfo: vp changed\n"); + bp = savebp; + goto again; + } + if ((bp + VPTRSZ + VNODESZ <= ewhere) && + ((error = copyout((caddr_t)&vp, bp, VPTRSZ)) || + (error = copyout((caddr_t)vp, bp + VPTRSZ, + VNODESZ)))) + return (error); + bp += VPTRSZ + VNODESZ; + } + omp = mp; + mp = mp->mnt_next; + vfs_unbusy(omp); + } while (mp != rootfs); + + *aneeded = bp - where; + if (bp > ewhere) + *acopysize = ewhere - where; + else + *acopysize = bp - where; + return (0); +}