Patched in Tegra support.

1 files changed, 179 insertions, 282 deletions

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index ebeb94ce1b0..679d2f50b14 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -32,14 +32,14 @@
 #include <linux/lockd/bind.h>
 #include <linux/seq_file.h>
 #include <linux/mount.h>
+#include <linux/nfs_idmap.h>
 #include <linux/vfs.h>
 #include <linux/inet.h>
 #include <linux/nfs_xdr.h>
 #include <linux/slab.h>
 #include <linux/compat.h>
-#include <linux/freezer.h>
-#include <linux/crc32.h>
 
+#include <asm/system.h>
 #include <asm/uaccess.h>
 
 #include "nfs4_fs.h"
@@ -50,15 +50,13 @@
 #include "fscache.h"
 #include "dns_resolve.h"
 #include "pnfs.h"
-#include "nfs.h"
-#include "netns.h"
 
 #define NFSDBG_FACILITY         NFSDBG_VFS
 
 #define NFS_64_BIT_INODE_NUMBERS_ENABLED        1
 
 /* Default is to see 64-bit inode numbers */
-static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
+static int enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
 
 static void nfs_invalidate_inode(struct inode *);
 static int nfs_update_inode(struct inode *, struct nfs_fattr *);
@@ -79,10 +77,9 @@ int nfs_wait_bit_killable(void *word)
 {
         if (fatal_signal_pending(current))
                 return -ERESTARTSYS;
-        freezable_schedule();
+        schedule();
         return 0;
 }
-EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
 
 /**
  * nfs_compat_user_ino64 - returns the user-visible inode number
@@ -107,29 +104,22 @@ u64 nfs_compat_user_ino64(u64 fileid)
         return ino;
 }
 
-int nfs_drop_inode(struct inode *inode)
-{
-        return NFS_STALE(inode) || generic_drop_inode(inode);
-}
-EXPORT_SYMBOL_GPL(nfs_drop_inode);
-
-void nfs_clear_inode(struct inode *inode)
+static void nfs_clear_inode(struct inode *inode)
 {
         /*
          * The following should never happen...
          */
-        WARN_ON_ONCE(nfs_have_writebacks(inode));
-        WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
+        BUG_ON(nfs_have_writebacks(inode));
+        BUG_ON(!list_empty(&NFS_I(inode)->open_files));
         nfs_zap_acl_cache(inode);
         nfs_access_zap_cache(inode);
         nfs_fscache_release_inode_cookie(inode);
 }
-EXPORT_SYMBOL_GPL(nfs_clear_inode);
 
 void nfs_evict_inode(struct inode *inode)
 {
         truncate_inode_pages(&inode->i_data, 0);
-        clear_inode(inode);
+        end_writeback(inode);
         nfs_clear_inode(inode);
 }
 
@@ -160,13 +150,11 @@ static void nfs_zap_caches_locked(struct inode *inode)
         nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
         nfsi->attrtimeo_timestamp = jiffies;
 
-        memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
-        if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
+        memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
+        if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
                 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
-                nfs_fscache_invalidate(inode);
-        } else {
+        else
                 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
-        }
 }
 
 void nfs_zap_caches(struct inode *inode)
@@ -181,7 +169,6 @@ void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
         if (mapping->nrpages != 0) {
                 spin_lock(&inode->i_lock);
                 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
-                nfs_fscache_invalidate(inode);
                 spin_unlock(&inode->i_lock);
         }
 }
@@ -197,7 +184,6 @@ void nfs_zap_acl_cache(struct inode *inode)
         NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
         spin_unlock(&inode->i_lock);
 }
-EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
 
 void nfs_invalidate_atime(struct inode *inode)
 {
@@ -205,7 +191,6 @@ void nfs_invalidate_atime(struct inode *inode)
         NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
         spin_unlock(&inode->i_lock);
 }
-EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
 
 /*
  * Invalidate, but do not unhash, the inode.
@@ -298,7 +283,9 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                 inode->i_mode = fattr->mode;
                 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
                                 && nfs_server_capable(inode, NFS_CAP_MODE))
-                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
+                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_ACCESS
+                                | NFS_INO_INVALID_ACL;
                 /* Why so? Because we want revalidate for devices/FIFOs, and
                  * that's precisely what we have in nfs_file_inode_operations.
                  */
