use local access checks when NQNFS ACCESS check cannot be used to server

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

diff --git a/usr/src/sys/nfs/nfs_bio.c b/usr/src/sys/nfs/nfs_bio.c
index 7444283..a970fa1 100644 (file)
--- a/usr/src/sys/nfs/nfs_bio.c
+++ b/usr/src/sys/nfs/nfs_bio.c
@@ -7,10 +7,11 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)nfs_bio.c   7.26 (Berkeley) %G%
+ *     @(#)nfs_bio.c   7.35 (Berkeley) %G%

  */
 
 #include <sys/param.h>
  */
 
 #include <sys/param.h>

+#include <sys/systm.h>

 #include <sys/resourcevar.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 #include <sys/resourcevar.h>
 #include <sys/proc.h>
 #include <sys/buf.h>


@@ -18,8 +19,9 @@
 #include <sys/trace.h>
 #include <sys/mount.h>
 #include <sys/kernel.h>
 #include <sys/trace.h>
 #include <sys/mount.h>
 #include <sys/kernel.h>

-#include <machine/endian.h>
+

 #include <vm/vm.h>
 #include <vm/vm.h>

+

 #include <nfs/nfsnode.h>
 #include <nfs/rpcv2.h>
 #include <nfs/nfsv2.h>
 #include <nfs/nfsnode.h>
 #include <nfs/rpcv2.h>
 #include <nfs/nfsv2.h>


@@ -41,7 +43,6 @@ nfs_bioread(vp, uio, ioflag, cred)
        int ioflag;
        struct ucred *cred;
 {
        int ioflag;
        struct ucred *cred;
 {

-       USES_VOP_GETATTR;

        register struct nfsnode *np = VTONFS(vp);
        register int biosize;
        struct buf *bp;
        register struct nfsnode *np = VTONFS(vp);
        register int biosize;
        struct buf *bp;


@@ -85,22 +86,21 @@ nfs_bioread(vp, uio, ioflag, cred)
         */
        if ((nmp->nm_flag & NFSMNT_NQNFS) == 0 && vp->v_type != VLNK) {
                if (np->n_flag & NMODIFIED) {
         */
        if ((nmp->nm_flag & NFSMNT_NQNFS) == 0 && vp->v_type != VLNK) {
                if (np->n_flag & NMODIFIED) {

-                       np->n_flag &= ~NMODIFIED;

                        if ((nmp->nm_flag & NFSMNT_MYWRITE) == 0 ||
                             vp->v_type != VREG)
                        if ((nmp->nm_flag & NFSMNT_MYWRITE) == 0 ||
                             vp->v_type != VREG)

-                               vinvalbuf(vp, TRUE);
+                               NFS_VINVBUF(np, vp, TRUE, cred, uio->uio_procp);

                        np->n_attrstamp = 0;
                        np->n_direofoffset = 0;
                        if (error = VOP_GETATTR(vp, &vattr, cred, uio->uio_procp))
                                return (error);
                        np->n_attrstamp = 0;
                        np->n_direofoffset = 0;
                        if (error = VOP_GETATTR(vp, &vattr, cred, uio->uio_procp))
                                return (error);

-                       np->n_mtime = vattr.va_mtime.tv_sec;
+                       np->n_mtime = vattr.va_mtime.ts_sec;

                } else {
                        if (error = VOP_GETATTR(vp, &vattr, cred, uio->uio_procp))
                                return (error);
                } else {
                        if (error = VOP_GETATTR(vp, &vattr, cred, uio->uio_procp))
                                return (error);

-                       if (np->n_mtime != vattr.va_mtime.tv_sec) {
+                       if (np->n_mtime != vattr.va_mtime.ts_sec) {

                                np->n_direofoffset = 0;
                                np->n_direofoffset = 0;

-                               vinvalbuf(vp, TRUE);
-                               np->n_mtime = vattr.va_mtime.tv_sec;
+                               NFS_VINVBUF(np, vp, TRUE, cred, uio->uio_procp);
+                               np->n_mtime = vattr.va_mtime.ts_sec;

                        }
                }
        }
                        }
                }
        }


@@ -116,14 +116,13 @@ nfs_bioread(vp, uio, ioflag, cred)
                } while (error == NQNFS_EXPIRED);
                if (error)
                        return (error);
                } while (error == NQNFS_EXPIRED);
                if (error)
                        return (error);

-               if (QUADNE(np->n_lrev, np->n_brev) ||
+               if (np->n_lrev != np->n_brev ||

                    ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) {
                        if (vp->v_type == VDIR) {
                                np->n_direofoffset = 0;
                                cache_purge(vp);
                        }
                    ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) {
                        if (vp->v_type == VDIR) {
                                np->n_direofoffset = 0;
                                cache_purge(vp);
                        }

-                       np->n_flag &= ~NMODIFIED;
-                       vinvalbuf(vp, TRUE);
+                       NFS_VINVBUF(np, vp, TRUE, cred, uio->uio_procp);

                        np->n_brev = np->n_lrev;
                }
            }
                        np->n_brev = np->n_lrev;
                }
            }


