NFS: Separate tracking of file nlinks cache validity from the mode/uid/gid

Rename can cause us to revalidate the access cache, so lets track the
nlinks separately from the mode/uid/gid.

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

diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index e924d65c125e3c7d04ea6cf66dfa306a9c8ac7f2..f748d2294261a23cc67f6ce2b5cfe07c6a927aa5 100644 (file)
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1711,7 +1711,7 @@ static void nfs_drop_nlink(struct inode *inode)
        NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
        nfs_set_cache_invalid(
                inode, NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME |
-                              NFS_INO_INVALID_OTHER | NFS_INO_REVAL_FORCED);
+                              NFS_INO_INVALID_NLINK | NFS_INO_REVAL_FORCED);
        spin_unlock(&inode->i_lock);
 }
 

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 3d18e66a4b8fce1a2f0b5a7a319db98259f94fd7..7bf9138330f245753cf4ee9d826c90e512042f17 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -538,7 +538,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st
                if (fattr->valid & NFS_ATTR_FATTR_NLINK)
                        set_nlink(inode, fattr->nlink);
                else if (nfs_server_capable(inode, NFS_CAP_NLINK))
-                       nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
+                       nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
                if (fattr->valid & NFS_ATTR_FATTR_OWNER)
                        inode->i_uid = fattr->uid;
                else if (nfs_server_capable(inode, NFS_CAP_OWNER))
@@ -801,8 +801,10 @@ static u32 nfs_get_valid_attrmask(struct inode *inode)
                reply_mask |= STATX_MTIME;
        if (!(cache_validity & NFS_INO_INVALID_SIZE))
                reply_mask |= STATX_SIZE;
+       if (!(cache_validity & NFS_INO_INVALID_NLINK))
+               reply_mask |= STATX_NLINK;
        if (!(cache_validity & NFS_INO_INVALID_OTHER))
-               reply_mask |= STATX_UID | STATX_GID | STATX_MODE | STATX_NLINK;
+               reply_mask |= STATX_UID | STATX_GID | STATX_MODE;
        if (!(cache_validity & NFS_INO_INVALID_BLOCKS))
                reply_mask |= STATX_BLOCKS;
        return reply_mask;
@@ -868,7 +870,9 @@ int nfs_getattr(struct user_namespace *mnt_userns, const struct path *path,
                do_update |= cache_validity & NFS_INO_INVALID_MTIME;
        if (request_mask & STATX_SIZE)
                do_update |= cache_validity & NFS_INO_INVALID_SIZE;
-       if (request_mask & (STATX_UID | STATX_GID | STATX_MODE | STATX_NLINK))
+       if (request_mask & STATX_NLINK)
+               do_update |= cache_validity & NFS_INO_INVALID_NLINK;
+       if (request_mask & (STATX_UID | STATX_GID | STATX_MODE))
                do_update |= cache_validity & NFS_INO_INVALID_OTHER;
        if (request_mask & STATX_BLOCKS)
                do_update |= cache_validity & NFS_INO_INVALID_BLOCKS;
@@ -1518,7 +1522,7 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
 
        /* Has the link count changed? */
        if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
-               invalid |= NFS_INO_INVALID_OTHER;
+               invalid |= NFS_INO_INVALID_NLINK;
 
        ts = inode->i_atime;
        if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec64_equal(&ts, &fattr->atime))
@@ -1942,6 +1946,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                                        | NFS_INO_INVALID_MTIME
                                        | NFS_INO_INVALID_SIZE
                                        | NFS_INO_INVALID_BLOCKS
+                                       | NFS_INO_INVALID_NLINK
                                        | NFS_INO_INVALID_OTHER;
                                if (S_ISDIR(inode->i_mode))
                                        nfs_force_lookup_revalidate(inode);