@@ -311,6 +298,8 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                         inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
                         inode->i_fop = &nfs_dir_operations;
                         inode->i_data.a_ops = &nfs_dir_aops;
+                        if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS))
+                                set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
                         /* Deal with crossing mountpoints */
                         if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
                                         fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
@@ -329,15 +318,13 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
                 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
                 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
-                inode->i_version = 0;
+                nfsi->change_attr = 0;
                 inode->i_size = 0;
-                clear_nlink(inode);
+                inode->i_nlink = 0;
                 inode->i_uid = -2;
                 inode->i_gid = -2;
                 inode->i_blocks = 0;
                 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
-                nfsi->write_io = 0;
-                nfsi->read_io = 0;
 
                 nfsi->read_cache_jiffies = fattr->time_start;
                 nfsi->attr_gencount = fattr->gencount;
@@ -348,32 +335,41 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
                         inode->i_mtime = fattr->mtime;
                 else if (nfs_server_capable(inode, NFS_CAP_MTIME))
-                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
+                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_DATA;
                 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
                         inode->i_ctime = fattr->ctime;
                 else if (nfs_server_capable(inode, NFS_CAP_CTIME))
-                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
+                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_ACCESS
+                                | NFS_INO_INVALID_ACL;
                 if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
-                        inode->i_version = fattr->change_attr;
+                        nfsi->change_attr = fattr->change_attr;
                 else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR))
-                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
+                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_DATA;
                 if (fattr->valid & NFS_ATTR_FATTR_SIZE)
                         inode->i_size = nfs_size_to_loff_t(fattr->size);
                 else
                         nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_DATA
                                 | NFS_INO_REVAL_PAGECACHE;
                 if (fattr->valid & NFS_ATTR_FATTR_NLINK)
-                        set_nlink(inode, fattr->nlink);
+                        inode->i_nlink = fattr->nlink;
                 else if (nfs_server_capable(inode, NFS_CAP_NLINK))
                         nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
                 if (fattr->valid & NFS_ATTR_FATTR_OWNER)
                         inode->i_uid = fattr->uid;
                 else if (nfs_server_capable(inode, NFS_CAP_OWNER))
-                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
+                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_ACCESS
+                                | NFS_INO_INVALID_ACL;
                 if (fattr->valid & NFS_ATTR_FATTR_GROUP)
                         inode->i_gid = fattr->gid;
                 else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
-                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
+                        nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_ACCESS
+                                | NFS_INO_INVALID_ACL;
                 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
                         inode->i_blocks = fattr->du.nfs2.blocks;
                 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
@@ -391,10 +387,9 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                 unlock_new_inode(inode);
         } else
                 nfs_refresh_inode(inode, fattr);
-        dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",
+        dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
                 inode->i_sb->s_id,
                 (long long)NFS_FILEID(inode),
-                nfs_display_fhandle_hash(fh),
                 atomic_read(&inode->i_count));
 
 out:
@@ -404,9 +399,8 @@ out_no_inode:
         dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
         goto out;
 }
-EXPORT_SYMBOL_GPL(nfs_fhget);
 
-#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE|ATTR_OPEN)
+#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE)
 
 int
 nfs_setattr(struct dentry *dentry, struct iattr *attr)
@@ -428,14 +422,12 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
 
         /* Optimization: if the end result is no change, don't RPC */
         attr->ia_valid &= NFS_VALID_ATTRS;
-        if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
+        if ((attr->ia_valid & ~ATTR_FILE) == 0)
                 return 0;
 
         /* Write all dirty data */
-        if (S_ISREG(inode->i_mode)) {
-                nfs_inode_dio_wait(inode);
+        if (S_ISREG(inode->i_mode))
                 nfs_wb_all(inode);
-        }
 
         fattr = nfs_alloc_fattr();
         if (fattr == NULL)
@@ -444,7 +436,7 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
          * Return any delegations if we're going to change ACLs
          */
         if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