@@ -146,7 +145,7 @@ nfs_bioread(vp, uio, ioflag, cred)
                nfsstats.biocache_reads++;
                lbn = uio->uio_offset / biosize;
                on = uio->uio_offset & (biosize-1);
                nfsstats.biocache_reads++;
                lbn = uio->uio_offset / biosize;
                on = uio->uio_offset & (biosize-1);

-               n = MIN((unsigned)(biosize - on), uio->uio_resid);
+               n = min((unsigned)(biosize - on), uio->uio_resid);

                diff = np->n_size - uio->uio_offset;
                if (diff <= 0)
                        return (error);
                diff = np->n_size - uio->uio_offset;
                if (diff <= 0)
                        return (error);


@@ -183,20 +182,21 @@ again:
                if (bp->b_resid) {
                   diff = (on >= (biosize-bp->b_resid)) ? 0 :
                        (biosize-bp->b_resid-on);
                if (bp->b_resid) {
                   diff = (on >= (biosize-bp->b_resid)) ? 0 :
                        (biosize-bp->b_resid-on);

-                  n = MIN(n, diff);
+                  n = min(n, diff);

                }
                break;
            case VLNK:
                nfsstats.biocache_readlinks++;
                on = 0;
                error = bread(vp, (daddr_t)0, NFS_MAXPATHLEN, cred, &bp);
                }
                break;
            case VLNK:
                nfsstats.biocache_readlinks++;
                on = 0;
                error = bread(vp, (daddr_t)0, NFS_MAXPATHLEN, cred, &bp);

-               n = MIN(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);
+               n = min(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);

                break;
            case VDIR:
                nfsstats.biocache_readdirs++;
                on = 0;
                break;
            case VDIR:
                nfsstats.biocache_readdirs++;
                on = 0;

-               error = bread(vp, uio->uio_offset, NFS_DIRBLKSIZ, cred, &bp);
-               n = MIN(uio->uio_resid, NFS_DIRBLKSIZ - bp->b_resid);
+               error = bread(vp, (daddr_t)uio->uio_offset, NFS_DIRBLKSIZ,
+                   cred, &bp);
+               n = min(uio->uio_resid, NFS_DIRBLKSIZ - bp->b_resid);

                break;
            };
            if (error) {
                break;
            };
            if (error) {


@@ -222,15 +222,14 @@ again:
                                return (error);
                        }
                        if ((np->n_flag & NQNFSNONCACHE) ||
                                return (error);
                        }
                        if ((np->n_flag & NQNFSNONCACHE) ||

-                           QUADNE(np->n_lrev, np->n_brev) ||
+                           np->n_lrev != np->n_brev ||

                            ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) {
                                if (vp->v_type == VDIR) {
                                        np->n_direofoffset = 0;
                                        cache_purge(vp);
                                }
                                brelse(bp);
                            ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) {
                                if (vp->v_type == VDIR) {
                                        np->n_direofoffset = 0;
                                        cache_purge(vp);
                                }
                                brelse(bp);

-                               np->n_flag &= ~NMODIFIED;
-                               vinvalbuf(vp, TRUE);
+                               NFS_VINVBUF(np, vp, TRUE, cred, uio->uio_procp);

                                np->n_brev = np->n_lrev;
                                continue;
                        }
                                np->n_brev = np->n_lrev;
                                continue;
                        }


