ext4: fast commit: export snapshot stats in fc_info

Snapshot-based fast commit can fall back when the commit-time snapshot
cannot be built (e.g. extent status cache misses). It is useful to
quantify the updates-locked window and to see why snapshotting failed.

Add best-effort snapshot counters to the ext4 superblock and extend
/proc/fs/ext4/<sb_id>/fc_info to report the number of snapshotted
inodes and ranges, snapshot failure reasons, and the average/max time
spent with journal updates locked.

Signed-off-by: Li Chen <chenl311@chinatelecom.cn>
Link: https://patch.msgid.link/20260515091829.194810-8-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 dd09d00a73afabcd08d9902401279fc591cafbd9..ddc903738c6b33eed90bdf0b3a669f0c20f5a6c7 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1550,6 +1550,36 @@ struct ext4_orphan_info {
                                                 * file blocks */
 };
 
+/*
+ * Ext4 fast commit snapshot statistics.
+ *
+ * These are best-effort counters intended for debugging / performance
+ * introspection; they are not exact under concurrent updates.
+ */
+struct ext4_fc_snap_stats {
+       atomic64_t lock_updates_ns_total;
+       atomic64_t lock_updates_ns_max;
+       atomic64_t lock_updates_samples;
+
+       atomic64_t snap_inodes;
+       atomic64_t snap_ranges;
+
+       atomic64_t snap_fail_es_miss;
+       atomic64_t snap_fail_es_delayed;
+       atomic64_t snap_fail_es_other;
+
+       atomic64_t snap_fail_inodes_cap;
+       atomic64_t snap_fail_ranges_cap;
+       atomic64_t snap_fail_nomem;
+       atomic64_t snap_fail_inode_loc;
+
+       /*
+        * Missing inode snapshots during log writing should never happen.
+        * Keep this counter to help catch unexpected regressions.
+        */
+       atomic64_t snap_fail_no_snap;
+};
+
 /*
  * fourth extended-fs super-block data in memory
  */
@@ -1824,6 +1854,7 @@ struct ext4_sb_info {
        struct mutex s_fc_lock;
        struct buffer_head *s_fc_bh;
        struct ext4_fc_stats s_fc_stats;
+       struct ext4_fc_snap_stats s_fc_snap_stats;
        tid_t s_fc_ineligible_tid;
 #ifdef CONFIG_EXT4_DEBUG
        int s_fc_debug_max_replay;

diff --git a/fs/ext4/fast_commit.c b/fs/ext4/fast_commit.c
index dc08f8ff43d95b7670702aec27f83f59e2966b37..4ef796b9b6cb5f9b1d8e1fcd9c3e95b1243e5721 100644 (file)
--- a/fs/ext4/fast_commit.c
+++ b/fs/ext4/fast_commit.c
@@ -281,6 +281,19 @@ static inline void ext4_fc_wake_inode_state(struct inode *inode, int bit)
                    ext4_inode_state_wait_bit(bit));
 }
 
