From 2436cb9fada98d477bb3508a30e520ab3bfaae3e Mon Sep 17 00:00:00 2001 From: Kent Overstreet Date: Sat, 20 Feb 2021 19:47:58 -0500 Subject: 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 Signed-off-by: Kent Overstreet --- fs/bcachefs/alloc_background.c | 8 ++--- fs/bcachefs/bcachefs_format.h | 73 ++++++++++++++++++++++++++++-------------- fs/bcachefs/btree_io.c | 2 +- fs/bcachefs/checksum.h | 6 ++-- fs/bcachefs/error.c | 10 +++--- fs/bcachefs/extents.c | 2 +- fs/bcachefs/journal_io.c | 6 ++-- fs/bcachefs/opts.c | 45 ++++++-------------------- fs/bcachefs/opts.h | 11 +++---- fs/bcachefs/replicas.c | 2 +- fs/bcachefs/str_hash.h | 6 ++-- fs/bcachefs/super.c | 40 +++++++++++------------ fs/bcachefs/super.h | 10 +++--- fs/bcachefs/sysfs.c | 2 +- 14 files changed, 110 insertions(+), 113 deletions(-) (limited to 'fs/bcachefs') diff --git a/fs/bcachefs/alloc_background.c b/fs/bcachefs/alloc_background.c index 34590e4b8f5d..add04dcb849b 100644 --- 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 e9e501a8c3ec..17cc6131de0c 100644 --- 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 b7d931335dd6..a0df2c67da65 100644 --- 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 24dee8039d57..728b7ef1a149 100644 --- 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 cd46706fb6f5..a8ee1db8aa39 100644 --- 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 515840bc3eaa..3fe9ef50f5c0 100644 --- 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 fdd5a837902c..756154b85526 100644 --- 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 a6c734efe328..0cfbb56a57c1 100644 --- 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 38d78ca46c9c..46f91f19dad4 100644 --- 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 ddaf833d0bf2..0498c8ac82c8 100644 --- 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 952b146af750..b85f895de346 100644 --- 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 de8e770ba300..7c23cae436bb 100644 --- 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 795229e2d6a1..28e6d78f9fcd 100644 --- 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 b9078adaa747..4b83a98621d7 100644 --- 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; -- cgit v1.2.3