dynamic allocation of vnodes

[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 3223a52..4720466 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.12 (Berkeley) %G%
+ *     @(#)vfs_subr.c  7.38 (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"


@@ -92,8 +93,8 @@ 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->m_stat.f_fsid.val[0] == fsid->val[0] &&
+                   mp->m_stat.f_fsid.val[1] == fsid->val[1]) {

                        return (mp);
                }
                mp = mp->m_next;
                        return (mp);
                }
                mp = mp->m_next;


@@ -111,8 +112,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 =


@@ -131,7 +132,7 @@ ndinit(ndp)
        ndp->ni_iovcnt = 1;
        ndp->ni_base = (caddr_t)&ndp->ni_dent;
        ndp->ni_rw = UIO_WRITE;
        ndp->ni_iovcnt = 1;
        ndp->ni_base = (caddr_t)&ndp->ni_dent;
        ndp->ni_rw = UIO_WRITE;

-       ndp->ni_segflg = UIO_SYSSPACE;
+       ndp->ni_uioseg = UIO_SYSSPACE;

 }
 
 /*
 }
 
 /*


@@ -169,35 +170,16 @@ ndrele(ndp)
  */
 struct vnode *vfreeh, **vfreet;
 extern struct vnodeops dead_vnodeops, spec_vnodeops;
  */
 struct vnode *vfreeh, **vfreet;
 extern struct vnodeops dead_vnodeops, spec_vnodeops;

-struct speclist *speclisth;
-struct speclist {
-       struct speclist *sl_next;
-       struct vnode *sl_vp;
-};
+extern void vclean();
+long numvnodes;

 
 /*
  * 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
         */


@@ -223,28 +205,37 @@ 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_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)
-               vgone(vp);
-       vp->v_flag = 0;
-       vp->v_shlockc = 0;
-       vp->v_exlockc = 0;
-       vp->v_socket = 0;
+       vp->v_type = VNON;

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

-       vp->v_mount = mp;

        insmntque(vp, mp);
        VREF(vp);
        *vpp = vp;
        insmntque(vp, mp);
        VREF(vp);
        *vpp = vp;


@@ -271,6 +262,7 @@ insmntque(vp, mp)
        /*
         * Insert into list of vnodes for the new mount point, if available.
         */
        /*
         * Insert into list of vnodes for the new mount point, if available.
         */

+       vp->v_mount = mp;

        if (mp == NULL) {
                vp->v_mountf = NULL;
                vp->v_mountb = NULL;
        if (mp == NULL) {
                vp->v_mountf = NULL;
                vp->v_mountb = NULL;


@@ -308,8 +300,7 @@ bdevvp(dev, vpp)
        }
        vp = nvp;
        vp->v_type = VBLK;
        }
        vp = nvp;
        vp->v_type = VBLK;

-       vp->v_rdev = dev;
-       if (nvp = checkalias(vp, (struct mount *)0)) {
+       if (nvp = checkalias(vp, dev, (struct mount *)0)) {

                vput(vp);
                vp = nvp;
        }
                vput(vp);
                vp = nvp;
        }


@@ -322,34 +313,49 @@ bdevvp(dev, vpp)
  * for which we already have a vnode (either because of
  * bdevvp() or because of a different vnode representing
  * the same block device). If such an alias exists, deallocate
  * for which we already have a vnode (either because of
  * bdevvp() or because of a different vnode representing
  * the same block device). If such an alias exists, deallocate

- * the existing contents and return the aliased inode. The
+ * the existing contents and return the aliased vnode. The

  * caller is responsible for filling it with its new contents.
  */
 struct vnode *
  * caller is responsible for filling it with its new contents.
  */
 struct vnode *

-checkalias(nvp, mp)
+checkalias(nvp, nvp_rdev, mp)

        register struct vnode *nvp;
        register struct vnode *nvp;

