Update bcachefs sources to 86a99a7b7f bcachefs: Convert some enums to x-macros

diff --git a/.bcachefs_revision b/.bcachefs_revision
index 2dbaaff95539a52c41ebfcf5b3f415f2e237c995..1499cab000dbdde79608eb1744ec447688133273 100644 (file)
--- a/.bcachefs_revision
+++ b/.bcachefs_revision
@@ -1 +1 @@
-cfb41d25c7a20e4c9b67a8d87f88b659412d5f3f
+86a99a7b7fe71ba1d293ad7a9fb09903e8429ae5

diff --git a/libbcachefs.c b/libbcachefs.c
index 8f656a276c1dcf4d5551389ad5ea2e60f88d19da..3cf7827ee28aad7e87aad475c0eeeb6a8be4f99c 100644 (file)
--- a/libbcachefs.c
+++ b/libbcachefs.c
@@ -241,8 +241,6 @@ struct bch_sb *bch2_format(struct bch_opt_strs      fs_opt_strs,
        sb.sb->time_base_lo     = cpu_to_le64(now.tv_sec * NSEC_PER_SEC + now.tv_nsec);
        sb.sb->time_precision   = cpu_to_le32(1);
 
-       sb.sb->features[0] |= 1ULL << BCH_FEATURE_NEW_SIPHASH;
-
        /* Member info: */
        mi = bch2_sb_resize_members(&sb,
                        (sizeof(*mi) + sizeof(struct bch_member) *
@@ -756,17 +754,17 @@ void bch2_sb_print(struct bch_sb *sb, bool print_layout,
               BCH_SB_DATA_REPLICAS_WANT(sb),
 
               BCH_SB_META_CSUM_TYPE(sb) < BCH_CSUM_OPT_NR
-              ? bch2_csum_types[BCH_SB_META_CSUM_TYPE(sb)]
+              ? bch2_csum_opts[BCH_SB_META_CSUM_TYPE(sb)]
               : "unknown",
               BCH_SB_META_CSUM_TYPE(sb),
 
               BCH_SB_DATA_CSUM_TYPE(sb) < BCH_CSUM_OPT_NR
-              ? bch2_csum_types[BCH_SB_DATA_CSUM_TYPE(sb)]
+              ? bch2_csum_opts[BCH_SB_DATA_CSUM_TYPE(sb)]
               : "unknown",
               BCH_SB_DATA_CSUM_TYPE(sb),
 
               BCH_SB_COMPRESSION_TYPE(sb) < BCH_COMPRESSION_OPT_NR
-              ? bch2_compression_types[BCH_SB_COMPRESSION_TYPE(sb)]
+              ? bch2_compression_opts[BCH_SB_COMPRESSION_TYPE(sb)]
               : "unknown",
               BCH_SB_COMPRESSION_TYPE(sb),
 

diff --git a/libbcachefs/bcachefs.h b/libbcachefs/bcachefs.h
index 9b186872c129abe98c83f45d241d5074a45c85c4..6ea26ae5c3b829aca48e0b1f8c1814ca7ca9ce0e 100644 (file)
--- a/libbcachefs/bcachefs.h
+++ b/libbcachefs/bcachefs.h
@@ -714,7 +714,7 @@ struct bch_fs {
        struct rhashtable       promote_table;
 
        mempool_t               compression_bounce[2];
-       mempool_t               compress_workspace[BCH_COMPRESSION_NR];
+       mempool_t               compress_workspace[BCH_COMPRESSION_TYPE_NR];
        mempool_t               decompress_workspace;
        ZSTD_parameters         zstd_params;
 

diff --git a/libbcachefs/bcachefs_format.h b/libbcachefs/bcachefs_format.h
index 66af4f4cdd53b6713612ef77a90052f85fa63aa3..966da01498611f40c677e16b2c992cf083b34fc9 100644 (file)
--- a/libbcachefs/bcachefs_format.h
+++ b/libbcachefs/bcachefs_format.h
@@ -432,47 +432,6 @@ struct bch_csum {
        __le64                  hi;
 } __attribute__((packed, aligned(8)));
 
-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_NR                     = 7,
-};
-
-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_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:
-               return true;
-       default:
-               return false;
-       }
-}
-
-enum bch_compression_type {
-       BCH_COMPRESSION_NONE            = 0,
-       BCH_COMPRESSION_LZ4_OLD         = 1,
-       BCH_COMPRESSION_GZIP            = 2,
-       BCH_COMPRESSION_LZ4             = 3,
-       BCH_COMPRESSION_ZSTD            = 4,
-       BCH_COMPRESSION_NR              = 5,
-};
-
 #define BCH_EXTENT_ENTRY_TYPES()               \
        x(ptr,                  0)              \
        x(crc32,                1)              \
@@ -1316,17 +1275,29 @@ LE64_BITMASK(BCH_SB_GC_RESERVE_BYTES,   struct bch_sb, flags[2],  4, 64);
 
 LE64_BITMASK(BCH_SB_ERASURE_CODE,      struct bch_sb, flags[3],  0, 16);
 
-/* Features: */
-enum bch_sb_features {
-       BCH_FEATURE_LZ4                 = 0,
-       BCH_FEATURE_GZIP                = 1,
-       BCH_FEATURE_ZSTD                = 2,
-       BCH_FEATURE_ATOMIC_NLINK        = 3, /* should have gone under compat */
-       BCH_FEATURE_EC                  = 4,
-       BCH_FEATURE_JOURNAL_SEQ_BLACKLIST_V3 = 5,
-       BCH_FEATURE_REFLINK             = 6,
-       BCH_FEATURE_NEW_SIPHASH         = 7,
-       BCH_FEATURE_INLINE_DATA         = 8,
+/*
+ * Features:
+ *
+ * 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
+ */
+#define BCH_SB_FEATURES()                      \
+       x(lz4,                          0)      \
+       x(gzip,                         1)      \
+       x(zstd,                         2)      \
+       x(atomic_nlink,                 3)      \
+       x(ec,                           4)      \
+       x(journal_seq_blacklist_v3,     5)      \
+       x(reflink,                      6)      \
+       x(new_siphash,                  7)      \
+       x(inline_data,                  8)
+
+enum bch_sb_feature {
+#define x(f, n) BCH_FEATURE_##f,
+       BCH_SB_FEATURES()
+#undef x
        BCH_FEATURE_NR,
 };
 
@@ -1346,13 +1317,6 @@ enum bch_error_actions {
        BCH_NR_ERROR_ACTIONS            = 3,
 };
 
-enum bch_csum_opts {
-       BCH_CSUM_OPT_NONE               = 0,
-       BCH_CSUM_OPT_CRC32C             = 1,
-       BCH_CSUM_OPT_CRC64              = 2,
-       BCH_CSUM_OPT_NR                 = 3,
-};
-
 enum bch_str_hash_type {
        BCH_STR_HASH_CRC32C             = 0,
        BCH_STR_HASH_CRC64              = 1,
@@ -1368,15 +1332,68 @@ enum bch_str_hash_opts {
        BCH_STR_HASH_OPT_NR             = 3,
 };
 
+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_NR                     = 7,
+};
+
+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_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:
+               return true;
+       default:
+               return false;
+       }
+}
+
+enum bch_csum_opts {
+       BCH_CSUM_OPT_NONE               = 0,
+       BCH_CSUM_OPT_CRC32C             = 1,
+       BCH_CSUM_OPT_CRC64              = 2,
+       BCH_CSUM_OPT_NR                 = 3,
+};
+
 #define BCH_COMPRESSION_TYPES()                \
-       x(NONE)                         \
-       x(LZ4)                          \
-       x(GZIP)                         \
-       x(ZSTD)
+       x(none,         0)              \
+       x(lz4_old,      1)              \
+       x(gzip,         2)              \
+       x(lz4,          3)              \
+       x(zstd,         4)
 
-enum bch_compression_opts {
-#define x(t) BCH_COMPRESSION_OPT_##t,
+enum bch_compression_type {
+#define x(t, n) BCH_COMPRESSION_TYPE_##t,
        BCH_COMPRESSION_TYPES()
+#undef x
+       BCH_COMPRESSION_TYPE_NR
+};
+
+#define BCH_COMPRESSION_OPTS()         \
+       x(none,         0)              \
+       x(lz4,          1)              \
+       x(gzip,         2)              \
+       x(zstd,         3)
+
+enum bch_compression_opts {
+#define x(t, n) BCH_COMPRESSION_OPT_##t,
+       BCH_COMPRESSION_OPTS()
 #undef x
        BCH_COMPRESSION_OPT_NR
 };

diff --git a/libbcachefs/bkey.c b/libbcachefs/bkey.c
index 4d0c9129cd4abcb9cef2dc9543f124f990d872cb..494126aea3212d58692c6055a3aaa189a2bd701b 100644 (file)
--- a/libbcachefs/bkey.c
+++ b/libbcachefs/bkey.c
@@ -173,8 +173,7 @@ static bool set_inc_field(struct pack_state *state, unsigned field, u64 v)
 
        if (bits > state->bits) {
                bits -= state->bits;
-               /* avoid shift by 64 if bits is 0 - bits is never 64 here: */
-               state->w |= (v >> 1) >> (bits - 1);
+               state->w |= v >> bits;
 
                *state->p = state->w;
                state->p = next_word(state->p);
@@ -183,7 +182,10 @@ static bool set_inc_field(struct pack_state *state, unsigned field, u64 v)
        }
 
        state->bits -= bits;
-       state->w |= v << state->bits;
+
+       EBUG_ON(!state->bits);
+       /* avoid shift by 64: */
+       state->w |= (v << 1) << (state->bits - 1);
 
        return true;
 }
@@ -370,7 +372,7 @@ static bool set_inc_field_lossy(struct pack_state *state, unsigned field, u64 v)
 
        if (bits > state->bits) {
                bits -= state->bits;
-               state->w |= (v >> 1) >> (bits - 1);
+               state->w |= v >> bits;
 
                *state->p = state->w;
                state->p = next_word(state->p);
@@ -379,7 +381,7 @@ static bool set_inc_field_lossy(struct pack_state *state, unsigned field, u64 v)
        }
 
        state->bits -= bits;
-       state->w |= v << state->bits;
+       state->w |= (v << 1) << (state->bits - 1);
 
        return ret;
 }

