NFS: Be more careful about mapping file permissions

[karo-tx-linux.git] / fs / nfs / dir.c

diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 32ccd7754f8a2875933d1f9c532b54c656971bfd..37a6180ee2e8dcc80911bf1302324644fd20fb01 100644 (file)
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -151,7 +151,7 @@ struct nfs_cache_array {
        struct nfs_cache_array_entry array[0];
 };
 
-typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
+typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, bool);
 typedef struct {
        struct file     *file;
        struct page     *page;
@@ -165,8 +165,8 @@ typedef struct {
        unsigned long   timestamp;
        unsigned long   gencount;
        unsigned int    cache_entry_index;
-       unsigned int    plus:1;
-       unsigned int    eof:1;
+       bool plus;
+       bool eof;
 } nfs_readdir_descriptor_t;
 
 /*
@@ -355,7 +355,7 @@ int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
                if (error == -ENOTSUPP && desc->plus) {
                        NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
                        clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
-                       desc->plus = 0;
+                       desc->plus = false;
                        goto again;
                }
                goto error;
@@ -557,7 +557,7 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *en
 
                count++;
 
-               if (desc->plus != 0)
+               if (desc->plus)
                        nfs_prime_dcache(file_dentry(desc->file), entry);
 
                status = nfs_readdir_add_to_array(entry, page);
@@ -860,7 +860,7 @@ static int nfs_readdir(struct file *file, struct dir_context *ctx)
        desc->ctx = ctx;
        desc->dir_cookie = &dir_ctx->dir_cookie;
        desc->decode = NFS_PROTO(inode)->decode_dirent;
-       desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;
+       desc->plus = nfs_use_readdirplus(inode, ctx);
 
        if (ctx->pos == 0 || nfs_attribute_cache_expired(inode))
                res = nfs_revalidate_mapping(inode, file->f_mapping);
@@ -885,8 +885,8 @@ static int nfs_readdir(struct file *file, struct dir_context *ctx)
                        clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
                        nfs_zap_caches(inode);
                        desc->page_index = 0;
-                       desc->plus = 0;
-                       desc->eof = 0;
+                       desc->plus = false;
+                       desc->eof = false;
                        continue;
                }
                if (res < 0)
@@ -1115,11 +1115,13 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
        /* Force a full look up iff the parent directory has changed */
        if (!nfs_is_exclusive_create(dir, flags) &&
            nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {
-
-               if (nfs_lookup_verify_inode(inode, flags)) {
+               error = nfs_lookup_verify_inode(inode, flags);
+               if (error) {
                        if (flags & LOOKUP_RCU)
                                return -ECHILD;
-                       goto out_zap_parent;
+                       if (error == -ESTALE)
+                               goto out_zap_parent;
+                       goto out_error;
                }
                nfs_advise_use_readdirplus(dir);
                goto out_valid;
@@ -1144,8 +1146,10 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
        trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
        trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);
-       if (error)
+       if (error == -ESTALE || error == -ENOENT)
                goto out_bad;
+       if (error)
+               goto out_error;
        if (nfs_compare_fh(NFS_FH(inode), fhandle))
                goto out_bad;
        if ((error = nfs_refresh_inode(inode, fattr)) != 0)
@@ -1427,8 +1431,10 @@ static int nfs_finish_open(struct nfs_open_context *ctx,
        err = finish_open(file, dentry, do_open, opened);
        if (err)
                goto out;
-       nfs_file_set_open_context(file, ctx);
-
+       if (S_ISREG(file->f_path.dentry->d_inode->i_mode))
+               nfs_file_set_open_context(file, ctx);
+       else
+               err = -ESTALE;
 out:
        return err;
 }
@@ -1512,7 +1518,7 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
                d_drop(dentry);
                switch (err) {
                case -ENOENT:
-                       d_add(dentry, NULL);
+                       d_splice_alias(NULL, dentry);
                        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
                        break;
                case -EISDIR:
@@ -2056,7 +2062,11 @@ int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        }
 
        error = rpc_wait_for_completion_task(task);
-       if (error == 0)
+       if (error != 0) {
+               ((struct nfs_renamedata *)task->tk_calldata)->cancelled = 1;
+               /* Paired with the atomic_dec_and_test() barrier in rpc_do_put_task() */
+               smp_wmb();
+       } else
                error = task->tk_status;
        rpc_put_task(task);
 out:
@@ -2365,16 +2375,40 @@ void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
 }
 EXPORT_SYMBOL_GPL(nfs_access_add_cache);
 
+#define NFS_MAY_READ (NFS4_ACCESS_READ)
+#define NFS_MAY_WRITE (NFS4_ACCESS_MODIFY | \
+               NFS4_ACCESS_EXTEND | \
+               NFS4_ACCESS_DELETE)
+#define NFS_FILE_MAY_WRITE (NFS4_ACCESS_MODIFY | \
+               NFS4_ACCESS_EXTEND)
+#define NFS_DIR_MAY_WRITE NFS_MAY_WRITE
+#define NFS_MAY_LOOKUP (NFS4_ACCESS_LOOKUP)
+#define NFS_MAY_EXECUTE (NFS4_ACCESS_EXECUTE)
+static int
+nfs_access_calc_mask(u32 access_result, umode_t umode)
+{
+       int mask = 0;
+
+       if (access_result & NFS_MAY_READ)
+               mask |= MAY_READ;
+       if (S_ISDIR(umode)) {
+               if ((access_result & NFS_DIR_MAY_WRITE) == NFS_DIR_MAY_WRITE)
+                       mask |= MAY_WRITE;
+               if ((access_result & NFS_MAY_LOOKUP) == NFS_MAY_LOOKUP)
+                       mask |= MAY_EXEC;
+       } else if (S_ISREG(umode)) {
+               if ((access_result & NFS_FILE_MAY_WRITE) == NFS_FILE_MAY_WRITE)
+                       mask |= MAY_WRITE;
+               if ((access_result & NFS_MAY_EXECUTE) == NFS_MAY_EXECUTE)
+                       mask |= MAY_EXEC;
+       } else if (access_result & NFS_MAY_WRITE)
+                       mask |= MAY_WRITE;
+       return mask;
+}
+
 void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result)
 {
-       entry->mask = 0;
-       if (access_result & NFS4_ACCESS_READ)
-               entry->mask |= MAY_READ;
-       if (access_result &
-           (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
-               entry->mask |= MAY_WRITE;
-       if (access_result & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
-               entry->mask |= MAY_EXEC;
+       entry->mask = access_result;
 }
 EXPORT_SYMBOL_GPL(nfs_access_set_mask);
 
@@ -2382,6 +2416,7 @@ static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
 {
        struct nfs_access_entry cache;
        bool may_block = (mask & MAY_NOT_BLOCK) == 0;
+       int cache_mask;
        int status;
 
        trace_nfs_access_enter(inode);
@@ -2397,7 +2432,8 @@ static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
                goto out;
 
        /* Be clever: ask server to check for all possible rights */
-       cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
+       cache.mask = NFS_MAY_LOOKUP | NFS_MAY_EXECUTE
+                    | NFS_MAY_WRITE | NFS_MAY_READ;
        cache.cred = cred;
        cache.jiffies = jiffies;
        status = NFS_PROTO(inode)->access(inode, &cache);
@@ -2411,7 +2447,8 @@ static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
        }
        nfs_access_add_cache(inode, &cache);
 out_cached:
-       if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)
+       cache_mask = nfs_access_calc_mask(cache.mask, inode->i_mode);
+       if ((mask & ~cache_mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)
                status = -EACCES;
 out:
        trace_nfs_access_exit(inode, status);