bcachefs: More enum strings

This patch converts more enums in the on disk format to our standard
x-macro-with-strings deal - to enable better pretty-printing.

Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>

diff --git a/fs/bcachefs/bcachefs_format.h b/fs/bcachefs/bcachefs_format.h
index 21f1948ef8d029b10e1ae8a918b786f670c58fda..7c28467912863bf84af21df732c3a287d3b2690b 100644 (file)
--- a/fs/bcachefs/bcachefs_format.h
+++ b/fs/bcachefs/bcachefs_format.h
@@ -1447,7 +1447,7 @@ LE64_BITMASK(BCH_SB_INODES_USE_KEY_CACHE,struct bch_sb, flags[3], 29, 30);
  * journal_seq_blacklist_v3:   gates BCH_SB_FIELD_journal_seq_blacklist
  * reflink:                    gates KEY_TYPE_reflink
  * inline_data:                        gates KEY_TYPE_inline_data
- * new_siphash:                        gates BCH_STR_HASH_SIPHASH
+ * new_siphash:                        gates BCH_STR_HASH_siphash
  * new_extent_overwrite:       gates BTREE_NODE_NEW_EXTENT_OVERWRITE
  */
 #define BCH_SB_FEATURES()                      \
@@ -1523,12 +1523,17 @@ enum bch_error_actions {
        BCH_ON_ERROR_NR
 };
 
+#define BCH_STR_HASH_TYPES()           \
+       x(crc32c,               0)      \
+       x(crc64,                1)      \
+       x(siphash_old,          2)      \
+       x(siphash,              3)
+
 enum bch_str_hash_type {
-       BCH_STR_HASH_CRC32C             = 0,
-       BCH_STR_HASH_CRC64              = 1,
-       BCH_STR_HASH_SIPHASH_OLD        = 2,
-       BCH_STR_HASH_SIPHASH            = 3,
-       BCH_STR_HASH_NR                 = 4,
+#define x(t, n) BCH_STR_HASH_##t = n,
+       BCH_STR_HASH_TYPES()
+#undef x
+       BCH_STR_HASH_NR
 };
 
 #define BCH_STR_HASH_OPTS()            \
@@ -1543,34 +1548,39 @@ enum bch_str_hash_opts {
        BCH_STR_HASH_OPT_NR
 };
 