-                NFS_PROTO(inode)->return_delegation(inode);
+                nfs_inode_return_delegation(inode);
         error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
         if (error == 0)
                 nfs_refresh_inode(inode, fattr);
@@ -452,7 +444,6 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
 out:
         return error;
 }
-EXPORT_SYMBOL_GPL(nfs_setattr);
 
 /**
  * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
@@ -511,7 +502,6 @@ void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
                 nfs_vmtruncate(inode, attr->ia_size);
         }
 }
-EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
 
 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
@@ -521,7 +511,6 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 
         /* Flush out writes to the server in order to update c/mtime.  */
         if (S_ISREG(inode->i_mode)) {
-                nfs_inode_dio_wait(inode);
                 err = filemap_write_and_wait(inode->i_mapping);
                 if (err)
                         goto out;
@@ -551,13 +540,12 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 out:
         return err;
 }
-EXPORT_SYMBOL_GPL(nfs_getattr);
 
 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
 {
         atomic_set(&l_ctx->count, 1);
-        l_ctx->lockowner.l_owner = current->files;
-        l_ctx->lockowner.l_pid = current->tgid;
+        l_ctx->lockowner = current->files;
+        l_ctx->pid = current->tgid;
         INIT_LIST_HEAD(&l_ctx->list);
 }
 
@@ -566,9 +554,9 @@ static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context
         struct nfs_lock_context *pos;
 
         list_for_each_entry(pos, &ctx->lock_context.list, list) {
-                if (pos->lockowner.l_owner != current->files)
+                if (pos->lockowner != current->files)
                         continue;
-                if (pos->lockowner.l_pid != current->tgid)
+                if (pos->pid != current->tgid)
                         continue;
                 atomic_inc(&pos->count);
                 return pos;
@@ -587,7 +575,7 @@ struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
                 spin_unlock(&inode->i_lock);
                 new = kmalloc(sizeof(*new), GFP_KERNEL);
                 if (new == NULL)
-                        return ERR_PTR(-ENOMEM);
+                        return NULL;
                 nfs_init_lock_context(new);
                 spin_lock(&inode->i_lock);
                 res = __nfs_find_lock_context(ctx);
@@ -640,34 +628,26 @@ void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
                 return;
         nfs_revalidate_inode(server, inode);
 }
-EXPORT_SYMBOL_GPL(nfs_close_context);
 
-struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode)
+struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred, fmode_t f_mode)
 {
         struct nfs_open_context *ctx;
-        struct rpc_cred *cred = rpc_lookup_cred();
-        if (IS_ERR(cred))
-                return ERR_CAST(cred);
 
         ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
-        if (!ctx) {
-                put_rpccred(cred);
-                return ERR_PTR(-ENOMEM);
+        if (ctx != NULL) {
+                nfs_sb_active(dentry->d_sb);
+                ctx->dentry = dget(dentry);
+                ctx->cred = get_rpccred(cred);
+                ctx->state = NULL;
+                ctx->mode = f_mode;
+                ctx->flags = 0;
+                ctx->error = 0;
+                nfs_init_lock_context(&ctx->lock_context);
+                ctx->lock_context.open_context = ctx;
+                INIT_LIST_HEAD(&ctx->list);
         }
-        nfs_sb_active(dentry->d_sb);
-        ctx->dentry = dget(dentry);
-        ctx->cred = cred;
-        ctx->state = NULL;
-        ctx->mode = f_mode;
-        ctx->flags = 0;
-        ctx->error = 0;
-        nfs_init_lock_context(&ctx->lock_context);
-        ctx->lock_context.open_context = ctx;
-        INIT_LIST_HEAD(&ctx->list);
-        ctx->mdsthreshold = NULL;
         return ctx;
 }
-EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
 
 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
 {
@@ -675,7 +655,6 @@ struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
                 atomic_inc(&ctx->lock_context.count);
         return ctx;
 }
-EXPORT_SYMBOL_GPL(get_nfs_open_context);
 
 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
 {
@@ -694,11 +673,7 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
         if (ctx->cred != NULL)
                 put_rpccred(ctx->cred);
         dput(ctx->dentry);
-        if (is_sync)
-                nfs_sb_deactive(sb);
-        else
-                nfs_sb_deactive_async(sb);
-        kfree(ctx->mdsthreshold);
+        nfs_sb_deactive(sb);
         kfree(ctx);
 }
 
@@ -706,7 +681,6 @@ void put_nfs_open_context(struct nfs_open_context *ctx)
 {
         __put_nfs_open_context(ctx, 0);
 }
-EXPORT_SYMBOL_GPL(put_nfs_open_context);
 
 /*
  * Ensure that mmap has a recent RPC credential for use when writing out
@@ -722,7 +696,6 @@ void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
         list_add(&ctx->list, &nfsi->open_files);
         spin_unlock(&inode->i_lock);
 }
-EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
 
 /*
  * Given an inode, search for an open context with the desired characteristics
@@ -765,10 +738,15 @@ static void nfs_file_clear_open_context(struct file *filp)
 int nfs_open(struct inode *inode, struct file *filp)
 {
         struct nfs_open_context *ctx;
+        struct rpc_cred *cred;
 
-        ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
-        if (IS_ERR(ctx))
-                return PTR_ERR(ctx);
+        cred = rpc_lookup_cred();
+        if (IS_ERR(cred))
+                return PTR_ERR(cred);
+        ctx = alloc_nfs_open_context(filp->f_path.dentry, cred, filp->f_mode);
+        put_rpccred(cred);
+        if (ctx == NULL)
+                return -ENOMEM;
         nfs_file_set_open_context(filp, ctx);
         put_nfs_open_context(ctx);
         nfs_fscache_set_inode_cookie(inode, filp);
@@ -867,7 +845,6 @@ int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
                 return NFS_STALE(inode) ? -ESTALE : 0;
         return __nfs_revalidate_inode(server, inode);
 }
-EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
 
 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
 {
@@ -884,21 +861,12 @@ static int nfs_invalidate_mapping(struct inode *inode, struct address_space *map
                 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
         spin_unlock(&inode->i_lock);
         nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
-        nfs_fscache_wait_on_invalidate(inode);
+        nfs_fscache_reset_inode_cookie(inode);
         dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
                         inode->i_sb->s_id, (long long)NFS_FILEID(inode));
         return 0;
 }
 
-static bool nfs_mapping_need_revalidate_inode(struct inode *inode)
-{
-        if (nfs_have_delegated_attributes(inode))
-                return false;
-        return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE)
-                || nfs_attribute_timeout(inode)
-                || NFS_STALE(inode);
-}
-
 /**
  * nfs_revalidate_mapping - Revalidate the pagecache
  * @inode - pointer to host inode
@@ -909,11 +877,9 @@ int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
         struct nfs_inode *nfsi = NFS_I(inode);
         int ret = 0;
 
-        /* swapfiles are not supposed to be shared. */
-        if (IS_SWAPFILE(inode))
-                goto out;
-
-        if (nfs_mapping_need_revalidate_inode(inode)) {
+        if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
+                        || nfs_attribute_cache_expired(inode)
+                        || NFS_STALE(inode)) {
                 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
                 if (ret < 0)
                         goto out;
@@ -931,8 +897,8 @@ static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr
 
         if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
                         && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
-                        && inode->i_version == fattr->pre_change_attr) {
-                inode->i_version = fattr->change_attr;
+                        && nfsi->change_attr == fattr->pre_change_attr) {
+                nfsi->change_attr = fattr->change_attr;
                 if (S_ISDIR(inode->i_mode))
                         nfsi->cache_validity |= NFS_INO_INVALID_DATA;
                 ret |= NFS_INO_INVALID_ATTR;
@@ -960,10 +926,6 @@ static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr
                 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
                 ret |= NFS_INO_INVALID_ATTR;
         }
-
-        if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
-                nfs_fscache_invalidate(inode);
-
         return ret;
 }
 
@@ -983,8 +945,6 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
         unsigned long invalid = 0;
 
 
-        if (nfs_have_delegated_attributes(inode))
-                return 0;
         /* Has the inode gone and changed behind our back? */
         if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
                 return -EIO;
@@ -992,12 +952,12 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
                 return -EIO;
 
         if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
