1 files changed, 75 insertions, 68 deletions

diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index e093e73178b7..e474ca2b2bfe 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -33,6 +33,7 @@
 #include <linux/pagevec.h>
 #include <linux/namei.h>
 #include <linux/mount.h>
+#include <linux/swap.h>
 #include <linux/sched.h>
 #include <linux/kmemleak.h>
 #include <linux/xattr.h>
@@ -46,7 +47,7 @@
 
 static int nfs_opendir(struct inode *, struct file *);
 static int nfs_closedir(struct inode *, struct file *);
-static int nfs_readdir(struct file *, void *, filldir_t);
+static int nfs_readdir(struct file *, struct dir_context *);
 static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
 static loff_t nfs_llseek_dir(struct file *, loff_t, int);
 static void nfs_readdir_clear_array(struct page*);
@@ -54,7 +55,7 @@ static void nfs_readdir_clear_array(struct page*);
 const struct file_operations nfs_dir_operations = {
         .llseek         = nfs_llseek_dir,
         .read           = generic_read_dir,
-        .readdir        = nfs_readdir,
+        .iterate        = nfs_readdir,
         .open           = nfs_opendir,
         .release        = nfs_closedir,
         .fsync          = nfs_fsync_dir,
@@ -147,6 +148,7 @@ typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
 typedef struct {
         struct file     *file;
         struct page     *page;
+        struct dir_context *ctx;
         unsigned long   page_index;
         u64             *dir_cookie;
         u64             last_cookie;
@@ -252,7 +254,7 @@ out:
 static
 int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
 {
-        loff_t diff = desc->file->f_pos - desc->current_index;
+        loff_t diff = desc->ctx->pos - desc->current_index;
         unsigned int index;
 
         if (diff < 0)
@@ -289,7 +291,7 @@ int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_des
                             || (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))) {
                                 ctx->duped = 0;
                                 ctx->attr_gencount = nfsi->attr_gencount;
-                        } else if (new_pos < desc->file->f_pos) {
+                        } else if (new_pos < desc->ctx->pos) {
                                 if (ctx->duped > 0
                                     && ctx->dup_cookie == *desc->dir_cookie) {
                                         if (printk_ratelimit()) {
@@ -307,7 +309,7 @@ int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_des
                                 ctx->dup_cookie = *desc->dir_cookie;
                                 ctx->duped = -1;
                         }
-                        desc->file->f_pos = new_pos;
+                        desc->ctx->pos = new_pos;
                         desc->cache_entry_index = i;
                         return 0;
                 }
@@ -405,13 +407,13 @@ different:
 }
 
 static
-bool nfs_use_readdirplus(struct inode *dir, struct file *filp)
+bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx)
 {
         if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
                 return false;
         if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
                 return true;
-        if (filp->f_pos == 0)
+        if (ctx->pos == 0)
                 return true;
         return false;
 }
@@ -435,6 +437,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         struct dentry *alias;
         struct inode *dir = parent->d_inode;
         struct inode *inode;
