keep track of pending selects

[unix-history] / 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 f201b08..a679371 100644 (file)
--- a/usr/src/sys/kern/vfs_subr.c
+++ b/usr/src/sys/kern/vfs_subr.c
@@ -14,7 +14,7 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *

- *     @(#)vfs_subr.c  7.21 (Berkeley) %G%
+ *     @(#)vfs_subr.c  7.46 (Berkeley) %G%

  */
 
 /*
  */
 
 /*


@@ -25,6 +25,7 @@
 #include "mount.h"
 #include "time.h"
 #include "vnode.h"
 #include "mount.h"
 #include "time.h"
 #include "vnode.h"

+#include "specdev.h"

 #include "namei.h"
 #include "ucred.h"
 #include "errno.h"
 #include "namei.h"
 #include "ucred.h"
 #include "errno.h"


@@ -41,9 +42,9 @@ vfs_remove(mp)
 
        if (mp == rootfs)
                panic("vfs_remove: unmounting root");
 
        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);
 }
 
        vfs_unlock(mp);
 }
 


@@ -55,11 +56,11 @@ vfs_lock(mp)
        register struct mount *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);
        }
                sleep((caddr_t)mp, PVFS);
        }

-       mp->m_flag |= M_MLOCK;
+       mp->mnt_flag |= MNT_MLOCK;

        return (0);
 }
 
        return (0);
 }
 


@@ -72,15 +73,51 @@ vfs_unlock(mp)
        register struct mount *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);
        }
 }
 
                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.
+ */
+void
+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.
  */
 /*
  * Lookup a mount point by filesystem identifier.
  */


@@ -92,11 +129,11 @@ getvfs(fsid)
 
        mp = rootfs;
        do {
 
        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);
                }
                        return (mp);
                }

-               mp = mp->m_next;
+               mp = mp->mnt_next;

        } while (mp != rootfs);
        return ((struct mount *)0);
 }
        } while (mp != rootfs);
        return ((struct mount *)0);
 }


@@ -111,8 +148,8 @@ void vattr_null(vap)
        vap->va_type = VNON;
        vap->va_mode = vap->va_nlink = vap->va_uid = vap->va_gid =
                vap->va_fsid = vap->va_fileid = vap->va_size =
        vap->va_type = VNON;
        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_size_rsv = vap->va_blocksize = vap->va_rdev =
+               vap->va_bytes = vap->va_bytes_rsv =

                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_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 =


@@ -170,38 +207,16 @@ ndrele(ndp)
 struct vnode *vfreeh, **vfreet;
 extern struct vnodeops dead_vnodeops, spec_vnodeops;
 extern void vclean();
 struct vnode *vfreeh, **vfreet;
 extern struct vnodeops dead_vnodeops, spec_vnodeops;
 extern void vclean();