diff --git a/libbcachefs/checksum.h b/libbcachefs/checksum.h
index b84e81bac8ff7b663b8f3238f2dceadc84bf5c9d..ca9e45906dc8813f707076670caabfdabcab4bd9 100644 (file)
--- a/libbcachefs/checksum.h
+++ b/libbcachefs/checksum.h
@@ -108,8 +108,8 @@ static inline enum bch_csum_type bch2_meta_checksum_type(struct bch_fs *c)
 }
 
 static const unsigned bch2_compression_opt_to_type[] = {
-#define x(t) [BCH_COMPRESSION_OPT_##t] = BCH_COMPRESSION_##t,
-       BCH_COMPRESSION_TYPES()
+#define x(t, n) [BCH_COMPRESSION_OPT_##t] = BCH_COMPRESSION_TYPE_##t,
+       BCH_COMPRESSION_OPTS()
 #undef x
 };
 

diff --git a/libbcachefs/compress.c b/libbcachefs/compress.c
index 3787390da47fc20835a77fe67c0e7286246e8338..bb557eda111b5c8a1820e5870adbc03a68f7e6bc 100644 (file)
--- a/libbcachefs/compress.c
+++ b/libbcachefs/compress.c
@@ -158,14 +158,14 @@ static int __bio_uncompress(struct bch_fs *c, struct bio *src,
        src_data = bio_map_or_bounce(c, src, READ);
 
        switch (crc.compression_type) {
-       case BCH_COMPRESSION_LZ4_OLD:
-       case BCH_COMPRESSION_LZ4:
+       case BCH_COMPRESSION_TYPE_lz4_old:
+       case BCH_COMPRESSION_TYPE_lz4:
                ret = LZ4_decompress_safe_partial(src_data.b, dst_data,
                                                  src_len, dst_len, dst_len);
                if (ret != dst_len)
                        goto err;
                break;
-       case BCH_COMPRESSION_GZIP: {
+       case BCH_COMPRESSION_TYPE_gzip: {
                z_stream strm = {
                        .next_in        = src_data.b,
                        .avail_in       = src_len,
@@ -185,7 +185,7 @@ static int __bio_uncompress(struct bch_fs *c, struct bio *src,
                        goto err;
                break;
        }
-       case BCH_COMPRESSION_ZSTD: {
+       case BCH_COMPRESSION_TYPE_zstd: {
                ZSTD_DCtx *ctx;
                size_t len;
 
@@ -290,10 +290,10 @@ static int attempt_compress(struct bch_fs *c,
                            void *workspace,
                            void *dst, size_t dst_len,
                            void *src, size_t src_len,
-                           unsigned compression_type)
+                           enum bch_compression_type compression_type)
 {
        switch (compression_type) {
-       case BCH_COMPRESSION_LZ4: {
+       case BCH_COMPRESSION_TYPE_lz4: {
                int len = src_len;
                int ret = LZ4_compress_destSize(
                                src,            dst,
@@ -305,7 +305,7 @@ static int attempt_compress(struct bch_fs *c,
 
                return ret;
        }
-       case BCH_COMPRESSION_GZIP: {
+       case BCH_COMPRESSION_TYPE_gzip: {
                z_stream strm = {
                        .next_in        = src,
                        .avail_in       = src_len,
@@ -326,7 +326,7 @@ static int attempt_compress(struct bch_fs *c,
 
                return strm.total_out;
        }
-       case BCH_COMPRESSION_ZSTD: {
+       case BCH_COMPRESSION_TYPE_zstd: {
                ZSTD_CCtx *ctx = ZSTD_initCCtx(workspace,
                        ZSTD_CCtxWorkspaceBound(c->zstd_params.cParams));
 
@@ -348,14 +348,14 @@ static int attempt_compress(struct bch_fs *c,
 static unsigned __bio_compress(struct bch_fs *c,
                               struct bio *dst, size_t *dst_len,
                               struct bio *src, size_t *src_len,
-                              unsigned compression_type)
+                              enum bch_compression_type compression_type)
 {
        struct bbuf src_data = { NULL }, dst_data = { NULL };
        void *workspace;
        unsigned pad;
        int ret = 0;
 
-       BUG_ON(compression_type >= BCH_COMPRESSION_NR);
+       BUG_ON(compression_type >= BCH_COMPRESSION_TYPE_NR);
        BUG_ON(!mempool_initialized(&c->compress_workspace[compression_type]));
 
        /* If it's only one block, don't bother trying to compress: */
@@ -452,8 +452,8 @@ unsigned bch2_bio_compress(struct bch_fs *c,
        /* Don't generate a bigger output than input: */
        dst->bi_iter.bi_size = min(dst->bi_iter.bi_size, src->bi_iter.bi_size);
 
-       if (compression_type == BCH_COMPRESSION_LZ4_OLD)
-               compression_type = BCH_COMPRESSION_LZ4;
+       if (compression_type == BCH_COMPRESSION_TYPE_lz4_old)
+               compression_type = BCH_COMPRESSION_TYPE_lz4;
 
        compression_type =
                __bio_compress(c, dst, dst_len, src, src_len, compression_type);
@@ -465,15 +465,15 @@ unsigned bch2_bio_compress(struct bch_fs *c,
 
 static int __bch2_fs_compress_init(struct bch_fs *, u64);
 
-#define BCH_FEATURE_NONE       0
+#define BCH_FEATURE_none       0
 
 static const unsigned bch2_compression_opt_to_feature[] = {
-#define x(t) [BCH_COMPRESSION_OPT_##t] = BCH_FEATURE_##t,
-       BCH_COMPRESSION_TYPES()
+#define x(t, n) [BCH_COMPRESSION_OPT_##t] = BCH_FEATURE_##t,
+       BCH_COMPRESSION_OPTS()
 #undef x
 };
 
-#undef BCH_FEATURE_NONE
+#undef BCH_FEATURE_none
 
 static int __bch2_check_set_has_compressed_data(struct bch_fs *c, u64 f)
 {
@@ -537,11 +537,11 @@ static int __bch2_fs_compress_init(struct bch_fs *c, u64 features)
                size_t          compress_workspace;
                size_t          decompress_workspace;
        } compression_types[] = {
-               { BCH_FEATURE_LZ4, BCH_COMPRESSION_LZ4, LZ4_MEM_COMPRESS, 0 },
-               { BCH_FEATURE_GZIP, BCH_COMPRESSION_GZIP,
+               { BCH_FEATURE_lz4, BCH_COMPRESSION_TYPE_lz4, LZ4_MEM_COMPRESS, 0 },
+               { BCH_FEATURE_gzip, BCH_COMPRESSION_TYPE_gzip,
                        zlib_deflate_workspacesize(MAX_WBITS, DEF_MEM_LEVEL),
                        zlib_inflate_workspacesize(), },
-               { BCH_FEATURE_ZSTD, BCH_COMPRESSION_ZSTD,
+               { BCH_FEATURE_zstd, BCH_COMPRESSION_TYPE_zstd,
                        ZSTD_CCtxWorkspaceBound(params.cParams),
                        ZSTD_DCtxWorkspaceBound() },
        }, *i;

diff --git a/libbcachefs/extents.c b/libbcachefs/extents.c
index 6bcc178604b0a81a3470b18b2c3742cd890d10b0..a70ece75035530e432b4029cbb597d0508cdc634 100644 (file)
--- a/libbcachefs/extents.c
+++ b/libbcachefs/extents.c
@@ -614,7 +614,7 @@ unsigned bch2_bkey_nr_ptrs_fully_allocated(struct bkey_s_c k)
 
                bkey_for_each_ptr_decode(k.k, ptrs, p, entry)
                        ret += !p.ptr.cached &&
-                               p.crc.compression_type == BCH_COMPRESSION_NONE;
+                               p.crc.compression_type == BCH_COMPRESSION_TYPE_none;
        }
 
        return ret;
@@ -629,7 +629,7 @@ unsigned bch2_bkey_sectors_compressed(struct bkey_s_c k)
 
        bkey_for_each_ptr_decode(k.k, ptrs, p, entry)
                if (!p.ptr.cached &&
-                   p.crc.compression_type != BCH_COMPRESSION_NONE)
+                   p.crc.compression_type != BCH_COMPRESSION_TYPE_none)
                        ret += p.crc.compressed_size;
 
        return ret;
@@ -1054,7 +1054,7 @@ const char *bch2_bkey_ptrs_invalid(const struct bch_fs *c, struct bkey_s_c k)
                        if (!bch2_checksum_type_valid(c, crc.csum_type))
                                return "invalid checksum type";
 
-                       if (crc.compression_type >= BCH_COMPRESSION_NR)
+                       if (crc.compression_type >= BCH_COMPRESSION_TYPE_NR)
                                return "invalid compression type";
 
                        if (bch2_csum_type_is_encryption(crc.csum_type)) {

diff --git a/libbcachefs/fsck.c b/libbcachefs/fsck.c
index cd230dc109841d7a435e21df317151c4626bc0d0..e25f064706ad431084772ef336a240c0d2945026 100644 (file)
--- a/libbcachefs/fsck.c
+++ b/libbcachefs/fsck.c
@@ -1124,7 +1124,7 @@ static int check_inode_nlink(struct bch_fs *c,
 
        if (!link->count &&
            !(u->bi_flags & BCH_INODE_UNLINKED) &&
-           (c->sb.features & (1 << BCH_FEATURE_ATOMIC_NLINK))) {
+           (c->sb.features & (1 << BCH_FEATURE_atomic_nlink))) {
                if (fsck_err(c, "unreachable inode %llu not marked as unlinked (type %u)",
                             u->bi_inum, mode_to_type(u->bi_mode)) ==
                    FSCK_ERR_IGNORE)
@@ -1159,7 +1159,7 @@ static int check_inode_nlink(struct bch_fs *c,
        }
 
        if (i_nlink != real_i_nlink &&
-           (c->sb.features & (1 << BCH_FEATURE_ATOMIC_NLINK))) {
+           (c->sb.features & (1 << BCH_FEATURE_atomic_nlink))) {
                if (fsck_err(c, "inode %llu has wrong i_nlink "
                             "(type %u i_nlink %u, should be %u)",
                             u->bi_inum, mode_to_type(u->bi_mode),

diff --git a/libbcachefs/io.c b/libbcachefs/io.c
index 86dee7e80daf771464c1501fa0304374a0a33a4d..01f61bc8175513ff4fadbaa251e6e2b711aa4b6e 100644 (file)
--- a/libbcachefs/io.c
+++ b/libbcachefs/io.c
@@ -1139,7 +1139,7 @@ static void bch2_write_data_inline(struct bch_write_op *op, unsigned data_len)
        unsigned sectors;
        int ret;
 
-       bch2_check_set_feature(op->c, BCH_FEATURE_INLINE_DATA);
+       bch2_check_set_feature(op->c, BCH_FEATURE_inline_data);
 
        ret = bch2_keylist_realloc(&op->insert_keys, op->inline_keys,
                                   ARRAY_SIZE(op->inline_keys),
@@ -1786,7 +1786,7 @@ static void __bch2_read_endio(struct work_struct *work)
        crc.offset     += rbio->offset_into_extent;
        crc.live_size   = bvec_iter_sectors(rbio->bvec_iter);
 
-       if (crc.compression_type != BCH_COMPRESSION_NONE) {
+       if (crc.compression_type != BCH_COMPRESSION_TYPE_none) {
                bch2_encrypt_bio(c, crc.csum_type, nonce, src);
                if (bch2_bio_uncompress(c, src, dst, dst_iter, crc))
                        goto decompression_err;
@@ -1994,7 +1994,7 @@ int __bch2_read_extent(struct bch_fs *c, struct bch_read_bio *orig,
 
        EBUG_ON(offset_into_extent + bvec_iter_sectors(iter) > k.k->size);
 
-       if (pick.crc.compression_type != BCH_COMPRESSION_NONE ||
+       if (pick.crc.compression_type != BCH_COMPRESSION_TYPE_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) &&

diff --git a/libbcachefs/journal_seq_blacklist.c b/libbcachefs/journal_seq_blacklist.c
index 787d9f7638d05f82b6a73f3d034f053f21752563..a21de00887535723b2f7ff06265b42bf35142463 100644 (file)
--- a/libbcachefs/journal_seq_blacklist.c
+++ b/libbcachefs/journal_seq_blacklist.c
@@ -121,7 +121,7 @@ int bch2_journal_seq_blacklist_add(struct bch_fs *c, u64 start, u64 end)
        bl->start[nr].end       = cpu_to_le64(end);
 out_write_sb:
        c->disk_sb.sb->features[0] |=
-               1ULL << BCH_FEATURE_JOURNAL_SEQ_BLACKLIST_V3;
+               1ULL << BCH_FEATURE_journal_seq_blacklist_v3;
 
        ret = bch2_write_super(c);
 out:
@@ -309,7 +309,7 @@ void bch2_blacklist_entries_gc(struct work_struct *work)
 
                if (!new_nr)
                        c->disk_sb.sb->features[0] &=
-                               ~(1ULL << BCH_FEATURE_JOURNAL_SEQ_BLACKLIST_V3);
+                               ~(1ULL << BCH_FEATURE_journal_seq_blacklist_v3);
 
                bch2_write_super(c);
        }

diff --git a/libbcachefs/move.c b/libbcachefs/move.c
index 2803056288c36beede8ea3d5b6f2b951f11c7b29..67e9fd3f86f52169f985a6eb6c51e90c6ea10885 100644 (file)
--- a/libbcachefs/move.c
+++ b/libbcachefs/move.c
@@ -272,7 +272,7 @@ int bch2_migrate_write_init(struct bch_fs *c, struct migrate_write *m,
 
                bkey_for_each_ptr_decode(k.k, ptrs, p, entry)
                        if (!p.ptr.cached &&
-                           p.crc.compression_type != BCH_COMPRESSION_NONE &&
+                           p.crc.compression_type != BCH_COMPRESSION_TYPE_none &&
                            bch2_dev_in_target(c, p.ptr.dev, data_opts.target))
                                compressed_sectors += p.crc.compressed_size;
 

diff --git a/libbcachefs/opts.c b/libbcachefs/opts.c
index cbacd2f36799bdf265181d381b6858540bfd7b15..94d6c044a27daa935ed9dec7c01c2456fcdc20fa 100644 (file)
--- a/libbcachefs/opts.c
+++ b/libbcachefs/opts.c
@@ -16,18 +16,24 @@ const char * const bch2_error_actions[] = {
        NULL
 };
 
-const char * const bch2_csum_types[] = {
+const char * const bch2_sb_features[] = {
+#define x(f, n) #f,
+       BCH_SB_FEATURES()
+#undef x
+       NULL
+};
+
+const char * const bch2_csum_opts[] = {
        "none",
        "crc32c",
        "crc64",
        NULL
 };
 
-const char * const bch2_compression_types[] = {
-       "none",
-       "lz4",
-       "gzip",
-       "zstd",
+const char * const bch2_compression_opts[] = {
+#define x(t, n) #t,
+       BCH_COMPRESSION_OPTS()
+#undef x
        NULL
 };
 
@@ -300,7 +306,7 @@ int bch2_opt_check_may_set(struct bch_fs *c, int id, u64 v)
                break;
        case Opt_erasure_code:
                if (v)
-                       bch2_check_set_feature(c, BCH_FEATURE_EC);
+                       bch2_check_set_feature(c, BCH_FEATURE_ec);
                break;
        }
 

diff --git a/libbcachefs/opts.h b/libbcachefs/opts.h
index 1f11f4152a6faf46d3f6a1c024c5e584be9b8ce6..1c05effa71e645087d0aa35d5fe3b80daebb2cee 100644 (file)
--- a/libbcachefs/opts.h
+++ b/libbcachefs/opts.h
@@ -9,8 +9,9 @@
 #include "bcachefs_format.h"
 
 extern const char * const bch2_error_actions[];
-extern const char * const bch2_csum_types[];
-extern const char * const bch2_compression_types[];
+extern const char * const bch2_sb_features[];
+extern const char * const bch2_csum_opts[];
+extern const char * const bch2_compression_opts[];
 extern const char * const bch2_str_hash_types[];
 extern const char * const bch2_data_types[];
 extern const char * const bch2_cache_replacement_policies[];
@@ -112,23 +113,23 @@ enum opt_type {
          "#",          NULL)                                           \
        x(metadata_checksum,            u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,                             \
-         OPT_STR(bch2_csum_types),                                     \
+         OPT_STR(bch2_csum_opts),                                      \
          BCH_SB_META_CSUM_TYPE,        BCH_CSUM_OPT_CRC32C,            \
          NULL,         NULL)                                           \
        x(data_checksum,                u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,                   \
-         OPT_STR(bch2_csum_types),                                     \
+         OPT_STR(bch2_csum_opts),                                      \
          BCH_SB_DATA_CSUM_TYPE,        BCH_CSUM_OPT_CRC32C,            \
          NULL,         NULL)                                           \
        x(compression,                  u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,                   \
-         OPT_STR(bch2_compression_types),                              \
-         BCH_SB_COMPRESSION_TYPE,      BCH_COMPRESSION_OPT_NONE,       \
+         OPT_STR(bch2_compression_opts),                               \
+         BCH_SB_COMPRESSION_TYPE,      BCH_COMPRESSION_OPT_none,       \
          NULL,         NULL)                                           \
        x(background_compression,       u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,                   \
-         OPT_STR(bch2_compression_types),                              \
-         BCH_SB_BACKGROUND_COMPRESSION_TYPE,BCH_COMPRESSION_OPT_NONE,  \
+         OPT_STR(bch2_compression_opts),                               \
+         BCH_SB_BACKGROUND_COMPRESSION_TYPE,BCH_COMPRESSION_OPT_none,  \
          NULL,         NULL)                                           \
        x(str_hash,                     u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,                             \

diff --git a/libbcachefs/recovery.c b/libbcachefs/recovery.c
index 9c90d2bbb7cc4a42993e004e4561e61ef6fca5f7..97b367252e821ca2dbcce0529c8728c9abc40027 100644 (file)
--- a/libbcachefs/recovery.c
+++ b/libbcachefs/recovery.c
@@ -866,7 +866,7 @@ int bch2_fs_recovery(struct bch_fs *c)
        }
 
        if (!c->sb.clean) {
-               if (!(c->sb.features & (1 << BCH_FEATURE_ATOMIC_NLINK))) {
+               if (!(c->sb.features & (1 << BCH_FEATURE_atomic_nlink))) {
                        bch_info(c, "checking inode link counts");
                        err = "error in recovery";
                        ret = bch2_fsck_inode_nlink(c);
@@ -907,6 +907,7 @@ int bch2_fs_recovery(struct bch_fs *c)
                        c->disk_sb.sb->version_min =
                                le16_to_cpu(bcachefs_metadata_version_min);
                c->disk_sb.sb->version = le16_to_cpu(bcachefs_metadata_version_current);
+               c->disk_sb.sb->features[0] |= 1ULL << BCH_FEATURE_new_siphash;
                write_sb = true;
        }
 
@@ -917,7 +918,7 @@ int bch2_fs_recovery(struct bch_fs *c)
 
        if (c->opts.fsck &&
            !test_bit(BCH_FS_ERROR, &c->flags)) {
-               c->disk_sb.sb->features[0] |= 1ULL << BCH_FEATURE_ATOMIC_NLINK;
+               c->disk_sb.sb->features[0] |= 1ULL << BCH_FEATURE_atomic_nlink;
                SET_BCH_SB_HAS_ERRORS(c->disk_sb.sb, 0);
                write_sb = true;
        }
@@ -1024,7 +1025,8 @@ int bch2_fs_initialize(struct bch_fs *c)
        mutex_lock(&c->sb_lock);
        c->disk_sb.sb->version = c->disk_sb.sb->version_min =
                le16_to_cpu(bcachefs_metadata_version_current);
-       c->disk_sb.sb->features[0] |= 1ULL << BCH_FEATURE_ATOMIC_NLINK;
+       c->disk_sb.sb->features[0] |= 1ULL << BCH_FEATURE_atomic_nlink;
+       c->disk_sb.sb->features[0] |= 1ULL << BCH_FEATURE_new_siphash;
 
        SET_BCH_SB_INITIALIZED(c->disk_sb.sb, true);
        SET_BCH_SB_CLEAN(c->disk_sb.sb, false);

diff --git a/libbcachefs/reflink.c b/libbcachefs/reflink.c
index 5cad39fe031f6d9e3d1a62eaf1b27749f21b78f5..2bf003ba3bd8b7cb9ae50e537cb9d9b590afb90d 100644 (file)
--- a/libbcachefs/reflink.c
+++ b/libbcachefs/reflink.c
@@ -171,7 +171,7 @@ s64 bch2_remap_range(struct bch_fs *c,
        if (!percpu_ref_tryget(&c->writes))
                return -EROFS;
 
-       bch2_check_set_feature(c, BCH_FEATURE_REFLINK);
+       bch2_check_set_feature(c, BCH_FEATURE_reflink);
 
        dst_end.offset += remap_sectors;
        src_end.offset += remap_sectors;

diff --git a/libbcachefs/str_hash.h b/libbcachefs/str_hash.h
index 582e718b6bd117191ed25c247302ca1da83b4700..76afa14c89a98eb7ac08c8ca95d9c8c8ed9d1f9b 100644 (file)
--- a/libbcachefs/str_hash.h
+++ b/libbcachefs/str_hash.h
@@ -23,7 +23,7 @@ bch2_str_hash_opt_to_type(struct bch_fs *c, enum bch_str_hash_opts opt)
        case BCH_STR_HASH_OPT_CRC64:
                return BCH_STR_HASH_CRC64;
        case BCH_STR_HASH_OPT_SIPHASH:
-               return c->sb.features & (1ULL << BCH_FEATURE_NEW_SIPHASH)
+               return c->sb.features & (1ULL << BCH_FEATURE_new_siphash)
                        ? BCH_STR_HASH_SIPHASH
                        : BCH_STR_HASH_SIPHASH_OLD;
        default:

diff --git a/libbcachefs/sysfs.c b/libbcachefs/sysfs.c
index 95e527844e0aaf3385792624f1ff31fe56abc8d7..a8bcba74758274cc23f9da4fed8caf22abe96dc4 100644 (file)
--- a/libbcachefs/sysfs.c
+++ b/libbcachefs/sysfs.c
@@ -276,7 +276,7 @@ static ssize_t bch2_compression_stats(struct bch_fs *c, char *buf)
                        struct extent_ptr_decoded p;
 
                        extent_for_each_ptr_decode(e, p, entry) {
-                               if (p.crc.compression_type == BCH_COMPRESSION_NONE) {
+                               if (p.crc.compression_type == BCH_COMPRESSION_TYPE_none) {
                                        nr_uncompressed_extents++;
                                        uncompressed_sectors += e.k->size;
                                } else {