NFS: Fix up inode attribute revalidation timeouts

The inode is considered revalidated when we've checked the value of the
change attribute against our cached value since that suffices to
establish whether or not the other cached values are valid.

Signed-off-by: Trond Myklebust <trond.myklebust@hammerspace.com>

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 529c4099f482a2cf1db9e72f78e40613914bb96d..327f9ae4dd3f64d7c2084f86525c324e6fc8a496 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -2066,24 +2066,22 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
        } else {
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_CHANGE;
-               cache_revalidated = false;
+               if (!have_delegation ||
+                   (nfsi->cache_validity & NFS_INO_INVALID_CHANGE) != 0)
+                       cache_revalidated = false;
        }
 
-       if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
+       if (fattr->valid & NFS_ATTR_FATTR_MTIME)
                inode->i_mtime = fattr->mtime;
-       } else if (fattr_supported & NFS_ATTR_FATTR_MTIME) {
+       else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_MTIME;
-               cache_revalidated = false;
-       }
 
-       if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
+       if (fattr->valid & NFS_ATTR_FATTR_CTIME)
                inode->i_ctime = fattr->ctime;
-       } else if (fattr_supported & NFS_ATTR_FATTR_CTIME) {
+       else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_CTIME;
-               cache_revalidated = false;
-       }
 
        /* Check if our cached file size is stale */
        if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
@@ -2111,19 +2109,15 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                        fattr->du.nfs3.used = 0;
                        fattr->valid |= NFS_ATTR_FATTR_SPACE_USED;
                }
-       } else {
+       } else
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_SIZE;
-               cache_revalidated = false;
-       }
 
        if (fattr->valid & NFS_ATTR_FATTR_ATIME)
                inode->i_atime = fattr->atime;
-       else if (fattr_supported & NFS_ATTR_FATTR_ATIME) {
+       else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_ATIME;
-               cache_revalidated = false;
-       }
 
        if (fattr->valid & NFS_ATTR_FATTR_MODE) {
                if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
@@ -2134,11 +2128,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                                | NFS_INO_INVALID_ACL;
                        attr_changed = true;
                }
-       } else if (fattr_supported & NFS_ATTR_FATTR_MODE) {
+       } else if (fattr_supported & NFS_ATTR_FATTR_MODE)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_MODE;
-               cache_revalidated = false;
-       }
 
        if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
                if (!uid_eq(inode->i_uid, fattr->uid)) {
@@ -2147,11 +2139,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                        inode->i_uid = fattr->uid;
                        attr_changed = true;
                }
-       } else if (fattr_supported & NFS_ATTR_FATTR_OWNER) {
+       } else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_OTHER;
-               cache_revalidated = false;
-       }
 
        if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
                if (!gid_eq(inode->i_gid, fattr->gid)) {
@@ -2160,11 +2150,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                        inode->i_gid = fattr->gid;
                        attr_changed = true;
                }
-       } else if (fattr_supported & NFS_ATTR_FATTR_GROUP) {
+       } else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_OTHER;
-               cache_revalidated = false;
-       }
 
        if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
                if (inode->i_nlink != fattr->nlink) {
@@ -2173,30 +2161,24 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                        set_nlink(inode, fattr->nlink);
                        attr_changed = true;
                }
-       } else if (fattr_supported & NFS_ATTR_FATTR_NLINK) {
+       } else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_NLINK;
-               cache_revalidated = false;
-       }
 
        if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
                /*
                 * report the blocks in 512byte units
                 */
                inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
-       } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED) {
+       } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_BLOCKS;
-               cache_revalidated = false;
-       }
 
-       if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED) {
+       if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
                inode->i_blocks = fattr->du.nfs2.blocks;
-       } else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED) {
+       else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED)
                nfsi->cache_validity |=
                        save_cache_validity & NFS_INO_INVALID_BLOCKS;
-               cache_revalidated = false;
-       }
 
        /* Update attrtimeo value if we're out of the unstable period */
        if (attr_changed) {