+        int status;
 
         if (filename.name[0] == '.') {
                 if (filename.len == 1)
@@ -447,7 +450,10 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         dentry = d_lookup(parent, &filename);
         if (dentry != NULL) {
                 if (nfs_same_file(dentry, entry)) {
-                        nfs_refresh_inode(dentry->d_inode, entry->fattr);
+                        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
+                        status = nfs_refresh_inode(dentry->d_inode, entry->fattr);
+                        if (!status)
+                                nfs_setsecurity(dentry->d_inode, entry->fattr, entry->label);
                         goto out;
                 } else {
                         if (d_invalidate(dentry) != 0)
@@ -460,7 +466,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         if (dentry == NULL)
                 return;
 
-        inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
+        inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);
         if (IS_ERR(inode))
                 goto out;
 
@@ -585,10 +591,16 @@ int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page,
         if (entry.fh == NULL || entry.fattr == NULL)
                 goto out;
 
+        entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
+        if (IS_ERR(entry.label)) {
+                status = PTR_ERR(entry.label);
+                goto out;
+        }
+
         array = nfs_readdir_get_array(page);
         if (IS_ERR(array)) {
                 status = PTR_ERR(array);
-                goto out;
+                goto out_label_free;
         }
         memset(array, 0, sizeof(struct nfs_cache_array));
         array->eof_index = -1;
@@ -614,6 +626,8 @@ int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page,
         nfs_readdir_free_large_page(pages_ptr, pages, array_size);
 out_release_array:
         nfs_readdir_release_array(page);
+out_label_free:
+        nfs4_label_free(entry.label);
 out:
         nfs_free_fattr(entry.fattr);
         nfs_free_fhandle(entry.fh);
@@ -702,8 +716,7 @@ int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
  * Once we've found the start of the dirent within a page: fill 'er up...
  */
 static 
-int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
-                   filldir_t filldir)
+int nfs_do_filldir(nfs_readdir_descriptor_t *desc)
 {
         struct file     *file = desc->file;
         int i = 0;
@@ -721,13 +734,12 @@ int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
                 struct nfs_cache_array_entry *ent;
 
                 ent = &array->array[i];
-                if (filldir(dirent, ent->string.name, ent->string.len,
-                    file->f_pos, nfs_compat_user_ino64(ent->ino),
-                    ent->d_type) < 0) {
+                if (!dir_emit(desc->ctx, ent->string.name, ent->string.len,
+                    nfs_compat_user_ino64(ent->ino), ent->d_type)) {
                         desc->eof = 1;
                         break;
                 }
-                file->f_pos++;
+                desc->ctx->pos++;
                 if (i < (array->size-1))
                         *desc->dir_cookie = array->array[i+1].cookie;
                 else
@@ -759,8 +771,7 @@ out:
  *       directory in the page cache by the time we get here.
  */
 static inline
-int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
-                     filldir_t filldir)
+int uncached_readdir(nfs_readdir_descriptor_t *desc)
 {
         struct page     *page = NULL;
         int             status;
@@ -785,7 +796,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
         if (status < 0)
                 goto out_release;
 
-        status = nfs_do_filldir(desc, dirent, filldir);
+        status = nfs_do_filldir(desc);
 
  out:
         dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
@@ -800,35 +811,37 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
    last cookie cache takes care of the common case of reading the
    whole directory.
  */
-static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
+static int nfs_readdir(struct file *file, struct dir_context *ctx)
 {
-        struct dentry   *dentry = filp->f_path.dentry;
+        struct dentry   *dentry = file->f_path.dentry;
         struct inode    *inode = dentry->d_inode;
         nfs_readdir_descriptor_t my_desc,
                         *desc = &my_desc;
-        struct nfs_open_dir_context *dir_ctx = filp->private_data;
-        int res;
+        struct nfs_open_dir_context *dir_ctx = file->private_data;
+        int res = 0;
 
         dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
                         dentry->d_parent->d_name.name, dentry->d_name.name,
-                        (long long)filp->f_pos);
+                        (long long)ctx->pos);
         nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
 
         /*
-         * filp->f_pos points to the dirent entry number.
+         * ctx->pos points to the dirent entry number.
          * *desc->dir_cookie has the cookie for the next entry. We have
          * to either find the entry with the appropriate number or
          * revalidate the cookie.
          */
         memset(desc, 0, sizeof(*desc));
 
-        desc->file = filp;
+        desc->file = file;
+        desc->ctx = ctx;
         desc->dir_cookie = &dir_ctx->dir_cookie;
         desc->decode = NFS_PROTO(inode)->decode_dirent;
-        desc->plus = nfs_use_readdirplus(inode, filp) ? 1 : 0;
+        desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;
 
         nfs_block_sillyrename(dentry);
-        res = nfs_revalidate_mapping(inode, filp->f_mapping);
+        if (ctx->pos == 0 || nfs_attribute_cache_expired(inode))
+                res = nfs_revalidate_mapping(inode, file->f_mapping);
         if (res < 0)
                 goto out;
 
@@ -840,7 +853,7 @@ static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                         /* This means either end of directory */
                         if (*desc->dir_cookie && desc->eof == 0) {
                                 /* Or that the server has 'lost' a cookie */
-                                res = uncached_readdir(desc, dirent, filldir);
+                                res = uncached_readdir(desc);
                                 if (res == 0)
                                         continue;
                         }
@@ -857,7 +870,7 @@ static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                 if (res < 0)
                         break;
 
-                res = nfs_do_filldir(desc, dirent, filldir);
+                res = nfs_do_filldir(desc);
                 if (res < 0)
                         break;
         } while (!desc->eof);
@@ -1040,6 +1053,7 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         struct dentry *parent;
         struct nfs_fh *fhandle = NULL;
         struct nfs_fattr *fattr = NULL;
+        struct nfs4_label *label = NULL;
         int error;
 
         if (flags & LOOKUP_RCU)
@@ -1082,7 +1096,11 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         if (fhandle == NULL || fattr == NULL)
                 goto out_error;
 
-        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+        label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
+        if (IS_ERR(label))
+                goto out_error;
+
+        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
         if (error)
                 goto out_bad;
         if (nfs_compare_fh(NFS_FH(inode), fhandle))
@@ -1090,8 +1108,12 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         if ((error = nfs_refresh_inode(inode, fattr)) != 0)
                 goto out_bad;
 
+        nfs_setsecurity(inode, fattr, label);
+
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fhandle);
+        nfs4_label_free(label);
+
 out_set_verifier:
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
  out_valid:
