bcachefs: Use x-macros for more enums

This patch standardizes all the enums that have associated string tables
(probably more enums should have string tables).

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

diff --git a/fs/bcachefs/alloc_background.c b/fs/bcachefs/alloc_background.c
index 34590e4b8f5d00464778cbf588f1da9fbd17cc5b..add04dcb849b22a37c465d2de0722b4effc689ae 100644 (file)
--- a/fs/bcachefs/alloc_background.c
+++ b/fs/bcachefs/alloc_background.c
@@ -720,13 +720,13 @@ static size_t find_reclaimable_buckets(struct bch_fs *c, struct bch_dev *ca)
        ca->inc_gen_needs_gc                    = 0;
 
        switch (ca->mi.replacement) {
-       case CACHE_REPLACEMENT_LRU:
+       case BCH_CACHE_REPLACEMENT_lru:
                find_reclaimable_buckets_lru(c, ca);
                break;
-       case CACHE_REPLACEMENT_FIFO:
+       case BCH_CACHE_REPLACEMENT_fifo:
                find_reclaimable_buckets_fifo(c, ca);
                break;
-       case CACHE_REPLACEMENT_RANDOM:
+       case BCH_CACHE_REPLACEMENT_random:
                find_reclaimable_buckets_random(c, ca);
                break;
        }
@@ -1037,7 +1037,7 @@ static int discard_invalidated_buckets(struct bch_fs *c, struct bch_dev *ca)
 
 static inline bool allocator_thread_running(struct bch_dev *ca)
 {
-       return ca->mi.state == BCH_MEMBER_STATE_RW &&
+       return ca->mi.state == BCH_MEMBER_STATE_rw &&
                test_bit(BCH_FS_ALLOCATOR_RUNNING, &ca->fs->flags);
 }
 

diff --git a/fs/bcachefs/bcachefs_format.h b/fs/bcachefs/bcachefs_format.h
index e9e501a8c3ec01d261d66ecb19fd8fa7f2a9b29f..17cc6131de0cfd0465a816c5f22e5c8b332774db 100644 (file)
--- a/fs/bcachefs/bcachefs_format.h
+++ b/fs/bcachefs/bcachefs_format.h
@@ -991,19 +991,29 @@ LE64_BITMASK(BCH_MEMBER_NR_READ_ERRORS,   struct bch_member, flags[1], 0,  20);
 LE64_BITMASK(BCH_MEMBER_NR_WRITE_ERRORS,struct bch_member, flags[1], 20, 40);
 #endif
 
+#define BCH_MEMBER_STATES()                    \
+       x(rw,           0)                      \
+       x(ro,           1)                      \
+       x(failed,       2)                      \
+       x(spare,        3)
+
 enum bch_member_state {
-       BCH_MEMBER_STATE_RW             = 0,
-       BCH_MEMBER_STATE_RO             = 1,
-       BCH_MEMBER_STATE_FAILED         = 2,
-       BCH_MEMBER_STATE_SPARE          = 3,
-       BCH_MEMBER_STATE_NR             = 4,
+#define x(t, n) BCH_MEMBER_STATE_##t = n,
+       BCH_MEMBER_STATES()
+#undef x
+       BCH_MEMBER_STATE_NR
 };
 
