BSD 4_3_Reno release

[unix-history] / usr / src / sys / nfs / nfs_subs.c

diff --git a/usr/src/sys/nfs/nfs_subs.c b/usr/src/sys/nfs/nfs_subs.c
index 55683c0..b2344f4 100644 (file)
--- a/usr/src/sys/nfs/nfs_subs.c
+++ b/usr/src/sys/nfs/nfs_subs.c
@@ -5,19 +5,22 @@
  * This code is derived from software contributed to Berkeley by
  * Rick Macklem at The University of Guelph.
  *
  * This code is derived from software contributed to Berkeley by
  * Rick Macklem at The University of Guelph.
  *

- * 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.
+ * Redistribution is only permitted until one year after the first shipment
+ * of 4.4BSD by the Regents.  Otherwise, redistribution and use in source and
+ * binary forms are permitted provided that: (1) source distributions retain
+ * this entire copyright notice and comment, and (2) distributions including
+ * binaries display the following acknowledgement:  This product includes
+ * software developed by the University of California, Berkeley and its
+ * contributors'' in the documentation or other materials provided with the
+ * distribution and in all advertising materials mentioning features or use
+ * of this software.  Neither the name of the University nor the names of
+ * its contributors may 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.

  *
  *

- *     @(#)nfs_subs.c  7.13 (Berkeley) %G%
+ *     @(#)nfs_subs.c  7.29 (Berkeley) 7/26/90

  */
 
 /*
  */
 
 /*


@@ -25,23 +28,16 @@
  * the nfs op functions. They do things like create the rpc header and
  * copy data between mbuf chains and uio lists.
  */
  * the nfs op functions. They do things like create the rpc header and
  * copy data between mbuf chains and uio lists.
  */

-#include "strings.h"

 #include "param.h"
 #include "param.h"

-#include "systm.h"

 #include "user.h"
 #include "proc.h"
 #include "user.h"
 #include "proc.h"

-#include "mount.h"
-#include "../ufs/dir.h"
-#include "time.h"
-#include "errno.h"
+#include "systm.h"

 #include "kernel.h"
 #include "kernel.h"

-#include "malloc.h"
-#include "mbuf.h"
+#include "mount.h"

 #include "file.h"
 #include "vnode.h"
 #include "file.h"
 #include "vnode.h"

-#include "uio.h"
-#include "namei.h"
-#include "ucred.h"
+#include "mbuf.h"
+#include "errno.h"

 #include "map.h"
 #include "rpcv2.h"
 #include "nfsv2.h"
 #include "map.h"
 #include "rpcv2.h"
 #include "nfsv2.h"


@@ -68,17 +64,19 @@ static u_long *rpc_uidp = (u_long *)0;
 static u_long nfs_xid = 1;
 static char *rpc_unixauth;
 extern long hostid;
 static u_long nfs_xid = 1;
 static char *rpc_unixauth;
 extern long hostid;

-extern enum vtype v_type[NFLNK+1];
-extern struct proc *nfs_iodwant[MAX_ASYNCDAEMON];
+enum vtype ntov_type[7] = { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON };
+extern struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];

 extern struct map nfsmap[NFS_MSIZ];
 extern struct map nfsmap[NFS_MSIZ];

+extern struct nfsreq nfsreqh;

 
 /* Function ret types */
 static char *nfs_unixauth();
 
 /*
  * Maximum number of groups passed through to NFS server.
 
 /* Function ret types */
 static char *nfs_unixauth();
 
 /*
  * Maximum number of groups passed through to NFS server.

+ * According to RFC1057 it should be 16.

  * For release 3.X systems, the maximum value is 8.
  * For release 3.X systems, the maximum value is 8.

- * For release 4.X systems, the maximum value is 10.
+ * For some other servers, the maximum value is 10.

  */
 int numgrps = 8;
 
  */
 int numgrps = 8;
 


@@ -107,7 +105,8 @@ struct mbuf *nfsm_reqh(prog, vers, procid, cred, hsiz, bpos, mb, retxid)
        int asiz, siz;
 
        NFSMGETHDR(mreq);
        int asiz, siz;
 
        NFSMGETHDR(mreq);

-       asiz = (((cred->cr_ngroups > numgrps) ? numgrps : cred->cr_ngroups)<<2);
+       asiz = ((((cred->cr_ngroups - 1) > numgrps) ? numgrps :
+                 (cred->cr_ngroups - 1)) << 2);

 #ifdef FILLINHOST
        asiz += nfsm_rndup(hostnamelen)+(9*NFSX_UNSIGNED);
 #else
 #ifdef FILLINHOST
        asiz += nfsm_rndup(hostnamelen)+(9*NFSX_UNSIGNED);
 #else


@@ -116,7 +115,7 @@ struct mbuf *nfsm_reqh(prog, vers, procid, cred, hsiz, bpos, mb, retxid)
 
        /* If we need a lot, alloc a cluster ?? */
        if ((asiz+hsiz+RPC_SIZ) > MHLEN)
 
        /* If we need a lot, alloc a cluster ?? */
        if ((asiz+hsiz+RPC_SIZ) > MHLEN)

-               NFSMCLGET(mreq, M_WAIT);
+               MCLGET(mreq, M_WAIT);

        mreq->m_len = NFSMSIZ(mreq);
        siz = mreq->m_len;
        m1 = mreq;
        mreq->m_len = NFSMSIZ(mreq);
        siz = mreq->m_len;
        m1 = mreq;


@@ -171,14 +170,15 @@ struct mbuf *nfsm_reqh(prog, vers, procid, cred, hsiz, bpos, mb, retxid)
  */
 nfsm_mbuftouio(mrep, uiop, siz, dpos)
        struct mbuf **mrep;
  */
 nfsm_mbuftouio(mrep, uiop, siz, dpos)
        struct mbuf **mrep;

-       struct uio *uiop;
+       register struct uio *uiop;

        int siz;
        caddr_t *dpos;
 {
        int siz;
        caddr_t *dpos;
 {

+       register char *mbufcp, *uiocp;

        register int xfer, left, len;
        register struct mbuf *mp;
        register int xfer, left, len;
        register struct mbuf *mp;

-       register char *mbufcp, *uiocp;

        long uiosiz, rem;
        long uiosiz, rem;

+       int error = 0;

 
        mp = *mrep;
        mbufcp = *dpos;
 
        mp = *mrep;
        mbufcp = *dpos;


@@ -186,7 +186,7 @@ nfsm_mbuftouio(mrep, uiop, siz, dpos)
        rem = nfsm_rndup(siz)-siz;
        while (siz > 0) {
                if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
        rem = nfsm_rndup(siz)-siz;
        while (siz > 0) {
                if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)

-                       return(EFBIG);
+                       return (EFBIG);

                left = uiop->uio_iov->iov_len;
                uiocp = uiop->uio_iov->iov_base;
                if (left > siz)
                left = uiop->uio_iov->iov_len;
                uiocp = uiop->uio_iov->iov_base;
                if (left > siz)


@@ -228,11 +228,15 @@ nfsm_mbuftouio(mrep, uiop, siz, dpos)
                }
                siz -= uiosiz;
        }
                }
                siz -= uiosiz;
        }

