bcachefs: Improve sysfs compression_stats

Break it out by compression type, and include average extent size.

Also, format into a nice table.

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

diff --git a/fs/bcachefs/sysfs.c b/fs/bcachefs/sysfs.c
index 0aa0978929380f8647a0d892112195c269535984..67739a116c6cfc1535ca9778a29cebc3574efdfd 100644 (file)
--- a/fs/bcachefs/sysfs.c
+++ b/fs/bcachefs/sysfs.c
@@ -258,15 +258,16 @@ static int bch2_compression_stats_to_text(struct printbuf *out, struct bch_fs *c
        struct btree_iter iter;
        struct bkey_s_c k;
        enum btree_id id;
-       u64 nr_uncompressed_extents = 0,
-           nr_compressed_extents = 0,
-           nr_incompressible_extents = 0,
-           uncompressed_sectors = 0,
-           incompressible_sectors = 0,
-           compressed_sectors_compressed = 0,
-           compressed_sectors_uncompressed = 0;
+       struct compression_type_stats {
+               u64             nr_extents;
+               u64             sectors_compressed;
+               u64             sectors_uncompressed;
+       } s[BCH_COMPRESSION_TYPE_NR];
+       u64 compressed_incompressible = 0;
        int ret = 0;
 
+       memset(s, 0, sizeof(s));
+
        if (!test_bit(BCH_FS_STARTED, &c->flags))
                return -EPERM;
 
@@ -279,36 +280,30 @@ static int bch2_compression_stats_to_text(struct printbuf *out, struct bch_fs *c
                ret = for_each_btree_key2(trans, iter, id, POS_MIN,
                                          BTREE_ITER_ALL_SNAPSHOTS, k, ({
                        struct bkey_ptrs_c ptrs = bch2_bkey_ptrs_c(k);
+                       struct bch_extent_crc_unpacked crc;
                        const union bch_extent_entry *entry;
-                       struct extent_ptr_decoded p;
-                       bool compressed = false, uncompressed = false, incompressible = false;
-
-                       bkey_for_each_ptr_decode(k.k, ptrs, p, entry) {
-                               switch (p.crc.compression_type) {
-                               case BCH_COMPRESSION_TYPE_none:
-                                       uncompressed = true;
-                                       uncompressed_sectors += k.k->size;
-                                       break;
-                               case BCH_COMPRESSION_TYPE_incompressible:
-                                       incompressible = true;
-                                       incompressible_sectors += k.k->size;
-                                       break;
-                               default:
-                                       compressed_sectors_compressed +=
-                                               p.crc.compressed_size;
-                                       compressed_sectors_uncompressed +=
-                                               p.crc.uncompressed_size;
-                                       compressed = true;
-                                       break;
+                       bool compressed = false, incompressible = false;
+
+                       bkey_for_each_crc(k.k, ptrs, crc, entry) {
+                               incompressible  |= crc.compression_type == BCH_COMPRESSION_TYPE_incompressible;
+                               compressed      |= crc_is_compressed(crc);
+
+                               if (crc_is_compressed(crc)) {
+                                       s[crc.compression_type].nr_extents++;
+                                       s[crc.compression_type].sectors_compressed += crc.compressed_size;
+                                       s[crc.compression_type].sectors_uncompressed += crc.uncompressed_size;
                                }
                        }
 
-                       if (incompressible)
-                               nr_incompressible_extents++;
-                       else if (uncompressed)
-                               nr_uncompressed_extents++;
-                       else if (compressed)
-                               nr_compressed_extents++;
+                       compressed_incompressible += compressed && incompressible;
+
+                       if (!compressed) {
+                               unsigned t = incompressible ? BCH_COMPRESSION_TYPE_incompressible : 0;
+
+                               s[t].nr_extents++;
+                               s[t].sectors_compressed += k.k->size;
+                               s[t].sectors_uncompressed += k.k->size;
+                       }
                        0;
                }));
        }
@@ -318,26 +313,45 @@ static int bch2_compression_stats_to_text(struct printbuf *out, struct bch_fs *c
        if (ret)
                return ret;
 
-       prt_printf(out, "uncompressed:\n");
-       prt_printf(out, "       nr extents:             %llu\n", nr_uncompressed_extents);
-       prt_printf(out, "       size:                   ");
-       prt_human_readable_u64(out, uncompressed_sectors << 9);
-       prt_printf(out, "\n");
+       prt_str(out, "type");
+       printbuf_tabstop_push(out, 12);
+       prt_tab(out);
 
-       prt_printf(out, "compressed:\n");
-       prt_printf(out, "       nr extents:             %llu\n", nr_compressed_extents);
-       prt_printf(out, "       compressed size:        ");
-       prt_human_readable_u64(out, compressed_sectors_compressed << 9);
-       prt_printf(out, "\n");
-       prt_printf(out, "       uncompressed size:      ");
-       prt_human_readable_u64(out, compressed_sectors_uncompressed << 9);
-       prt_printf(out, "\n");
+       prt_str(out, "compressed");
+       printbuf_tabstop_push(out, 16);
+       prt_tab_rjust(out);
+
+       prt_str(out, "uncompressed");
+       printbuf_tabstop_push(out, 16);
+       prt_tab_rjust(out);
+
+       prt_str(out, "average extent size");
+       printbuf_tabstop_push(out, 24);
+       prt_tab_rjust(out);
+       prt_newline(out);
+
+       for (unsigned i = 0; i < ARRAY_SIZE(s); i++) {
+               prt_str(out, bch2_compression_types[i]);
+               prt_tab(out);
+
+               prt_human_readable_u64(out, s[i].sectors_compressed << 9);
+               prt_tab_rjust(out);
+
+               prt_human_readable_u64(out, s[i].sectors_uncompressed << 9);
+               prt_tab_rjust(out);
+
+               prt_human_readable_u64(out, s[i].nr_extents
+                                      ? div_u64(s[i].sectors_uncompressed << 9, s[i].nr_extents)
+                                      : 0);
+               prt_tab_rjust(out);
+               prt_newline(out);
+       }
+
+       if (compressed_incompressible) {
+               prt_printf(out, "%llu compressed & incompressible extents", compressed_incompressible);
+               prt_newline(out);
+       }
 
-       prt_printf(out, "incompressible:\n");
-       prt_printf(out, "       nr extents:             %llu\n", nr_incompressible_extents);
-       prt_printf(out, "       size:                   ");
-       prt_human_readable_u64(out, incompressible_sectors << 9);
-       prt_printf(out, "\n");
        return 0;
 }