@@ -238,8 +237,7 @@ again:
                    ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) {
                        np->n_direofoffset = 0;
                        brelse(bp);
                    ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) {
                        np->n_direofoffset = 0;
                        brelse(bp);

-                       np->n_flag &= ~NMODIFIED;
-                       vinvalbuf(vp, TRUE);
+                       NFS_VINVBUF(np, vp, TRUE, cred, uio->uio_procp);

                        np->n_brev = np->n_lrev;
                        continue;
                }
                        np->n_brev = np->n_lrev;
                        continue;
                }


@@ -266,53 +264,61 @@ again:
 /*
  * Vnode op for write using bio
  */
 /*
  * Vnode op for write using bio
  */

-nfs_write (ap)
-       struct vop_write_args *ap;
+nfs_write(ap)
+       struct vop_write_args /* {
+               struct vnode *a_vp;
+               struct uio *a_uio;
+               int  a_ioflag;
+               struct ucred *a_cred;
+       } */ *ap;

 {
 {

-       USES_VOP_GETATTR;

        register int biosize;
        register int biosize;

-       struct proc *p = ap->a_uio->uio_procp;
+       register struct uio *uio = ap->a_uio;
+       struct proc *p = uio->uio_procp;
+       register struct vnode *vp = ap->a_vp;
+       struct nfsnode *np = VTONFS(vp);
+       register struct ucred *cred = ap->a_cred;
+       int ioflag = ap->a_ioflag;

        struct buf *bp;
        struct buf *bp;

-       struct nfsnode *np = VTONFS(ap->a_vp);

        struct vattr vattr;
        struct nfsmount *nmp;
        daddr_t lbn, bn;
        int n, on, error = 0;
 
 #ifdef DIAGNOSTIC
        struct vattr vattr;
        struct nfsmount *nmp;
        daddr_t lbn, bn;
        int n, on, error = 0;
 
 #ifdef DIAGNOSTIC

-       if (ap->a_uio->uio_rw != UIO_WRITE)
+       if (uio->uio_rw != UIO_WRITE)

                panic("nfs_write mode");
                panic("nfs_write mode");

-       if (ap->a_uio->uio_segflg == UIO_USERSPACE && ap->a_uio->uio_procp != curproc)
+       if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc)

                panic("nfs_write proc");
 #endif
                panic("nfs_write proc");
 #endif

-       if (ap->a_vp->v_type != VREG)
+       if (vp->v_type != VREG)

                return (EIO);
        if (np->n_flag & NWRITEERR) {
                np->n_flag &= ~NWRITEERR;
                return (np->n_error);
        }
                return (EIO);
        if (np->n_flag & NWRITEERR) {
                np->n_flag &= ~NWRITEERR;
                return (np->n_error);
        }

-       if (ap->a_ioflag & (IO_APPEND | IO_SYNC)) {
+       if (ioflag & (IO_APPEND | IO_SYNC)) {

                if (np->n_flag & NMODIFIED) {
                if (np->n_flag & NMODIFIED) {

-                       np->n_flag &= ~NMODIFIED;
-                       vinvalbuf(ap->a_vp, TRUE);
+                       np->n_attrstamp = 0;
+                       NFS_VINVBUF(np, vp, TRUE, cred, p);

                }
                }

-               if (ap->a_ioflag & IO_APPEND) {
+               if (ioflag & IO_APPEND) {

                        np->n_attrstamp = 0;
                        np->n_attrstamp = 0;

-                       if (error = VOP_GETATTR(ap->a_vp, &vattr, ap->a_cred, p))
+                       if (error = VOP_GETATTR(vp, &vattr, cred, p))

                                return (error);
                                return (error);

-                       ap->a_uio->uio_offset = np->n_size;
+                       uio->uio_offset = np->n_size;

                }
        }
                }
        }

-       nmp = VFSTONFS(ap->a_vp->v_mount);
-       if (ap->a_uio->uio_offset < 0)
+       nmp = VFSTONFS(vp->v_mount);
+       if (uio->uio_offset < 0)

                return (EINVAL);
                return (EINVAL);

-       if (ap->a_uio->uio_resid == 0)
+       if (uio->uio_resid == 0)

                return (0);
        /*
         * Maybe this should be above the vnode op call, but so long as
         * file servers have no limits, i don't think it matters
         */
                return (0);
        /*
         * Maybe this should be above the vnode op call, but so long as
         * file servers have no limits, i don't think it matters
         */

-       if (p && ap->a_uio->uio_offset + ap->a_uio->uio_resid >
+       if (p && uio->uio_offset + uio->uio_resid >

              p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
                psignal(p, SIGXFSZ);
                return (EFBIG);
              p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
                psignal(p, SIGXFSZ);
                return (EFBIG);


@@ -331,34 +337,34 @@ nfs_write (ap)
                 * If non-cachable, just do the rpc
                 */
                if ((nmp->nm_flag & NFSMNT_NQNFS) &&
                 * If non-cachable, just do the rpc
                 */
                if ((nmp->nm_flag & NFSMNT_NQNFS) &&

-                   NQNFS_CKINVALID(ap->a_vp, np, NQL_WRITE)) {
+                   NQNFS_CKINVALID(vp, np, NQL_WRITE)) {

                        do {
                        do {

-                               error = nqnfs_getlease(ap->a_vp, NQL_WRITE, ap->a_cred, p);
+                               error = nqnfs_getlease(vp, NQL_WRITE, cred, p);

                        } while (error == NQNFS_EXPIRED);
                        if (error)
                                return (error);
                        } while (error == NQNFS_EXPIRED);
                        if (error)
                                return (error);

-                       if (QUADNE(np->n_lrev, np->n_brev) ||
+                       if (np->n_lrev != np->n_brev ||

                            (np->n_flag & NQNFSNONCACHE)) {
                            (np->n_flag & NQNFSNONCACHE)) {

-                               vinvalbuf(ap->a_vp, TRUE);
+                               NFS_VINVBUF(np, vp, TRUE, cred, p);

                                np->n_brev = np->n_lrev;
                        }
                }
                if (np->n_flag & NQNFSNONCACHE)
                                np->n_brev = np->n_lrev;
                        }
                }
                if (np->n_flag & NQNFSNONCACHE)

-                       return (nfs_writerpc(ap->a_vp, ap->a_uio, ap->a_cred));
+                       return (nfs_writerpc(vp, uio, cred, 0));

                nfsstats.biocache_writes++;
                nfsstats.biocache_writes++;

-               lbn = ap->a_uio->uio_offset / biosize;
-               on = ap->a_uio->uio_offset & (biosize-1);
-               n = MIN((unsigned)(biosize - on), ap->a_uio->uio_resid);
-               if (ap->a_uio->uio_offset + n > np->n_size) {
-                       np->n_size = ap->a_uio->uio_offset + n;
-                       vnode_pager_setsize(ap->a_vp, (u_long)np->n_size);
+               lbn = uio->uio_offset / biosize;
+               on = uio->uio_offset & (biosize-1);
+               n = min((unsigned)(biosize - on), uio->uio_resid);
+               if (uio->uio_offset + n > np->n_size) {
+                       np->n_size = uio->uio_offset + n;
+                       vnode_pager_setsize(vp, (u_long)np->n_size);

                }
                bn = lbn * (biosize / DEV_BSIZE);
 again:
                }
                bn = lbn * (biosize / DEV_BSIZE);
 again:

-               bp = getblk(ap->a_vp, bn, biosize);
+               bp = getblk(vp, bn, biosize);

                if (bp->b_wcred == NOCRED) {
                if (bp->b_wcred == NOCRED) {

-                       crhold(ap->a_cred);
-                       bp->b_wcred = ap->a_cred;
+                       crhold(cred);
+                       bp->b_wcred = cred;

                }
 
                /*
                }
 
                /*


@@ -379,27 +385,29 @@ again:
                 * In case getblk() and/or bwrite() delayed us.
                 */
                if ((nmp->nm_flag & NFSMNT_NQNFS) &&
                 * In case getblk() and/or bwrite() delayed us.
                 */
                if ((nmp->nm_flag & NFSMNT_NQNFS) &&

-                   NQNFS_CKINVALID(ap->a_vp, np, NQL_WRITE)) {
+                   NQNFS_CKINVALID(vp, np, NQL_WRITE)) {

                        do {
                        do {

-                               error = nqnfs_getlease(ap->a_vp, NQL_WRITE, ap->a_cred, p);
+                               error = nqnfs_getlease(vp, NQL_WRITE, cred, p);

                        } while (error == NQNFS_EXPIRED);
                        if (error) {
                                brelse(bp);
                                return (error);
                        }
                        } while (error == NQNFS_EXPIRED);
                        if (error) {
                                brelse(bp);
                                return (error);
                        }

-                       if (QUADNE(np->n_lrev, np->n_brev) ||
+                       if (np->n_lrev != np->n_brev ||

                            (np->n_flag & NQNFSNONCACHE)) {
                            (np->n_flag & NQNFSNONCACHE)) {

-                               vinvalbuf(ap->a_vp, TRUE);
+                               brelse(bp);
+                               NFS_VINVBUF(np, vp, TRUE, cred, p);

                                np->n_brev = np->n_lrev;
                                np->n_brev = np->n_lrev;

+                               goto again;

                        }
                }
                        }
                }

-               if (error = uiomove(bp->b_un.b_addr + on, n, ap->a_uio)) {
+               if (error = uiomove(bp->b_un.b_addr + on, n, uio)) {

                        brelse(bp);
                        return (error);
                }
                if (bp->b_dirtyend > 0) {
                        brelse(bp);
                        return (error);
                }
                if (bp->b_dirtyend > 0) {

-                       bp->b_dirtyoff = MIN(on, bp->b_dirtyoff);
-                       bp->b_dirtyend = MAX((on+n), bp->b_dirtyend);
+                       bp->b_dirtyoff = min(on, bp->b_dirtyoff);
+                       bp->b_dirtyend = max((on+n), bp->b_dirtyend);

                } else {
                        bp->b_dirtyoff = on;
                        bp->b_dirtyend = on+n;
                } else {
                        bp->b_dirtyoff = on;
                        bp->b_dirtyend = on+n;


@@ -409,14 +417,14 @@ again:
                        bp->b_validoff = bp->b_dirtyoff;
                        bp->b_validend = bp->b_dirtyend;
                } else {
                        bp->b_validoff = bp->b_dirtyoff;
                        bp->b_validend = bp->b_dirtyend;
                } else {

-                       bp->b_validoff = MIN(bp->b_validoff, bp->b_dirtyoff);
-                       bp->b_validend = MAX(bp->b_validend, bp->b_dirtyend);
+                       bp->b_validoff = min(bp->b_validoff, bp->b_dirtyoff);
+                       bp->b_validend = max(bp->b_validend, bp->b_dirtyend);

                }
 
                /*
                 * If the lease is non-cachable or IO_SYNC do bwrite().
                 */
                }
 
                /*
                 * If the lease is non-cachable or IO_SYNC do bwrite().
                 */

-               if ((np->n_flag & NQNFSNONCACHE) || (ap->a_ioflag & IO_SYNC)) {
+               if ((np->n_flag & NQNFSNONCACHE) || (ioflag & IO_SYNC)) {

                        bp->b_proc = p;
                        bwrite(bp);
                } else if ((n+on) == biosize &&
                        bp->b_proc = p;
                        bwrite(bp);
                } else if ((n+on) == biosize &&


@@ -428,6 +436,6 @@ again:
                        bp->b_proc = (struct proc *)0;
                        bdwrite(bp);
                }
                        bp->b_proc = (struct proc *)0;
                        bdwrite(bp);
                }

-       } while (error == 0 && ap->a_uio->uio_resid > 0 && n != 0);
+       } while (error == 0 && uio->uio_resid > 0 && n != 0);

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