-
-#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];
+long numvnodes;
+struct vattr va_null;

 
 /*
  * Initialize the vnode structures and initialize each file system type.
  */
 vfsinit()
 {
 
 /*
  * Initialize the vnode structures and initialize each file system type.
  */
 vfsinit()
 {

-       register struct vnode *vp = vnode;

        struct vfsops **vfsp;
 
        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
         */
        /*
         * Initialize the vnode name cache
         */


@@ -209,6 +224,7 @@ vfsinit()
        /*
         * Initialize each file system type.
         */
        /*
         * Initialize each file system type.
         */

+       vattr_null(&va_null);

        for (vfsp = &vfssw[0]; vfsp <= &vfssw[MOUNT_MAXTYPE]; vfsp++) {
                if (*vfsp == NULL)
                        continue;
        for (vfsp = &vfssw[0]; vfsp <= &vfssw[MOUNT_MAXTYPE]; vfsp++) {
                if (*vfsp == NULL)
                        continue;


@@ -227,26 +243,34 @@ getnewvnode(tag, mp, vops, vpp)
 {
        register struct vnode *vp, *vq;
 
 {
        register struct vnode *vp, *vq;
 

-       if ((vp = vfreeh) == NULL) {
-               tablefull("vnode");
-               *vpp = 0;
-               return (ENFILE);
+       if (numvnodes < desiredvnodes) {
+               vp = (struct vnode *)malloc(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;
+               if (vp->v_type != VBAD)
+                       vgone(vp);
+               vp->v_flag = 0;
+               vp->v_shlockc = 0;
+               vp->v_exlockc = 0;
+               vp->v_lastr = 0;
+               vp->v_socket = 0;

        }
        }

-       if (vp->v_usecount)
-               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_type = VNON;

-       vp->v_flag = 0;
-       vp->v_shlockc = 0;
-       vp->v_exlockc = 0;
-       vp->v_lastr = 0;
-       vp->v_socket = 0;

        cache_purge(vp);
        vp->v_tag = tag;
        vp->v_op = vops;
        cache_purge(vp);
        vp->v_tag = tag;
        vp->v_op = vops;


@@ -282,14 +306,14 @@ insmntque(vp, mp)
                vp->v_mountb = NULL;
                return;
        }
                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;
+       if (mp->mnt_mounth) {
+               vp->v_mountf = mp->mnt_mounth;
+               vp->v_mountb = &mp->mnt_mounth;
+               mp->mnt_mounth->v_mountb = &vp->v_mountf;
+               mp->mnt_mounth = vp;

        } else {
        } else {

-               mp->m_mounth = vp;
-               vp->v_mountb = &mp->m_mounth;
+               mp->mnt_mounth = vp;
+               vp->v_mountb = &mp->mnt_mounth;

                vp->v_mountf = NULL;
        }
 }
                vp->v_mountf = NULL;
        }
 }


@@ -340,7 +364,7 @@ checkalias(nvp, nvp_rdev, mp)
        struct vnode **vpp;
 
        if (nvp->v_type != VBLK && nvp->v_type != VCHR)
        struct vnode **vpp;
 
        if (nvp->v_type != VBLK && nvp->v_type != VCHR)

-               return ((struct vnode *)0);
+               return (NULLVP);

 
        vpp = &speclisth[SPECHASH(nvp_rdev)];
 loop:
 
        vpp = &speclisth[SPECHASH(nvp_rdev)];
 loop:


@@ -359,18 +383,19 @@ loop:
                break;
        }
        if (vp == NULL || vp->v_tag != VT_NON) {
                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_hashchain = vpp;
                nvp->v_specnext = *vpp;
                MALLOC(nvp->v_specinfo, struct specinfo *,
                        sizeof(struct specinfo), M_VNODE, M_WAITOK);
                nvp->v_rdev = nvp_rdev;
                nvp->v_hashchain = vpp;
                nvp->v_specnext = *vpp;

+               nvp->v_specflags = 0;

                *vpp = nvp;
                *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);
        }
        VOP_UNLOCK(vp);
        vclean(vp, 0);


@@ -448,7 +473,7 @@ void vrele(vp)
                vprint("vrele: bad ref count", vp);
        if (vp->v_usecount > 0)
                return;
                vprint("vrele: bad ref count", vp);
        if (vp->v_usecount > 0)
                return;

-       if (vfreeh == (struct vnode *)0) {
+       if (vfreeh == NULLVP) {

                /*
                 * insert into empty list
                 */
                /*
                 * insert into empty list
                 */


@@ -506,14 +531,23 @@ vflush(mp, skipvp, flags)
        register struct vnode *vp, *nvp;
        int busy = 0;
 
        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.
                nvp = vp->v_mountf;
                /*
                 * Skip over a selected vnode.

-                * Used by ufs to skip over the quota structure inode.

                 */
                if (vp == skipvp)
                        continue;
                 */
                if (vp == skipvp)
                        continue;

+               /*
+                * 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.
                /*
                 * With v_usecount == 0, all we need to do is clear
                 * out the vnode data structures and we are done.


@@ -526,7 +560,7 @@ vflush(mp, skipvp, flags)
                 * For block or character devices, revert to an
                 * anonymous device. For all other files, just kill them.
                 */
                 * 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 {
                        if (vp->v_type != VBLK && vp->v_type != VCHR) {
                                vgone(vp);
                        } else {


@@ -548,9 +582,9 @@ vflush(mp, skipvp, flags)
 /*
  * Disassociate the underlying file system from a vnode.
  */
 /*
  * Disassociate the underlying file system from a vnode.
  */

-void vclean(vp, doclose)
+void vclean(vp, flags)

        register struct vnode *vp;
        register struct vnode *vp;

-       long doclose;
+       long flags;

 {
        struct vnodeops *origops;
        int active;
 {
        struct vnodeops *origops;
        int active;


@@ -578,7 +612,7 @@ void vclean(vp, doclose)
         * occur while the buffer list is being cleaned out.
         */
        VOP_LOCK(vp);
         * occur while the buffer list is being cleaned out.
         */
        VOP_LOCK(vp);

-       if (doclose)
+       if (flags & DOCLOSE)

                vinvalbuf(vp, 1);
        /*
         * Prevent any further operations on the vnode from
                vinvalbuf(vp, 1);
        /*
         * Prevent any further operations on the vnode from


@@ -593,7 +627,7 @@ void vclean(vp, doclose)
         */
        (*(origops->vn_unlock))(vp);
        if (active) {
         */
        (*(origops->vn_unlock))(vp);
        if (active) {

-               if (doclose)
+               if (flags & DOCLOSE)

                        (*(origops->vn_close))(vp, 0, NOCRED);
                (*(origops->vn_inactive))(vp);
        }
                        (*(origops->vn_close))(vp, 0, NOCRED);
                (*(origops->vn_inactive))(vp);
        }


@@ -623,13 +657,36 @@ void vgoneall(vp)
 {
        register struct vnode *vq;
 
 {
        register struct vnode *vq;
 

-       while (vp->v_flag & VALIASED) {
-               for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
-                       if (vq->v_rdev != vp->v_rdev || vp == vq)
-                               continue;
-                       vgone(vq);
-                       break;
+       if (vp->v_flag & VALIASED) {
+               /*
+                * 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);
 }
        }
        vgone(vp);
 }


@@ -645,10 +702,19 @@ void vgone(vp)
        struct vnode *vx;
        long count;
 
        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.
         */
        /*
         * Clean out the filesystem specific data.
         */

-       vclean(vp, 1);
+       vclean(vp, DOCLOSE);

        /*
         * Delete from old mount point vnode list, if on one.
         */
        /*
         * Delete from old mount point vnode list, if on one.
         */


@@ -678,7 +744,8 @@ void vgone(vp)
                if (vp->v_flag & VALIASED) {
                        count = 0;
                        for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
                if (vp->v_flag & VALIASED) {
                        count = 0;
                        for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {

-                               if (vq->v_rdev != vp->v_rdev)
+                               if (vq->v_rdev != vp->v_rdev ||
+                                   vq->v_type != vp->v_type)

                                        continue;
                                count++;
                                vx = vq;
                                        continue;
                                count++;
                                vx = vq;


@@ -709,6 +776,25 @@ void vgone(vp)
        vp->v_type = VBAD;
 }
 
        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.
  */
 /*
  * Calculate the total number of references to a special device.
  */


@@ -722,7 +808,7 @@ vcount(vp)
                return (vp->v_usecount);
 loop:
        for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
                return (vp->v_usecount);
 loop:
        for (count = 0, vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {

-               if (vq->v_rdev != vp->v_rdev)
+               if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type)

                        continue;
                /*
                 * Alias, but not in use, so flush it out.
                        continue;
                /*
                 * Alias, but not in use, so flush it out.


@@ -740,16 +826,106 @@ loop:
  * Print out a description of a vnode.
  */
 static char *typename[] =
  * Print out a description of a vnode.
  */
 static char *typename[] =

-       { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VBAD" };
+   { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" };

 
 vprint(label, vp)
        char *label;
        register struct vnode *vp;
 {
 
 vprint(label, vp)
        char *label;
        register struct vnode *vp;
 {

+       char buf[64];

 
        if (label != NULL)
                printf("%s: ", label);
 
        if (label != NULL)
                printf("%s: ", label);

-       printf("type %s, usecount %d, refcount %d,\n\t", typename[vp->v_type],
+       printf("type %s, usecount %d, refcount %d,", typename[vp->v_type],

                vp->v_usecount, vp->v_holdcnt);
                vp->v_usecount, 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 & VEXLOCK)
+               strcat(buf, "|VEXLOCK");
+       if (vp->v_flag & VSHLOCK)
+               strcat(buf, "|VSHLOCK");
+       if (vp->v_flag & VLWAIT)
+               strcat(buf, "|VLWAIT");
+       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);
 }
        VOP_PRINT(vp);
 }

+
+int kinfo_vdebug = 1;
+int kinfo_vgetfailed;
+#define KINFO_VNODESLOP        10
+/*
+ * Dump vnode list (via kinfo).
+ * Copyout address of vnode followed by vnode.
+ */
+kinfo_vnode(op, where, acopysize, arg, aneeded)
+       char *where;
+       int *acopysize, *aneeded;
+{
+       register struct mount *mp = rootfs;
+       struct mount *omp;
+       struct vnode *vp;
+       register needed = 0;
+       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);
+}