nfsd: rename MAY_ flags

Rename nfsd_permission() specific MAY_* flags to NFSD_MAY_* to make it
clear, that these are not used outside nfsd, and to avoid name and
number space conflicts with the VFS.

[comment from hch: rename MAY_READ, MAY_WRITE and MAY_EXEC as well]

Signed-off-by: Miklos Szeredi <mszeredi@suse.cz>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>

1 files changed, 59 insertions, 56 deletions

diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index a3a291f771f4..5e05ddda4560 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -144,7 +144,7 @@ nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,
         dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name);
 
         /* Obtain dentry and export. */
-        err = fh_verify(rqstp, fhp, S_IFDIR, MAY_EXEC);
+        err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
         if (err)
                 return err;
 
@@ -262,14 +262,14 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
 {
         struct dentry   *dentry;
         struct inode    *inode;
-        int             accmode = MAY_SATTR;
+        int             accmode = NFSD_MAY_SATTR;
         int             ftype = 0;
         __be32          err;
         int             host_err;
         int             size_change = 0;
 
         if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_SIZE))
-                accmode |= MAY_WRITE|MAY_OWNER_OVERRIDE;
+                accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE;
         if (iap->ia_valid & ATTR_SIZE)
                 ftype = S_IFREG;
 
@@ -331,7 +331,8 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
          */
         if (iap->ia_valid & ATTR_SIZE) {
                 if (iap->ia_size < inode->i_size) {
-                        err = nfsd_permission(rqstp, fhp->fh_export, dentry, MAY_TRUNC|MAY_OWNER_OVERRIDE);
+                        err = nfsd_permission(rqstp, fhp->fh_export, dentry,
+                                        NFSD_MAY_TRUNC|NFSD_MAY_OWNER_OVERRIDE);
                         if (err)
                                 goto out;
                 }
@@ -462,7 +463,7 @@ nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
         unsigned int flags = 0;
 
         /* Get inode */
-        error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, MAY_SATTR);
+        error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, NFSD_MAY_SATTR);
         if (error)
                 return error;
 