+       dev_t nvp_rdev;

        struct mount *mp;
 {
        register struct vnode *vp;
        struct mount *mp;
 {
        register struct vnode *vp;

-       register struct speclist *slp;
+       struct vnode **vpp;

 
        if (nvp->v_type != VBLK && nvp->v_type != VCHR)
                return ((struct vnode *)0);
 
        if (nvp->v_type != VBLK && nvp->v_type != VCHR)
                return ((struct vnode *)0);

+
+       vpp = &speclisth[SPECHASH(nvp_rdev)];

 loop:
 loop:

-       for (slp = speclisth; slp; slp = slp->sl_next) {
-               vp = slp->sl_vp;
-               if (nvp->v_rdev != vp->v_rdev ||
-                   nvp->v_type != vp->v_type)
+       for (vp = *vpp; vp; vp = vp->v_specnext) {
+               if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type)

                        continue;
                        continue;

+               /*
+                * Alias, but not in use, so flush it out.
+                */
+               if (vp->v_usecount == 0) {
+                       vgone(vp);
+                       goto loop;
+               }

                if (vget(vp))
                        goto loop;
                break;
        }
                if (vget(vp))
                        goto loop;
                break;
        }

-       if (slp == NULL) {
-               MALLOC(slp, struct speclist *, sizeof(*slp), M_VNODE, M_WAITOK);
-               slp->sl_vp = nvp;
-               slp->sl_next = speclisth;
-               speclisth = slp;
+       if (vp == NULL || vp->v_tag != VT_NON) {
+               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;
+               *vpp = nvp;
+               if (vp != NULL) {
+                       nvp->v_flag |= VALIASED;
+                       vp->v_flag |= VALIASED;
+                       vput(vp);
+               }

                return ((struct vnode *)0);
        }
        VOP_UNLOCK(vp);
                return ((struct vnode *)0);
        }
        VOP_UNLOCK(vp);


@@ -379,7 +385,7 @@ vget(vp)
                sleep((caddr_t)vp, PINOD);
                return (1);
        }
                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
                if (vq = vp->v_freef)
                        vq->v_freeb = vp->v_freeb;
                else


@@ -400,7 +406,7 @@ void vref(vp)
        struct vnode *vp;
 {
 
        struct vnode *vp;
 {
 

-       vp->v_count++;
+       vp->v_usecount++;

 }
 
 /*
 }
 
 /*


@@ -423,11 +429,10 @@ void vrele(vp)
 
        if (vp == NULL)
                panic("vrele: null vp");
 
        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)
+       vp->v_usecount--;
+       if (vp->v_usecount < 0)
+               vprint("vrele: bad ref count", vp);
+       if (vp->v_usecount > 0)

                return;
        if (vfreeh == (struct vnode *)0) {
                /*
                return;
        if (vfreeh == (struct vnode *)0) {
                /*


@@ -447,6 +452,85 @@ void vrele(vp)
        VOP_INACTIVE(vp);
 }
 
        VOP_INACTIVE(vp);
 }
 

+/*
+ * Page or buffer structure gets a reference.
+ */
+vhold(vp)
+       register struct vnode *vp;
+{
+
+       vp->v_holdcnt++;
+}
+
+/*
+ * Page or buffer structure frees a reference.
+ */
+holdrele(vp)
+       register struct vnode *vp;
+{
+
+       if (vp->v_holdcnt <= 0)
+               panic("holdrele: holdcnt");
+       vp->v_holdcnt--;
+}
+
+/*
+ * Remove any vnodes in the vnode table belonging to mount point mp.
+ *
+ * If MNT_NOFORCE is specified, there should not be any active ones,
+ * return error if any are found (nb: this is a user error, not a
+ * system error). If MNT_FORCE is specified, detach any active vnodes
+ * that are found.
+ */
+int busyprt = 0;       /* patch to print out busy vnodes */
+
+vflush(mp, skipvp, flags)
+       struct mount *mp;
+       struct vnode *skipvp;
+       int flags;
+{
+       register struct vnode *vp, *nvp;
+       int busy = 0;
+
+       for (vp = mp->m_mounth; vp; vp = nvp) {
+               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_usecount == 0, all we need to do is clear
+                * out the vnode data structures and we are done.
+                */
+               if (vp->v_usecount == 0) {
+                       vgone(vp);
+                       continue;
+               }
+               /*
+                * For block or character devices, revert to an
+                * anonymous device. For all other files, just kill them.
+                */
+               if (flags & MNT_FORCE) {
+                       if (vp->v_type != VBLK && vp->v_type != VCHR) {
+                               vgone(vp);
+                       } else {
+                               vclean(vp, 0);
+                               vp->v_op = &spec_vnodeops;
+                               insmntque(vp, (struct mount *)0);
+                       }
+                       continue;
+               }
+               if (busyprt)
+                       vprint("vflush: busy vnode", vp);
+               busy++;
+       }
+       if (busy)
+               return (EBUSY);
+       return (0);
+}
+

 /*
  * Disassociate the underlying file system from a vnode.
  */
 /*
  * Disassociate the underlying file system from a vnode.
  */


@@ -459,21 +543,29 @@ void vclean(vp, doclose)
 
        /*
         * Check to see if the vnode is in use.
 
        /*
         * 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);
                VREF(vp);

-               VOP_LOCK(vp);
-       }

        /*
         * Prevent the vnode from being recycled or
         * brought into use while we clean it out.
         */
        /*
         * 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;
        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 (doclose)
+               vinvalbuf(vp, 1);

        /*
         * Prevent any further operations on the vnode from
         * being passed through to the old file system.
        /*
         * Prevent any further operations on the vnode from
         * being passed through to the old file system.


@@ -485,8 +577,8 @@ void vclean(vp, doclose)
         * If purging an active vnode, it must be unlocked, closed,
         * and deactivated before being reclaimed.
         */
         * If purging an active vnode, it must be unlocked, closed,
         * and deactivated before being reclaimed.
         */

+       (*(origops->vn_unlock))(vp);

        if (active) {
        if (active) {

-               (*(origops->vn_unlock))(vp);

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


@@ -508,6 +600,49 @@ void vclean(vp, doclose)
        }
 }
 
        }
 }
 

