ext4: fix fast commit wait/wake bit mapping on 64-bit

On 64-bit, ext4 dynamic inode states live in the upper half of i_flags,
and ext4_test_inode_state() applies the corresponding +32 offset.

The fast-commit wait and wake paths open-coded the wait key with the raw
EXT4_STATE_* value. Add small helpers for the state wait word and bit,
and use them for the FC_COMMITTING and FC_FLUSHING_DATA waits so the wait
key follows the same mapping as the state helpers.

Fixes: 857d32f26181 ("ext4: rework fast commit commit path")
Reported-by: Sashiko AI review <sashiko-bot@kernel.org>
Signed-off-by: Li Chen <chenl311@chinatelecom.cn>
Reviewed-by: Baokun Li <libaokun@linux.alibaba.com>
Reviewed-by: Zhang Yi <yi.zhang@huawei.com>
Reviewed-by: Jan Kara <jack@suse.cz>
Link: https://patch.msgid.link/20260513085818.552432-1-me@linux.beauty
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 94283a991e5c4f0fe5ad2ccdd6646960702d1af9..6569d1d575a01a682d5a54d4116c1f5b75327631 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -2000,6 +2000,8 @@ EXT4_INODE_BIT_FNS(flag, flags, 0)
 static inline int ext4_test_inode_state(struct inode *inode, int bit);
 static inline void ext4_set_inode_state(struct inode *inode, int bit);
 static inline void ext4_clear_inode_state(struct inode *inode, int bit);
+static inline unsigned long *ext4_inode_state_wait_word(struct inode *inode);
+static inline int ext4_inode_state_wait_bit(int bit);
 #if (BITS_PER_LONG < 64)
 EXT4_INODE_BIT_FNS(state, state_flags, 0)
 
@@ -2015,6 +2017,24 @@ static inline void ext4_clear_state_flags(struct ext4_inode_info *ei)
        /* We depend on the fact that callers will set i_flags */
 }
 #endif