-                        inode->i_version != fattr->change_attr)
+                        nfsi->change_attr != fattr->change_attr)
                 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
 
         /* Verify a few of the more important attributes */
         if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
-                invalid |= NFS_INO_INVALID_ATTR;
+                invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
 
         if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
                 cur_size = i_size_read(inode);
@@ -1059,10 +1019,7 @@ void nfs_fattr_init(struct nfs_fattr *fattr)
         fattr->valid = 0;
         fattr->time_start = jiffies;
         fattr->gencount = nfs_inc_attr_generation_counter();
-        fattr->owner_name = NULL;
-        fattr->group_name = NULL;
 }
-EXPORT_SYMBOL_GPL(nfs_fattr_init);
 
 struct nfs_fattr *nfs_alloc_fattr(void)
 {
@@ -1073,7 +1030,6 @@ struct nfs_fattr *nfs_alloc_fattr(void)
                 nfs_fattr_init(fattr);
         return fattr;
 }
-EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
 
 struct nfs_fh *nfs_alloc_fhandle(void)
 {
@@ -1084,68 +1040,6 @@ struct nfs_fh *nfs_alloc_fhandle(void)
                 fh->size = 0;
         return fh;
 }
-EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
-
-#ifdef NFS_DEBUG
-/*
- * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
- *                             in the same way that wireshark does
- *
- * @fh: file handle
- *
- * For debugging only.
- */
-u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
-{
-        /* wireshark uses 32-bit AUTODIN crc and does a bitwise
-         * not on the result */
-        return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size);
-}
-
-/*
- * _nfs_display_fhandle - display an NFS file handle on the console
- *
- * @fh: file handle to display
- * @caption: display caption
- *
- * For debugging only.
- */
-void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
-{
-        unsigned short i;
-
-        if (fh == NULL || fh->size == 0) {
-                printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
-                return;
-        }
-
-        printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
-               caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
-        for (i = 0; i < fh->size; i += 16) {
-                __be32 *pos = (__be32 *)&fh->data[i];
-
-                switch ((fh->size - i - 1) >> 2) {
-                case 0:
-                        printk(KERN_DEFAULT " %08x\n",
-                                be32_to_cpup(pos));
-                        break;
-                case 1:
-                        printk(KERN_DEFAULT " %08x %08x\n",
-                                be32_to_cpup(pos), be32_to_cpup(pos + 1));
-                        break;
-                case 2:
-                        printk(KERN_DEFAULT " %08x %08x %08x\n",
-                                be32_to_cpup(pos), be32_to_cpup(pos + 1),
-                                be32_to_cpup(pos + 2));
-                        break;
-                default:
-                        printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
-                                be32_to_cpup(pos), be32_to_cpup(pos + 1),
-                                be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
-                }
-        }
-}
-#endif
 
 /**
  * nfs_inode_attrs_need_update - check if the inode attributes need updating
@@ -1205,17 +1099,14 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
 
         return status;
 }
-EXPORT_SYMBOL_GPL(nfs_refresh_inode);
 
 static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
 {
         struct nfs_inode *nfsi = NFS_I(inode);
 
         nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
-        if (S_ISDIR(inode->i_mode)) {
+        if (S_ISDIR(inode->i_mode))
                 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
-                nfs_fscache_invalidate(inode);
-        }
         if ((fattr->valid & NFS_ATTR_FATTR) == 0)
                 return 0;
         return nfs_refresh_inode_locked(inode, fattr);
@@ -1244,7 +1135,6 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
         spin_unlock(&inode->i_lock);
         return status;
 }
-EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
 
 /**
  * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
@@ -1273,7 +1163,7 @@ int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fa
         }
         if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
                         (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
-                fattr->pre_change_attr = inode->i_version;
+                fattr->pre_change_attr = NFS_I(inode)->change_attr;
                 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
         }
         if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
@@ -1296,7 +1186,6 @@ out_noforce:
         spin_unlock(&inode->i_lock);
         return status;
 }
-EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
 
 /*
  * Many nfs protocol calls return the new file attributes after
@@ -1319,31 +1208,18 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
         unsigned long now = jiffies;
         unsigned long save_cache_validity;
 
-        dfprintk(VFS, "NFS: %s(%s/%ld fh_crc=0x%08x ct=%d info=0x%x)\n",
+        dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
                         __func__, inode->i_sb->s_id, inode->i_ino,
-                        nfs_display_fhandle_hash(NFS_FH(inode)),
                         atomic_read(&inode->i_count), fattr->valid);
 
-        if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) {
-                printk(KERN_ERR "NFS: server %s error: fileid changed\n"
-                        "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
-                        NFS_SERVER(inode)->nfs_client->cl_hostname,
-                        inode->i_sb->s_id, (long long)nfsi->fileid,
-                        (long long)fattr->fileid);
-                goto out_err;
-        }
+        if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
+                goto out_fileid;
 
         /*
          * Make sure the inode's type hasn't changed.
          */