-       if (rem > 0)
-               mbufcp += rem;

        *dpos = mbufcp;
        *mrep = mp;
        *dpos = mbufcp;
        *mrep = mp;

-       return(0);
+       if (rem > 0) {
+               if (len < rem)
+                       error = nfs_adv(mrep, dpos, rem, len);
+               else
+                       *dpos += rem;
+       }
+       return (error);

 }
 
 /*
 }
 
 /*


@@ -244,12 +248,11 @@ nfsm_uiotombuf(uiop, mq, siz, bpos)
        int siz;
        caddr_t *bpos;
 {
        int siz;
        caddr_t *bpos;
 {

-       register struct mbuf *mp;
-       struct mbuf *mp2;
-       long xfer, left, uiosiz;
-       int clflg;
-       int rem, len;
-       char *cp, *uiocp;
+       register char *uiocp;
+       register struct mbuf *mp, *mp2;
+       register int xfer, left, len;
+       int uiosiz, clflg, rem;
+       char *cp;

 
        if (siz > MLEN)         /* or should it >= MCLBYTES ?? */
                clflg = 1;
 
        if (siz > MLEN)         /* or should it >= MCLBYTES ?? */
                clflg = 1;


@@ -259,7 +262,7 @@ nfsm_uiotombuf(uiop, mq, siz, bpos)
        mp2 = *mq;
        while (siz > 0) {
                if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
        mp2 = *mq;
        while (siz > 0) {
                if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)

-                       return(EINVAL);
+                       return (EINVAL);

                left = uiop->uio_iov->iov_len;
                uiocp = uiop->uio_iov->iov_base;
                if (left > siz)
                left = uiop->uio_iov->iov_len;
                uiocp = uiop->uio_iov->iov_base;
                if (left > siz)


@@ -268,7 +271,7 @@ nfsm_uiotombuf(uiop, mq, siz, bpos)
                while (left > 0) {
                        MGET(mp, M_WAIT, MT_DATA);
                        if (clflg)
                while (left > 0) {
                        MGET(mp, M_WAIT, MT_DATA);
                        if (clflg)

-                               NFSMCLGET(mp, M_WAIT);
+                               MCLGET(mp, M_WAIT);

                        mp->m_len = NFSMSIZ(mp);
                        mp2->m_next = mp;
                        mp2 = mp;
                        mp->m_len = NFSMSIZ(mp);
                        mp2->m_next = mp;
                        mp2 = mp;


@@ -314,7 +317,7 @@ nfsm_uiotombuf(uiop, mq, siz, bpos)
        } else
                *bpos = mtod(mp, caddr_t)+mp->m_len;
        *mq = mp;
        } else
                *bpos = mtod(mp, caddr_t)+mp->m_len;
        *mq = mp;

-       return(0);
+       return (0);

 }
 
 /*
 }
 
 /*


@@ -340,17 +343,16 @@ nfsm_disct(mdp, dposp, siz, left, updateflg, cp2)
        while (left == 0) {
                *mdp = mp = mp->m_next;
                if (mp == NULL)
        while (left == 0) {
                *mdp = mp = mp->m_next;
                if (mp == NULL)

-                       return(EBADRPC);
+                       return (EBADRPC);

                left = mp->m_len;
                *dposp = mtod(mp, caddr_t);
        }
        if (left >= siz) {
                *cp2 = *dposp;
                *dposp += siz;
                left = mp->m_len;
                *dposp = mtod(mp, caddr_t);
        }
        if (left >= siz) {
                *cp2 = *dposp;
                *dposp += siz;

-               return(0);

        } else if (mp->m_next == NULL) {
        } else if (mp->m_next == NULL) {

-               return(EBADRPC);
-       } else if (siz > MCLBYTES) {
+               return (EBADRPC);
+       } else if (siz > MHLEN) {

                panic("nfs S too big");
        } else {
                /* Iff update, you can overwrite, else must alloc new mbuf */
                panic("nfs S too big");
        } else {
                /* Iff update, you can overwrite, else must alloc new mbuf */


@@ -363,26 +365,23 @@ nfsm_disct(mdp, dposp, siz, left, updateflg, cp2)
                        mp->m_len -= left;
                        mp = mp2;
                }
                        mp->m_len -= left;
                        mp = mp2;
                }