+
+static inline unsigned long *ext4_inode_state_wait_word(struct inode *inode)
+{
+#if (BITS_PER_LONG < 64)
+       return &EXT4_I(inode)->i_state_flags;
+#else
+       return &EXT4_I(inode)->i_flags;
+#endif
+}
+
+static inline int ext4_inode_state_wait_bit(int bit)
+{
+#if (BITS_PER_LONG < 64)
+       return bit;
+#else
+       return bit + 32;
+#endif
+}
 #else
 /* Assume that user mode programs are passing in an ext4fs superblock, not
  * a kernel struct super_block.  This will allow us to call the feature-test

diff --git a/fs/ext4/fast_commit.c b/fs/ext4/fast_commit.c
index b3c22636251dde7e36262212204c0e3b3ff73c78..1775bce9649a938922be664a2285146c97259c9f 100644 (file)
--- a/fs/ext4/fast_commit.c
+++ b/fs/ext4/fast_commit.c
@@ -239,6 +239,8 @@ void ext4_fc_del(struct inode *inode)
        struct ext4_inode_info *ei = EXT4_I(inode);
        struct ext4_fc_dentry_update *fc_dentry;
        wait_queue_head_t *wq;
+       unsigned long *wait_word = ext4_inode_state_wait_word(inode);
+       int wait_bit = ext4_inode_state_wait_bit(EXT4_STATE_FC_FLUSHING_DATA);
        int alloc_ctx;
 
        if (ext4_fc_disabled(inode->i_sb))
@@ -268,17 +270,9 @@ void ext4_fc_del(struct inode *inode)
        WARN_ON(ext4_test_inode_state(inode, EXT4_STATE_FC_COMMITTING)
                && !ext4_test_mount_flag(inode->i_sb, EXT4_MF_FC_INELIGIBLE));
        while (ext4_test_inode_state(inode, EXT4_STATE_FC_FLUSHING_DATA)) {
-#if (BITS_PER_LONG < 64)
-               DEFINE_WAIT_BIT(wait, &ei->i_state_flags,
-                               EXT4_STATE_FC_FLUSHING_DATA);
-               wq = bit_waitqueue(&ei->i_state_flags,
-                                  EXT4_STATE_FC_FLUSHING_DATA);
-#else
-               DEFINE_WAIT_BIT(wait, &ei->i_flags,
-                               EXT4_STATE_FC_FLUSHING_DATA);
-               wq = bit_waitqueue(&ei->i_flags,
-                                  EXT4_STATE_FC_FLUSHING_DATA);
-#endif
+               DEFINE_WAIT_BIT(wait, wait_word, wait_bit);
+
+               wq = bit_waitqueue(wait_word, wait_bit);
                prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
                if (ext4_test_inode_state(inode, EXT4_STATE_FC_FLUSHING_DATA)) {
                        ext4_fc_unlock(inode->i_sb, alloc_ctx);
@@ -542,6 +536,8 @@ void ext4_fc_track_inode(handle_t *handle, struct inode *inode)
 {
        struct ext4_inode_info *ei = EXT4_I(inode);
        wait_queue_head_t *wq;
+       unsigned long *wait_word = ext4_inode_state_wait_word(inode);
+       int wait_bit = ext4_inode_state_wait_bit(EXT4_STATE_FC_COMMITTING);
        int ret;
 
        if (S_ISDIR(inode->i_mode))
@@ -564,17 +560,9 @@ void ext4_fc_track_inode(handle_t *handle, struct inode *inode)
        lockdep_assert_not_held(&ei->i_data_sem);
 
        while (ext4_test_inode_state(inode, EXT4_STATE_FC_COMMITTING)) {
-#if (BITS_PER_LONG < 64)
-               DEFINE_WAIT_BIT(wait, &ei->i_state_flags,
-                               EXT4_STATE_FC_COMMITTING);
-               wq = bit_waitqueue(&ei->i_state_flags,
-                                  EXT4_STATE_FC_COMMITTING);
-#else
-               DEFINE_WAIT_BIT(wait, &ei->i_flags,
-                               EXT4_STATE_FC_COMMITTING);
-               wq = bit_waitqueue(&ei->i_flags,
-                                  EXT4_STATE_FC_COMMITTING);
-#endif
+               DEFINE_WAIT_BIT(wait, wait_word, wait_bit);
+
+               wq = bit_waitqueue(wait_word, wait_bit);
                prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
                if (ext4_test_inode_state(inode, EXT4_STATE_FC_COMMITTING))
                        schedule();
@@ -1034,6 +1022,8 @@ static int ext4_fc_perform_commit(journal_t *journal)
        int ret = 0;
        u32 crc = 0;
        int alloc_ctx;
+       int flushing_wait_bit =
+               ext4_inode_state_wait_bit(EXT4_STATE_FC_FLUSHING_DATA);
 
        /*
         * Step 1: Mark all inodes on s_fc_q[MAIN] with
@@ -1059,11 +1049,8 @@ static int ext4_fc_perform_commit(journal_t *journal)
        list_for_each_entry(iter, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list) {
                ext4_clear_inode_state(&iter->vfs_inode,
                                       EXT4_STATE_FC_FLUSHING_DATA);
-#if (BITS_PER_LONG < 64)
-               wake_up_bit(&iter->i_state_flags, EXT4_STATE_FC_FLUSHING_DATA);
-#else
-               wake_up_bit(&iter->i_flags, EXT4_STATE_FC_FLUSHING_DATA);
-#endif
+               wake_up_bit(ext4_inode_state_wait_word(&iter->vfs_inode),
+                           flushing_wait_bit);
        }
 
        /*
@@ -1279,6 +1266,8 @@ static void ext4_fc_cleanup(journal_t *journal, int full, tid_t tid)
        struct ext4_inode_info *ei;
        struct ext4_fc_dentry_update *fc_dentry;
        int alloc_ctx;
+       int committing_wait_bit =
+               ext4_inode_state_wait_bit(EXT4_STATE_FC_COMMITTING);
 
        if (full && sbi->s_fc_bh)
                sbi->s_fc_bh = NULL;
@@ -1315,11 +1304,8 @@ static void ext4_fc_cleanup(journal_t *journal, int full, tid_t tid)
                 * barrier in prepare_to_wait() in ext4_fc_track_inode().
                 */
                smp_mb();
-#if (BITS_PER_LONG < 64)
-               wake_up_bit(&ei->i_state_flags, EXT4_STATE_FC_COMMITTING);
-#else
-               wake_up_bit(&ei->i_flags, EXT4_STATE_FC_COMMITTING);
-#endif
+               wake_up_bit(ext4_inode_state_wait_word(&ei->vfs_inode),
+                           committing_wait_bit);
        }
 
        while (!list_empty(&sbi->s_fc_dentry_q[FC_Q_MAIN])) {