-enum cache_replacement {
-       CACHE_REPLACEMENT_LRU           = 0,
-       CACHE_REPLACEMENT_FIFO          = 1,
-       CACHE_REPLACEMENT_RANDOM        = 2,
-       CACHE_REPLACEMENT_NR            = 3,
+#define BCH_CACHE_REPLACEMENT_POLICIES()       \
+       x(lru,          0)                      \
+       x(fifo,         1)                      \
+       x(random,       2)
+
+enum bch_cache_replacement_policies {
+#define x(t, n) BCH_CACHE_REPLACEMENT_##t = n,
+       BCH_CACHE_REPLACEMENT_POLICIES()
+#undef x
+       BCH_CACHE_REPLACEMENT_NR
 };
 
 struct bch_sb_field_members {
@@ -1405,11 +1415,16 @@ enum bch_sb_compat {
 
 #define BCH_BKEY_PTRS_MAX              16U
 
+#define BCH_ERROR_ACTIONS()            \
+       x(continue,             0)      \
+       x(ro,                   1)      \
+       x(panic,                2)
+
 enum bch_error_actions {
-       BCH_ON_ERROR_CONTINUE           = 0,
-       BCH_ON_ERROR_RO                 = 1,
-       BCH_ON_ERROR_PANIC              = 2,
-       BCH_NR_ERROR_ACTIONS            = 3,
+#define x(t, n) BCH_ON_ERROR_##t = n,
+       BCH_ERROR_ACTIONS()
+#undef x
+       BCH_ON_ERROR_NR
 };
 
 enum bch_str_hash_type {
@@ -1420,11 +1435,16 @@ enum bch_str_hash_type {
        BCH_STR_HASH_NR                 = 4,
 };
 
+#define BCH_STR_HASH_OPTS()            \
+       x(crc32c,               0)      \
+       x(crc64,                1)      \
+       x(siphash,              2)
+
 enum bch_str_hash_opts {
-       BCH_STR_HASH_OPT_CRC32C         = 0,
-       BCH_STR_HASH_OPT_CRC64          = 1,
-       BCH_STR_HASH_OPT_SIPHASH        = 2,
-       BCH_STR_HASH_OPT_NR             = 3,
+#define x(t, n) BCH_STR_HASH_OPT_##t = n,
+       BCH_STR_HASH_OPTS()
+#undef x
+       BCH_STR_HASH_OPT_NR
 };
 
 enum bch_csum_type {
@@ -1459,11 +1479,16 @@ static inline _Bool bch2_csum_type_is_encryption(enum bch_csum_type type)
        }
 }
 
+#define BCH_CSUM_OPTS()                        \
+       x(none,                 0)      \
+       x(crc32c,               1)      \
+       x(crc64,                2)
+
 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 x(t, n) BCH_CSUM_OPT_##t = n,
+       BCH_CSUM_OPTS()
+#undef x
+       BCH_CSUM_OPT_NR
 };
 
 #define BCH_COMPRESSION_TYPES()                \
@@ -1475,7 +1500,7 @@ enum bch_csum_opts {
        x(incompressible,       5)
 
 enum bch_compression_type {
-#define x(t, n) BCH_COMPRESSION_TYPE_##t,
+#define x(t, n) BCH_COMPRESSION_TYPE_##t = n,
        BCH_COMPRESSION_TYPES()
 #undef x
        BCH_COMPRESSION_TYPE_NR
@@ -1488,7 +1513,7 @@ enum bch_compression_type {
        x(zstd,         3)
 
 enum bch_compression_opts {
-#define x(t, n) BCH_COMPRESSION_OPT_##t,
+#define x(t, n) BCH_COMPRESSION_OPT_##t = n,
        BCH_COMPRESSION_OPTS()
 #undef x
        BCH_COMPRESSION_OPT_NR

diff --git a/fs/bcachefs/btree_io.c b/fs/bcachefs/btree_io.c
index b7d931335dd6e8fd77101f4dfc9f21c0f23e748c..a0df2c67da65c40fa8c04c8f7260828295466977 100644 (file)
--- a/fs/bcachefs/btree_io.c
+++ b/fs/bcachefs/btree_io.c
@@ -954,7 +954,7 @@ int bch2_btree_node_read_done(struct bch_fs *c, struct bch_dev *ca,
        bkey_for_each_ptr(bch2_bkey_ptrs(bkey_i_to_s(&b->key)), ptr) {
                struct bch_dev *ca = bch_dev_bkey_exists(c, ptr->dev);
 
-               if (ca->mi.state != BCH_MEMBER_STATE_RW)
+               if (ca->mi.state != BCH_MEMBER_STATE_rw)
                        set_btree_node_need_rewrite(b);
        }
 out:

diff --git a/fs/bcachefs/checksum.h b/fs/bcachefs/checksum.h
index 24dee8039d57bd37f652e85273d0089abd9a5c3d..728b7ef1a1490f7bd2e38db93df4729d3eec9dd2 100644 (file)
--- a/fs/bcachefs/checksum.h
+++ b/fs/bcachefs/checksum.h
@@ -77,11 +77,11 @@ static inline enum bch_csum_type bch2_csum_opt_to_type(enum bch_csum_opts type,
                                                       bool data)
 {
        switch (type) {
-       case BCH_CSUM_OPT_NONE:
+       case BCH_CSUM_OPT_none:
             return BCH_CSUM_NONE;
-       case BCH_CSUM_OPT_CRC32C:
+       case BCH_CSUM_OPT_crc32c:
             return data ? BCH_CSUM_CRC32C : BCH_CSUM_CRC32C_NONZERO;
-       case BCH_CSUM_OPT_CRC64:
+       case BCH_CSUM_OPT_crc64:
             return data ? BCH_CSUM_CRC64 : BCH_CSUM_CRC64_NONZERO;
        default:
             BUG();

diff --git a/fs/bcachefs/error.c b/fs/bcachefs/error.c
index cd46706fb6f5a8020ad63a128b5c28fc910163b8..a8ee1db8aa3917851dfdd011e9d00e63bf8a84bd 100644 (file)
--- a/fs/bcachefs/error.c
+++ b/fs/bcachefs/error.c
@@ -11,13 +11,13 @@ bool bch2_inconsistent_error(struct bch_fs *c)
        set_bit(BCH_FS_ERROR, &c->flags);
 
        switch (c->opts.errors) {
-       case BCH_ON_ERROR_CONTINUE:
+       case BCH_ON_ERROR_continue:
                return false;
-       case BCH_ON_ERROR_RO:
+       case BCH_ON_ERROR_ro:
                if (bch2_fs_emergency_read_only(c))
                        bch_err(c, "emergency read only");
                return true;
-       case BCH_ON_ERROR_PANIC:
+       case BCH_ON_ERROR_panic:
                panic(bch2_fmt(c, "panic after error"));
                return true;
        default:
@@ -38,10 +38,10 @@ void bch2_io_error_work(struct work_struct *work)
        bool dev;
 
        down_write(&c->state_lock);
-       dev = bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_RO,
+       dev = bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_ro,
                                    BCH_FORCE_IF_DEGRADED);
        if (dev
-           ? __bch2_dev_set_state(c, ca, BCH_MEMBER_STATE_RO,
+           ? __bch2_dev_set_state(c, ca, BCH_MEMBER_STATE_ro,
                                  BCH_FORCE_IF_DEGRADED)
            : bch2_fs_emergency_read_only(c))
                bch_err(ca,

diff --git a/fs/bcachefs/extents.c b/fs/bcachefs/extents.c
index 515840bc3eaadf5f3617177c2d7491f12cefbfcf..3fe9ef50f5c09c7596e03ffb025729191f596328 100644 (file)
--- a/fs/bcachefs/extents.c
+++ b/fs/bcachefs/extents.c
@@ -724,7 +724,7 @@ static unsigned bch2_extent_ptr_durability(struct bch_fs *c,
 
        ca = bch_dev_bkey_exists(c, p.ptr.dev);
 
-       if (ca->mi.state != BCH_MEMBER_STATE_FAILED)
+       if (ca->mi.state != BCH_MEMBER_STATE_failed)
                durability = max_t(unsigned, durability, ca->mi.durability);
 
        if (p.has_ec)

diff --git a/fs/bcachefs/journal_io.c b/fs/bcachefs/journal_io.c
index fdd5a837902c6c802ad396800cc776fcc279b4d3..756154b855267d07a6909541ce41a79555383c37 100644 (file)
--- a/fs/bcachefs/journal_io.c
+++ b/fs/bcachefs/journal_io.c
@@ -870,8 +870,8 @@ int bch2_journal_read(struct bch_fs *c, struct list_head *list,
                    !(bch2_dev_has_data(c, ca) & (1 << BCH_DATA_journal)))
                        continue;
 
-               if ((ca->mi.state == BCH_MEMBER_STATE_RW ||
-                    ca->mi.state == BCH_MEMBER_STATE_RO) &&
+               if ((ca->mi.state == BCH_MEMBER_STATE_rw ||
+                    ca->mi.state == BCH_MEMBER_STATE_ro) &&
                    percpu_ref_tryget(&ca->io_ref))
                        closure_call(&ca->journal.read,
                                     bch2_journal_read_device,
@@ -1064,7 +1064,7 @@ static void __journal_write_alloc(struct journal *j,
                 * it:
                 */
                if (!ca->mi.durability ||
-                   ca->mi.state != BCH_MEMBER_STATE_RW ||
+                   ca->mi.state != BCH_MEMBER_STATE_rw ||
                    !ja->nr ||
                    bch2_bkey_has_device(bkey_i_to_s_c(&w->key),
                                         ca->dev_idx) ||

diff --git a/fs/bcachefs/opts.c b/fs/bcachefs/opts.c
index a6c734efe328f94225ecae669f96689e1300d27d..0cfbb56a57c103211c2761603747f65f17fb41a2 100644 (file)
--- a/fs/bcachefs/opts.c
+++ b/fs/bcachefs/opts.c
@@ -9,86 +9,59 @@
 #include "super-io.h"
 #include "util.h"
 
+#define x(t, n) #t,
+
 const char * const bch2_error_actions[] = {
-       "continue",
-       "remount-ro",
-       "panic",
+       BCH_ERROR_ACTIONS()
        NULL
 };
 
 const char * const bch2_sb_features[] = {
-#define x(f, n) #f,
        BCH_SB_FEATURES()
-#undef x
        NULL
 };
 
 const char * const bch2_sb_compat[] = {
-#define x(f, n) #f,
        BCH_SB_COMPAT()
-#undef x
        NULL
 };
 
 const char * const bch2_btree_ids[] = {
-#define x(name, ...) #name,
        BCH_BTREE_IDS()
-#undef x
        NULL
 };
 
 const char * const bch2_csum_opts[] = {
-       "none",
-       "crc32c",
-       "crc64",
+       BCH_CSUM_OPTS()
        NULL
 };
 
 const char * const bch2_compression_opts[] = {
-#define x(t, n) #t,
        BCH_COMPRESSION_OPTS()
-#undef x
        NULL
 };
 
 const char * const bch2_str_hash_types[] = {
-       "crc32c",
-       "crc64",
-       "siphash",
+       BCH_STR_HASH_OPTS()
        NULL
 };
 
 const char * const bch2_data_types[] = {
-#define x(t, n) #t,
        BCH_DATA_TYPES()
-#undef x
        NULL
 };
 
 const char * const bch2_cache_replacement_policies[] = {
-       "lru",
-       "fifo",
-       "random",
+       BCH_CACHE_REPLACEMENT_POLICIES()
        NULL
 };
 
-/* Default is -1; we skip past it for struct cached_dev's cache mode */
-const char * const bch2_cache_modes[] = {
-       "default",
-       "writethrough",
-       "writeback",
-       "writearound",
-       "none",
+const char * const bch2_member_states[] = {
+       BCH_MEMBER_STATES()
        NULL
 };
 
-const char * const bch2_dev_state[] = {
-       "readwrite",
-       "readonly",
-       "failed",
-       "spare",
-       NULL
-};
+#undef x
 
 void bch2_opts_apply(struct bch_opts *dst, struct bch_opts src)
 {

diff --git a/fs/bcachefs/opts.h b/fs/bcachefs/opts.h
index 38d78ca46c9c40694d853ba3e3ab9499873dc394..46f91f19dad426eefe643d83a3408237fea4b2d9 100644 (file)
--- a/fs/bcachefs/opts.h
+++ b/fs/bcachefs/opts.h
@@ -17,8 +17,7 @@ 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[];
-extern const char * const bch2_cache_modes[];
-extern const char * const bch2_dev_state[];
+extern const char * const bch2_member_states[];
 
 /*
  * Mount options; we also store defaults in the superblock.
@@ -91,7 +90,7 @@ enum opt_type {
        x(errors,                       u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,                             \
          OPT_STR(bch2_error_actions),                                  \
-         BCH_SB_ERROR_ACTION,          BCH_ON_ERROR_RO,                \
+         BCH_SB_ERROR_ACTION,          BCH_ON_ERROR_ro,                \
          NULL,         "Action to take on filesystem error")           \
        x(metadata_replicas,            u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,                             \
@@ -116,12 +115,12 @@ enum opt_type {
        x(metadata_checksum,            u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,                             \
          OPT_STR(bch2_csum_opts),                                      \
-         BCH_SB_META_CSUM_TYPE,        BCH_CSUM_OPT_CRC32C,            \
+         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_opts),                                      \
-         BCH_SB_DATA_CSUM_TYPE,        BCH_CSUM_OPT_CRC32C,            \
+         BCH_SB_DATA_CSUM_TYPE,        BCH_CSUM_OPT_crc32c,            \
          NULL,         NULL)                                           \
        x(compression,                  u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,                   \
@@ -136,7 +135,7 @@ enum opt_type {
        x(str_hash,                     u8,                             \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,                             \
          OPT_STR(bch2_str_hash_types),                                 \
-         BCH_SB_STR_HASH_TYPE,         BCH_STR_HASH_OPT_SIPHASH,       \
+         BCH_SB_STR_HASH_TYPE,         BCH_STR_HASH_OPT_siphash,       \
          NULL,         "Hash function for directory entries and xattrs")\
        x(metadata_target,              u16,                            \
          OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,                   \

diff --git a/fs/bcachefs/replicas.c b/fs/bcachefs/replicas.c
index ddaf833d0bf28d3686a73d87463895c042adf58b..0498c8ac82c8728bce8aee0b9cf74b76a008d26f 100644 (file)
--- a/fs/bcachefs/replicas.c
+++ b/fs/bcachefs/replicas.c
@@ -982,7 +982,7 @@ bool bch2_have_enough_devs(struct bch_fs *c, struct bch_devs_mask devs,
                        struct bch_dev *ca = bch_dev_bkey_exists(c, e->devs[i]);
 
                        nr_online += test_bit(e->devs[i], devs.d);
-                       nr_failed += ca->mi.state == BCH_MEMBER_STATE_FAILED;
+                       nr_failed += ca->mi.state == BCH_MEMBER_STATE_failed;
                }
 
                if (nr_failed == e->nr_devs)

diff --git a/fs/bcachefs/str_hash.h b/fs/bcachefs/str_hash.h
index 952b146af75020d5bb5bf8f070d894da3345a456..b85f895de34642b69a2aba132cb693f4d992460a 100644 (file)
--- a/fs/bcachefs/str_hash.h
+++ b/fs/bcachefs/str_hash.h
@@ -18,11 +18,11 @@ static inline enum bch_str_hash_type
 bch2_str_hash_opt_to_type(struct bch_fs *c, enum bch_str_hash_opts opt)
 {
        switch (opt) {
-       case BCH_STR_HASH_OPT_CRC32C:
+       case BCH_STR_HASH_OPT_crc32c:
                return BCH_STR_HASH_CRC32C;
-       case BCH_STR_HASH_OPT_CRC64:
+       case BCH_STR_HASH_OPT_crc64:
                return BCH_STR_HASH_CRC64;
-       case BCH_STR_HASH_OPT_SIPHASH:
+       case BCH_STR_HASH_OPT_siphash:
                return c->sb.features & (1ULL << BCH_FEATURE_new_siphash)
                        ? BCH_STR_HASH_SIPHASH
                        : BCH_STR_HASH_SIPHASH_OLD;

diff --git a/fs/bcachefs/super.c b/fs/bcachefs/super.c
index de8e770ba30073120977aee44e41902786016040..7c23cae436bb7feb9465317505c8e0302f0ab19c 100644 (file)
--- a/fs/bcachefs/super.c
+++ b/fs/bcachefs/super.c
@@ -1171,7 +1171,7 @@ static int bch2_dev_alloc(struct bch_fs *c, unsigned dev_idx)
 
        ca->fs = c;
 
-       if (ca->mi.state == BCH_MEMBER_STATE_RW &&
+       if (ca->mi.state == BCH_MEMBER_STATE_rw &&
            bch2_dev_allocator_start(ca)) {
                bch2_dev_free(ca);
                goto err;
@@ -1276,16 +1276,16 @@ bool bch2_dev_state_allowed(struct bch_fs *c, struct bch_dev *ca,
        lockdep_assert_held(&c->state_lock);
 
        switch (new_state) {
-       case BCH_MEMBER_STATE_RW:
+       case BCH_MEMBER_STATE_rw:
                return true;
-       case BCH_MEMBER_STATE_RO:
-               if (ca->mi.state != BCH_MEMBER_STATE_RW)
+       case BCH_MEMBER_STATE_ro:
+               if (ca->mi.state != BCH_MEMBER_STATE_rw)
                        return true;
 
                /* do we have enough devices to write to?  */
                for_each_member_device(ca2, c, i)
                        if (ca2 != ca)
-                               nr_rw += ca2->mi.state == BCH_MEMBER_STATE_RW;
+                               nr_rw += ca2->mi.state == BCH_MEMBER_STATE_rw;
 
                required = max(!(flags & BCH_FORCE_IF_METADATA_DEGRADED)
                               ? c->opts.metadata_replicas
@@ -1295,10 +1295,10 @@ bool bch2_dev_state_allowed(struct bch_fs *c, struct bch_dev *ca,
                               : c->opts.data_replicas_required);
 
                return nr_rw >= required;
-       case BCH_MEMBER_STATE_FAILED:
-       case BCH_MEMBER_STATE_SPARE:
-               if (ca->mi.state != BCH_MEMBER_STATE_RW &&
-                   ca->mi.state != BCH_MEMBER_STATE_RO)
+       case BCH_MEMBER_STATE_failed:
+       case BCH_MEMBER_STATE_spare:
+               if (ca->mi.state != BCH_MEMBER_STATE_rw &&
+                   ca->mi.state != BCH_MEMBER_STATE_ro)
                        return true;
 
                /* do we have enough devices to read from?  */
@@ -1335,8 +1335,8 @@ static bool bch2_fs_may_start(struct bch_fs *c)
                        ca = bch_dev_locked(c, i);
 
                        if (!bch2_dev_is_online(ca) &&
-                           (ca->mi.state == BCH_MEMBER_STATE_RW ||
-                            ca->mi.state == BCH_MEMBER_STATE_RO)) {
+                           (ca->mi.state == BCH_MEMBER_STATE_rw ||
+                            ca->mi.state == BCH_MEMBER_STATE_ro)) {
                                mutex_unlock(&c->sb_lock);
                                return false;
                        }
@@ -1369,7 +1369,7 @@ static const char *__bch2_dev_read_write(struct bch_fs *c, struct bch_dev *ca)
 {
        lockdep_assert_held(&c->state_lock);
 
-       BUG_ON(ca->mi.state != BCH_MEMBER_STATE_RW);
+       BUG_ON(ca->mi.state != BCH_MEMBER_STATE_rw);
 
        bch2_dev_allocator_add(c, ca);
        bch2_recalc_capacity(c);
@@ -1392,10 +1392,10 @@ int __bch2_dev_set_state(struct bch_fs *c, struct bch_dev *ca,
        if (!bch2_dev_state_allowed(c, ca, new_state, flags))
                return -EINVAL;
 
-       if (new_state != BCH_MEMBER_STATE_RW)
+       if (new_state != BCH_MEMBER_STATE_rw)
                __bch2_dev_read_only(c, ca);
 
-       bch_notice(ca, "%s", bch2_dev_state[new_state]);
+       bch_notice(ca, "%s", bch2_member_states[new_state]);
 
        mutex_lock(&c->sb_lock);
        mi = bch2_sb_get_members(c->disk_sb.sb);
@@ -1403,7 +1403,7 @@ int __bch2_dev_set_state(struct bch_fs *c, struct bch_dev *ca,
        bch2_write_super(c);
        mutex_unlock(&c->sb_lock);
 
-       if (new_state == BCH_MEMBER_STATE_RW &&
+       if (new_state == BCH_MEMBER_STATE_rw &&
            __bch2_dev_read_write(c, ca))
                ret = -ENOMEM;
 
@@ -1465,7 +1465,7 @@ int bch2_dev_remove(struct bch_fs *c, struct bch_dev *ca, int flags)
         */
        percpu_ref_put(&ca->ref);
 
-       if (!bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_FAILED, flags)) {
+       if (!bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_failed, flags)) {
                bch_err(ca, "Cannot remove without losing data");
                goto err;
        }
@@ -1549,7 +1549,7 @@ int bch2_dev_remove(struct bch_fs *c, struct bch_dev *ca, int flags)
        bch2_dev_usage_journal_reserve(c);
        return 0;
 err:
-       if (ca->mi.state == BCH_MEMBER_STATE_RW &&
+       if (ca->mi.state == BCH_MEMBER_STATE_rw &&
            !percpu_ref_is_zero(&ca->io_ref))
                __bch2_dev_read_write(c, ca);
        up_write(&c->state_lock);
@@ -1673,7 +1673,7 @@ have_slot:
        if (ret)
                goto err_late;
 
-       if (ca->mi.state == BCH_MEMBER_STATE_RW) {
+       if (ca->mi.state == BCH_MEMBER_STATE_rw) {
                err = __bch2_dev_read_write(c, ca);
                if (err)
                        goto err_late;
@@ -1734,7 +1734,7 @@ int bch2_dev_online(struct bch_fs *c, const char *path)
                goto err;
        }
 
-       if (ca->mi.state == BCH_MEMBER_STATE_RW) {
+       if (ca->mi.state == BCH_MEMBER_STATE_rw) {
                err = __bch2_dev_read_write(c, ca);
                if (err)
                        goto err;
@@ -1768,7 +1768,7 @@ int bch2_dev_offline(struct bch_fs *c, struct bch_dev *ca, int flags)
                return 0;
        }
 
-       if (!bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_FAILED, flags)) {
+       if (!bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_failed, flags)) {
                bch_err(ca, "Cannot offline required disk");
                up_write(&c->state_lock);
                return -EINVAL;

diff --git a/fs/bcachefs/super.h b/fs/bcachefs/super.h
index 795229e2d6a11c31425d2326b751ef58d90da8e0..28e6d78f9fcd5dd00f0968de79602495314740c5 100644 (file)
--- a/fs/bcachefs/super.h
+++ b/fs/bcachefs/super.h
@@ -34,7 +34,7 @@ static inline bool bch2_dev_is_online(struct bch_dev *ca)
 static inline bool bch2_dev_is_readable(struct bch_dev *ca)
 {
        return bch2_dev_is_online(ca) &&
-               ca->mi.state != BCH_MEMBER_STATE_FAILED;
+               ca->mi.state != BCH_MEMBER_STATE_failed;
 }
 
 static inline bool bch2_dev_get_ioref(struct bch_dev *ca, int rw)
@@ -42,8 +42,8 @@ static inline bool bch2_dev_get_ioref(struct bch_dev *ca, int rw)
        if (!percpu_ref_tryget(&ca->io_ref))
                return false;
 
-       if (ca->mi.state == BCH_MEMBER_STATE_RW ||
-           (ca->mi.state == BCH_MEMBER_STATE_RO && rw == READ))
+       if (ca->mi.state == BCH_MEMBER_STATE_rw ||
+           (ca->mi.state == BCH_MEMBER_STATE_ro && rw == READ))
                return true;
 
        percpu_ref_put(&ca->io_ref);
@@ -158,11 +158,11 @@ static inline struct bch_dev *bch2_get_next_online_dev(struct bch_fs *c,
        __for_each_online_member(ca, c, iter, ~0)
 
 #define for_each_rw_member(ca, c, iter)                                        \
-       __for_each_online_member(ca, c, iter, 1 << BCH_MEMBER_STATE_RW)
+       __for_each_online_member(ca, c, iter, 1 << BCH_MEMBER_STATE_rw)
 
 #define for_each_readable_member(ca, c, iter)                          \
        __for_each_online_member(ca, c, iter,                           \
-               (1 << BCH_MEMBER_STATE_RW)|(1 << BCH_MEMBER_STATE_RO))
+               (1 << BCH_MEMBER_STATE_rw)|(1 << BCH_MEMBER_STATE_ro))
 
 /*
  * If a key exists that references a device, the device won't be going away and

diff --git a/fs/bcachefs/sysfs.c b/fs/bcachefs/sysfs.c
index b9078adaa747dbeb387ee76ca31ba7c3645a6e80..4b83a98621d77abf0a815b601ab2532d82b207f5 100644 (file)
--- a/fs/bcachefs/sysfs.c
+++ b/fs/bcachefs/sysfs.c
@@ -886,7 +886,7 @@ SHOW(bch2_dev)
        }
 
        if (attr == &sysfs_state_rw) {
-               bch2_string_opt_to_text(&out, bch2_dev_state,
+               bch2_string_opt_to_text(&out, bch2_member_states,
                                        ca->mi.state);
                pr_buf(&out, "\n");
                return out.pos - buf;