ext4: simplify updating of fast commit stats

Move fast commit stats updating logic to a separate function from
ext4_fc_commit(). This significantly improves readability of
ext4_fc_commit().

Signed-off-by: Harshad Shirwadkar <harshadshirwadkar@gmail.com>
Link: https://lore.kernel.org/r/20211223202140.2061101-4-harshads@google.com
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index d71485d..82fa51d 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1747,7 +1747,6 @@ struct ext4_sb_info {
        spinlock_t s_fc_lock;
        struct buffer_head *s_fc_bh;
        struct ext4_fc_stats s_fc_stats;
-       u64 s_fc_avg_commit_time;
 #ifdef CONFIG_EXT4_DEBUG
        int s_fc_debug_max_replay;
 #endif

diff --git a/fs/ext4/fast_commit.c b/fs/ext4/fast_commit.c
index 2771ade..a373840 100644 (file)
--- a/fs/ext4/fast_commit.c
+++ b/fs/ext4/fast_commit.c
@@ -1075,6 +1075,32 @@ out:
        return ret;
 }
 
+static void ext4_fc_update_stats(struct super_block *sb, int status,
+                                u64 commit_time, int nblks)
+{
+       struct ext4_fc_stats *stats = &EXT4_SB(sb)->s_fc_stats;
+
+       jbd_debug(1, "Fast commit ended with status = %d", status);
+       if (status == EXT4_FC_STATUS_OK) {
+               stats->fc_num_commits++;
+               stats->fc_numblks += nblks;
+               if (likely(stats->s_fc_avg_commit_time))
+                       stats->s_fc_avg_commit_time =
+                               (commit_time +
+                                stats->s_fc_avg_commit_time * 3) / 4;
+               else
+                       stats->s_fc_avg_commit_time = commit_time;
+       } else if (status == EXT4_FC_STATUS_FAILED ||
+                  status == EXT4_FC_STATUS_INELIGIBLE) {
+               if (status == EXT4_FC_STATUS_FAILED)
+                       stats->fc_failed_commits++;
+               stats->fc_ineligible_commits++;
+       } else {
+               stats->fc_skipped_commits++;
+       }
+       trace_ext4_fc_commit_stop(sb, nblks, status);
+}
+
 /*
  * The main commit entry point. Performs a fast commit for transaction
  * commit_tid if needed. If it's not possible to perform a fast commit
@@ -1087,7 +1113,7 @@ int ext4_fc_commit(journal_t *journal, tid_t commit_tid)
        struct ext4_sb_info *sbi = EXT4_SB(sb);
        int nblks = 0, ret, bsize = journal->j_blocksize;
        int subtid = atomic_read(&sbi->s_fc_subtid);
-       int reason = EXT4_FC_REASON_OK, fc_bufs_before = 0;
+       int status = EXT4_FC_STATUS_OK, fc_bufs_before = 0;
        ktime_t start_time, commit_time;
 
        trace_ext4_fc_commit_start(sb);
@@ -1104,69 +1130,52 @@ restart_fc:
                if (atomic_read(&sbi->s_fc_subtid) <= subtid &&
                        commit_tid > journal->j_commit_sequence)
                        goto restart_fc;
-               reason = EXT4_FC_REASON_ALREADY_COMMITTED;
-               goto out;
+               ext4_fc_update_stats(sb, EXT4_FC_STATUS_SKIPPED, 0, 0);
+               return 0;
        } else if (ret) {
-               sbi->s_fc_stats.fc_ineligible_reason_count[EXT4_FC_COMMIT_FAILED]++;
-               reason = EXT4_FC_REASON_FC_START_FAILED;
-               goto out;
+               /*
+                * Commit couldn't start. Just update stats and perform a
+                * full commit.
+                */
+               ext4_fc_update_stats(sb, EXT4_FC_STATUS_FAILED, 0, 0);
+               return jbd2_complete_transaction(journal, commit_tid);
        }
+
        /*
         * After establishing journal barrier via jbd2_fc_begin_commit(), check
         * if we are fast commit ineligible.
         */
        if (ext4_test_mount_flag(sb, EXT4_MF_FC_INELIGIBLE)) {
-               reason = EXT4_FC_REASON_INELIGIBLE;
-               goto out;
+               status = EXT4_FC_STATUS_INELIGIBLE;
+               goto fallback;
        }
 
        fc_bufs_before = (sbi->s_fc_bytes + bsize - 1) / bsize;
        ret = ext4_fc_perform_commit(journal);
        if (ret < 0) {
-               sbi->s_fc_stats.fc_ineligible_reason_count[EXT4_FC_COMMIT_FAILED]++;
-               reason = EXT4_FC_REASON_FC_FAILED;
-               goto out;
+               status = EXT4_FC_STATUS_FAILED;
+               goto fallback;
        }
        nblks = (sbi->s_fc_bytes + bsize - 1) / bsize - fc_bufs_before;
        ret = jbd2_fc_wait_bufs(journal, nblks);
        if (ret < 0) {
-               sbi->s_fc_stats.fc_ineligible_reason_count[EXT4_FC_COMMIT_FAILED]++;
-               reason = EXT4_FC_REASON_FC_FAILED;
-               goto out;
+               status = EXT4_FC_STATUS_FAILED;
+               goto fallback;
        }
        atomic_inc(&sbi->s_fc_subtid);