+/*
+ * Eliminate all activity associated with  the requested vnode
+ * and with all vnodes aliased to the requested vnode.
+ */
+void vgoneall(vp)
+       register struct vnode *vp;
+{
+       register struct vnode *vq;
+
+       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);
+}
+

 /*
  * Eliminate all activity associated with a vnode
  * in preparation for reuse.
 /*
  * Eliminate all activity associated with a vnode
  * in preparation for reuse.


@@ -515,10 +650,19 @@ void vclean(vp, doclose)
 void vgone(vp)
        register struct vnode *vp;
 {
 void vgone(vp)
        register struct vnode *vp;
 {

-       register struct speclist *slp;
-       struct speclist *pslp;

        register struct vnode *vq;
        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.
         */
        /*
         * Clean out the filesystem specific data.
         */


@@ -537,21 +681,35 @@ void vgone(vp)
         * If special device, remove it from special device alias list.
         */
        if (vp->v_type == VBLK || vp->v_type == VCHR) {
         * If special device, remove it from special device alias list.
         */
        if (vp->v_type == VBLK || vp->v_type == VCHR) {

-               if (speclisth->sl_vp == vp) {
-                       slp = speclisth;
-                       speclisth = slp->sl_next;
+               if (*vp->v_hashchain == vp) {
+                       *vp->v_hashchain = vp->v_specnext;

                } else {
                } else {

-                       for (pslp = speclisth, slp = pslp->sl_next; slp;
-                            pslp = slp, slp = slp->sl_next) {
-                               if (slp->sl_vp != vp)
+                       for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
+                               if (vq->v_specnext != vp)

                                        continue;
                                        continue;

-                               pslp->sl_next = slp->sl_next;
+                               vq->v_specnext = vp->v_specnext;

                                break;
                        }
                                break;
                        }

-                       if (slp == NULL)
+                       if (vq == NULL)

                                panic("missing bdev");
                }
                                panic("missing bdev");
                }

-               FREE(slp, M_VNODE);
+               if (vp->v_flag & VALIASED) {
+                       count = 0;
+                       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++;
+                               vx = vq;
+                       }
+                       if (count == 0)
+                               panic("missing alias");
+                       if (count == 1)
+                               vx->v_flag &= ~VALIASED;
+                       vp->v_flag &= ~VALIASED;
+               }
+               FREE(vp->v_specinfo, M_VNODE);
+               vp->v_specinfo = NULL;

        }
        /*
         * If it is on the freelist, move it to the head of the list.
        }
        /*
         * If it is on the freelist, move it to the head of the list.


@@ -569,3 +727,90 @@ 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.
+ */
+vcount(vp)
+       register struct vnode *vp;
+{
+       register struct vnode *vq;
+       int count;
+
+       if ((vp->v_flag & VALIASED) == 0)
+               return (vp->v_usecount);
+loop:
+       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_usecount == 0) {
+                       vgone(vq);
+                       goto loop;
+               }
+               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, refcount %d,", typename[vp->v_type],
+               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 & VXLOCK)
+               strcat(buf, "|VXLOCK");
+       if (vp->v_flag & VXWANT)
+               strcat(buf, "|VXWANT");
+       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 & VALIASED)
+               strcat(buf, "|VALIASED");
+       if (vp->v_flag & VBWAIT)
+               strcat(buf, "|VBWAIT");
+       if (buf[0] != '\0')
+               printf(" flags (%s)", &buf[1]);
+       printf("\n\t");
+       VOP_PRINT(vp);
+}