fs: add an icount_read helper

Instead of doing direct access to ->i_count, add a helper to handle
this. This will make it easier to convert i_count to a refcount later.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Link: https://lore.kernel.org/9bc62a84c6b9d6337781203f60837bd98fbc4a96.1756222464.git.josef@toxicpanda.com
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index d5a2c77bc90871ae22e781449c02d87cbe6d69ad..ce839783c0df6a9b8aeeec77e119aa9b39527c01 100644 (file)
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -1430,7 +1430,7 @@ static int spufs_mfc_open(struct inode *inode, struct file *file)
        if (ctx->owner != current->mm)
                return -EINVAL;
 
-       if (atomic_read(&inode->i_count) != 1)
+       if (icount_read(inode) != 1)
                return -EBUSY;
 
        mutex_lock(&ctx->mapping_lock);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index de722b232ec145963f27612e7df85760d5df09cb..5bcd8e25fa78f7b3a147ffdb1d441464810e1933 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4538,7 +4538,7 @@ static void btrfs_prune_dentries(struct btrfs_root *root)
 
        inode = btrfs_find_first_inode(root, min_ino);
        while (inode) {
-               if (atomic_read(&inode->vfs_inode.i_count) > 1)
+               if (icount_read(&inode->vfs_inode) > 1)
                        d_prune_aliases(&inode->vfs_inode);
 
                min_ino = btrfs_ino(inode) + 1;

diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 0f497c39ff8246d755e01ef5df4b6db0af8f8352..62dba710504d5293df999e9648ca60b65becdbe8 100644 (file)
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -2221,7 +2221,7 @@ static int trim_caps_cb(struct inode *inode, int mds, void *arg)
                        int count;
                        dput(dentry);
                        d_prune_aliases(inode);
-                       count = atomic_read(&inode->i_count);
+                       count = icount_read(inode);
                        if (count == 1)
                                (*remaining)--;
                        doutc(cl, "%p %llx.%llx cap %p pruned, count now %d\n",

diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index df4051613b290a78728176d3b8198ad90de84977..ba4fd9aba1c14de56b89ebbeb4597f7becf947ff 100644 (file)
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -252,10 +252,10 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
                       "nonexistent device\n", __func__, __LINE__);
                return;
        }