@@ -2074,7 +2079,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                }
        } else if (server->caps & NFS_CAP_NLINK) {
                nfsi->cache_validity |= save_cache_validity &
-                               (NFS_INO_INVALID_OTHER
+                               (NFS_INO_INVALID_NLINK
                                | NFS_INO_REVAL_FORCED);
                cache_revalidated = false;
        }

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 8dc595ce40cae3337fab3e0181c85aec5fa3d112..a74c1c3c41924e30a0ba0a2c9d983b2c391fcd12 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -1167,14 +1167,14 @@ int nfs4_call_sync(struct rpc_clnt *clnt,
 static void
 nfs4_inc_nlink_locked(struct inode *inode)
 {
-       nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
+       nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
        inc_nlink(inode);
 }
 
 static void
 nfs4_dec_nlink_locked(struct inode *inode)
 {
-       nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
+       nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
        drop_nlink(inode);
 }
 
@@ -4717,11 +4717,11 @@ static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
                        /* Note: If we moved a directory, nlink will change */
                        nfs4_update_changeattr(old_dir, &res->old_cinfo,
                                        res->old_fattr->time_start,
-                                       NFS_INO_INVALID_OTHER |
+                                       NFS_INO_INVALID_NLINK |
                                            NFS_INO_INVALID_DATA);
                        nfs4_update_changeattr(new_dir, &res->new_cinfo,
                                        res->new_fattr->time_start,
-                                       NFS_INO_INVALID_OTHER |
+                                       NFS_INO_INVALID_NLINK |
                                            NFS_INO_INVALID_DATA);
                } else
                        nfs4_update_changeattr(old_dir, &res->old_cinfo,
@@ -5433,8 +5433,9 @@ static void nfs4_bitmask_set(__u32 bitmask[NFS4_BITMASK_SZ], const __u32 *src,
                bitmask[1] |= FATTR4_WORD1_TIME_ACCESS;
        if (cache_validity & NFS_INO_INVALID_OTHER)
                bitmask[1] |= FATTR4_WORD1_MODE | FATTR4_WORD1_OWNER |
-                               FATTR4_WORD1_OWNER_GROUP |
-                               FATTR4_WORD1_NUMLINKS;
+                               FATTR4_WORD1_OWNER_GROUP;
+       if (cache_validity & NFS_INO_INVALID_NLINK)
+               bitmask[1] |= FATTR4_WORD1_NUMLINKS;
        if (label && label->len && cache_validity & NFS_INO_INVALID_LABEL)
                bitmask[2] |= FATTR4_WORD2_SECURITY_LABEL;
        if (cache_validity & NFS_INO_INVALID_CTIME)

diff --git a/fs/nfs/nfstrace.h b/fs/nfs/nfstrace.h
index cdba6eebe3cbe2834efa20a3bf25d98c6f524f55..a0ebc53160dd9f43d19ec35e43beb61017e4bb9b 100644 (file)
--- a/fs/nfs/nfstrace.h
+++ b/fs/nfs/nfstrace.h
@@ -48,6 +48,7 @@ TRACE_DEFINE_ENUM(NFS_INO_INVALID_OTHER);
 TRACE_DEFINE_ENUM(NFS_INO_DATA_INVAL_DEFER);
 TRACE_DEFINE_ENUM(NFS_INO_INVALID_BLOCKS);
 TRACE_DEFINE_ENUM(NFS_INO_INVALID_XATTR);
+TRACE_DEFINE_ENUM(NFS_INO_INVALID_NLINK);
 
 #define nfs_show_cache_validity(v) \
        __print_flags(v, "|", \
@@ -65,7 +66,8 @@ TRACE_DEFINE_ENUM(NFS_INO_INVALID_XATTR);
                        { NFS_INO_INVALID_OTHER, "INVALID_OTHER" }, \
                        { NFS_INO_DATA_INVAL_DEFER, "DATA_INVAL_DEFER" }, \
                        { NFS_INO_INVALID_BLOCKS, "INVALID_BLOCKS" }, \
-                       { NFS_INO_INVALID_XATTR, "INVALID_XATTR" })
+                       { NFS_INO_INVALID_XATTR, "INVALID_XATTR" }, \
+                       { NFS_INO_INVALID_NLINK, "INVALID_NLINK" })
 
 TRACE_DEFINE_ENUM(NFS_INO_ADVISE_RDPLUS);
 TRACE_DEFINE_ENUM(NFS_INO_STALE);

diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 624ffd47a9d48d107472f9f4e11ea880e76f6963..41165b988dfb3a91aa04053723c48a38366ecfed 100644 (file)
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -246,11 +246,13 @@ struct nfs4_copy_state {
                                BIT(13)         /* Deferred cache invalidation */
 #define NFS_INO_INVALID_BLOCKS BIT(14)         /* cached blocks are invalid */
 #define NFS_INO_INVALID_XATTR  BIT(15)         /* xattrs are invalid */
+#define NFS_INO_INVALID_NLINK  BIT(16)         /* cached nlinks is invalid */
 
 #define NFS_INO_INVALID_ATTR   (NFS_INO_INVALID_CHANGE \
                | NFS_INO_INVALID_CTIME \
                | NFS_INO_INVALID_MTIME \
                | NFS_INO_INVALID_SIZE \
+               | NFS_INO_INVALID_NLINK \
                | NFS_INO_INVALID_OTHER)        /* inode metadata is invalid */
 
 /*