-        if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
-                /*
-                * Big trouble! The inode has become a different object.
-                */
-                printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n",
-                                __func__, inode->i_ino, inode->i_mode, fattr->mode);
-                goto out_err;
-        }
+        if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
+                goto out_changed;
 
         server = NFS_SERVER(inode);
         /* Update the fsid? */
@@ -1368,31 +1244,50 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
 
         /* More cache consistency checks */
         if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
-                if (inode->i_version != fattr->change_attr) {
+                if (nfsi->change_attr != fattr->change_attr) {
                         dprintk("NFS: change_attr change on server for file %s/%ld\n",
                                         inode->i_sb->s_id, inode->i_ino);
-                        invalid |= NFS_INO_INVALID_ATTR
-                                | NFS_INO_INVALID_DATA
-                                | NFS_INO_INVALID_ACCESS
-                                | NFS_INO_INVALID_ACL
-                                | NFS_INO_REVAL_PAGECACHE;
+                        invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
                         if (S_ISDIR(inode->i_mode))
                                 nfs_force_lookup_revalidate(inode);
-                        inode->i_version = fattr->change_attr;
+                        nfsi->change_attr = fattr->change_attr;
                 }
         } else if (server->caps & NFS_CAP_CHANGE_ATTR)
                 invalid |= save_cache_validity;
 
         if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
-                memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
+                /* NFSv2/v3: Check if the mtime agrees */
+                if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
+                        dprintk("NFS: mtime change on server for file %s/%ld\n",
+                                        inode->i_sb->s_id, inode->i_ino);
+                        invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
+                        if (S_ISDIR(inode->i_mode))
+                                nfs_force_lookup_revalidate(inode);
+                        memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
+                }
         } else if (server->caps & NFS_CAP_MTIME)
                 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_DATA
+                                | NFS_INO_REVAL_PAGECACHE
                                 | NFS_INO_REVAL_FORCED);
 
         if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
-                memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
+                /* If ctime has changed we should definitely clear access+acl caches */
+                if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
+                        invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
+                        /* and probably clear data for a directory too as utimes can cause
+                         * havoc with our cache.
+                         */
+                        if (S_ISDIR(inode->i_mode)) {
+                                invalid |= NFS_INO_INVALID_DATA;
+                                nfs_force_lookup_revalidate(inode);
+                        }
+                        memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
+                }
         } else if (server->caps & NFS_CAP_CTIME)
                 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
+                                | NFS_INO_INVALID_ACCESS
+                                | NFS_INO_INVALID_ACL
                                 | NFS_INO_REVAL_FORCED);
 
         /* Check if our cached file size is stale */
@@ -1466,7 +1361,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                         invalid |= NFS_INO_INVALID_ATTR;
                         if (S_ISDIR(inode->i_mode))
                                 invalid |= NFS_INO_INVALID_DATA;
-                        set_nlink(inode, fattr->nlink);
+                        inode->i_nlink = fattr->nlink;
                 }
         } else if (server->caps & NFS_CAP_NLINK)
                 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
@@ -1499,14 +1394,17 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
                                 || S_ISLNK(inode->i_mode)))
                 invalid &= ~NFS_INO_INVALID_DATA;