-               /* Alloc cluster iff we need it */
-               if (!M_HASCL(mp) && siz > NFSMSIZ(mp)) {
-                       NFSMCLGET(mp, M_WAIT);
-                       if (!M_HASCL(mp))
-                               return(ENOBUFS);
-               }

                *cp2 = p = mtod(mp, caddr_t);
                bcopy(*dposp, p, left);         /* Copy what was left */
                siz2 = siz-left;
                p += left;
                mp2 = mp->m_next;
                *cp2 = p = mtod(mp, caddr_t);
                bcopy(*dposp, p, left);         /* Copy what was left */
                siz2 = siz-left;
                p += left;
                mp2 = mp->m_next;

-               /* Loop arround copying up the siz2 bytes */
+               /* Loop around copying up the siz2 bytes */

                while (siz2 > 0) {
                        if (mp2 == NULL)
                                return (EBADRPC);
                        xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;
                while (siz2 > 0) {
                        if (mp2 == NULL)
                                return (EBADRPC);
                        xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;

-                       bcopy(mtod(mp2, caddr_t), p, xfer);
-                       NFSMADV(mp2, xfer);
-                       mp2->m_len -= xfer;
-                       siz2 -= xfer;
+                       if (xfer > 0) {
+                               bcopy(mtod(mp2, caddr_t), p, xfer);
+                               NFSMADV(mp2, xfer);
+                               mp2->m_len -= xfer;
+                               p += xfer;
+                               siz2 -= xfer;
+                       }

                        if (siz2 > 0)
                                mp2 = mp2->m_next;
                }
                        if (siz2 > 0)
                                mp2 = mp2->m_next;
                }