@@ -563,20 +564,20 @@ struct accessmap {
         int             how;
 };
 static struct accessmap nfs3_regaccess[] = {
-    {   NFS3_ACCESS_READ,       MAY_READ                        },
-    {   NFS3_ACCESS_EXECUTE,    MAY_EXEC                        },
-    {   NFS3_ACCESS_MODIFY,     MAY_WRITE|MAY_TRUNC             },
-    {   NFS3_ACCESS_EXTEND,     MAY_WRITE                       },
+    {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
+    {   NFS3_ACCESS_EXECUTE,    NFSD_MAY_EXEC                   },
+    {   NFS3_ACCESS_MODIFY,     NFSD_MAY_WRITE|NFSD_MAY_TRUNC   },
+    {   NFS3_ACCESS_EXTEND,     NFSD_MAY_WRITE                  },
 
     {   0,                      0                               }
 };
 
 static struct accessmap nfs3_diraccess[] = {
-    {   NFS3_ACCESS_READ,       MAY_READ                        },
-    {   NFS3_ACCESS_LOOKUP,     MAY_EXEC                        },
-    {   NFS3_ACCESS_MODIFY,     MAY_EXEC|MAY_WRITE|MAY_TRUNC    },
-    {   NFS3_ACCESS_EXTEND,     MAY_EXEC|MAY_WRITE              },
-    {   NFS3_ACCESS_DELETE,     MAY_REMOVE                      },
+    {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
+    {   NFS3_ACCESS_LOOKUP,     NFSD_MAY_EXEC                   },
+    {   NFS3_ACCESS_MODIFY,     NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC},
+    {   NFS3_ACCESS_EXTEND,     NFSD_MAY_EXEC|NFSD_MAY_WRITE    },
+    {   NFS3_ACCESS_DELETE,     NFSD_MAY_REMOVE                 },
 
     {   0,                      0                               }
 };
@@ -589,10 +590,10 @@ static struct accessmap	nfs3_anyaccess[] = {
          * mainly at mode bits, and we make sure to ignore read-only
          * filesystem checks
          */
-    {   NFS3_ACCESS_READ,       MAY_READ                        },
-    {   NFS3_ACCESS_EXECUTE,    MAY_EXEC                        },
-    {   NFS3_ACCESS_MODIFY,     MAY_WRITE|MAY_LOCAL_ACCESS      },
-    {   NFS3_ACCESS_EXTEND,     MAY_WRITE|MAY_LOCAL_ACCESS      },
+    {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
+    {   NFS3_ACCESS_EXECUTE,    NFSD_MAY_EXEC                   },
+    {   NFS3_ACCESS_MODIFY,     NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS    },
+    {   NFS3_ACCESS_EXTEND,     NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS    },
 
     {   0,                      0                               }
 };
@@ -606,7 +607,7 @@ nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *suppor
         u32                     query, result = 0, sresult = 0;
         __be32                  error;
 
-        error = fh_verify(rqstp, fhp, 0, MAY_NOP);
+        error = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP);
         if (error)
                 goto out;
 
@@ -678,7 +679,7 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
          * and (hopefully) checked permission - so allow OWNER_OVERRIDE
          * in case a chmod has now revoked permission.
          */
-        err = fh_verify(rqstp, fhp, type, access | MAY_OWNER_OVERRIDE);
+        err = fh_verify(rqstp, fhp, type, access | NFSD_MAY_OWNER_OVERRIDE);
         if (err)
                 goto out;
 
@@ -689,7 +690,7 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
          * or any access when mandatory locking enabled
          */
         err = nfserr_perm;
-        if (IS_APPEND(inode) && (access & MAY_WRITE))
+        if (IS_APPEND(inode) && (access & NFSD_MAY_WRITE))
                 goto out;
         /*
          * We must ignore files (but only files) which might have mandatory
@@ -706,14 +707,14 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
          * Check to see if there are any leases on this file.
          * This may block while leases are broken.
          */
-        host_err = break_lease(inode, O_NONBLOCK | ((access & MAY_WRITE) ? FMODE_WRITE : 0));
+        host_err = break_lease(inode, O_NONBLOCK | ((access & NFSD_MAY_WRITE) ? FMODE_WRITE : 0));
         if (host_err == -EWOULDBLOCK)
                 host_err = -ETIMEDOUT;
         if (host_err) /* NOMEM or WOULDBLOCK */
                 goto out_nfserr;
 
-        if (access & MAY_WRITE) {
-                if (access & MAY_READ)
+        if (access & NFSD_MAY_WRITE) {
+                if (access & NFSD_MAY_READ)
                         flags = O_RDWR|O_LARGEFILE;
                 else
                         flags = O_WRONLY|O_LARGEFILE;
@@ -1069,12 +1070,12 @@ nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
 
         if (file) {
                 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
-                                MAY_READ|MAY_OWNER_OVERRIDE);
+                                NFSD_MAY_READ|NFSD_MAY_OWNER_OVERRIDE);
                 if (err)
                         goto out;
                 err = nfsd_vfs_read(rqstp, fhp, file, offset, vec, vlen, count);
         } else {
-                err = nfsd_open(rqstp, fhp, S_IFREG, MAY_READ, &file);
+                err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
                 if (err)
                         goto out;
                 err = nfsd_vfs_read(rqstp, fhp, file, offset, vec, vlen, count);
@@ -1098,13 +1099,13 @@ nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
 
         if (file) {
                 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
-                                MAY_WRITE|MAY_OWNER_OVERRIDE);
+                                NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE);
                 if (err)
                         goto out;
                 err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, cnt,
                                 stablep);
         } else {
-                err = nfsd_open(rqstp, fhp, S_IFREG, MAY_WRITE, &file);
+                err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file);
                 if (err)
                         goto out;
 
@@ -1136,7 +1137,8 @@ nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
         if ((u64)count > ~(u64)offset)
                 return nfserr_inval;
 
-        if ((err = nfsd_open(rqstp, fhp, S_IFREG, MAY_WRITE, &file)) != 0)
+        err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file);
+        if (err)
                 return err;
         if (EX_ISSYNC(fhp->fh_export)) {
                 if (file->f_op && file->f_op->fsync) {
@@ -1197,7 +1199,7 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
         if (isdotent(fname, flen))
                 goto out;
 
-        err = fh_verify(rqstp, fhp, S_IFDIR, MAY_CREATE);
+        err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
         if (err)
                 goto out;
 
@@ -1334,7 +1336,7 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out;
         if (!(iap->ia_valid & ATTR_MODE))
                 iap->ia_mode = 0;
-        err = fh_verify(rqstp, fhp, S_IFDIR, MAY_CREATE);
+        err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
         if (err)
                 goto out;
 
@@ -1471,7 +1473,7 @@ nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
         __be32          err;
         int             host_err;
 
-        err = fh_verify(rqstp, fhp, S_IFLNK, MAY_NOP);
+        err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP);
         if (err)
                 goto out;
 
@@ -1526,7 +1528,7 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
         if (isdotent(fname, flen))
                 goto out;
 
-        err = fh_verify(rqstp, fhp, S_IFDIR, MAY_CREATE);
+        err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
         if (err)
                 goto out;
         fh_lock(fhp);
@@ -1591,10 +1593,10 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
         __be32          err;
         int             host_err;
 
-        err = fh_verify(rqstp, ffhp, S_IFDIR, MAY_CREATE);
+        err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE);
         if (err)
                 goto out;
-        err = fh_verify(rqstp, tfhp, -S_IFDIR, MAY_NOP);
+        err = fh_verify(rqstp, tfhp, -S_IFDIR, NFSD_MAY_NOP);
         if (err)
                 goto out;
 