@@ -1108,6 +1130,7 @@ out_zap_parent:
  out_bad:
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fhandle);
+        nfs4_label_free(label);
         nfs_mark_for_revalidate(dir);
         if (inode && S_ISDIR(inode->i_mode)) {
                 /* Purge readdir caches. */
@@ -1128,6 +1151,7 @@ out_zap_parent:
 out_error:
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fhandle);
+        nfs4_label_free(label);
         dput(parent);
         dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
                         __func__, dentry->d_parent->d_name.name,
@@ -1256,6 +1280,7 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
         struct inode *inode = NULL;
         struct nfs_fh *fhandle = NULL;
         struct nfs_fattr *fattr = NULL;
+        struct nfs4_label *label = NULL;
         int error;
 
         dfprintk(VFS, "NFS: lookup(%s/%s)\n",
@@ -1282,17 +1307,21 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
         if (fhandle == NULL || fattr == NULL)
                 goto out;
 
+        label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
+        if (IS_ERR(label))
+                goto out;
+
         parent = dentry->d_parent;
         /* Protect against concurrent sillydeletes */
         nfs_block_sillyrename(parent);
-        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+        error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
         if (error == -ENOENT)
                 goto no_entry;
         if (error < 0) {
                 res = ERR_PTR(error);
                 goto out_unblock_sillyrename;
         }
-        inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
+        inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
         res = ERR_CAST(inode);
         if (IS_ERR(res))
                 goto out_unblock_sillyrename;
@@ -1310,6 +1339,7 @@ no_entry:
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
 out_unblock_sillyrename:
         nfs_unblock_sillyrename(parent);
+        nfs4_label_free(label);
 out:
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fhandle);
@@ -1357,18 +1387,6 @@ static int nfs_finish_open(struct nfs_open_context *ctx,
 {
         int err;
 
-        if (ctx->dentry != dentry) {
-                dput(ctx->dentry);
-                ctx->dentry = dget(dentry);
-        }
-
-        /* If the open_intent is for execute, we have an extra check to make */
-        if (ctx->mode & FMODE_EXEC) {
-                err = nfs_may_open(dentry->d_inode, ctx->cred, open_flags);
-                if (err < 0)
-                        goto out;
-        }
-
         err = finish_open(file, dentry, do_open, opened);
         if (err)
                 goto out;
@@ -1427,13 +1445,13 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
 
         nfs_block_sillyrename(dentry->d_parent);
         inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
-        d_drop(dentry);
+        nfs_unblock_sillyrename(dentry->d_parent);
         if (IS_ERR(inode)) {
-                nfs_unblock_sillyrename(dentry->d_parent);
                 put_nfs_open_context(ctx);
                 err = PTR_ERR(inode);
                 switch (err) {
                 case -ENOENT:
+                        d_drop(dentry);
                         d_add(dentry, NULL);
                         break;
                 case -EISDIR:
@@ -1449,16 +1467,8 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
                 }
                 goto out;
         }
-        res = d_add_unique(dentry, inode);
-        if (res != NULL)
-                dentry = res;
-
-        nfs_unblock_sillyrename(dentry->d_parent);
-        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-
-        err = nfs_finish_open(ctx, dentry, file, open_flags, opened);
 
-        dput(res);
+        err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened);
 out:
         return err;
 
@@ -1528,7 +1538,8 @@ no_open:
  * Code common to create, mkdir, and mknod.
  */
 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
-                                struct nfs_fattr *fattr)
+                                struct nfs_fattr *fattr,
+                                struct nfs4_label *label)
 {
         struct dentry *parent = dget_parent(dentry);
         struct inode *dir = parent->d_inode;
@@ -1541,18 +1552,18 @@ int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
         if (dentry->d_inode)
                 goto out;
         if (fhandle->size == 0) {
-                error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+                error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
                 if (error)
                         goto out_error;
         }
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
         if (!(fattr->valid & NFS_ATTR_FATTR)) {
                 struct nfs_server *server = NFS_SB(dentry->d_sb);
-                error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
+                error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr, NULL);
                 if (error < 0)
                         goto out_error;
         }