@@ -394,7 +393,7 @@ nfsm_disct(mdp, dposp, siz, left, updateflg, cp2)
 }
 
 /*
 }
 
 /*

- * Advance the position in the mbuf chain with/without freeing mbufs
+ * Advance the position in the mbuf chain.

  */
 nfs_adv(mdp, dposp, offs, left)
        struct mbuf **mdp;
  */
 nfs_adv(mdp, dposp, offs, left)
        struct mbuf **mdp;


@@ -411,12 +410,12 @@ nfs_adv(mdp, dposp, offs, left)
                offs -= s;
                m = m->m_next;
                if (m == NULL)
                offs -= s;
                m = m->m_next;
                if (m == NULL)

-                       return(EBADRPC);
+                       return (EBADRPC);

                s = m->m_len;
        }
        *mdp = m;
        *dposp = mtod(m, caddr_t)+offs;
                s = m->m_len;
        }
        *mdp = m;
        *dposp = mtod(m, caddr_t)+offs;

-       return(0);
+       return (0);

 }
 
 /*
 }
 
 /*


@@ -454,7 +453,7 @@ nfsm_strtmbuf(mb, bpos, cp, siz)
        while (siz > 0) {
                MGET(m1, M_WAIT, MT_DATA);
                if (siz > MLEN)
        while (siz > 0) {
                MGET(m1, M_WAIT, MT_DATA);
                if (siz > MLEN)

-                       NFSMCLGET(m1, M_WAIT);
+                       MCLGET(m1, M_WAIT);

                m1->m_len = NFSMSIZ(m1);
                m2->m_next = m1;
                m2 = m1;
                m1->m_len = NFSMSIZ(m1);
                m2->m_next = m1;
                m2 = m1;


@@ -481,7 +480,7 @@ nfsm_strtmbuf(mb, bpos, cp, siz)
        }
        *mb = m1;
        *bpos = mtod(m1, caddr_t)+m1->m_len;
        }
        *mb = m1;
        *bpos = mtod(m1, caddr_t)+m1->m_len;

-       return(0);
+       return (0);

 }
 
 /*
 }
 
 /*


@@ -506,18 +505,17 @@ nfs_init()
        for (i = 0; i < NFS_NPROCS; i++)
                nfs_procids[i] = txdr_unsigned(i);
        /* Ensure async daemons disabled */
        for (i = 0; i < NFS_NPROCS; i++)
                nfs_procids[i] = txdr_unsigned(i);
        /* Ensure async daemons disabled */

-       for (i = 0; i < MAX_ASYNCDAEMON; i++)
+       for (i = 0; i < NFS_MAXASYNCDAEMON; i++)

                nfs_iodwant[i] = (struct proc *)0;
                nfs_iodwant[i] = (struct proc *)0;

-       v_type[0] = VNON;
-       v_type[1] = VREG;
-       v_type[2] = VDIR;
-       v_type[3] = VBLK;
-       v_type[4] = VCHR;
-       v_type[5] = VLNK;

        nfs_xdrneg1 = txdr_unsigned(-1);
        nfs_nhinit();                   /* Init the nfsnode table */
        nfs_xdrneg1 = txdr_unsigned(-1);
        nfs_nhinit();                   /* Init the nfsnode table */

+       nfsrv_initcache();              /* Init the server request cache */

        rminit(nfsmap, (long)NFS_MAPREG, (long)1, "nfs mapreg", NFS_MSIZ);
        rminit(nfsmap, (long)NFS_MAPREG, (long)1, "nfs mapreg", NFS_MSIZ);

-       /* And start timer */
+
+       /*
+        * Initialize reply list and start timer
+        */
+       nfsreqh.r_prev = nfsreqh.r_next = &nfsreqh;

        nfs_timer();
 }
 
        nfs_timer();
 }
 