+static void ext4_fc_snap_stats_update_max(atomic64_t *stat, u64 value)
+{
+       u64 old = atomic64_read(stat);
+
+       while (value > old) {
+               u64 prev = atomic64_cmpxchg(stat, old, value);
+
+               if (prev == old)
+                       break;
+               old = prev;
+       }
+}
+
 /*
  * Remove inode from fast commit list. If the inode is being committed
  * we wait until inode commit is done.
@@ -868,6 +881,8 @@ static int ext4_fc_write_inode(struct inode *inode, u32 *crc)
 {
        struct ext4_inode_info *ei = EXT4_I(inode);
        struct ext4_fc_inode_snap *snap = ei->i_fc_snap;
+       struct ext4_fc_snap_stats *stats =
+               &EXT4_SB(inode->i_sb)->s_fc_snap_stats;
        struct ext4_fc_inode fc_inode;
        struct ext4_fc_tl tl;
        u8 *dst;
@@ -875,13 +890,17 @@ static int ext4_fc_write_inode(struct inode *inode, u32 *crc)
        int inode_len;
        int ret;
 
-       if (!snap)
+       if (!snap) {
+               atomic64_inc(&stats->snap_fail_no_snap);
                return -ECANCELED;
+       }
 
        src = snap->inode_buf;
        inode_len = snap->inode_len;
-       if (!src || inode_len == 0)
+       if (!src || inode_len == 0) {
+               atomic64_inc(&stats->snap_fail_no_snap);
                return -ECANCELED;
+       }
 
        fc_inode.fc_ino = cpu_to_le32(inode->i_ino);
        tl.fc_tag = cpu_to_le16(EXT4_FC_TAG_INODE);
@@ -911,13 +930,17 @@ static int ext4_fc_write_inode_data(struct inode *inode, u32 *crc)
 {
        struct ext4_inode_info *ei = EXT4_I(inode);
        struct ext4_fc_inode_snap *snap = ei->i_fc_snap;
+       struct ext4_fc_snap_stats *stats =
+               &EXT4_SB(inode->i_sb)->s_fc_snap_stats;
        struct ext4_fc_add_range fc_ext;
        struct ext4_fc_del_range lrange;
        struct ext4_extent *ex;
        struct ext4_fc_range *range;
 
-       if (!snap)
+       if (!snap) {
+               atomic64_inc(&stats->snap_fail_no_snap);
                return -ECANCELED;
+       }
 
        list_for_each_entry(range, &snap->data_list, list) {
                if (range->tag == EXT4_FC_TAG_DEL_RANGE) {
@@ -978,6 +1001,8 @@ static int ext4_fc_snapshot_inode_data(struct inode *inode,
                                       int *snap_err)
 {
        struct ext4_inode_info *ei = EXT4_I(inode);
+       struct ext4_fc_snap_stats *stats =
+               &EXT4_SB(inode->i_sb)->s_fc_snap_stats;
        ext4_lblk_t start_lblk, end_lblk, cur_lblk;
        unsigned int nr_ranges = 0;
 
@@ -1005,11 +1030,13 @@ static int ext4_fc_snapshot_inode_data(struct inode *inode,
                u64 remaining = (u64)end_lblk - cur_lblk + 1;
 
                if (!ext4_es_lookup_extent(inode, cur_lblk, NULL, &es, NULL)) {
+                       atomic64_inc(&stats->snap_fail_es_miss);
                        ext4_fc_set_snap_err(snap_err, EXT4_FC_SNAP_ERR_ES_MISS);
                        return -EAGAIN;
                }
 
                if (ext4_es_is_delayed(&es)) {
+                       atomic64_inc(&stats->snap_fail_es_delayed);
                        ext4_fc_set_snap_err(snap_err,
                                             EXT4_FC_SNAP_ERR_ES_DELAYED);
                        return -EAGAIN;
@@ -1024,6 +1051,7 @@ static int ext4_fc_snapshot_inode_data(struct inode *inode,
                }
 
                if (nr_ranges_total + nr_ranges >= EXT4_FC_SNAPSHOT_MAX_RANGES) {
+                       atomic64_inc(&stats->snap_fail_ranges_cap);
                        ext4_fc_set_snap_err(snap_err,
                                             EXT4_FC_SNAP_ERR_RANGES_CAP);
                        return -E2BIG;
@@ -1031,6 +1059,7 @@ static int ext4_fc_snapshot_inode_data(struct inode *inode,
 
                range = kmem_cache_alloc(ext4_fc_range_cachep, GFP_NOFS);
                if (!range) {
+                       atomic64_inc(&stats->snap_fail_nomem);
                        ext4_fc_set_snap_err(snap_err, EXT4_FC_SNAP_ERR_NOMEM);
                        return -ENOMEM;
                }
@@ -1058,6 +1087,7 @@ static int ext4_fc_snapshot_inode_data(struct inode *inode,
                                range->len = max;
                } else {
                        kmem_cache_free(ext4_fc_range_cachep, range);
+                       atomic64_inc(&stats->snap_fail_es_other);
                        ext4_fc_set_snap_err(snap_err, EXT4_FC_SNAP_ERR_ES_OTHER);
                        return -EAGAIN;
                }
@@ -1081,6 +1111,8 @@ static int ext4_fc_snapshot_inode(struct inode *inode,
                                  unsigned int *nr_rangesp, int *snap_err)
 {
        struct ext4_inode_info *ei = EXT4_I(inode);
+       struct ext4_fc_snap_stats *stats =
+               &EXT4_SB(inode->i_sb)->s_fc_snap_stats;
        struct ext4_fc_inode_snap *snap;
        int inode_len = EXT4_GOOD_OLD_INODE_SIZE;
        struct ext4_iloc iloc;
@@ -1091,6 +1123,7 @@ static int ext4_fc_snapshot_inode(struct inode *inode,
 
        ret = ext4_get_inode_loc_noio(inode, &iloc);
        if (ret) {
+               atomic64_inc(&stats->snap_fail_inode_loc);
                ext4_fc_set_snap_err(snap_err, EXT4_FC_SNAP_ERR_INODE_LOC);
                return ret;
        }
@@ -1102,6 +1135,7 @@ static int ext4_fc_snapshot_inode(struct inode *inode,
 
        snap = kmalloc(struct_size(snap, inode_buf, inode_len), GFP_NOFS);
        if (!snap) {
+               atomic64_inc(&stats->snap_fail_nomem);
                ext4_fc_set_snap_err(snap_err, EXT4_FC_SNAP_ERR_NOMEM);
                brelse(iloc.bh);
                return -ENOMEM;
@@ -1126,6 +1160,8 @@ static int ext4_fc_snapshot_inode(struct inode *inode,
        list_splice_tail_init(&ranges, &snap->data_list);
        ext4_fc_unlock(inode->i_sb, alloc_ctx);
 
+       atomic64_inc(&stats->snap_inodes);
+       atomic64_add(nr_ranges, &stats->snap_ranges);
        if (nr_rangesp)
                *nr_rangesp = nr_ranges;
        return 0;
@@ -1229,12 +1265,10 @@ static int ext4_fc_snapshot_inodes(journal_t *journal, struct inode **inodes,
        int ret = 0;
        int alloc_ctx;
 
-       if (!inodes_size)
-               return 0;
-
        alloc_ctx = ext4_fc_lock(sb);
        list_for_each_entry(iter, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list) {
                if (i >= inodes_size) {
+                       atomic64_inc(&sbi->s_fc_snap_stats.snap_fail_inodes_cap);
                        ext4_fc_set_snap_err(snap_err,
                                             EXT4_FC_SNAP_ERR_INODES_CAP);
                        ret = -E2BIG;
@@ -1260,6 +1294,7 @@ static int ext4_fc_snapshot_inodes(journal_t *journal, struct inode **inodes,
                        continue;
 
                if (i >= inodes_size) {
+                       atomic64_inc(&sbi->s_fc_snap_stats.snap_fail_inodes_cap);
                        ext4_fc_set_snap_err(snap_err,
                                             EXT4_FC_SNAP_ERR_INODES_CAP);
                        ret = -E2BIG;
@@ -1303,6 +1338,7 @@ static int ext4_fc_perform_commit(journal_t *journal, tid_t commit_tid)
 {
        struct super_block *sb = journal->j_private;
        struct ext4_sb_info *sbi = EXT4_SB(sb);
+       struct ext4_fc_snap_stats *snap_stats = &sbi->s_fc_snap_stats;
        struct ext4_inode_info *iter;
        struct ext4_fc_head head;
        struct inode *inode;
@@ -1362,8 +1398,13 @@ static int ext4_fc_perform_commit(journal_t *journal, tid_t commit_tid)
                return ret;
 
        ret = ext4_fc_alloc_snapshot_inodes(sb, &inodes, &inodes_size);
-       if (ret)
+       if (ret) {
+               if (ret == -E2BIG)
+                       atomic64_inc(&snap_stats->snap_fail_inodes_cap);
+               else if (ret == -ENOMEM)
+                       atomic64_inc(&snap_stats->snap_fail_nomem);
                return ret;
+       }
 
        /* Step 4: Mark all inodes as being committed. */
        jbd2_journal_lock_updates(journal);