-       if (atomic_read(&inode->i_count) > 1) {
+       if (icount_read(inode) > 1) {
                ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: count=%d",
                         __func__, __LINE__, inode->i_ino,
-                        atomic_read(&inode->i_count));
+                        icount_read(inode));
                return;
        }
        if (inode->i_nlink) {

diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index cc57367fb641d7bb448d65f132ef5734c3795422..6088a67b2aaebb76e6cf705226ea179f4433b6cc 100644 (file)
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -1767,7 +1767,7 @@ static int writeback_single_inode(struct inode *inode,
        int ret = 0;
 
        spin_lock(&inode->i_lock);
-       if (!atomic_read(&inode->i_count))
+       if (!icount_read(inode))
                WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
        else
                WARN_ON(inode->i_state & I_WILL_FREE);

diff --git a/fs/hpfs/inode.c b/fs/hpfs/inode.c
index a59e8fa630db67a974b420874a8d6e401cb29de4..34008442ee265f156f707a638cc4b9a84e74e524 100644 (file)
--- a/fs/hpfs/inode.c
+++ b/fs/hpfs/inode.c
@@ -184,7 +184,7 @@ void hpfs_write_inode(struct inode *i)
        struct hpfs_inode_info *hpfs_inode = hpfs_i(i);
        struct inode *parent;
        if (i->i_ino == hpfs_sb(i->i_sb)->sb_root) return;
-       if (hpfs_inode->i_rddir_off && !atomic_read(&i->i_count)) {
+       if (hpfs_inode->i_rddir_off && !icount_read(i)) {
                if (*hpfs_inode->i_rddir_off)
                        pr_err("write_inode: some position still there\n");
                kfree(hpfs_inode->i_rddir_off);

diff --git a/fs/inode.c b/fs/inode.c
index 01a554e1127940f7e1ac926e01c159476c5074c8..fe4868e2a9545b671afed5fb77616a9e4cb197ea 100644 (file)
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -534,7 +534,7 @@ static void __inode_add_lru(struct inode *inode, bool rotate)
 {
        if (inode->i_state & (I_DIRTY_ALL | I_SYNC | I_FREEING | I_WILL_FREE))
                return;
-       if (atomic_read(&inode->i_count))
+       if (icount_read(inode))
                return;
        if (!(inode->i_sb->s_flags & SB_ACTIVE))
                return;
@@ -871,11 +871,11 @@ void evict_inodes(struct super_block *sb)
 again:
        spin_lock(&sb->s_inode_list_lock);
        list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
-               if (atomic_read(&inode->i_count))
+               if (icount_read(inode))
                        continue;
 
                spin_lock(&inode->i_lock);
-               if (atomic_read(&inode->i_count)) {
+               if (icount_read(inode)) {
                        spin_unlock(&inode->i_lock);
                        continue;
                }
@@ -937,7 +937,7 @@ static enum lru_status inode_lru_isolate(struct list_head *item,
         * unreclaimable for a while. Remove them lazily here; iput,
         * sync, or the last page cache deletion will requeue them.
         */
-       if (atomic_read(&inode->i_count) ||
+       if (icount_read(inode) ||
            (inode->i_state & ~I_REFERENCED) ||
            !mapping_shrinkable(&inode->i_data)) {
                list_lru_isolate(lru, &inode->i_lru);

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 338ef77ae4230812b198dcce47ffeab5f5b2b40e..b52805951856b5f41cc9a298fe6418e5c8155f78 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -608,7 +608,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                inode->i_sb->s_id,
                (unsigned long long)NFS_FILEID(inode),
                nfs_display_fhandle_hash(fh),
-               atomic_read(&inode->i_count));
+               icount_read(inode));
 
 out:
        return inode;
@@ -2229,7 +2229,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
        dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%llx)\n",
                        __func__, inode->i_sb->s_id, inode->i_ino,
                        nfs_display_fhandle_hash(NFS_FH(inode)),
-                       atomic_read(&inode->i_count), fattr->valid);
+                       icount_read(inode), fattr->valid);
 
        if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
                /* Only a mounted-on-fileid? Just exit */

diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c
index 079b868552c21d6d6f51c2d935f2854c9f8cd6ce..46bfc543f9467c9efb8df3fdcfe15bd8513d33f4 100644 (file)
--- a/fs/notify/fsnotify.c
+++ b/fs/notify/fsnotify.c
@@ -66,7 +66,7 @@ static void fsnotify_unmount_inodes(struct super_block *sb)
                 * removed all zero refcount inodes, in any case.  Test to
                 * be sure.
                 */
-               if (!atomic_read(&inode->i_count)) {
+               if (!icount_read(inode)) {
                        spin_unlock(&inode->i_lock);
                        continue;
                }

diff --git a/fs/smb/client/inode.c b/fs/smb/client/inode.c
index 75be4b46bc6f18e40b879cf798e0fa107f594f51..211d5b8b42f4ad8bb56a79bba5b314ac12bea7ff 100644 (file)
--- a/fs/smb/client/inode.c
+++ b/fs/smb/client/inode.c
@@ -2749,7 +2749,7 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
        }
 
        cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
-                full_path, inode, inode->i_count.counter,
+                full_path, inode, icount_read(inode),
                 dentry, cifs_get_time(dentry), jiffies);
 
 again:

diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index f3e3b20686085e3b76adac5cff9b5ff3b956c204..a0269ba96e3de21cd0686d73fd35ee007a024ecc 100644 (file)
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -358,7 +358,7 @@ static void ubifs_evict_inode(struct inode *inode)
                goto out;
 
        dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode);
-       ubifs_assert(c, !atomic_read(&inode->i_count));
+       ubifs_assert(c, !icount_read(inode));
 
        truncate_inode_pages_final(&inode->i_data);
 

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 9c39251961a32ac1642586ca418b017f3efcdb4f..df8eab11dc48d077ced30a69bf91e5af1ab5cf6b 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1035,7 +1035,7 @@ xfs_itruncate_extents_flags(
        int                     error = 0;
 
        xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
-       if (atomic_read(&VFS_I(ip)->i_count))
+       if (icount_read(VFS_I(ip)))
                xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL);
        ASSERT(new_size <= XFS_ISIZE(ip));
        ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);

diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index e1794e3e3156b119c29196648ea582f984a44e65..34001503fc8b9a567faf26a21061abc4965c2b61 100644 (file)
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -1151,7 +1151,7 @@ DECLARE_EVENT_CLASS(xfs_iref_class,
        TP_fast_assign(
                __entry->dev = VFS_I(ip)->i_sb->s_dev;
                __entry->ino = ip->i_ino;
-               __entry->count = atomic_read(&VFS_I(ip)->i_count);
+               __entry->count = icount_read(VFS_I(ip));
                __entry->pincount = atomic_read(&ip->i_pincount);
                __entry->iflags = ip->i_flags;
                __entry->caller_ip = caller_ip;

diff --git a/include/linux/fs.h b/include/linux/fs.h
index c34554d8c4feb98e93ebee1319c9da8fac76f371..c4fd010cf5bff1badbd40527c43f36bf21dd9d00 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2611,6 +2611,11 @@ static inline void mark_inode_dirty_sync(struct inode *inode)
        __mark_inode_dirty(inode, I_DIRTY_SYNC);
 }
 
+static inline int icount_read(const struct inode *inode)
+{
+       return atomic_read(&inode->i_count);
+}
+
 /*
  * Returns true if the given inode itself only has dirty timestamps (its pages
  * may still be dirty) and isn't currently being allocated or freed.

diff --git a/include/trace/events/filelock.h b/include/trace/events/filelock.h
index b8d1e00a7982c9ef966f414ee279ed91663bf550..fdd36b1daa25783d2bbaeaad7af0737cb6acecb8 100644 (file)
--- a/include/trace/events/filelock.h
+++ b/include/trace/events/filelock.h
@@ -189,7 +189,7 @@ TRACE_EVENT(generic_add_lease,
                __entry->i_ino = inode->i_ino;
                __entry->wcount = atomic_read(&inode->i_writecount);
                __entry->rcount = atomic_read(&inode->i_readcount);
-               __entry->icount = atomic_read(&inode->i_count);
+               __entry->icount = icount_read(inode);
                __entry->owner = fl->c.flc_owner;
                __entry->flags = fl->c.flc_flags;
                __entry->type = fl->c.flc_type;

diff --git a/security/landlock/fs.c b/security/landlock/fs.c
index c04f8879ad03ce8a2d303a78dda30e0ab3354fb6..0bade2c5aa1d007e6e13951aba19ae01d21a9baf 100644 (file)
--- a/security/landlock/fs.c
+++ b/security/landlock/fs.c
@@ -1281,7 +1281,7 @@ static void hook_sb_delete(struct super_block *const sb)
                struct landlock_object *object;
 
                /* Only handles referenced inodes. */
-               if (!atomic_read(&inode->i_count))
+               if (!icount_read(inode))
                        continue;
 
                /*