add islocked vnode op

[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..d3469ac 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.22 (Berkeley) %G%

  */
 
 /*
  */
 
 /*


@@ -131,7 +131,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,11 +169,15 @@ 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();
+
+#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];

 
 /*
  * Initialize the vnode structures and initialize each file system type.
 
 /*
  * Initialize the vnode structures and initialize each file system type.


@@ -228,23 +232,24 @@ getnewvnode(tag, mp, vops, vpp)
                *vpp = 0;
                return (ENFILE);
        }
                *vpp = 0;
                return (ENFILE);
        }

-       if (vp->v_count)
+       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;
                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)
+       if (vp->v_type != VNON && vp->v_type != VBAD)

                vgone(vp);
                vgone(vp);

+       vp->v_type = VNON;

        vp->v_flag = 0;
        vp->v_shlockc = 0;
        vp->v_exlockc = 0;
        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;
        vp->v_socket = 0;
        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 +276,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 +314,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 +327,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) {
+               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;
+               *vpp = nvp;

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


@@ -379,7 +399,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 +420,7 @@ void vref(vp)
        struct vnode *vp;
 {
 
        struct vnode *vp;
 {
 

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

 }
 
 /*
 }
 
 /*


@@ -423,11 +443,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 +466,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 +557,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 +591,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 +614,26 @@ 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;
+
+       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;
+               }
+       }
+       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,9 +641,9 @@ 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;

 
        /*
         * Clean out the filesystem specific data.
 
        /*
         * Clean out the filesystem specific data.


@@ -537,21 +663,34 @@ 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)
+                                       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 +708,67 @@ 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)
+                       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", "VBAD" };
+
+vprint(label, vp)
+       char *label;
+       register struct vnode *vp;
+{
+
+       if (label != NULL)
+               printf("%s: ", label);
+       printf("type %s, usecount %d, refcount %d,\n\t", typename[vp->v_type],
+               vp->v_usecount, vp->v_holdcnt);
+       VOP_PRINT(vp);
+}