@@ -534,9 +532,9 @@ static char *nfs_unixauth(cr)
        /* Maybe someday there should be a cache of AUTH_SHORT's */
        if ((p = rpc_uidp) == NULL) {
 #ifdef FILLINHOST
        /* Maybe someday there should be a cache of AUTH_SHORT's */
        if ((p = rpc_uidp) == NULL) {
 #ifdef FILLINHOST

-               i = nfsm_rndup(hostnamelen)+(19*NFSX_UNSIGNED);
+               i = nfsm_rndup(hostnamelen)+(25*NFSX_UNSIGNED);

 #else
 #else

-               i = 19*NFSX_UNSIGNED;
+               i = 25*NFSX_UNSIGNED;

 #endif
                MALLOC(p, u_long *, i, M_TEMP, M_WAITOK);
                bzero((caddr_t)p, i);
 #endif
                MALLOC(p, u_long *, i, M_TEMP, M_WAITOK);
                bzero((caddr_t)p, i);


@@ -556,9 +554,9 @@ static char *nfs_unixauth(cr)
        }
        *p++ = txdr_unsigned(cr->cr_uid);
        *p++ = txdr_unsigned(cr->cr_groups[0]);
        }
        *p++ = txdr_unsigned(cr->cr_uid);
        *p++ = txdr_unsigned(cr->cr_groups[0]);

-       ngr = (cr->cr_ngroups > numgrps) ? numgrps : cr->cr_ngroups;
+       ngr = ((cr->cr_ngroups - 1) > numgrps) ? numgrps : (cr->cr_ngroups - 1);

        *p++ = txdr_unsigned(ngr);
        *p++ = txdr_unsigned(ngr);

-       for (i = 0; i < ngr; i++)
+       for (i = 1; i <= ngr; i++)

                *p++ = txdr_unsigned(cr->cr_groups[i]);
        /* And add the AUTH_NULL */
        *p++ = 0;
                *p++ = txdr_unsigned(cr->cr_groups[i]);
        /* And add the AUTH_NULL */
        *p++ = 0;


@@ -566,7 +564,7 @@ static char *nfs_unixauth(cr)
        i = (((caddr_t)p)-rpc_unixauth)-12;
        p = (u_long *)(rpc_unixauth+4);
        *p = txdr_unsigned(i);
        i = (((caddr_t)p)-rpc_unixauth)-12;
        p = (u_long *)(rpc_unixauth+4);
        *p = txdr_unsigned(i);

