xnu-517.9.5.tar.gz

[apple/xnu.git] / bsd / nfs / nfs_node.c

diff --git a/bsd/nfs/nfs_node.c b/bsd/nfs/nfs_node.c
index 383428171e7937d522f16f462ea30270819e2078..b05a62cc77bf19273c3510f4cc3fda2ad020d14a 100644 (file)
--- a/bsd/nfs/nfs_node.c
+++ b/bsd/nfs/nfs_node.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.

  *
  * @APPLE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_LICENSE_HEADER_START@
  * 


@@ -74,10 +74,6 @@
 #include <nfs/nfsnode.h>
 #include <nfs/nfsmount.h>
 
 #include <nfs/nfsnode.h>
 #include <nfs/nfsmount.h>
 

-#ifdef MALLOC_DEFINE
-static MALLOC_DEFINE(M_NFSNODE, "NFS node", "NFS vnode private part");
-#endif
-

 LIST_HEAD(nfsnodehashhead, nfsnode) *nfsnodehashtbl;
 u_long nfsnodehash;
 
 LIST_HEAD(nfsnodehashhead, nfsnode) *nfsnodehashtbl;
 u_long nfsnodehash;
 


@@ -89,7 +85,7 @@ u_long nfsnodehash;
  * and build nfsnode free list.
  */
 void
  * and build nfsnode free list.
  */
 void

-nfs_nhinit()
+nfs_nhinit(void)

 {
        nfsnodehashtbl = hashinit(desiredvnodes, M_NFSNODE, &nfsnodehash);
 }
 {
        nfsnodehashtbl = hashinit(desiredvnodes, M_NFSNODE, &nfsnodehash);
 }


@@ -134,19 +130,27 @@ nfs_nget(mntp, fhp, fhsize, npp)
        register struct vnode *vp;
        struct vnode *nvp;
        int error;
        register struct vnode *vp;
        struct vnode *nvp;
        int error;

+       struct mount *mp;

 
        /* Check for unmount in progress */
 
        /* Check for unmount in progress */