@@ -1661,10 +1663,10 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
         __be32          err;
         int             host_err;
 
-        err = fh_verify(rqstp, ffhp, S_IFDIR, MAY_REMOVE);
+        err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE);
         if (err)
                 goto out;
-        err = fh_verify(rqstp, tfhp, S_IFDIR, MAY_CREATE);
+        err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE);
         if (err)
                 goto out;
 
@@ -1768,7 +1770,7 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
         err = nfserr_acces;
         if (!flen || isdotent(fname, flen))
                 goto out;
-        err = fh_verify(rqstp, fhp, S_IFDIR, MAY_REMOVE);
+        err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE);
         if (err)
                 goto out;
 
@@ -1834,7 +1836,7 @@ nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp,
         struct file     *file;
         loff_t          offset = *offsetp;
 
-        err = nfsd_open(rqstp, fhp, S_IFDIR, MAY_READ, &file);
+        err = nfsd_open(rqstp, fhp, S_IFDIR, NFSD_MAY_READ, &file);
         if (err)
                 goto out;
 
@@ -1875,7 +1877,7 @@ out:
 __be32
 nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat)
 {
-        __be32 err = fh_verify(rqstp, fhp, 0, MAY_NOP);
+        __be32 err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP);
         if (!err && vfs_statfs(fhp->fh_dentry,stat))
                 err = nfserr_io;
         return err;
@@ -1896,18 +1898,18 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
         struct inode    *inode = dentry->d_inode;
         int             err;
 
-        if (acc == MAY_NOP)
+        if (acc == NFSD_MAY_NOP)
                 return 0;
 #if 0
         dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
                 acc,
-                (acc & MAY_READ)?       " read"  : "",
-                (acc & MAY_WRITE)?      " write" : "",
-                (acc & MAY_EXEC)?       " exec"  : "",
-                (acc & MAY_SATTR)?      " sattr" : "",
-                (acc & MAY_TRUNC)?      " trunc" : "",
-                (acc & MAY_LOCK)?       " lock"  : "",
-                (acc & MAY_OWNER_OVERRIDE)? " owneroverride" : "",
+                (acc & NFSD_MAY_READ)?  " read"  : "",
+                (acc & NFSD_MAY_WRITE)? " write" : "",
+                (acc & NFSD_MAY_EXEC)?  " exec"  : "",
+                (acc & NFSD_MAY_SATTR)? " sattr" : "",
+                (acc & NFSD_MAY_TRUNC)? " trunc" : "",
+                (acc & NFSD_MAY_LOCK)?  " lock"  : "",
+                (acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "",
                 inode->i_mode,
                 IS_IMMUTABLE(inode)?    " immut" : "",
                 IS_APPEND(inode)?       " append" : "",
@@ -1920,18 +1922,18 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
          * system.  But if it is IRIX doing check on write-access for a 
          * device special file, we ignore rofs.
          */
-        if (!(acc & MAY_LOCAL_ACCESS))
-                if (acc & (MAY_WRITE | MAY_SATTR | MAY_TRUNC)) {
+        if (!(acc & NFSD_MAY_LOCAL_ACCESS))
+                if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) {
                         if (exp_rdonly(rqstp, exp) ||
                             __mnt_is_readonly(exp->ex_path.mnt))
                                 return nfserr_rofs;
-                        if (/* (acc & MAY_WRITE) && */ IS_IMMUTABLE(inode))
+                        if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode))
                                 return nfserr_perm;
                 }
-        if ((acc & MAY_TRUNC) && IS_APPEND(inode))
+        if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode))
                 return nfserr_perm;
 
-        if (acc & MAY_LOCK) {
+        if (acc & NFSD_MAY_LOCK) {
                 /* If we cannot rely on authentication in NLM requests,
                  * just allow locks, otherwise require read permission, or
                  * ownership
@@ -1939,7 +1941,7 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
                 if (exp->ex_flags & NFSEXP_NOAUTHNLM)
                         return 0;
                 else
-                        acc = MAY_READ | MAY_OWNER_OVERRIDE;
+                        acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE;
         }
         /*
          * The file owner always gets access permission for accesses that
@@ -1955,15 +1957,16 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
          * We must trust the client to do permission checking - using "ACCESS"
          * with NFSv3.
          */
-        if ((acc & MAY_OWNER_OVERRIDE) &&
+        if ((acc & NFSD_MAY_OWNER_OVERRIDE) &&
             inode->i_uid == current->fsuid)
                 return 0;
 
+        /* This assumes  NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */
         err = permission(inode, acc & (MAY_READ|MAY_WRITE|MAY_EXEC), NULL);
 
         /* Allow read access to binaries even when mode 111 */
         if (err == -EACCES && S_ISREG(inode->i_mode) &&
-            acc == (MAY_READ | MAY_OWNER_OVERRIDE))
+            acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE))
                 err = permission(inode, MAY_EXEC, NULL);
 
         return err? nfserrno(err) : 0;