-       return(rpc_unixauth);
+       return (rpc_unixauth);

 }
 
 /*
 }
 
 /*


@@ -599,7 +597,7 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
        int error = 0;
        struct mbuf *md;
        enum vtype type;
        int error = 0;
        struct mbuf *md;
        enum vtype type;

-       dev_t rdev;
+       long rdev;

        struct timeval mtime;
        struct vnode *nvp;
 
        struct timeval mtime;
        struct vnode *nvp;
 


@@ -610,7 +608,7 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
                return (error);
        fp = (struct nfsv2_fattr *)cp2;
        type = nfstov_type(fp->fa_type);
                return (error);
        fp = (struct nfsv2_fattr *)cp2;
        type = nfstov_type(fp->fa_type);

-       rdev = fxdr_unsigned(dev_t, fp->fa_rdev);
+       rdev = fxdr_unsigned(long, fp->fa_rdev);

        fxdr_time(&fp->fa_mtime, &mtime);
        /*
         * If v_type == VNON it is a new node, so fill in the v_type,
        fxdr_time(&fp->fa_mtime, &mtime);
        /*
         * If v_type == VNON it is a new node, so fill in the v_type,


@@ -621,17 +619,28 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
         */
        np = VTONFS(vp);
        if (vp->v_type == VNON) {
         */
        np = VTONFS(vp);
        if (vp->v_type == VNON) {

-               vp->v_type = type;
+               if (type == VCHR && rdev == 0xffffffff)
+                       vp->v_type = type = VFIFO;
+               else
+                       vp->v_type = type;
+               if (vp->v_type == VFIFO) {
+#ifdef FIFO
+                       extern struct vnodeops fifo_nfsv2nodeops;
+                       vp->v_op = &fifo_nfsv2nodeops;
+#else
+                       return (EOPNOTSUPP);
+#endif /* FIFO */
+               }

                if (vp->v_type == VCHR || vp->v_type == VBLK) {
                if (vp->v_type == VCHR || vp->v_type == VBLK) {

-                       vp->v_rdev = rdev;

                        vp->v_op = &spec_nfsv2nodeops;
                        vp->v_op = &spec_nfsv2nodeops;

-                       if (nvp = checkalias(vp, vp->v_mount)) {
+                       if (nvp = checkalias(vp, (dev_t)rdev, vp->v_mount)) {

                                /*
                                 * Reinitialize aliased node.
                                 */
                                np = VTONFS(nvp);
                                np->n_vnode = nvp;
                                /*
                                 * Reinitialize aliased node.
                                 */
                                np = VTONFS(nvp);
                                np->n_vnode = nvp;

-                               np->n_flag = NLOCKED;
+                               np->n_flag = 0;
+                               nfs_lock(nvp);

                                bcopy((caddr_t)&VTONFS(vp)->n_fh,
                                        (caddr_t)&np->n_fh, NFSX_FH);
                                insque(np, nfs_hash(&np->n_fh));
                                bcopy((caddr_t)&VTONFS(vp)->n_fh,
                                        (caddr_t)&np->n_fh, NFSX_FH);
                                insque(np, nfs_hash(&np->n_fh));


@@ -655,18 +664,20 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
        vap->va_size = fxdr_unsigned(u_long, fp->fa_size);
        if ((np->n_flag & NMODIFIED) == 0 || vap->va_size > np->n_size)
                np->n_size = vap->va_size;
        vap->va_size = fxdr_unsigned(u_long, fp->fa_size);
        if ((np->n_flag & NMODIFIED) == 0 || vap->va_size > np->n_size)
                np->n_size = vap->va_size;

-       vap->va_size1 = 0;              /* OR -1 ?? */
+       vap->va_size_rsv = 0;

        vap->va_blocksize = fxdr_unsigned(long, fp->fa_blocksize);
        vap->va_blocksize = fxdr_unsigned(long, fp->fa_blocksize);

-       vap->va_rdev = rdev;
-       vap->va_bytes = fxdr_unsigned(long, fp->fa_blocks) * vap->va_blocksize;
-       vap->va_bytes1 = 0;
-       vap->va_fsid = fxdr_unsigned(long, fp->fa_fsid);
+       vap->va_rdev = (dev_t)rdev;
+       vap->va_bytes = fxdr_unsigned(long, fp->fa_blocks) * NFS_FABLKSIZE;
+       vap->va_bytes_rsv = 0;
+       vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];

        vap->va_fileid = fxdr_unsigned(long, fp->fa_fileid);
        vap->va_fileid = fxdr_unsigned(long, fp->fa_fileid);

-       fxdr_time(&fp->fa_atime, &vap->va_atime);
-       fxdr_time(&fp->fa_ctime, &vap->va_ctime);
+       vap->va_atime.tv_sec = fxdr_unsigned(long, fp->fa_atime.tv_sec);
+       vap->va_atime.tv_usec = 0;
+       vap->va_flags = fxdr_unsigned(u_long, fp->fa_atime.tv_usec);

        vap->va_mtime = mtime;
        vap->va_mtime = mtime;

-       vap->va_gen = 0;
-       vap->va_flags = 0;
+       vap->va_ctime.tv_sec = fxdr_unsigned(long, fp->fa_ctime.tv_sec);
+       vap->va_ctime.tv_usec = 0;
+       vap->va_gen = fxdr_unsigned(u_long, fp->fa_ctime.tv_usec);

        np->n_attrstamp = time.tv_sec;
        *dposp = dpos;
        *mdp = md;
        np->n_attrstamp = time.tv_sec;
        *dposp = dpos;
        *mdp = md;


@@ -705,8 +716,7 @@ nfs_getattrcache(vp, vap)
 }
 
 /*
 }
 
 /*

- * nfs_namei - a liitle like namei(), but for one element only
- *     essentially look up file handle, fill in ndp and call VOP_LOOKUP()
+ * Set up nameidata for a namei() call and do it

  */
 nfs_namei(ndp, fhp, len, mdp, dposp)
        register struct nameidata *ndp;
  */
 nfs_namei(ndp, fhp, len, mdp, dposp)
        register struct nameidata *ndp;


@@ -718,69 +728,63 @@ nfs_namei(ndp, fhp, len, mdp, dposp)
        register int i, rem;
        register struct mbuf *md;
        register char *cp;
        register int i, rem;
        register struct mbuf *md;
        register char *cp;

-       struct vnode *dp = (struct vnode *)0;
+       struct vnode *dp;

        int flag;
        int flag;

-       int docache;
-       int wantparent;
-       int lockparent;
-       int error = 0;
-
-       ndp->ni_vp = ndp->ni_dvp = (struct vnode *)0;
-       flag = ndp->ni_nameiop & OPFLAG;
-       wantparent = ndp->ni_nameiop & (LOCKPARENT | WANTPARENT);
-       lockparent = ndp->ni_nameiop & LOCKPARENT;
-       docache = (ndp->ni_nameiop & NOCACHE) ^ NOCACHE;
-       if (flag == DELETE || wantparent)
-               docache = 0;
+       int error;

 
 

-       /* Fill in the nameidata and call lookup */
-       cp = *dposp;
-       md = *mdp;
-       rem = mtod(md, caddr_t)+md->m_len-cp;
-       ndp->ni_hash = 0;
-       for (i = 0; i < len;) {
-               if (rem == 0) {
-                       md = md->m_next;
-                       if (md == NULL)
-                               return (EBADRPC);
-                       cp = mtod(md, caddr_t);
-                       rem = md->m_len;
-               }
-               if (*cp == '\0' || *cp == '/')
-                       return (EINVAL);
-               if (*cp & 0200)
-                       if ((*cp&0377) == ('/'|0200) || flag != DELETE)
+       if ((ndp->ni_nameiop & HASBUF) == 0) {
+               flag = ndp->ni_nameiop & OPFLAG;
+               /*
+                * Copy the name from the mbuf list to the d_name field of ndp
+                * and set the various ndp fields appropriately.
+                */
+               cp = *dposp;
+               md = *mdp;
+               rem = mtod(md, caddr_t)+md->m_len-cp;
+               ndp->ni_hash = 0;
+               for (i = 0; i < len;) {
+                       while (rem == 0) {
+                               md = md->m_next;
+                               if (md == NULL)
+                                       return (EBADRPC);
+                               cp = mtod(md, caddr_t);
+                               rem = md->m_len;
+                       }
+                       if (*cp == '\0' || *cp == '/')

                                return (EINVAL);
                                return (EINVAL);

-               ndp->ni_dent.d_name[i++] = *cp;
-               ndp->ni_hash += (unsigned char)*cp * i;
-               cp++;
-               rem--;
-       }
-       *mdp = md;
-       len = nfsm_rndup(len)-len;
-       if (len > 0)
-               *dposp = cp+len;
-       else
+                       if (*cp & 0200)
+                               if ((*cp&0377) == ('/'|0200) || flag != DELETE)
+                                       return (EINVAL);
+                       ndp->ni_dent.d_name[i++] = *cp;
+                       ndp->ni_hash += (unsigned char)*cp * i;
+                       cp++;
+                       rem--;
+               }
+               *mdp = md;

                *dposp = cp;
                *dposp = cp;

+               len = nfsm_rndup(len)-len;
+               if (len > 0) {
+                       if (rem < len) {
+                               if (error = nfs_adv(mdp, dposp, len, rem))
+                                       return (error);
+                       } else
+                               *dposp += len;
+               }
+       } else
+               i = len;

        ndp->ni_namelen = i;
        ndp->ni_dent.d_namlen = i;
        ndp->ni_dent.d_name[i] = '\0';
        ndp->ni_namelen = i;
        ndp->ni_dent.d_namlen = i;
        ndp->ni_dent.d_name[i] = '\0';

+       ndp->ni_segflg = UIO_SYSSPACE;

        ndp->ni_pathlen = 1;
        ndp->ni_pathlen = 1;

-       ndp->ni_dirp = ndp->ni_ptr = &ndp->ni_dent.d_name[0];
+       ndp->ni_pnbuf = ndp->ni_dirp = ndp->ni_ptr = &ndp->ni_dent.d_name[0];

        ndp->ni_next = &ndp->ni_dent.d_name[i];
        ndp->ni_next = &ndp->ni_dent.d_name[i];

-       ndp->ni_loopcnt = 0;    /* Not actually used for now */
-       ndp->ni_endoff = 0;
-       if (docache)
-               ndp->ni_makeentry = 1;
-       else
-               ndp->ni_makeentry = 0;
-       ndp->ni_isdotdot = (i == 2 && 
-               ndp->ni_dent.d_name[1] == '.' && ndp->ni_dent.d_name[0] == '.');
+       ndp->ni_nameiop |= (NOCROSSMOUNT | REMOTE | HASBUF);

 
 

-       if (error = nfsrv_fhtovp(fhp, TRUE, &dp, ndp->ni_cred))
+       if (error = nfsrv_fhtovp(fhp, FALSE, &dp, ndp->ni_cred))

                return (error);
        if (dp->v_type != VDIR) {
                return (error);
        if (dp->v_type != VDIR) {

-               vput(dp);
+               vrele(dp);

                return (ENOTDIR);
        }
        /*
                return (ENOTDIR);
        }
        /*


@@ -788,75 +792,13 @@ nfs_namei(ndp, fhp, len, mdp, dposp)
         * called from rename()
         */
        ndp->ni_cdir = dp;
         * called from rename()
         */
        ndp->ni_cdir = dp;

-       ndp->ni_rdir = (struct vnode *)0;
-
-       /*
-        * Handle "..":
-        * If this vnode is the root of the mounted
-        *    file system, then ignore it so can't get out
-        */
-       if (ndp->ni_isdotdot && (dp->v_flag & VROOT)) {
-               ndp->ni_dvp = dp;
-               ndp->ni_vp = dp;
-               VREF(dp);
-               goto nextname;
-       }
+       ndp->ni_rdir = NULLVP;

 
        /*
 
        /*

-        * We now have a segment name to search for, and a directory to search.
+        * And call namei() to do the real work

         */
         */

-       if (error = VOP_LOOKUP(dp, ndp)) {
-               if (ndp->ni_vp != NULL)
-                       panic("leaf should be empty");
-               /*
-                * If creating and at end of pathname, then can consider
-                * allowing file to be created.
-                */
-               if (ndp->ni_dvp->v_mount->m_flag & (M_RDONLY | M_EXRDONLY))
-                       error = EROFS;
-               if (flag == LOOKUP || flag == DELETE || error != ENOENT)
-                       goto bad;
-               /*
-                * We return with ni_vp NULL to indicate that the entry
-                * doesn't currently exist, leaving a pointer to the
-                * (possibly locked) directory inode in ndp->ni_dvp.
-                */
-               return (0);     /* should this be ENOENT? */
-       }
-
-       dp = ndp->ni_vp;
-
-nextname:
-       ndp->ni_ptr = ndp->ni_next;
-       /*
-        * Check for read-only file systems
-        */
-       if (flag == DELETE || flag == RENAME) {
-               /*
-                * Disallow directory write attempts on read-only
-                * file systems.
-                */
-               if ((dp->v_mount->m_flag & (M_RDONLY|M_EXRDONLY)) ||
-                   (wantparent && (ndp->ni_dvp->v_mount->m_flag & (M_RDONLY|M_EXRDONLY)))) {
-                       error = EROFS;
-                       goto bad2;
-               }
-       }
-
-       if (!wantparent)
-               vrele(ndp->ni_dvp);
-
-       if ((ndp->ni_nameiop & LOCKLEAF) == 0)
-               VOP_UNLOCK(dp);
-       return (0);
-
-bad2:
-       if (lockparent)
-               VOP_UNLOCK(ndp->ni_dvp);
-       vrele(ndp->ni_dvp);
-bad:
-       vput(dp);
-       ndp->ni_vp = NULL;
+       error = namei(ndp);
+       vrele(dp);

        return (error);
 }
 
        return (error);
 }
 


@@ -939,12 +881,12 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred)
 
        if ((mp = getvfs(&fhp->fh_fsid)) == NULL)
                return (ESTALE);
 
        if ((mp = getvfs(&fhp->fh_fsid)) == NULL)
                return (ESTALE);

-       if ((mp->m_flag & M_EXPORTED) == 0)
+       if ((mp->mnt_flag & MNT_EXPORTED) == 0)

                return (EACCES);
        if (VFS_FHTOVP(mp, &fhp->fh_fid, vpp))
                return (ESTALE);
        if (cred->cr_uid == 0)
                return (EACCES);
        if (VFS_FHTOVP(mp, &fhp->fh_fid, vpp))
                return (ESTALE);
        if (cred->cr_uid == 0)

-               cred->cr_uid = mp->m_exroot;
+               cred->cr_uid = mp->mnt_exroot;

        if (!lockflag)
                VOP_UNLOCK(*vpp);
        return (0);
        if (!lockflag)
                VOP_UNLOCK(*vpp);
        return (0);