Merge branch 'leases-devel'

[mirror_ubuntu-jammy-kernel.git] / fs / nfs / inode.c

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index d5d022f92c377ed8ac0df42227cfc84d934b49be..853213b3a209512c84bfe9c92b55dba6416ac75d 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -2059,35 +2059,33 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                                        | NFS_INO_INVALID_OTHER;
                                if (S_ISDIR(inode->i_mode))
                                        nfs_force_lookup_revalidate(inode);
+                               attr_changed = true;
                                dprintk("NFS: change_attr change on server for file %s/%ld\n",
                                                inode->i_sb->s_id,
                                                inode->i_ino);
                        } else if (!have_delegation)
                                nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER;
                        inode_set_iversion_raw(inode, fattr->change_attr);
-                       attr_changed = true;
                }
        } 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) {
@@ -2100,7 +2098,6 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                                i_size_write(inode, new_isize);
                                if (!have_writers)
                                        invalid |= NFS_INO_INVALID_DATA;
-                               attr_changed = true;
                        }
                        dprintk("NFS: isize change on server for file %s/%ld "
                                        "(%Ld to %Ld)\n",
@@ -2115,19 +2112,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)) {
@@ -2136,71 +2129,55 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                        inode->i_mode = newmode;
                        invalid |= NFS_INO_INVALID_ACCESS
                                | 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)) {
                        invalid |= NFS_INO_INVALID_ACCESS
                                | NFS_INO_INVALID_ACL;
                        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)) {
                        invalid |= NFS_INO_INVALID_ACCESS
                                | NFS_INO_INVALID_ACL;
                        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) {
                        if (S_ISDIR(inode->i_mode))
                                invalid |= NFS_INO_INVALID_DATA;
                        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) {