@@ -1384,12 +1425,15 @@ static int ext4_fc_perform_commit(journal_t *journal, tid_t commit_tid)
        ret = ext4_fc_snapshot_inodes(journal, inodes, inodes_size,
                                      &snap_inodes, &snap_ranges, &snap_err);
        jbd2_journal_unlock_updates(journal);
-       if (trace_ext4_fc_lock_updates_enabled()) {
-               locked_ns = ktime_to_ns(ktime_sub(ktime_get(), lock_start));
+       locked_ns = ktime_to_ns(ktime_sub(ktime_get(), lock_start));
+       atomic64_add(locked_ns, &snap_stats->lock_updates_ns_total);
+       atomic64_inc(&snap_stats->lock_updates_samples);
+       ext4_fc_snap_stats_update_max(&snap_stats->lock_updates_ns_max,
+                                     locked_ns);
+       if (trace_ext4_fc_lock_updates_enabled())
                trace_call__ext4_fc_lock_updates(sb, commit_tid, locked_ns,
                                                 snap_inodes, snap_ranges,
                                                 ret, snap_err);
-       }
        kvfree(inodes);
        if (ret)
                return ret;
@@ -2657,11 +2701,26 @@ int ext4_fc_info_show(struct seq_file *seq, void *v)
 {
        struct ext4_sb_info *sbi = EXT4_SB((struct super_block *)seq->private);
        struct ext4_fc_stats *stats = &sbi->s_fc_stats;
+       struct ext4_fc_snap_stats *snap_stats = &sbi->s_fc_snap_stats;
+       u64 lock_avg_ns = 0;
+       u64 lock_updates_samples;
+       u64 lock_updates_ns_total;
+       u64 lock_updates_ns_max;
        int i;
 
        if (v != SEQ_START_TOKEN)
                return 0;
 
+       lock_updates_samples =
+               atomic64_read(&snap_stats->lock_updates_samples);
+       lock_updates_ns_total =
+               atomic64_read(&snap_stats->lock_updates_ns_total);
+       lock_updates_ns_max =
+               atomic64_read(&snap_stats->lock_updates_ns_max);
+       if (lock_updates_samples)
+               lock_avg_ns = div64_u64(lock_updates_ns_total,
+                                       lock_updates_samples);
+
        seq_printf(seq,
                "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,
@@ -2672,6 +2731,23 @@ int ext4_fc_info_show(struct seq_file *seq, void *v)
                seq_printf(seq, "\"%s\":\t%d\n", fc_ineligible_reasons[i],
                        stats->fc_ineligible_reason_count[i]);
 
+       seq_printf(seq,
+                  "Snapshot stats:\n%llu inodes\n%llu ranges\n%lluus lock_updates_avg\n%lluus lock_updates_max\n",
+                  atomic64_read(&snap_stats->snap_inodes),
+                  atomic64_read(&snap_stats->snap_ranges),
+                  div_u64(lock_avg_ns, 1000),
+                  div_u64(lock_updates_ns_max, 1000));
+       seq_printf(seq,
+                  "Snapshot failures:\n%llu es_miss\n%llu es_delayed\n%llu es_other\n%llu inodes_cap\n%llu ranges_cap\n%llu nomem\n%llu inode_loc\n%llu no_snap\n",
+                  atomic64_read(&snap_stats->snap_fail_es_miss),
+                  atomic64_read(&snap_stats->snap_fail_es_delayed),
+                  atomic64_read(&snap_stats->snap_fail_es_other),
+                  atomic64_read(&snap_stats->snap_fail_inodes_cap),
+                  atomic64_read(&snap_stats->snap_fail_ranges_cap),
+                  atomic64_read(&snap_stats->snap_fail_nomem),
+                  atomic64_read(&snap_stats->snap_fail_inode_loc),
+                  atomic64_read(&snap_stats->snap_fail_no_snap));
+
        return 0;
 }
 

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 7c484a53c62ef5c24c84885d18eec8179f5fd8c1..f2c52cc7467655097fbdfa2ca3e6249b86bcf802 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -4544,6 +4544,7 @@ static void ext4_fast_commit_init(struct super_block *sb)
        sbi->s_fc_ineligible_tid = 0;
        mutex_init(&sbi->s_fc_lock);
        memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));
+       memset(&sbi->s_fc_snap_stats, 0, sizeof(sbi->s_fc_snap_stats));
        sbi->s_fc_replay_state.fc_regions = NULL;
        sbi->s_fc_replay_state.fc_regions_size = 0;
        sbi->s_fc_replay_state.fc_regions_used = 0;