-        if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
+        if (!nfs_have_delegation(inode, FMODE_READ) ||
                         (save_cache_validity & NFS_INO_REVAL_FORCED))
                 nfsi->cache_validity |= invalid;
 
-        if (invalid & NFS_INO_INVALID_DATA)
-                nfs_fscache_invalidate(inode);
-
         return 0;
+ out_changed:
+        /*
+         * Big trouble! The inode has become a different object.
+         */
+        printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
+                        __func__, inode->i_ino, inode->i_mode, fattr->mode);
  out_err:
         /*
          * No need to worry about unhashing the dentry, as the
@@ -1515,7 +1413,35 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
          */
         nfs_invalidate_inode(inode);
         return -ESTALE;
+
+ out_fileid:
+        printk(KERN_ERR "NFS: server %s error: fileid changed\n"
+                "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
+                NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
+                (long long)nfsi->fileid, (long long)fattr->fileid);
+        goto out_err;
+}
+
+
+#ifdef CONFIG_NFS_V4
+
+/*
+ * Clean out any remaining NFSv4 state that might be left over due
+ * to open() calls that passed nfs_atomic_lookup, but failed to call
+ * nfs_open().
+ */
+void nfs4_evict_inode(struct inode *inode)
+{
+        truncate_inode_pages(&inode->i_data, 0);
+        end_writeback(inode);
+        pnfs_return_layout(inode);
+        pnfs_destroy_layout(NFS_I(inode));
+        /* If we are holding a delegation, return it! */
+        nfs_inode_return_delegation_noreclaim(inode);
+        /* First call standard NFS clear_inode() code */
+        nfs_clear_inode(inode);
 }
+#endif
 
 struct inode *nfs_alloc_inode(struct super_block *sb)
 {
@@ -1529,16 +1455,16 @@ struct inode *nfs_alloc_inode(struct super_block *sb)
         nfsi->acl_access = ERR_PTR(-EAGAIN);
         nfsi->acl_default = ERR_PTR(-EAGAIN);
 #endif
-#if IS_ENABLED(CONFIG_NFS_V4)
+#ifdef CONFIG_NFS_V4
         nfsi->nfs4_acl = NULL;
 #endif /* CONFIG_NFS_V4 */
         return &nfsi->vfs_inode;
 }
-EXPORT_SYMBOL_GPL(nfs_alloc_inode);
 
 static void nfs_i_callback(struct rcu_head *head)
 {
         struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
 }
 
@@ -1546,16 +1472,16 @@ void nfs_destroy_inode(struct inode *inode)
 {
         call_rcu(&inode->i_rcu, nfs_i_callback);
 }
-EXPORT_SYMBOL_GPL(nfs_destroy_inode);
 
 static inline void nfs4_init_once(struct nfs_inode *nfsi)
 {
-#if IS_ENABLED(CONFIG_NFS_V4)
+#ifdef CONFIG_NFS_V4
         INIT_LIST_HEAD(&nfsi->open_states);
         nfsi->delegation = NULL;
         nfsi->delegation_state = 0;
         init_rwsem(&nfsi->rwsem);
         nfsi->layout = NULL;
+        atomic_set(&nfsi->commits_outstanding, 0);
 #endif
 }
 
@@ -1567,10 +1493,9 @@ static void init_once(void *foo)
         INIT_LIST_HEAD(&nfsi->open_files);
         INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
         INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
-        INIT_LIST_HEAD(&nfsi->commit_info.list);
+        INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
         nfsi->npages = 0;
-        nfsi->commit_info.ncommit = 0;
-        atomic_set(&nfsi->commit_info.rpcs_out, 0);
+        nfsi->ncommit = 0;
         atomic_set(&nfsi->silly_count, 1);
         INIT_HLIST_HEAD(&nfsi->silly_list);
         init_waitqueue_head(&nfsi->waitqueue);
@@ -1592,16 +1517,10 @@ static int __init nfs_init_inodecache(void)
 
 static void nfs_destroy_inodecache(void)
 {
-        /*
-         * Make sure all delayed rcu free inodes are flushed before we
-         * destroy cache.
-         */
-        rcu_barrier();
         kmem_cache_destroy(nfs_inode_cachep);
 }
 
 struct workqueue_struct *nfsiod_workqueue;