-       if (mntp->mnt_kern_flag & MNTK_UNMOUNT) {
+       if (!mntp || (mntp->mnt_kern_flag & MNTK_UNMOUNT)) {

                *npp = 0;
                *npp = 0;

-               return (EPERM);
+               return (!mntp ? ENXIO : EPERM);

        }
 
        nhpp = NFSNOHASH(nfs_hash(fhp, fhsize));
 loop:
        for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
        }
 
        nhpp = NFSNOHASH(nfs_hash(fhp, fhsize));
 loop:
        for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {

-               if (mntp != NFSTOV(np)->v_mount || np->n_fhsize != fhsize ||
+               mp = (np->n_flag & NINIT) ? np->n_mount : NFSTOV(np)->v_mount;
+               if (mntp != mp || np->n_fhsize != fhsize ||

                    bcmp((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize))
                        continue;
                    bcmp((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize))
                        continue;

+               /* if the node is still being initialized, sleep on it */
+               if (np->n_flag & NINIT) {
+                       np->n_flag |= NWINIT;
+                       tsleep(np, PINOD, "nfsngt", 0);
+                       goto loop;
+               }

                vp = NFSTOV(np);
                if (vget(vp, LK_EXCLUSIVE, p))
                        goto loop;
                vp = NFSTOV(np);
                if (vget(vp, LK_EXCLUSIVE, p))
                        goto loop;


@@ -167,29 +171,19 @@ loop:
        nfs_node_hash_lock = 1;
 
        /*
        nfs_node_hash_lock = 1;
 
        /*

-        * Do the MALLOC before the getnewvnode since doing so afterward
-        * might cause a bogus v_data pointer to get dereferenced
-        * elsewhere if MALLOC should block.
+        * allocate and initialize nfsnode and stick it in the hash
+        * before calling getnewvnode().  Anyone finding it in the
+        * hash before initialization is complete will wait for it.

         */
        MALLOC_ZONE(np, struct nfsnode *, sizeof *np, M_NFSNODE, M_WAITOK);
         */
        MALLOC_ZONE(np, struct nfsnode *, sizeof *np, M_NFSNODE, M_WAITOK);

-               
-       error = getnewvnode(VT_NFS, mntp, nfsv2_vnodeop_p, &nvp);
-       if (error) {
-               if (nfs_node_hash_lock < 0)
-                       wakeup(&nfs_node_hash_lock);
-               nfs_node_hash_lock = 0;
-               *npp = 0;
-               FREE_ZONE(np, sizeof *np, M_NFSNODE);
-               return (error);
-       }
-       vp = nvp;

        bzero((caddr_t)np, sizeof *np);
        bzero((caddr_t)np, sizeof *np);

-       vp->v_data = np;
-       np->n_vnode = vp;
-       /*
-        * Insert the nfsnode in the hash queue for its new file handle
-        */
-       LIST_INSERT_HEAD(nhpp, np, n_hash);
+       np->n_flag |= NINIT;
+       np->n_mount = mntp;
+       lockinit(&np->n_lock, PINOD, "nfsnode", 0, 0);
+       /* lock the new nfsnode */
+       lockmgr(&np->n_lock, LK_EXCLUSIVE, NULL, p);
+
+       /* Insert the nfsnode in the hash queue for its new file handle */

        if (fhsize > NFS_SMALLFH) {
                MALLOC_ZONE(np->n_fhp, nfsfh_t *,
                                fhsize, M_NFSBIGFH, M_WAITOK);
        if (fhsize > NFS_SMALLFH) {
                MALLOC_ZONE(np->n_fhp, nfsfh_t *,
                                fhsize, M_NFSBIGFH, M_WAITOK);


@@ -197,18 +191,38 @@ loop:
                np->n_fhp = &np->n_fh;
        bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize);
        np->n_fhsize = fhsize;
                np->n_fhp = &np->n_fh;
        bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize);
        np->n_fhsize = fhsize;

-       *npp = np;
+       LIST_INSERT_HEAD(nhpp, np, n_hash);
+       np->n_flag |= NHASHED;

 
 

+       /* release lock on hash table */

        if (nfs_node_hash_lock < 0)
                wakeup(&nfs_node_hash_lock);
        nfs_node_hash_lock = 0;
 
        if (nfs_node_hash_lock < 0)
                wakeup(&nfs_node_hash_lock);
        nfs_node_hash_lock = 0;
 

-       /*
-        * Lock the new nfsnode.
-        */
-       vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+       /* now, attempt to get a new vnode */
+       error = getnewvnode(VT_NFS, mntp, nfsv2_vnodeop_p, &nvp);
+       if (error) {
+               LIST_REMOVE(np, n_hash);
+               np->n_flag &= ~NHASHED;
+               if (np->n_fhsize > NFS_SMALLFH)
+                       FREE_ZONE((caddr_t)np->n_fhp, np->n_fhsize, M_NFSBIGFH);
+               FREE_ZONE(np, sizeof *np, M_NFSNODE);
+               *npp = 0;
+               return (error);
+       }
+       vp = nvp;
+       vp->v_data = np;
+       np->n_vnode = vp;
+       *npp = np;

 
 

-       return (0);
+       /* node is now initialized, check if anyone's waiting for it */
+       np->n_flag &= ~NINIT;
+       if (np->n_flag & NWINIT) {
+               np->n_flag &= ~NWINIT;
+               wakeup((caddr_t)np);
+       }
+
+       return (error);

 }
 
 int
 }
 
 int


@@ -240,34 +254,17 @@ nfs_inactive(ap)
 #if DIAGNOSTIC
                kprintf("nfs_inactive removing %s, dvp=%x, a_vp=%x, ap=%x, np=%x, sp=%x\n", &sp->s_name[0], (unsigned)sp->s_dvp, (unsigned)ap->a_vp, (unsigned)ap, (unsigned)np, (unsigned)sp);
 #endif
 #if DIAGNOSTIC
                kprintf("nfs_inactive removing %s, dvp=%x, a_vp=%x, ap=%x, np=%x, sp=%x\n", &sp->s_name[0], (unsigned)sp->s_dvp, (unsigned)ap->a_vp, (unsigned)ap, (unsigned)np, (unsigned)sp);
 #endif

-               /*
-                * We get a reference (vget) to ensure getnewvnode()
-                * doesn't recycle vp while we're asleep awaiting I/O.
-                * Note we don't need the reference unless usecount is
-                * already zero.  In the case of a forcible unmount it
-                * wont be zero and doing a vget would fail because
-                * vclean holds VXLOCK.
-                */
-                if (ap->a_vp->v_usecount > 0) {
-                        VREF(ap->a_vp);
-                } else if (vget(ap->a_vp, 0, ap->a_p))
-                       panic("nfs_inactive: vget failed");

                (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1);
                (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1);

+               np->n_size = 0;

                ubc_setsize(ap->a_vp, (off_t)0);
                ubc_setsize(ap->a_vp, (off_t)0);

-
-                /* We have a problem. The dvp could have gone away on us
-                 * while in the unmount path. Thus it appears as VBAD and we
-                 * cannot use it. If we tried locking the parent (future), for silly
-                 * rename files, it is unclear where we would lock. The unmount
-                 * code just pulls unlocked vnodes as it goes thru its list and
-                 * yanks them. Could unmount be smarter to see if a busy reg vnode has
-                 * a parent, and not yank it yet? Put in more passes at unmount
-                 * time? In the meantime, just check if it went away on us. Could
-                 * have gone away during the nfs_vinvalbuf or ubc_setsize which block.
-                 * Or perhaps even before nfs_inactive got called.
-                 */
-                if ((sp->s_dvp)->v_type != VBAD) 
-                        nfs_removeit(sp); /* uses the dvp */
+               nfs_removeit(sp);
+               /*
+                * remove nfsnode from hash now so we can't accidentally find it
+                * again if another object gets created with the same filehandle
+                * before this vnode gets reclaimed
+                */
+               LIST_REMOVE(np, n_hash);
+               np->n_flag &= ~NHASHED;

                cred = sp->s_cred;
                if (cred != NOCRED) {
                        sp->s_cred = NOCRED;
                cred = sp->s_cred;
                if (cred != NOCRED) {
                        sp->s_cred = NOCRED;


@@ -275,10 +272,9 @@ nfs_inactive(ap)
                }
                vrele(sp->s_dvp);
                FREE_ZONE((caddr_t)sp, sizeof (struct sillyrename), M_NFSREQ);
                }
                vrele(sp->s_dvp);
                FREE_ZONE((caddr_t)sp, sizeof (struct sillyrename), M_NFSREQ);

-               vrele(ap->a_vp);

        }
        np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NQNFSEVICTED |
        }
        np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NQNFSEVICTED |