-       jbd2_fc_end_commit(journal);
-out:
-       spin_lock(&sbi->s_fc_lock);
-       if (reason != EXT4_FC_REASON_OK &&
-               reason != EXT4_FC_REASON_ALREADY_COMMITTED) {
-               sbi->s_fc_stats.fc_ineligible_commits++;
-       } else {
-               sbi->s_fc_stats.fc_num_commits++;
-               sbi->s_fc_stats.fc_numblks += nblks;
-       }
-       spin_unlock(&sbi->s_fc_lock);
-       nblks = (reason == EXT4_FC_REASON_OK) ? nblks : 0;
-       trace_ext4_fc_commit_stop(sb, nblks, reason);
-       commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
+       ret = jbd2_fc_end_commit(journal);
        /*
-        * weight the commit time higher than the average time so we don't
-        * react too strongly to vast changes in the commit time
+        * weight the commit time higher than the average time so we
+        * don't react too strongly to vast changes in the commit time
         */
-       if (likely(sbi->s_fc_avg_commit_time))
-               sbi->s_fc_avg_commit_time = (commit_time +
-                               sbi->s_fc_avg_commit_time * 3) / 4;
-       else
-               sbi->s_fc_avg_commit_time = commit_time;
-       jbd_debug(1,
-               "Fast commit ended with blks = %d, reason = %d, subtid - %d",
-               nblks, reason, subtid);
-       if (reason == EXT4_FC_REASON_FC_FAILED)
-               return jbd2_fc_end_commit_fallback(journal);
-       if (reason == EXT4_FC_REASON_FC_START_FAILED ||
-               reason == EXT4_FC_REASON_INELIGIBLE)
-               return jbd2_complete_transaction(journal, commit_tid);
-       return 0;
+       commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
+       ext4_fc_update_stats(sb, status, commit_time, nblks);
+       return ret;
+
+fallback:
+       ret = jbd2_fc_end_commit_fallback(journal);
+       ext4_fc_update_stats(sb, status, 0, 0);
+       return ret;
 }
 
 /*
@@ -2124,7 +2133,7 @@ int ext4_fc_info_show(struct seq_file *seq, void *v)
                "fc stats:\n%ld commits\n%ld ineligible\n%ld numblks\n%lluus avg_commit_time\n",
                   stats->fc_num_commits, stats->fc_ineligible_commits,
                   stats->fc_numblks,
-                  div_u64(sbi->s_fc_avg_commit_time, 1000));
+                  div_u64(stats->s_fc_avg_commit_time, 1000));
        seq_puts(seq, "Ineligible reasons:\n");
        for (i = 0; i < EXT4_FC_REASON_MAX; i++)
                seq_printf(seq, "\"%s\":\t%d\n", fc_ineligible_reasons[i],

diff --git a/fs/ext4/fast_commit.h b/fs/ext4/fast_commit.h
index 937c381..083ad1c 100644 (file)
--- a/fs/ext4/fast_commit.h
+++ b/fs/ext4/fast_commit.h
@@ -71,21 +71,19 @@ struct ext4_fc_tail {
 };
 
 /*
- * Fast commit reason codes
+ * Fast commit status codes
+ */
+enum {
+       EXT4_FC_STATUS_OK = 0,
+       EXT4_FC_STATUS_INELIGIBLE,
+       EXT4_FC_STATUS_SKIPPED,
+       EXT4_FC_STATUS_FAILED,
+};
+
+/*
+ * Fast commit ineligiblity reasons:
  */
 enum {
-       /*
-        * Commit status codes:
-        */
-       EXT4_FC_REASON_OK = 0,
-       EXT4_FC_REASON_INELIGIBLE,
-       EXT4_FC_REASON_ALREADY_COMMITTED,
-       EXT4_FC_REASON_FC_START_FAILED,
-       EXT4_FC_REASON_FC_FAILED,
-
-       /*
-        * Fast commit ineligiblity reasons:
-        */
        EXT4_FC_REASON_XATTR = 0,
        EXT4_FC_REASON_CROSS_RENAME,
        EXT4_FC_REASON_JOURNAL_FLAG_CHANGE,
@@ -117,7 +115,10 @@ struct ext4_fc_stats {
        unsigned int fc_ineligible_reason_count[EXT4_FC_REASON_MAX];
        unsigned long fc_num_commits;
        unsigned long fc_ineligible_commits;
+       unsigned long fc_failed_commits;
+       unsigned long fc_skipped_commits;
        unsigned long fc_numblks;
+       u64 s_fc_avg_commit_time;
 };
 
 #define EXT4_FC_REPLAY_REALLOC_INCREMENT       4