Merge branch 'linus' into timers/urgent

Get upstream changes so we can apply fixes against them

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

1 files changed, 51 insertions, 43 deletions

diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 5d051419527b..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>
@@ -436,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)
@@ -448,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)
@@ -461,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;
 
@@ -586,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;
@@ -615,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);
@@ -805,7 +818,7 @@ static int nfs_readdir(struct file *file, struct dir_context *ctx)
         nfs_readdir_descriptor_t my_desc,
                         *desc = &my_desc;
         struct nfs_open_dir_context *dir_ctx = file->private_data;
-        int res;
+        int res = 0;
 
         dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
                         dentry->d_parent->d_name.name, dentry->d_name.name,
@@ -827,7 +840,8 @@ static int nfs_readdir(struct file *file, struct dir_context *ctx)
         desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;
 
         nfs_block_sillyrename(dentry);
-        res = nfs_revalidate_mapping(inode, file->f_mapping);
+        if (ctx->pos == 0 || nfs_attribute_cache_expired(inode))
+                res = nfs_revalidate_mapping(inode, file->f_mapping);
         if (res < 0)
                 goto out;
 
@@ -1039,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)
@@ -1081,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))
@@ -1089,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:
@@ -1107,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. */
@@ -1127,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,
@@ -1255,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",
@@ -1281,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;
@@ -1309,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);
@@ -1356,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;
@@ -1426,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:
@@ -1448,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;
 
@@ -1527,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;
@@ -1540,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;
@@ -1720,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);
@@ -1758,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;
@@ -1798,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
@@ -1869,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,
@@ -1887,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 */