-               NQNFSNONCACHE | NQNFSWRITE);
+               NQNFSNONCACHE | NQNFSWRITE | NHASHED);

        VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
        return (0);
 }
        VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
        return (0);
 }


@@ -294,14 +290,17 @@ nfs_reclaim(ap)
 {
        register struct vnode *vp = ap->a_vp;
        register struct nfsnode *np = VTONFS(vp);
 {
        register struct vnode *vp = ap->a_vp;
        register struct nfsnode *np = VTONFS(vp);

-       register struct nfsmount *nmp = VFSTONFS(vp->v_mount);
+       register struct nfsmount *nmp;

        register struct nfsdmap *dp, *dp2;
        extern int prtactive;
 
        if (prtactive && vp->v_usecount != 0)
                vprint("nfs_reclaim: pushing active", vp);
 
        register struct nfsdmap *dp, *dp2;
        extern int prtactive;
 
        if (prtactive && vp->v_usecount != 0)
                vprint("nfs_reclaim: pushing active", vp);
 

-       LIST_REMOVE(np, n_hash);
+       if (np->n_flag & NHASHED) {
+               LIST_REMOVE(np, n_hash);
+               np->n_flag &= ~NHASHED;
+       }

 
         /*
          * In case we block during FREE_ZONEs below, get the entry out
 
         /*
          * In case we block during FREE_ZONEs below, get the entry out


@@ -312,7 +311,8 @@ nfs_reclaim(ap)
        /*
         * For nqnfs, take it off the timer queue as required.
         */
        /*
         * For nqnfs, take it off the timer queue as required.
         */

-       if ((nmp->nm_flag & NFSMNT_NQNFS) && np->n_timer.cqe_next != 0) {
+       nmp = VFSTONFS(vp->v_mount);
+       if (nmp && (nmp->nm_flag & NFSMNT_NQNFS) && np->n_timer.cqe_next != 0) {

                CIRCLEQ_REMOVE(&nmp->nm_timerhead, np, n_timer);
        }
 
                CIRCLEQ_REMOVE(&nmp->nm_timerhead, np, n_timer);
        }
 


@@ -339,57 +339,30 @@ nfs_reclaim(ap)
        return (0);
 }
 
        return (0);
 }
 