-        inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
+        inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
         error = PTR_ERR(inode);
         if (IS_ERR(inode))
                 goto out_error;
@@ -1721,7 +1732,7 @@ int nfs_unlink(struct inode *dir, struct dentry *dentry)
                 dir->i_ino, dentry->d_name.name);
 
         spin_lock(&dentry->d_lock);
-        if (dentry->d_count > 1) {
+        if (d_count(dentry) > 1) {
                 spin_unlock(&dentry->d_lock);
                 /* Start asynchronous writeout of the inode */
                 write_inode_now(dentry->d_inode, 0);
@@ -1759,7 +1770,6 @@ EXPORT_SYMBOL_GPL(nfs_unlink);
  */
 int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
 {
-        struct pagevec lru_pvec;
         struct page *page;
         char *kaddr;
         struct iattr attr;
@@ -1799,11 +1809,8 @@ int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
          * No big deal if we can't add this page to the page cache here.
          * READLINK will get the missing page from the server if needed.
          */
-        pagevec_init(&lru_pvec, 0);
-        if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0,
+        if (!add_to_page_cache_lru(page, dentry->d_inode->i_mapping, 0,
                                                         GFP_KERNEL)) {
-                pagevec_add(&lru_pvec, page);
-                pagevec_lru_add_file(&lru_pvec);
                 SetPageUptodate(page);
                 unlock_page(page);
         } else
@@ -1870,7 +1877,7 @@ int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
                  old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
                  new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
-                 new_dentry->d_count);
+                 d_count(new_dentry));
 
         /*
          * For non-directories, check whether the target is busy and if so,
@@ -1888,7 +1895,7 @@ int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         rehash = new_dentry;
                 }
 
-                if (new_dentry->d_count > 2) {
+                if (d_count(new_dentry) > 2) {
                         int err;
 
                         /* copy the target dentry's name */