+#define BCH_CSUM_TYPES()                       \
+       x(none,                         0)      \
+       x(crc32c_nonzero,               1)      \
+       x(crc64_nonzero,                2)      \
+       x(chacha20_poly1305_80,         3)      \
+       x(chacha20_poly1305_128,        4)      \
+       x(crc32c,                       5)      \
+       x(crc64,                        6)      \
+       x(xxhash,                       7)
+
 enum bch_csum_type {
-       BCH_CSUM_NONE                   = 0,
-       BCH_CSUM_CRC32C_NONZERO         = 1,
-       BCH_CSUM_CRC64_NONZERO          = 2,
-       BCH_CSUM_CHACHA20_POLY1305_80   = 3,
-       BCH_CSUM_CHACHA20_POLY1305_128  = 4,
-       BCH_CSUM_CRC32C                 = 5,
-       BCH_CSUM_CRC64                  = 6,
-       BCH_CSUM_XXHASH                 = 7,
-       BCH_CSUM_NR                     = 8,
+#define x(t, n) BCH_CSUM_##t = n,
+       BCH_CSUM_TYPES()
+#undef x
+       BCH_CSUM_NR
 };
 
 static const unsigned bch_crc_bytes[] = {
-       [BCH_CSUM_NONE]                         = 0,
-       [BCH_CSUM_CRC32C_NONZERO]               = 4,
-       [BCH_CSUM_CRC32C]                       = 4,
-       [BCH_CSUM_CRC64_NONZERO]                = 8,
-       [BCH_CSUM_CRC64]                        = 8,
-       [BCH_CSUM_XXHASH]                       = 8,
-       [BCH_CSUM_CHACHA20_POLY1305_80]         = 10,
-       [BCH_CSUM_CHACHA20_POLY1305_128]        = 16,
+       [BCH_CSUM_none]                         = 0,
+       [BCH_CSUM_crc32c_nonzero]               = 4,
+       [BCH_CSUM_crc32c]                       = 4,
+       [BCH_CSUM_crc64_nonzero]                = 8,
+       [BCH_CSUM_crc64]                        = 8,
+       [BCH_CSUM_xxhash]                       = 8,
+       [BCH_CSUM_chacha20_poly1305_80]         = 10,
+       [BCH_CSUM_chacha20_poly1305_128]        = 16,
 };
 
 static inline _Bool bch2_csum_type_is_encryption(enum bch_csum_type type)
 {
        switch (type) {
-       case BCH_CSUM_CHACHA20_POLY1305_80:
-       case BCH_CSUM_CHACHA20_POLY1305_128:
+       case BCH_CSUM_chacha20_poly1305_80:
+       case BCH_CSUM_chacha20_poly1305_128:
                return true;
        default:
                return false;

diff --git a/fs/bcachefs/checksum.c b/fs/bcachefs/checksum.c
index d20924e579bffd9d3b34b1dee7e35857eb22d346..fbe8603cfb3060eeeb7e29f5b5c64916ce381983 100644 (file)
--- a/fs/bcachefs/checksum.c
+++ b/fs/bcachefs/checksum.c
@@ -35,18 +35,18 @@ struct bch2_checksum_state {
 static void bch2_checksum_init(struct bch2_checksum_state *state)
 {
        switch (state->type) {
-       case BCH_CSUM_NONE:
-       case BCH_CSUM_CRC32C:
-       case BCH_CSUM_CRC64:
+       case BCH_CSUM_none:
+       case BCH_CSUM_crc32c:
+       case BCH_CSUM_crc64:
                state->seed = 0;
                break;
-       case BCH_CSUM_CRC32C_NONZERO:
+       case BCH_CSUM_crc32c_nonzero:
                state->seed = U32_MAX;
                break;
-       case BCH_CSUM_CRC64_NONZERO:
+       case BCH_CSUM_crc64_nonzero:
                state->seed = U64_MAX;
                break;
-       case BCH_CSUM_XXHASH:
+       case BCH_CSUM_xxhash:
                xxh64_reset(&state->h64state, 0);
                break;
        default:
@@ -57,15 +57,15 @@ static void bch2_checksum_init(struct bch2_checksum_state *state)
 static u64 bch2_checksum_final(const struct bch2_checksum_state *state)
 {
        switch (state->type) {
-       case BCH_CSUM_NONE:
-       case BCH_CSUM_CRC32C:
-       case BCH_CSUM_CRC64:
+       case BCH_CSUM_none:
+       case BCH_CSUM_crc32c:
+       case BCH_CSUM_crc64:
                return state->seed;
-       case BCH_CSUM_CRC32C_NONZERO:
+       case BCH_CSUM_crc32c_nonzero:
                return state->seed ^ U32_MAX;
-       case BCH_CSUM_CRC64_NONZERO:
+       case BCH_CSUM_crc64_nonzero:
                return state->seed ^ U64_MAX;
-       case BCH_CSUM_XXHASH:
+       case BCH_CSUM_xxhash:
                return xxh64_digest(&state->h64state);
        default:
                BUG();
@@ -75,17 +75,17 @@ static u64 bch2_checksum_final(const struct bch2_checksum_state *state)
 static void bch2_checksum_update(struct bch2_checksum_state *state, const void *data, size_t len)
 {
        switch (state->type) {
-       case BCH_CSUM_NONE:
+       case BCH_CSUM_none:
                return;
-       case BCH_CSUM_CRC32C_NONZERO:
-       case BCH_CSUM_CRC32C:
+       case BCH_CSUM_crc32c_nonzero:
+       case BCH_CSUM_crc32c:
                state->seed = crc32c(state->seed, data, len);
                break;
-       case BCH_CSUM_CRC64_NONZERO:
-       case BCH_CSUM_CRC64:
+       case BCH_CSUM_crc64_nonzero:
+       case BCH_CSUM_crc64:
                state->seed = crc64_be(state->seed, data, len);
                break;
-       case BCH_CSUM_XXHASH:
+       case BCH_CSUM_xxhash:
                xxh64_update(&state->h64state, data, len);
                break;
        default:
@@ -161,12 +161,12 @@ struct bch_csum bch2_checksum(struct bch_fs *c, unsigned type,
                              struct nonce nonce, const void *data, size_t len)
 {
        switch (type) {
-       case BCH_CSUM_NONE:
-       case BCH_CSUM_CRC32C_NONZERO:
-       case BCH_CSUM_CRC64_NONZERO:
-       case BCH_CSUM_CRC32C:
-       case BCH_CSUM_XXHASH:
-       case BCH_CSUM_CRC64: {
+       case BCH_CSUM_none:
+       case BCH_CSUM_crc32c_nonzero:
+       case BCH_CSUM_crc64_nonzero:
+       case BCH_CSUM_crc32c:
+       case BCH_CSUM_xxhash:
+       case BCH_CSUM_crc64: {
                struct bch2_checksum_state state;
 
                state.type = type;
@@ -177,8 +177,8 @@ struct bch_csum bch2_checksum(struct bch_fs *c, unsigned type,
                return (struct bch_csum) { .lo = cpu_to_le64(bch2_checksum_final(&state)) };
        }
 
-       case BCH_CSUM_CHACHA20_POLY1305_80:
-       case BCH_CSUM_CHACHA20_POLY1305_128: {
+       case BCH_CSUM_chacha20_poly1305_80:
+       case BCH_CSUM_chacha20_poly1305_128: {
                SHASH_DESC_ON_STACK(desc, c->poly1305);
                u8 digest[POLY1305_DIGEST_SIZE];
                struct bch_csum ret = { 0 };
@@ -212,13 +212,13 @@ static struct bch_csum __bch2_checksum_bio(struct bch_fs *c, unsigned type,
        struct bio_vec bv;
 
        switch (type) {
-       case BCH_CSUM_NONE:
+       case BCH_CSUM_none:
                return (struct bch_csum) { 0 };
-       case BCH_CSUM_CRC32C_NONZERO:
-       case BCH_CSUM_CRC64_NONZERO:
-       case BCH_CSUM_CRC32C:
-       case BCH_CSUM_XXHASH:
-       case BCH_CSUM_CRC64: {
+       case BCH_CSUM_crc32c_nonzero:
+       case BCH_CSUM_crc64_nonzero:
+       case BCH_CSUM_crc32c:
+       case BCH_CSUM_xxhash:
+       case BCH_CSUM_crc64: {
                struct bch2_checksum_state state;
 
                state.type = type;
@@ -238,8 +238,8 @@ static struct bch_csum __bch2_checksum_bio(struct bch_fs *c, unsigned type,
                return (struct bch_csum) { .lo = cpu_to_le64(bch2_checksum_final(&state)) };
        }
 
-       case BCH_CSUM_CHACHA20_POLY1305_80:
-       case BCH_CSUM_CHACHA20_POLY1305_128: {
+       case BCH_CSUM_chacha20_poly1305_80:
+       case BCH_CSUM_chacha20_poly1305_128: {
                SHASH_DESC_ON_STACK(desc, c->poly1305);
                u8 digest[POLY1305_DIGEST_SIZE];
                struct bch_csum ret = { 0 };

diff --git a/fs/bcachefs/checksum.h b/fs/bcachefs/checksum.h
index 6841fb16568a652779be0ed795768b5d5d8c79e9..f5c1a609c5c42fe408a5896498c1aeed748679ff 100644 (file)
--- a/fs/bcachefs/checksum.h
+++ b/fs/bcachefs/checksum.h
@@ -13,9 +13,9 @@ static inline bool bch2_checksum_mergeable(unsigned type)
 {
 
        switch (type) {
-       case BCH_CSUM_NONE:
-       case BCH_CSUM_CRC32C:
-       case BCH_CSUM_CRC64:
+       case BCH_CSUM_none:
+       case BCH_CSUM_crc32c:
+       case BCH_CSUM_crc64:
                return true;
        default:
                return false;
@@ -78,13 +78,13 @@ static inline enum bch_csum_type bch2_csum_opt_to_type(enum bch_csum_opts type,
 {
        switch (type) {
        case BCH_CSUM_OPT_none:
-            return BCH_CSUM_NONE;
+            return BCH_CSUM_none;
        case BCH_CSUM_OPT_crc32c:
-            return data ? BCH_CSUM_CRC32C : BCH_CSUM_CRC32C_NONZERO;
+            return data ? BCH_CSUM_crc32c : BCH_CSUM_crc32c_nonzero;
        case BCH_CSUM_OPT_crc64:
-            return data ? BCH_CSUM_CRC64 : BCH_CSUM_CRC64_NONZERO;
+            return data ? BCH_CSUM_crc64 : BCH_CSUM_crc64_nonzero;
        case BCH_CSUM_OPT_xxhash:
-            return BCH_CSUM_XXHASH;
+            return BCH_CSUM_xxhash;
        default:
             BUG();
        }
@@ -95,8 +95,8 @@ static inline enum bch_csum_type bch2_data_checksum_type(struct bch_fs *c,
 {
        if (c->sb.encryption_type)
                return c->opts.wide_macs
-                       ? BCH_CSUM_CHACHA20_POLY1305_128
-                       : BCH_CSUM_CHACHA20_POLY1305_80;
+                       ? BCH_CSUM_chacha20_poly1305_128
+                       : BCH_CSUM_chacha20_poly1305_80;
 
        return bch2_csum_opt_to_type(opt, true);
 }
@@ -104,7 +104,7 @@ static inline enum bch_csum_type bch2_data_checksum_type(struct bch_fs *c,
 static inline enum bch_csum_type bch2_meta_checksum_type(struct bch_fs *c)
 {
        if (c->sb.encryption_type)
-               return BCH_CSUM_CHACHA20_POLY1305_128;
+               return BCH_CSUM_chacha20_poly1305_128;
 
        return bch2_csum_opt_to_type(c->opts.metadata_checksum, false);
 }

diff --git a/fs/bcachefs/ec.c b/fs/bcachefs/ec.c
index 32b17f05a750925c80bfd80d31a840992feca8f6..bc8bb963ae43ed0dc9991486e0e0bae069f12261 100644 (file)
--- a/fs/bcachefs/ec.c
+++ b/fs/bcachefs/ec.c
@@ -1154,7 +1154,7 @@ static void ec_stripe_key_init(struct bch_fs *c,
        s->v.nr_blocks                  = nr_data + nr_parity;
        s->v.nr_redundant               = nr_parity;
        s->v.csum_granularity_bits      = ilog2(c->sb.encoded_extent_max);
-       s->v.csum_type                  = BCH_CSUM_CRC32C;
+       s->v.csum_type                  = BCH_CSUM_crc32c;
        s->v.pad                        = 0;
 
        while ((u64s = stripe_val_u64s(&s->v)) > BKEY_VAL_U64s_MAX) {

diff --git a/fs/bcachefs/extents.c b/fs/bcachefs/extents.c
index 7f1a5c81ef0986e8dec79696834988f67d3514dd..8592a0f6327eb8dcaf84d9a12cefbdec79b8be35 100644 (file)
--- a/fs/bcachefs/extents.c
+++ b/fs/bcachefs/extents.c
@@ -968,12 +968,12 @@ void bch2_bkey_ptrs_to_text(struct printbuf *out, struct bch_fs *c,
                case BCH_EXTENT_ENTRY_crc128:
                        crc = bch2_extent_crc_unpack(k.k, entry_to_crc(entry));
 
-                       pr_buf(out, "crc: c_size %u size %u offset %u nonce %u csum %u compress %u",
+                       pr_buf(out, "crc: c_size %u size %u offset %u nonce %u csum %s compress %s",
                               crc.compressed_size,
                               crc.uncompressed_size,
                               crc.offset, crc.nonce,
-                              crc.csum_type,
-                              crc.compression_type);
+                              bch2_csum_types[crc.csum_type],
+                              bch2_compression_types[crc.compression_type]);
                        break;
                case BCH_EXTENT_ENTRY_stripe_ptr:
                        ec = &entry->stripe_ptr;

diff --git a/fs/bcachefs/io.c b/fs/bcachefs/io.c
index 3acd357919a2a654ef9f819874c295cad2020e44..c5bd17f913f24a438074f465f6aba94aeefe0819 100644 (file)
--- a/fs/bcachefs/io.c
+++ b/fs/bcachefs/io.c
@@ -2104,7 +2104,7 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig,
        EBUG_ON(offset_into_extent + bvec_iter_sectors(iter) > k.k->size);
 
        if (crc_is_compressed(pick.crc) ||
-           (pick.crc.csum_type != BCH_CSUM_NONE &&
+           (pick.crc.csum_type != BCH_CSUM_none &&
             (bvec_iter_sectors(iter) != pick.crc.uncompressed_size ||
              (bch2_csum_type_is_encryption(pick.crc.csum_type) &&
               (flags & BCH_READ_USER_MAPPED)) ||

diff --git a/fs/bcachefs/opts.c b/fs/bcachefs/opts.c
index ff99c6d24abdd6fb7a54011085ddf962bc03b190..a955ef2008c935c019f30784dab9e849763b36a7 100644 (file)
--- a/fs/bcachefs/opts.c
+++ b/fs/bcachefs/opts.c
@@ -31,17 +31,32 @@ const char * const bch2_btree_ids[] = {
        NULL
 };
 
+const char * const bch2_csum_types[] = {
+       BCH_CSUM_TYPES()
+       NULL
+};
+
 const char * const bch2_csum_opts[] = {
        BCH_CSUM_OPTS()
        NULL
 };
 
+const char * const bch2_compression_types[] = {
+       BCH_COMPRESSION_TYPES()
+       NULL
+};
+
 const char * const bch2_compression_opts[] = {
        BCH_COMPRESSION_OPTS()
        NULL
 };
 
 const char * const bch2_str_hash_types[] = {
+       BCH_STR_HASH_TYPES()
+       NULL
+};
+
+const char * const bch2_str_hash_opts[] = {
        BCH_STR_HASH_OPTS()
        NULL
 };

diff --git a/fs/bcachefs/opts.h b/fs/bcachefs/opts.h
index 4e59bff095783b847c0b7e044c2fccf1cb446b40..10c022ec6ee0fb00ea7ebb796cc9bdbf73eb9ccf 100644 (file)
--- a/fs/bcachefs/opts.h
+++ b/fs/bcachefs/opts.h
@@ -12,9 +12,12 @@ extern const char * const bch2_error_actions[];
 extern const char * const bch2_sb_features[];
 extern const char * const bch2_sb_compat[];
 extern const char * const bch2_btree_ids[];
+extern const char * const bch2_csum_types[];
 extern const char * const bch2_csum_opts[];
+extern const char * const bch2_compression_types[];
 extern const char * const bch2_compression_opts[];
 extern const char * const bch2_str_hash_types[];
+extern const char * const bch2_str_hash_opts[];
 extern const char * const bch2_data_types[];
 extern const char * const bch2_cache_replacement_policies[];
 extern const char * const bch2_member_states[];
@@ -140,7 +143,7 @@ enum opt_type {
          NULL,         NULL)                                           \
        x(str_hash,                     u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,                             \
-         OPT_STR(bch2_str_hash_types),                                 \
+         OPT_STR(bch2_str_hash_opts),                                  \
          BCH_SB_STR_HASH_TYPE,         BCH_STR_HASH_OPT_siphash,       \
          NULL,         "Hash function for directory entries and xattrs")\
        x(metadata_target,              u16,                            \

diff --git a/fs/bcachefs/str_hash.h b/fs/bcachefs/str_hash.h
index 789dde7c6ac68069c78ba9432f709523efbc9383..57d636740d2f81ffa8a19adf9dd3d3f036746a65 100644 (file)
--- a/fs/bcachefs/str_hash.h
+++ b/fs/bcachefs/str_hash.h
@@ -20,13 +20,13 @@ bch2_str_hash_opt_to_type(struct bch_fs *c, enum bch_str_hash_opts opt)
 {
        switch (opt) {
        case BCH_STR_HASH_OPT_crc32c:
-               return BCH_STR_HASH_CRC32C;
+               return BCH_STR_HASH_crc32c;
        case BCH_STR_HASH_OPT_crc64:
-               return BCH_STR_HASH_CRC64;
+               return BCH_STR_HASH_crc64;
        case BCH_STR_HASH_OPT_siphash:
                return c->sb.features & (1ULL << BCH_FEATURE_new_siphash)
-                       ? BCH_STR_HASH_SIPHASH
-                       : BCH_STR_HASH_SIPHASH_OLD;
+                       ? BCH_STR_HASH_siphash
+                       : BCH_STR_HASH_siphash_old;
        default:
             BUG();
        }
@@ -51,7 +51,7 @@ bch2_hash_info_init(struct bch_fs *c, const struct bch_inode_unpacked *bi)
                .siphash_key = { .k0 = bi->bi_hash_seed }
        };
 
-       if (unlikely(info.type == BCH_STR_HASH_SIPHASH_OLD)) {
+       if (unlikely(info.type == BCH_STR_HASH_siphash_old)) {
                SHASH_DESC_ON_STACK(desc, c->sha256);
                u8 digest[SHA256_DIGEST_SIZE];
 
@@ -77,16 +77,16 @@ static inline void bch2_str_hash_init(struct bch_str_hash_ctx *ctx,
                                     const struct bch_hash_info *info)
 {
        switch (info->type) {
-       case BCH_STR_HASH_CRC32C:
+       case BCH_STR_HASH_crc32c:
                ctx->crc32c = crc32c(~0, &info->siphash_key.k0,
                                     sizeof(info->siphash_key.k0));
                break;
-       case BCH_STR_HASH_CRC64:
+       case BCH_STR_HASH_crc64:
                ctx->crc64 = crc64_be(~0, &info->siphash_key.k0,
                                      sizeof(info->siphash_key.k0));
                break;
-       case BCH_STR_HASH_SIPHASH_OLD:
-       case BCH_STR_HASH_SIPHASH:
+       case BCH_STR_HASH_siphash_old:
+       case BCH_STR_HASH_siphash:
                SipHash24_Init(&ctx->siphash, &info->siphash_key);
                break;
        default:
@@ -99,14 +99,14 @@ static inline void bch2_str_hash_update(struct bch_str_hash_ctx *ctx,
                                       const void *data, size_t len)
 {
        switch (info->type) {
-       case BCH_STR_HASH_CRC32C:
+       case BCH_STR_HASH_crc32c:
                ctx->crc32c = crc32c(ctx->crc32c, data, len);
                break;
-       case BCH_STR_HASH_CRC64:
+       case BCH_STR_HASH_crc64:
                ctx->crc64 = crc64_be(ctx->crc64, data, len);
                break;
-       case BCH_STR_HASH_SIPHASH_OLD:
-       case BCH_STR_HASH_SIPHASH:
+       case BCH_STR_HASH_siphash_old:
+       case BCH_STR_HASH_siphash:
                SipHash24_Update(&ctx->siphash, data, len);
                break;
        default:
@@ -118,12 +118,12 @@ static inline u64 bch2_str_hash_end(struct bch_str_hash_ctx *ctx,
                                   const struct bch_hash_info *info)
 {
        switch (info->type) {
-       case BCH_STR_HASH_CRC32C:
+       case BCH_STR_HASH_crc32c:
                return ctx->crc32c;
-       case BCH_STR_HASH_CRC64:
+       case BCH_STR_HASH_crc64:
                return ctx->crc64 >> 1;
-       case BCH_STR_HASH_SIPHASH_OLD:
-       case BCH_STR_HASH_SIPHASH:
+       case BCH_STR_HASH_siphash_old:
+       case BCH_STR_HASH_siphash:
                return SipHash24_End(&ctx->siphash) >> 1;
        default:
                BUG();