-#if 0

 /*
  * Lock an nfsnode
  */
 int
 nfs_lock(ap)
        struct vop_lock_args /* {
 /*
  * Lock an nfsnode
  */
 int
 nfs_lock(ap)
        struct vop_lock_args /* {

-               struct vnode *a_vp;
+                struct vnode *a_vp;
+                int a_flags;
+                struct proc *a_p;

        } */ *ap;
 {
        register struct vnode *vp = ap->a_vp;
 
        /*
         * Ugh, another place where interruptible mounts will get hung.
        } */ *ap;
 {
        register struct vnode *vp = ap->a_vp;
 
        /*
         * Ugh, another place where interruptible mounts will get hung.

-        * If you make this sleep interruptible, then you have to fix all
+        * If you make this call interruptible, then you have to fix all

         * the VOP_LOCK() calls to expect interruptibility.
         */
         * the VOP_LOCK() calls to expect interruptibility.
         */

-       while (vp->v_flag & VXLOCK) {
-               vp->v_flag |= VXWANT;
-               (void) tsleep((caddr_t)vp, PINOD, "nfslck", 0);
-       }

        if (vp->v_tag == VT_NON)
        if (vp->v_tag == VT_NON)

-               return (ENOENT);
-
-#if 0
-       /*
-        * Only lock regular files.  If a server crashed while we were
-        * holding a directory lock, we could easily end up sleeping
-        * until the server rebooted while holding a lock on the root.
-        * Locks are only needed for protecting critical sections in
-        * VMIO at the moment.
-        * New vnodes will have type VNON but they should be locked
-        * since they may become VREG.  This is checked in loadattrcache
-        * and unwanted locks are released there.
-        */
-       if (vp->v_type == VREG || vp->v_type == VNON) {
-               while (np->n_flag & NLOCKED) {
-                       np->n_flag |= NWANTED;
-                       (void) tsleep((caddr_t) np, PINOD, "nfslck2", 0);
-                       /*
-                        * If the vnode has transmuted into a VDIR while we
-                        * were asleep, then skip the lock.
-                        */
-                       if (vp->v_type != VREG && vp->v_type != VNON)
-                               return (0);
-               }
-               np->n_flag |= NLOCKED;
-       }
-#endif
-
-       return (0);
+               return (ENOENT); /* ??? -- got to check something and error, but what? */
+        
+       return(lockmgr(&VTONFS(vp)->n_lock, ap->a_flags, &vp->v_interlock,
+                ap->a_p));
+       

 }
 
 /*
 }
 
 /*


@@ -397,26 +370,16 @@ nfs_lock(ap)
  */
 int
 nfs_unlock(ap)
  */
 int
 nfs_unlock(ap)

-       struct vop_unlock_args /* {
-               struct vnode *a_vp;
-       } */ *ap;
+        struct vop_unlock_args /* {
+                struct vnode *a_vp;
+                int a_flags;
+                struct proc *a_p;
+        } */ *ap;

 {
 {

-#if 0
-       struct vnode* vp = ap->a_vp;
-        struct nfsnode* np = VTONFS(vp);
-
-       if (vp->v_type == VREG || vp->v_type == VNON) {
-               if (!(np->n_flag & NLOCKED))
-                       panic("nfs_unlock: nfsnode not locked");
-               np->n_flag &= ~NLOCKED;
-               if (np->n_flag & NWANTED) {
-                       np->n_flag &= ~NWANTED;
-                       wakeup((caddr_t) np);
-               }
-       }
-#endif
+        struct vnode *vp = ap->a_vp;

 
 

-       return (0);
+        return (lockmgr(&VTONFS(vp)->n_lock, ap->a_flags | LK_RELEASE,
+                &vp->v_interlock, ap->a_p));

 }
 
 /*
 }
 
 /*


@@ -428,24 +391,6 @@ nfs_islocked(ap)
                struct vnode *a_vp;
        } */ *ap;
 {
                struct vnode *a_vp;
        } */ *ap;
 {

-       return VTONFS(ap->a_vp)->n_flag & NLOCKED ? 1 : 0;
-}
-#endif
-
-/*
- * Nfs abort op, called after namei() when a CREATE/DELETE isn't actually
- * done. Currently nothing to do.
- */
-/* ARGSUSED */
-int
-nfs_abortop(ap)
-       struct vop_abortop_args /* {
-               struct vnode *a_dvp;
-               struct componentname *a_cnp;
-       } */ *ap;
-{
+       return (lockstatus(&VTONFS(ap->a_vp)->n_lock));

 
 

-       if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF)
-               FREE_ZONE(ap->a_cnp->cn_pnbuf, ap->a_cnp->cn_pnlen, M_NAMEI);
-       return (0);

 }
 }