-EXPORT_SYMBOL_GPL(nfsiod_workqueue);
 
 /*
  * start up the nfsiod workqueue
@@ -1631,28 +1550,6 @@ static void nfsiod_stop(void)
         destroy_workqueue(wq);
 }
 
-int nfs_net_id;
-EXPORT_SYMBOL_GPL(nfs_net_id);
-
-static int nfs_net_init(struct net *net)
-{
-        nfs_clients_init(net);
-        return nfs_dns_resolver_cache_init(net);
-}
-
-static void nfs_net_exit(struct net *net)
-{
-        nfs_dns_resolver_cache_destroy(net);
-        nfs_cleanup_cb_ident_idr(net);
-}
-
-static struct pernet_operations nfs_net_ops = {
-        .init = nfs_net_init,
-        .exit = nfs_net_exit,
-        .id   = &nfs_net_id,
-        .size = sizeof(struct nfs_net),
-};
-
 /*
  * Initialize NFS
  */
@@ -1660,77 +1557,76 @@ static int __init init_nfs_fs(void)
 {
         int err;
 
-        err = nfs_dns_resolver_init();
+        err = nfs_idmap_init();
         if (err < 0)
-                goto out10;;
+                goto out9;
 
-        err = register_pernet_subsys(&nfs_net_ops);
+        err = nfs_dns_resolver_init();
         if (err < 0)
-                goto out9;
+                goto out8;
 
         err = nfs_fscache_register();
         if (err < 0)
-                goto out8;
+                goto out7;
 
         err = nfsiod_start();
         if (err)
-                goto out7;
+                goto out6;
 
         err = nfs_fs_proc_init();
         if (err)
-                goto out6;
+                goto out5;
 
         err = nfs_init_nfspagecache();
         if (err)
-                goto out5;
+                goto out4;
 
         err = nfs_init_inodecache();
         if (err)
-                goto out4;
+                goto out3;
 
         err = nfs_init_readpagecache();
         if (err)
-                goto out3;
+                goto out2;
 
         err = nfs_init_writepagecache();
         if (err)
-                goto out2;
+                goto out1;
 
         err = nfs_init_directcache();
         if (err)
-                goto out1;
+                goto out0;
 
 #ifdef CONFIG_PROC_FS
-        rpc_proc_register(&init_net, &nfs_rpcstat);
+        rpc_proc_register(&nfs_rpcstat);
 #endif
         if ((err = register_nfs_fs()) != 0)
-                goto out0;
-
+                goto out;
         return 0;
-out0:
+out:
 #ifdef CONFIG_PROC_FS
-        rpc_proc_unregister(&init_net, "nfs");
+        rpc_proc_unregister("nfs");
 #endif
         nfs_destroy_directcache();
-out1:
+out0:
         nfs_destroy_writepagecache();
-out2:
+out1:
         nfs_destroy_readpagecache();
-out3:
+out2:
         nfs_destroy_inodecache();
-out4:
+out3:
         nfs_destroy_nfspagecache();
-out5:
+out4:
         nfs_fs_proc_exit();
-out6:
+out5:
         nfsiod_stop();
-out7:
+out6:
         nfs_fscache_unregister();
+out7:
+        nfs_dns_resolver_destroy();
 out8:
-        unregister_pernet_subsys(&nfs_net_ops);
+        nfs_idmap_quit();
 out9:
-        nfs_dns_resolver_destroy();
-out10:
         return err;
 }
 
@@ -1742,11 +1638,12 @@ static void __exit exit_nfs_fs(void)
         nfs_destroy_inodecache();
         nfs_destroy_nfspagecache();
         nfs_fscache_unregister();
-        unregister_pernet_subsys(&nfs_net_ops);
         nfs_dns_resolver_destroy();
+        nfs_idmap_quit();
 #ifdef CONFIG_PROC_FS
-        rpc_proc_unregister(&init_net, "nfs");
+        rpc_proc_unregister("nfs");
 #endif
+        nfs_cleanup_cb_ident_idr();
         unregister_nfs_fs();
         nfs_fs_proc_exit();
         nfsiod_stop();