projects / linux-block.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 3db3084)
bcachefs: add counter_flags for counters
authorHongbo Li <lihongbo22@huawei.com>
Tue, 12 Nov 2024 08:15:47 +0000 (16:15 +0800)
committerKent Overstreet <kent.overstreet@linux.dev>
Fri, 10 Jan 2025 04:38:41 +0000 (23:38 -0500)
In bcachefs, io_read and io_write counter record the amount
of data which has been read and written. They increase in
unit of sector, so to display correctly, they need to be
shifted to the left by the size of a sector. Other counters
like io_move, move_extent_{read, write, finish} also have
this problem.

In order to support different unit, we add extra column to
mark the counter type by using TYPE_COUNTER and TYPE_SECTORS
in BCH_PERSISTENT_COUNTERS().

Fixes: 1c6fdbd8f246 ("bcachefs: Initial commit")
Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
fs/bcachefs/sb-counters_format.h patch | blob | blame | history
fs/bcachefs/sysfs.c patch | blob | blame | history

diff --git a/fs/bcachefs/sb-counters_format.h b/fs/bcachefs/sb-counters_format.h
index 62ea478215d08e77a5a7708a2a7dfc39f9236355..fdcf598f08b120eafe33f7880c23be1c80f3e934 100644 (file)
--- a/fs/bcachefs/sb-counters_format.h
+++ b/fs/bcachefs/sb-counters_format.h
@@ -2,86 +2,91 @@
 #ifndef _BCACHEFS_SB_COUNTERS_FORMAT_H
 #define _BCACHEFS_SB_COUNTERS_FORMAT_H
 
-#define BCH_PERSISTENT_COUNTERS()                              \
-       x(io_read,                                      0)      \
-       x(io_write,                                     1)      \
-       x(io_move,                                      2)      \
-       x(bucket_invalidate,                            3)      \
-       x(bucket_discard,                               4)      \
-       x(bucket_alloc,                                 5)      \
-       x(bucket_alloc_fail,                            6)      \
-       x(btree_cache_scan,                             7)      \
-       x(btree_cache_reap,                             8)      \
-       x(btree_cache_cannibalize,                      9)      \
-       x(btree_cache_cannibalize_lock,                 10)     \
-       x(btree_cache_cannibalize_lock_fail,            11)     \
-       x(btree_cache_cannibalize_unlock,               12)     \
-       x(btree_node_write,                             13)     \
-       x(btree_node_read,                              14)     \
-       x(btree_node_compact,                           15)     \
-       x(btree_node_merge,                             16)     \
-       x(btree_node_split,                             17)     \
-       x(btree_node_rewrite,                           18)     \
-       x(btree_node_alloc,                             19)     \
-       x(btree_node_free,                              20)     \
-       x(btree_node_set_root,                          21)     \
-       x(btree_path_relock_fail,                       22)     \
-       x(btree_path_upgrade_fail,                      23)     \
-       x(btree_reserve_get_fail,                       24)     \
-       x(journal_entry_full,                           25)     \
-       x(journal_full,                                 26)     \
-       x(journal_reclaim_finish,                       27)     \
-       x(journal_reclaim_start,                        28)     \
-       x(journal_write,                                29)     \
-       x(read_promote,                                 30)     \
-       x(read_bounce,                                  31)     \
-       x(read_split,                                   33)     \
-       x(read_retry,                                   32)     \
-       x(read_reuse_race,                              34)     \
-       x(move_extent_read,                             35)     \
-       x(move_extent_write,                            36)     \
-       x(move_extent_finish,                           37)     \
-       x(move_extent_fail,                             38)     \
-       x(move_extent_start_fail,                       39)     \
-       x(copygc,                                       40)     \
-       x(copygc_wait,                                  41)     \
-       x(gc_gens_end,                                  42)     \
-       x(gc_gens_start,                                43)     \
-       x(trans_blocked_journal_reclaim,                44)     \
-       x(trans_restart_btree_node_reused,              45)     \
-       x(trans_restart_btree_node_split,               46)     \
-       x(trans_restart_fault_inject,                   47)     \
-       x(trans_restart_iter_upgrade,                   48)     \
-       x(trans_restart_journal_preres_get,             49)     \
-       x(trans_restart_journal_reclaim,                50)     \
-       x(trans_restart_journal_res_get,                51)     \
-       x(trans_restart_key_cache_key_realloced,        52)     \
-       x(trans_restart_key_cache_raced,                53)     \
-       x(trans_restart_mark_replicas,                  54)     \
-       x(trans_restart_mem_realloced,                  55)     \
-       x(trans_restart_memory_allocation_failure,      56)     \
-       x(trans_restart_relock,                         57)     \
-       x(trans_restart_relock_after_fill,              58)     \
-       x(trans_restart_relock_key_cache_fill,          59)     \
-       x(trans_restart_relock_next_node,               60)     \
-       x(trans_restart_relock_parent_for_fill,         61)     \
-       x(trans_restart_relock_path,                    62)     \
-       x(trans_restart_relock_path_intent,             63)     \
-       x(trans_restart_too_many_iters,                 64)     \
-       x(trans_restart_traverse,                       65)     \
-       x(trans_restart_upgrade,                        66)     \
-       x(trans_restart_would_deadlock,                 67)     \
-       x(trans_restart_would_deadlock_write,           68)     \
-       x(trans_restart_injected,                       69)     \
-       x(trans_restart_key_cache_upgrade,              70)     \
-       x(trans_traverse_all,                           71)     \
-       x(transaction_commit,                           72)     \
-       x(write_super,                                  73)     \
-       x(trans_restart_would_deadlock_recursion_limit, 74)     \
-       x(trans_restart_write_buffer_flush,             75)     \
-       x(trans_restart_split_race,                     76)     \
-       x(write_buffer_flush_slowpath,                  77)     \
-       x(write_buffer_flush_sync,                      78)
+enum counters_flags {
+       TYPE_COUNTER    = BIT(0),       /* event counters */
+       TYPE_SECTORS    = BIT(1),       /* amount counters, the unit is sectors */
+};
+
+#define BCH_PERSISTENT_COUNTERS()                                      \
+       x(io_read,                                      0,      TYPE_SECTORS)   \
+       x(io_write,                                     1,      TYPE_SECTORS)   \
+       x(io_move,                                      2,      TYPE_SECTORS)   \
+       x(bucket_invalidate,                            3,      TYPE_COUNTER)   \
+       x(bucket_discard,                               4,      TYPE_COUNTER)   \
+       x(bucket_alloc,                                 5,      TYPE_COUNTER)   \
+       x(bucket_alloc_fail,                            6,      TYPE_COUNTER)   \
+       x(btree_cache_scan,                             7,      TYPE_COUNTER)   \
+       x(btree_cache_reap,                             8,      TYPE_COUNTER)   \
+       x(btree_cache_cannibalize,                      9,      TYPE_COUNTER)   \
+       x(btree_cache_cannibalize_lock,                 10,     TYPE_COUNTER)   \
+       x(btree_cache_cannibalize_lock_fail,            11,     TYPE_COUNTER)   \
+       x(btree_cache_cannibalize_unlock,               12,     TYPE_COUNTER)   \
+       x(btree_node_write,                             13,     TYPE_COUNTER)   \
+       x(btree_node_read,                              14,     TYPE_COUNTER)   \
+       x(btree_node_compact,                           15,     TYPE_COUNTER)   \
+       x(btree_node_merge,                             16,     TYPE_COUNTER)   \
+       x(btree_node_split,                             17,     TYPE_COUNTER)   \
+       x(btree_node_rewrite,                           18,     TYPE_COUNTER)   \
+       x(btree_node_alloc,                             19,     TYPE_COUNTER)   \
+       x(btree_node_free,                              20,     TYPE_COUNTER)   \
+       x(btree_node_set_root,                          21,     TYPE_COUNTER)   \
+       x(btree_path_relock_fail,                       22,     TYPE_COUNTER)   \
+       x(btree_path_upgrade_fail,                      23,     TYPE_COUNTER)   \
+       x(btree_reserve_get_fail,                       24,     TYPE_COUNTER)   \
+       x(journal_entry_full,                           25,     TYPE_COUNTER)   \
+       x(journal_full,                                 26,     TYPE_COUNTER)   \
+       x(journal_reclaim_finish,                       27,     TYPE_COUNTER)   \
+       x(journal_reclaim_start,                        28,     TYPE_COUNTER)   \
+       x(journal_write,                                29,     TYPE_COUNTER)   \
+       x(read_promote,                                 30,     TYPE_COUNTER)   \
+       x(read_bounce,                                  31,     TYPE_COUNTER)   \
+       x(read_split,                                   33,     TYPE_COUNTER)   \
+       x(read_retry,                                   32,     TYPE_COUNTER)   \
+       x(read_reuse_race,                              34,     TYPE_COUNTER)   \
+       x(move_extent_read,                             35,     TYPE_SECTORS)   \
+       x(move_extent_write,                            36,     TYPE_SECTORS)   \
+       x(move_extent_finish,                           37,     TYPE_SECTORS)   \
+       x(move_extent_fail,                             38,     TYPE_COUNTER)   \
+       x(move_extent_start_fail,                       39,     TYPE_COUNTER)   \
+       x(copygc,                                       40,     TYPE_COUNTER)   \
+       x(copygc_wait,                                  41,     TYPE_COUNTER)   \
+       x(gc_gens_end,                                  42,     TYPE_COUNTER)   \
+       x(gc_gens_start,                                43,     TYPE_COUNTER)   \
+       x(trans_blocked_journal_reclaim,                44,     TYPE_COUNTER)   \
+       x(trans_restart_btree_node_reused,              45,     TYPE_COUNTER)   \
+       x(trans_restart_btree_node_split,               46,     TYPE_COUNTER)   \
+       x(trans_restart_fault_inject,                   47,     TYPE_COUNTER)   \
+       x(trans_restart_iter_upgrade,                   48,     TYPE_COUNTER)   \
+       x(trans_restart_journal_preres_get,             49,     TYPE_COUNTER)   \
+       x(trans_restart_journal_reclaim,                50,     TYPE_COUNTER)   \
+       x(trans_restart_journal_res_get,                51,     TYPE_COUNTER)   \
+       x(trans_restart_key_cache_key_realloced,        52,     TYPE_COUNTER)   \
+       x(trans_restart_key_cache_raced,                53,     TYPE_COUNTER)   \
+       x(trans_restart_mark_replicas,                  54,     TYPE_COUNTER)   \
+       x(trans_restart_mem_realloced,                  55,     TYPE_COUNTER)   \
+       x(trans_restart_memory_allocation_failure,      56,     TYPE_COUNTER)   \
+       x(trans_restart_relock,                         57,     TYPE_COUNTER)   \
+       x(trans_restart_relock_after_fill,              58,     TYPE_COUNTER)   \
+       x(trans_restart_relock_key_cache_fill,          59,     TYPE_COUNTER)   \
+       x(trans_restart_relock_next_node,               60,     TYPE_COUNTER)   \
+       x(trans_restart_relock_parent_for_fill,         61,     TYPE_COUNTER)   \
+       x(trans_restart_relock_path,                    62,     TYPE_COUNTER)   \
+       x(trans_restart_relock_path_intent,             63,     TYPE_COUNTER)   \
+       x(trans_restart_too_many_iters,                 64,     TYPE_COUNTER)   \
+       x(trans_restart_traverse,                       65,     TYPE_COUNTER)   \
+       x(trans_restart_upgrade,                        66,     TYPE_COUNTER)   \
+       x(trans_restart_would_deadlock,                 67,     TYPE_COUNTER)   \
+       x(trans_restart_would_deadlock_write,           68,     TYPE_COUNTER)   \
+       x(trans_restart_injected,                       69,     TYPE_COUNTER)   \
+       x(trans_restart_key_cache_upgrade,              70,     TYPE_COUNTER)   \
+       x(trans_traverse_all,                           71,     TYPE_COUNTER)   \
+       x(transaction_commit,                           72,     TYPE_COUNTER)   \
+       x(write_super,                                  73,     TYPE_COUNTER)   \
+       x(trans_restart_would_deadlock_recursion_limit, 74,     TYPE_COUNTER)   \
+       x(trans_restart_write_buffer_flush,             75,     TYPE_COUNTER)   \
+       x(trans_restart_split_race,                     76,     TYPE_COUNTER)   \
+       x(write_buffer_flush_slowpath,                  77,     TYPE_COUNTER)   \
+       x(write_buffer_flush_sync,                      78,     TYPE_COUNTER)
 
 enum bch_persistent_counters {
 #define x(t, n, ...) BCH_COUNTER_##t,
diff --git a/fs/bcachefs/sysfs.c b/fs/bcachefs/sysfs.c
index 48bc6ad03f0932f11cdf1b7c1e3c7dc8fe898699..a7eb1f5114847c87146f94c6d19fdfa1d543a1dc 100644 (file)
--- a/fs/bcachefs/sysfs.c
+++ b/fs/bcachefs/sysfs.c
@@ -505,15 +505,22 @@ SHOW(bch2_fs_counters)
 
        printbuf_tabstop_push(out, 32);
 
-       #define x(t, ...) \
+       #define x(t, n, f, ...) \
                if (attr == &sysfs_##t) {                                       \
                        counter             = percpu_u64_get(&c->counters[BCH_COUNTER_##t]);\
                        counter_since_mount = counter - c->counters_on_mount[BCH_COUNTER_##t];\
+                       if (f & TYPE_SECTORS) {                                 \
+                               counter <<= 9;                                  \
+                               counter_since_mount <<= 9;                      \
+                       }                                                       \
+                                                                               \
                        prt_printf(out, "since mount:\t");                      \
+                       (f & TYPE_COUNTER) ? prt_u64(out, counter_since_mount) :\
                        prt_human_readable_u64(out, counter_since_mount);       \
                        prt_newline(out);                                       \
                                                                                \
                        prt_printf(out, "since filesystem creation:\t");        \
+                       (f & TYPE_COUNTER) ? prt_u64(out, counter) :            \
                        prt_human_readable_u64(out, counter);                   \
                        prt_newline(out);                                       \
                }
Linux 6.x block layer and io_uring tree(s)