From ae43a58d97fc00e31770142da832fb8a249808eb Mon Sep 17 00:00:00 2001 From: Kent Overstreet Date: Sun, 23 Oct 2022 17:39:22 -0400 Subject: [PATCH] Update bcachefs sources to 70fa0c1ff4 fixup! bcachefs: Btree key cache improvements --- .bcachefs_revision | 2 +- include/linux/rcupdate.h | 2 + include/trace/events/bcachefs.h | 28 ++++----- libbcachefs/alloc_background.h | 16 ++--- libbcachefs/backpointers.c | 10 ++- libbcachefs/backpointers.h | 4 +- libbcachefs/bcachefs.h | 2 +- libbcachefs/bcachefs_format.h | 97 +++++++++++++++-------------- libbcachefs/bcachefs_ioctl.h | 8 +-- libbcachefs/bkey.c | 3 - libbcachefs/bkey_methods.c | 29 ++++----- libbcachefs/bkey_methods.h | 2 +- libbcachefs/btree_cache.c | 9 ++- libbcachefs/btree_gc.c | 4 +- libbcachefs/btree_io.c | 2 + libbcachefs/btree_iter.c | 13 ++-- libbcachefs/btree_key_cache.c | 11 ++-- libbcachefs/btree_key_cache.h | 1 + libbcachefs/btree_locking.h | 1 + libbcachefs/btree_types.h | 2 +- libbcachefs/btree_update_interior.c | 6 +- libbcachefs/buckets.c | 8 ++- libbcachefs/checksum.h | 10 +-- libbcachefs/dirent.h | 4 +- libbcachefs/ec.h | 4 +- libbcachefs/errcode.c | 1 + libbcachefs/extents.h | 22 ++++--- libbcachefs/fifo.h | 2 +- libbcachefs/fsck.c | 29 +++++---- libbcachefs/inode.h | 18 +++--- libbcachefs/journal.h | 4 +- libbcachefs/lru.h | 4 +- libbcachefs/quota.h | 4 +- libbcachefs/recovery.c | 53 ++++++++++------ libbcachefs/reflink.h | 12 ++-- libbcachefs/replicas_types.h | 1 + libbcachefs/subvolume.c | 1 + libbcachefs/subvolume.h | 8 +-- libbcachefs/sysfs.c | 12 ++-- libbcachefs/tests.c | 47 +++++++------- libbcachefs/xattr.h | 4 +- 41 files changed, 267 insertions(+), 233 deletions(-) diff --git a/.bcachefs_revision b/.bcachefs_revision index e8327f5..206b9d4 100644 --- a/.bcachefs_revision +++ b/.bcachefs_revision @@ -1 +1 @@ -cd779e0cc51cb232d17eec4537cb4769af202b5f +70fa0c1ff48feba041a8243b1a52ee57cffe1e0e diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h index ae29224..3db40cb 100644 --- a/include/linux/rcupdate.h +++ b/include/linux/rcupdate.h @@ -4,6 +4,8 @@ #include #include +#define ULONG_CMP_GE(a, b) (ULONG_MAX / 2 >= (a) - (b)) + #define rcu_dereference_check(p, c) rcu_dereference(p) #define rcu_dereference_raw(p) rcu_dereference(p) #define rcu_dereference_protected(p, c) rcu_dereference(p) diff --git a/include/trace/events/bcachefs.h b/include/trace/events/bcachefs.h index d3d9e96..444f43f 100644 --- a/include/trace/events/bcachefs.h +++ b/include/trace/events/bcachefs.h @@ -354,7 +354,7 @@ TRACE_EVENT(btree_reserve_get_fail, ), TP_fast_assign( - strlcpy(__entry->trans_fn, trans_fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans_fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; __entry->required = required; ), @@ -411,7 +411,7 @@ TRACE_EVENT(btree_path_relock_fail, TP_fast_assign( struct btree *b = btree_path_node(path, level); - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; __entry->btree_id = path->btree_id; __entry->level = path->level; @@ -462,7 +462,7 @@ TRACE_EVENT(btree_path_upgrade_fail, TP_fast_assign( struct six_lock_count c; - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; __entry->btree_id = path->btree_id; __entry->level = level; @@ -524,7 +524,7 @@ TRACE_EVENT(bucket_alloc, TP_fast_assign( __entry->dev = ca->dev; - strlcpy(__entry->reserve, alloc_reserve, sizeof(__entry->reserve)); + strscpy(__entry->reserve, alloc_reserve, sizeof(__entry->reserve)); __entry->user = user; __entry->bucket = bucket; ), @@ -568,7 +568,7 @@ TRACE_EVENT(bucket_alloc_fail, TP_fast_assign( __entry->dev = ca->dev; - strlcpy(__entry->reserve, alloc_reserve, sizeof(__entry->reserve)); + strscpy(__entry->reserve, alloc_reserve, sizeof(__entry->reserve)); __entry->free = free; __entry->avail = avail; __entry->copygc_wait_amount = copygc_wait_amount; @@ -578,7 +578,7 @@ TRACE_EVENT(bucket_alloc_fail, __entry->need_journal_commit = need_journal_commit; __entry->nouse = nouse; __entry->nonblocking = nonblocking; - strlcpy(__entry->err, err, sizeof(__entry->err)); + strscpy(__entry->err, err, sizeof(__entry->err)); ), TP_printk("%d,%d reserve %s free %llu avail %llu copygc_wait %llu/%lli seen %llu open %llu need_journal_commit %llu nouse %llu nonblocking %u err %s", @@ -616,7 +616,7 @@ TRACE_EVENT(discard_buckets, __entry->open = open; __entry->need_journal_commit = need_journal_commit; __entry->discarded = discarded; - strlcpy(__entry->err, err, sizeof(__entry->err)); + strscpy(__entry->err, err, sizeof(__entry->err)); ), TP_printk("%d%d seen %llu open %llu need_journal_commit %llu discarded %llu err %s", @@ -766,7 +766,7 @@ DECLARE_EVENT_CLASS(transaction_event, ), TP_fast_assign( - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; ), @@ -811,7 +811,7 @@ TRACE_EVENT(trans_restart_journal_preres_get, ), TP_fast_assign( - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; __entry->flags = flags; ), @@ -871,7 +871,7 @@ DECLARE_EVENT_CLASS(transaction_restart_iter, ), TP_fast_assign( - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; __entry->btree_id = path->btree_id; TRACE_BPOS_assign(pos, path->pos) @@ -918,7 +918,7 @@ TRACE_EVENT(trans_restart_upgrade, ), TP_fast_assign( - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; __entry->btree_id = path->btree_id; __entry->old_locks_want = old_locks_want; @@ -1027,7 +1027,7 @@ TRACE_EVENT(trans_restart_would_deadlock_write, ), TP_fast_assign( - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); ), TP_printk("%s", __entry->trans_fn) @@ -1046,7 +1046,7 @@ TRACE_EVENT(trans_restart_mem_realloced, ), TP_fast_assign( - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; __entry->bytes = bytes; ), @@ -1075,7 +1075,7 @@ TRACE_EVENT(trans_restart_key_cache_key_realloced, ), TP_fast_assign( - strlcpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); + strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); __entry->caller_ip = caller_ip; __entry->btree_id = path->btree_id; diff --git a/libbcachefs/alloc_background.h b/libbcachefs/alloc_background.h index 044bc72..ee683bd 100644 --- a/libbcachefs/alloc_background.h +++ b/libbcachefs/alloc_background.h @@ -103,34 +103,34 @@ int bch2_alloc_v4_invalid(const struct bch_fs *, struct bkey_s_c, int, struct pr void bch2_alloc_v4_swab(struct bkey_s); void bch2_alloc_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_alloc (struct bkey_ops) { \ +#define bch2_bkey_ops_alloc ((struct bkey_ops) { \ .key_invalid = bch2_alloc_v1_invalid, \ .val_to_text = bch2_alloc_to_text, \ .trans_trigger = bch2_trans_mark_alloc, \ .atomic_trigger = bch2_mark_alloc, \ -} +}) -#define bch2_bkey_ops_alloc_v2 (struct bkey_ops) { \ +#define bch2_bkey_ops_alloc_v2 ((struct bkey_ops) { \ .key_invalid = bch2_alloc_v2_invalid, \ .val_to_text = bch2_alloc_to_text, \ .trans_trigger = bch2_trans_mark_alloc, \ .atomic_trigger = bch2_mark_alloc, \ -} +}) -#define bch2_bkey_ops_alloc_v3 (struct bkey_ops) { \ +#define bch2_bkey_ops_alloc_v3 ((struct bkey_ops) { \ .key_invalid = bch2_alloc_v3_invalid, \ .val_to_text = bch2_alloc_to_text, \ .trans_trigger = bch2_trans_mark_alloc, \ .atomic_trigger = bch2_mark_alloc, \ -} +}) -#define bch2_bkey_ops_alloc_v4 (struct bkey_ops) { \ +#define bch2_bkey_ops_alloc_v4 ((struct bkey_ops) { \ .key_invalid = bch2_alloc_v4_invalid, \ .val_to_text = bch2_alloc_to_text, \ .swab = bch2_alloc_v4_swab, \ .trans_trigger = bch2_trans_mark_alloc, \ .atomic_trigger = bch2_mark_alloc, \ -} +}) static inline bool bkey_is_alloc(const struct bkey *k) { diff --git a/libbcachefs/backpointers.c b/libbcachefs/backpointers.c index d74de1d..dace68e 100644 --- a/libbcachefs/backpointers.c +++ b/libbcachefs/backpointers.c @@ -984,9 +984,8 @@ int bch2_check_extents_to_backpointers(struct bch_fs *c) break; if (!bpos_cmp(start, POS_MIN) && bpos_cmp(end, SPOS_MAX)) - bch_verbose(c, "check_extents_to_backpointers(): alloc info does not fit in ram," - "running in multiple passes with %zu nodes per pass", - btree_nodes_fit_in_ram(c)); + bch_verbose(c, "%s(): alloc info does not fit in ram, running in multiple passes with %zu nodes per pass", + __func__, btree_nodes_fit_in_ram(c)); if (bpos_cmp(start, POS_MIN) || bpos_cmp(end, SPOS_MAX)) { struct printbuf buf = PRINTBUF; @@ -1099,9 +1098,8 @@ int bch2_check_backpointers_to_extents(struct bch_fs *c) if (!bbpos_cmp(start, BBPOS_MIN) && bbpos_cmp(end, BBPOS_MAX)) - bch_verbose(c, "check_backpointers_to_extents(): extents do not fit in ram," - "running in multiple passes with %zu nodes per pass", - btree_nodes_fit_in_ram(c)); + bch_verbose(c, "%s(): extents do not fit in ram, running in multiple passes with %zu nodes per pass", + __func__, btree_nodes_fit_in_ram(c)); if (bbpos_cmp(start, BBPOS_MIN) || bbpos_cmp(end, BBPOS_MAX)) { diff --git a/libbcachefs/backpointers.h b/libbcachefs/backpointers.h index 1c97e36..8c58f92 100644 --- a/libbcachefs/backpointers.h +++ b/libbcachefs/backpointers.h @@ -10,11 +10,11 @@ void bch2_backpointer_to_text(struct printbuf *, const struct bch_backpointer *) void bch2_backpointer_k_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); void bch2_backpointer_swab(struct bkey_s); -#define bch2_bkey_ops_backpointer (struct bkey_ops) { \ +#define bch2_bkey_ops_backpointer ((struct bkey_ops) { \ .key_invalid = bch2_backpointer_invalid, \ .val_to_text = bch2_backpointer_k_to_text, \ .swab = bch2_backpointer_swab, \ -} +}) void bch2_extent_ptr_to_bp(struct bch_fs *, enum btree_id, unsigned, struct bkey_s_c, struct extent_ptr_decoded, diff --git a/libbcachefs/bcachefs.h b/libbcachefs/bcachefs.h index 33186fa..fcbe8f8 100644 --- a/libbcachefs/bcachefs.h +++ b/libbcachefs/bcachefs.h @@ -282,7 +282,7 @@ do { \ "When reading btree nodes, read all replicas and " \ "compare them") -/* Parameters that should only be compiled in in debug mode: */ +/* Parameters that should only be compiled in debug mode: */ #define BCH_DEBUG_PARAMS_DEBUG() \ BCH_DEBUG_PARAM(expensive_debug_checks, \ "Enables various runtime debugging checks that " \ diff --git a/libbcachefs/bcachefs_format.h b/libbcachefs/bcachefs_format.h index bfcb75a..5da9f3a 100644 --- a/libbcachefs/bcachefs_format.h +++ b/libbcachefs/bcachefs_format.h @@ -147,7 +147,7 @@ struct bpos { #else #error edit for your odd byteorder. #endif -} __attribute__((packed, aligned(4))); +} __packed __aligned(4); #define KEY_INODE_MAX ((__u64)~0ULL) #define KEY_OFFSET_MAX ((__u64)~0ULL) @@ -181,7 +181,7 @@ struct bversion { __u32 hi; __u64 lo; #endif -} __attribute__((packed, aligned(4))); +} __packed __aligned(4); struct bkey { /* Size of combined key and value, in u64s */ @@ -214,7 +214,7 @@ struct bkey { __u8 pad[1]; #endif -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bkey_packed { __u64 _data[0]; @@ -248,7 +248,7 @@ struct bkey_packed { * to the same size as struct bkey should hopefully be safest. */ __u8 pad[sizeof(struct bkey) - 3]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define BKEY_U64s (sizeof(struct bkey) / sizeof(__u64)) #define BKEY_U64s_MAX U8_MAX @@ -478,7 +478,7 @@ struct bch_set { struct bch_csum { __le64 lo; __le64 hi; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define BCH_EXTENT_ENTRY_TYPES() \ x(ptr, 0) \ @@ -515,7 +515,7 @@ struct bch_extent_crc32 { _compressed_size:7, type:2; #endif -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define CRC32_SIZE_MAX (1U << 7) #define CRC32_NONCE_MAX 0 @@ -541,7 +541,7 @@ struct bch_extent_crc64 { type:3; #endif __u64 csum_lo; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define CRC64_SIZE_MAX (1U << 9) #define CRC64_NONCE_MAX ((1U << 10) - 1) @@ -565,7 +565,7 @@ struct bch_extent_crc128 { type:4; #endif struct bch_csum csum; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define CRC128_SIZE_MAX (1U << 13) #define CRC128_NONCE_MAX ((1U << 13) - 1) @@ -591,7 +591,7 @@ struct bch_extent_ptr { cached:1, type:1; #endif -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_extent_stripe_ptr { #if defined(__LITTLE_ENDIAN_BITFIELD) @@ -643,7 +643,7 @@ struct bch_btree_ptr { __u64 _data[0]; struct bch_extent_ptr start[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_btree_ptr_v2 { struct bch_val v; @@ -655,7 +655,7 @@ struct bch_btree_ptr_v2 { struct bpos min_key; __u64 _data[0]; struct bch_extent_ptr start[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); LE16_BITMASK(BTREE_PTR_RANGE_UPDATED, struct bch_btree_ptr_v2, flags, 0, 1); @@ -664,7 +664,7 @@ struct bch_extent { __u64 _data[0]; union bch_extent_entry start[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_reservation { struct bch_val v; @@ -672,7 +672,7 @@ struct bch_reservation { __le32 generation; __u8 nr_replicas; __u8 pad[3]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* Maximum size (in u64s) a single pointer could be: */ #define BKEY_EXTENT_PTR_U64s_MAX\ @@ -706,7 +706,7 @@ struct bch_inode { __le32 bi_flags; __le16 bi_mode; __u8 fields[0]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_inode_v2 { struct bch_val v; @@ -716,7 +716,7 @@ struct bch_inode_v2 { __le64 bi_flags; __le16 bi_mode; __u8 fields[0]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_inode_v3 { struct bch_val v; @@ -728,7 +728,7 @@ struct bch_inode_v3 { __le64 bi_size; __le64 bi_version; __u8 fields[0]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define INODEv3_FIELDS_START_INITIAL 6 #define INODEv3_FIELDS_START_CUR (offsetof(struct bch_inode_v3, fields) / sizeof(u64)) @@ -738,7 +738,7 @@ struct bch_inode_generation { __le32 bi_generation; __le32 pad; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* * bi_subvol and bi_parent_subvol are only set for subvolume roots: @@ -891,7 +891,7 @@ struct bch_dirent { __u8 d_type; __u8 d_name[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define DT_SUBVOL 16 #define BCH_DT_MAX 17 @@ -914,7 +914,7 @@ struct bch_xattr { __u8 x_name_len; __le16 x_val_len; __u8 x_name[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* Bucket/allocation information: */ @@ -923,7 +923,7 @@ struct bch_alloc { __u8 fields; __u8 gen; __u8 data[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define BCH_ALLOC_FIELDS_V1() \ x(read_time, 16) \ @@ -948,7 +948,7 @@ struct bch_alloc_v2 { __u8 oldest_gen; __u8 data_type; __u8 data[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define BCH_ALLOC_FIELDS_V2() \ x(read_time, 64) \ @@ -967,7 +967,7 @@ struct bch_alloc_v3 { __u8 oldest_gen; __u8 data_type; __u8 data[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); LE32_BITMASK(BCH_ALLOC_V3_NEED_DISCARD,struct bch_alloc_v3, flags, 0, 1) LE32_BITMASK(BCH_ALLOC_V3_NEED_INC_GEN,struct bch_alloc_v3, flags, 1, 2) @@ -985,7 +985,7 @@ struct bch_alloc_v4 { __u64 io_time[2]; __u32 stripe; __u32 nr_external_backpointers; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define BCH_ALLOC_V4_U64s_V0 6 #define BCH_ALLOC_V4_U64s (sizeof(struct bch_alloc_v4) / sizeof(u64)) @@ -1005,7 +1005,7 @@ struct bch_backpointer { __u64 bucket_offset:40; __u32 bucket_len; struct bpos pos; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* Quotas: */ @@ -1030,7 +1030,7 @@ struct bch_quota_counter { struct bch_quota { struct bch_val v; struct bch_quota_counter c[Q_COUNTERS]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* Erasure coding */ @@ -1046,7 +1046,7 @@ struct bch_stripe { __u8 pad; struct bch_extent_ptr ptrs[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* Reflink: */ @@ -1063,14 +1063,14 @@ struct bch_reflink_p { */ __le32 front_pad; __le32 back_pad; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_reflink_v { struct bch_val v; __le64 refcount; union bch_extent_entry start[0]; __u64 _data[0]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_indirect_inline_data { struct bch_val v; @@ -1127,7 +1127,7 @@ LE32_BITMASK(BCH_SNAPSHOT_SUBVOL, struct bch_snapshot, flags, 1, 2) struct bch_lru { struct bch_val v; __le64 idx; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define LRU_ID_STRIPES (1U << 16) @@ -1326,19 +1326,19 @@ struct bch_replicas_entry_v0 { __u8 data_type; __u8 nr_devs; __u8 devs[]; -} __attribute__((packed)); +} __packed; struct bch_sb_field_replicas_v0 { struct bch_sb_field field; struct bch_replicas_entry_v0 entries[]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_replicas_entry { __u8 data_type; __u8 nr_devs; __u8 nr_required; __u8 devs[]; -} __attribute__((packed)); +} __packed; #define replicas_entry_bytes(_i) \ (offsetof(typeof(*(_i)), devs) + (_i)->nr_devs) @@ -1346,7 +1346,7 @@ struct bch_replicas_entry { struct bch_sb_field_replicas { struct bch_sb_field field; struct bch_replicas_entry entries[0]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* BCH_SB_FIELD_quota: */ @@ -1363,7 +1363,7 @@ struct bch_sb_quota_type { struct bch_sb_field_quota { struct bch_sb_field field; struct bch_sb_quota_type q[QTYP_NR]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* BCH_SB_FIELD_disk_groups: */ @@ -1372,7 +1372,7 @@ struct bch_sb_field_quota { struct bch_disk_group { __u8 label[BCH_SB_LABEL_SIZE]; __le64 flags[2]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); LE64_BITMASK(BCH_GROUP_DELETED, struct bch_disk_group, flags[0], 0, 1) LE64_BITMASK(BCH_GROUP_DATA_ALLOWED, struct bch_disk_group, flags[0], 1, 6) @@ -1381,7 +1381,7 @@ LE64_BITMASK(BCH_GROUP_PARENT, struct bch_disk_group, flags[0], 6, 24) struct bch_sb_field_disk_groups { struct bch_sb_field field; struct bch_disk_group entries[0]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* BCH_SB_FIELD_counters */ @@ -1565,7 +1565,7 @@ struct bch_sb_layout { __u8 nr_superblocks; __u8 pad[5]; __le64 sb_offset[61]; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #define BCH_SB_LAYOUT_SECTOR 7 @@ -1616,7 +1616,7 @@ struct bch_sb { struct bch_sb_field start[0]; __le64 _data[0]; }; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); /* * Flags: @@ -1899,6 +1899,7 @@ enum bch_compression_opts { static inline __le64 __bch2_sb_magic(struct bch_sb *sb) { __le64 ret; + memcpy(&ret, &sb->uuid, sizeof(ret)); return ret; } @@ -1973,26 +1974,26 @@ enum { struct jset_entry_usage { struct jset_entry entry; __le64 v; -} __attribute__((packed)); +} __packed; struct jset_entry_data_usage { struct jset_entry entry; __le64 v; struct bch_replicas_entry r; -} __attribute__((packed)); +} __packed; struct jset_entry_clock { struct jset_entry entry; __u8 rw; __u8 pad[7]; __le64 time; -} __attribute__((packed)); +} __packed; struct jset_entry_dev_usage_type { __le64 buckets; __le64 sectors; __le64 fragmented; -} __attribute__((packed)); +} __packed; struct jset_entry_dev_usage { struct jset_entry entry; @@ -2003,7 +2004,7 @@ struct jset_entry_dev_usage { __le64 _buckets_unavailable; /* No longer used */ struct jset_entry_dev_usage_type d[]; -} __attribute__((packed)); +} __packed; static inline unsigned jset_entry_dev_usage_nr_types(struct jset_entry_dev_usage *u) { @@ -2014,7 +2015,7 @@ static inline unsigned jset_entry_dev_usage_nr_types(struct jset_entry_dev_usage struct jset_entry_log { struct jset_entry entry; u8 d[]; -} __attribute__((packed)); +} __packed; /* * On disk format for a journal entry: @@ -2049,7 +2050,7 @@ struct jset { struct jset_entry start[0]; __u64 _data[0]; }; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); LE32_BITMASK(JSET_CSUM_TYPE, struct jset, flags, 0, 4); LE32_BITMASK(JSET_BIG_ENDIAN, struct jset, flags, 4, 5); @@ -2112,7 +2113,7 @@ struct bset { struct bkey_packed start[0]; __u64 _data[0]; }; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); LE32_BITMASK(BSET_CSUM_TYPE, struct bset, flags, 0, 4); @@ -2145,7 +2146,7 @@ struct btree_node { }; }; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); LE64_BITMASK(BTREE_NODE_ID, struct btree_node, flags, 0, 4); LE64_BITMASK(BTREE_NODE_LEVEL, struct btree_node, flags, 4, 8); @@ -2166,6 +2167,6 @@ struct btree_node_entry { }; }; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); #endif /* _BCACHEFS_FORMAT_H */ diff --git a/libbcachefs/bcachefs_ioctl.h b/libbcachefs/bcachefs_ioctl.h index b2edabf..ad47a50 100644 --- a/libbcachefs/bcachefs_ioctl.h +++ b/libbcachefs/bcachefs_ioctl.h @@ -208,7 +208,7 @@ struct bch_ioctl_data { __u64 pad[8]; }; }; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); enum bch_data_event { BCH_DATA_EVENT_PROGRESS = 0, @@ -224,7 +224,7 @@ struct bch_ioctl_data_progress { __u64 sectors_done; __u64 sectors_total; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_ioctl_data_event { __u8 type; @@ -233,12 +233,12 @@ struct bch_ioctl_data_event { struct bch_ioctl_data_progress p; __u64 pad2[15]; }; -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); struct bch_replicas_usage { __u64 sectors; struct bch_replicas_entry r; -} __attribute__((packed)); +} __packed; static inline struct bch_replicas_usage * replicas_usage_next(struct bch_replicas_usage *u) diff --git a/libbcachefs/bkey.c b/libbcachefs/bkey.c index f7e5d0c..630df06 100644 --- a/libbcachefs/bkey.c +++ b/libbcachefs/bkey.c @@ -17,9 +17,6 @@ const struct bkey_format bch2_bkey_format_current = BKEY_FORMAT_CURRENT; -struct bkey __bch2_bkey_unpack_key(const struct bkey_format *, - const struct bkey_packed *); - void bch2_bkey_packed_to_binary_text(struct printbuf *out, const struct bkey_format *f, const struct bkey_packed *k) diff --git a/libbcachefs/bkey_methods.c b/libbcachefs/bkey_methods.c index 14d910a..6939d74 100644 --- a/libbcachefs/bkey_methods.c +++ b/libbcachefs/bkey_methods.c @@ -29,13 +29,13 @@ static int deleted_key_invalid(const struct bch_fs *c, struct bkey_s_c k, return 0; } -#define bch2_bkey_ops_deleted (struct bkey_ops) { \ +#define bch2_bkey_ops_deleted ((struct bkey_ops) { \ .key_invalid = deleted_key_invalid, \ -} +}) -#define bch2_bkey_ops_whiteout (struct bkey_ops) { \ +#define bch2_bkey_ops_whiteout ((struct bkey_ops) { \ .key_invalid = deleted_key_invalid, \ -} +}) static int empty_val_key_invalid(const struct bch_fs *c, struct bkey_s_c k, int rw, struct printbuf *err) @@ -49,9 +49,9 @@ static int empty_val_key_invalid(const struct bch_fs *c, struct bkey_s_c k, return 0; } -#define bch2_bkey_ops_error (struct bkey_ops) { \ +#define bch2_bkey_ops_error ((struct bkey_ops) { \ .key_invalid = empty_val_key_invalid, \ -} +}) static int key_type_cookie_invalid(const struct bch_fs *c, struct bkey_s_c k, int rw, struct printbuf *err) @@ -65,13 +65,13 @@ static int key_type_cookie_invalid(const struct bch_fs *c, struct bkey_s_c k, return 0; } -#define bch2_bkey_ops_cookie (struct bkey_ops) { \ +#define bch2_bkey_ops_cookie ((struct bkey_ops) { \ .key_invalid = key_type_cookie_invalid, \ -} +}) -#define bch2_bkey_ops_hash_whiteout (struct bkey_ops) { \ +#define bch2_bkey_ops_hash_whiteout ((struct bkey_ops) {\ .key_invalid = empty_val_key_invalid, \ -} +}) static int key_type_inline_data_invalid(const struct bch_fs *c, struct bkey_s_c k, int rw, struct printbuf *err) @@ -89,10 +89,10 @@ static void key_type_inline_data_to_text(struct printbuf *out, struct bch_fs *c, datalen, min(datalen, 32U), d.v->data); } -#define bch2_bkey_ops_inline_data (struct bkey_ops) { \ +#define bch2_bkey_ops_inline_data ((struct bkey_ops) { \ .key_invalid = key_type_inline_data_invalid, \ .val_to_text = key_type_inline_data_to_text, \ -} +}) static int key_type_set_invalid(const struct bch_fs *c, struct bkey_s_c k, int rw, struct printbuf *err) @@ -112,10 +112,10 @@ static bool key_type_set_merge(struct bch_fs *c, struct bkey_s l, struct bkey_s_ return true; } -#define bch2_bkey_ops_set (struct bkey_ops) { \ +#define bch2_bkey_ops_set ((struct bkey_ops) { \ .key_invalid = key_type_set_invalid, \ .key_merge = key_type_set_merge, \ -} +}) const struct bkey_ops bch2_bkey_ops[] = { #define x(name, nr) [KEY_TYPE_##name] = bch2_bkey_ops_##name, @@ -440,6 +440,7 @@ void __bch2_bkey_compat(unsigned level, enum btree_id btree_id, btree_id == BTREE_ID_inodes) { if (!bkey_packed(k)) { struct bkey_i *u = packed_to_bkey(k); + swap(u->k.p.inode, u->k.p.offset); } else if (f->bits_per_field[BKEY_FIELD_INODE] && f->bits_per_field[BKEY_FIELD_OFFSET]) { diff --git a/libbcachefs/bkey_methods.h b/libbcachefs/bkey_methods.h index db894b4..4739b3c 100644 --- a/libbcachefs/bkey_methods.h +++ b/libbcachefs/bkey_methods.h @@ -18,7 +18,7 @@ extern const char * const bch2_bkey_types[]; * * When invalid, error string is returned via @err. @rw indicates whether key is * being read or written; more aggressive checks can be enabled when rw == WRITE. -*/ + */ struct bkey_ops { int (*key_invalid)(const struct bch_fs *c, struct bkey_s_c k, int rw, struct printbuf *err); diff --git a/libbcachefs/btree_cache.c b/libbcachefs/btree_cache.c index 8dd2db4..d1cbf92 100644 --- a/libbcachefs/btree_cache.c +++ b/libbcachefs/btree_cache.c @@ -118,7 +118,9 @@ static int btree_node_data_alloc(struct bch_fs *c, struct btree *b, gfp_t gfp) static struct btree *__btree_node_mem_alloc(struct bch_fs *c, gfp_t gfp) { - struct btree *b = kzalloc(sizeof(struct btree), gfp); + struct btree *b; + + b = kzalloc(sizeof(struct btree), gfp); if (!b) return NULL; @@ -136,7 +138,9 @@ static struct btree *__btree_node_mem_alloc(struct bch_fs *c, gfp_t gfp) struct btree *__bch2_btree_node_mem_alloc(struct bch_fs *c) { struct btree_cache *bc = &c->btree_cache; - struct btree *b = __btree_node_mem_alloc(c, GFP_KERNEL); + struct btree *b; + + b = __btree_node_mem_alloc(c, GFP_KERNEL); if (!b) return NULL; @@ -155,6 +159,7 @@ struct btree *__bch2_btree_node_mem_alloc(struct bch_fs *c) void bch2_btree_node_hash_remove(struct btree_cache *bc, struct btree *b) { int ret = rhashtable_remove_fast(&bc->table, &b->hash, bch_btree_cache_params); + BUG_ON(ret); /* Cause future lookups for this node to fail: */ diff --git a/libbcachefs/btree_gc.c b/libbcachefs/btree_gc.c index 801a09f..20e804e 100644 --- a/libbcachefs/btree_gc.c +++ b/libbcachefs/btree_gc.c @@ -199,7 +199,7 @@ static int set_node_min(struct bch_fs *c, struct btree *b, struct bpos new_min) struct bkey_i_btree_ptr_v2 *new; int ret; - new = kmalloc(BKEY_BTREE_PTR_U64s_MAX * sizeof(u64), GFP_KERNEL); + new = kmalloc_array(BKEY_BTREE_PTR_U64s_MAX, sizeof(u64), GFP_KERNEL); if (!new) return -ENOMEM; @@ -228,7 +228,7 @@ static int set_node_max(struct bch_fs *c, struct btree *b, struct bpos new_max) if (ret) return ret; - new = kmalloc(BKEY_BTREE_PTR_U64s_MAX * sizeof(u64), GFP_KERNEL); + new = kmalloc_array(BKEY_BTREE_PTR_U64s_MAX, sizeof(u64), GFP_KERNEL); if (!new) return -ENOMEM; diff --git a/libbcachefs/btree_io.c b/libbcachefs/btree_io.c index dd6b536..90f67cc 100644 --- a/libbcachefs/btree_io.c +++ b/libbcachefs/btree_io.c @@ -1216,6 +1216,7 @@ static void btree_node_read_endio(struct bio *bio) if (rb->have_ioref) { struct bch_dev *ca = bch_dev_bkey_exists(c, rb->pick.ptr.dev); + bch2_latency_acct(ca, rb->start_time, READ); } @@ -1403,6 +1404,7 @@ static void btree_node_read_all_replicas_endio(struct bio *bio) if (rb->have_ioref) { struct bch_dev *ca = bch_dev_bkey_exists(c, rb->pick.ptr.dev); + bch2_latency_acct(ca, rb->start_time, READ); } diff --git a/libbcachefs/btree_iter.c b/libbcachefs/btree_iter.c index d18346a..da11615 100644 --- a/libbcachefs/btree_iter.c +++ b/libbcachefs/btree_iter.c @@ -214,6 +214,7 @@ err: if (p) { struct bkey uk = bkey_unpack_key(l->b, p); + bch2_bkey_to_text(&buf2, &uk); } else { prt_printf(&buf2, "(none)"); @@ -221,6 +222,7 @@ err: if (k) { struct bkey uk = bkey_unpack_key(l->b, k); + bch2_bkey_to_text(&buf3, &uk); } else { prt_printf(&buf3, "(none)"); @@ -1801,7 +1803,8 @@ struct bkey_i *bch2_btree_journal_peek(struct btree_trans *trans, if (bpos_cmp(start_pos, iter->journal_pos) < 0) iter->journal_idx = 0; - k = bch2_journal_keys_peek_upto(trans->c, iter->btree_id, 0, + k = bch2_journal_keys_peek_upto(trans->c, iter->btree_id, + iter->path->level, start_pos, end_pos, &iter->journal_idx); @@ -1823,7 +1826,7 @@ struct bkey_s_c btree_trans_peek_journal(struct btree_trans *trans, { struct bkey_i *next_journal = bch2_btree_journal_peek(trans, iter, iter->path->pos, - k.k ? k.k->p : iter->path->l[0].b->key.k.p); + k.k ? k.k->p : path_l(iter->path)->b->key.k.p); if (next_journal) { iter->k = next_journal->k; @@ -2902,7 +2905,7 @@ void __bch2_trans_init(struct btree_trans *trans, struct bch_fs *c, unsigned fn_ bch2_trans_alloc_paths(trans, c); s = btree_trans_stats(trans); - if (s) { + if (s && s->max_mem) { unsigned expected_mem_bytes = roundup_pow_of_two(s->max_mem); trans->mem = kmalloc(expected_mem_bytes, GFP_KERNEL); @@ -2913,9 +2916,9 @@ void __bch2_trans_init(struct btree_trans *trans, struct bch_fs *c, unsigned fn_ } else { trans->mem_bytes = expected_mem_bytes; } - - trans->nr_max_paths = s->nr_max_paths; } + if (s) + trans->nr_max_paths = s->nr_max_paths; trans->srcu_idx = srcu_read_lock(&c->btree_trans_barrier); diff --git a/libbcachefs/btree_key_cache.c b/libbcachefs/btree_key_cache.c index cd52dd5..66fb698 100644 --- a/libbcachefs/btree_key_cache.c +++ b/libbcachefs/btree_key_cache.c @@ -104,6 +104,7 @@ static void bkey_cached_free(struct btree_key_cache *bc, six_unlock_intent(&ck->c.lock); } +#ifdef __KERNEL__ static void __bkey_cached_move_to_freelist_ordered(struct btree_key_cache *bc, struct bkey_cached *ck) { @@ -119,17 +120,18 @@ static void __bkey_cached_move_to_freelist_ordered(struct btree_key_cache *bc, list_move(&ck->list, &bc->freed_nonpcpu); } +#endif static void bkey_cached_move_to_freelist(struct btree_key_cache *bc, struct bkey_cached *ck) { - struct btree_key_cache_freelist *f; - bool freed = false; - BUG_ON(test_bit(BKEY_CACHED_DIRTY, &ck->flags)); if (!ck->c.lock.readers) { #ifdef __KERNEL__ + struct btree_key_cache_freelist *f; + bool freed = false; + preempt_disable(); f = this_cpu_ptr(bc->pcpu_freed); @@ -193,11 +195,12 @@ bkey_cached_alloc(struct btree_trans *trans, struct btree_path *path) struct bch_fs *c = trans->c; struct btree_key_cache *bc = &c->btree_key_cache; struct bkey_cached *ck = NULL; - struct btree_key_cache_freelist *f; bool pcpu_readers = btree_uses_pcpu_readers(path->btree_id); if (!pcpu_readers) { #ifdef __KERNEL__ + struct btree_key_cache_freelist *f; + preempt_disable(); f = this_cpu_ptr(bc->pcpu_freed); if (f->nr) diff --git a/libbcachefs/btree_key_cache.h b/libbcachefs/btree_key_cache.h index 670746e..eccea15 100644 --- a/libbcachefs/btree_key_cache.h +++ b/libbcachefs/btree_key_cache.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _BCACHEFS_BTREE_KEY_CACHE_H #define _BCACHEFS_BTREE_KEY_CACHE_H diff --git a/libbcachefs/btree_locking.h b/libbcachefs/btree_locking.h index bf8d188..fb237c9 100644 --- a/libbcachefs/btree_locking.h +++ b/libbcachefs/btree_locking.h @@ -296,6 +296,7 @@ static inline void bch2_btree_node_lock_write_nofail(struct btree_trans *trans, struct btree_bkey_cached_common *b) { int ret = __btree_node_lock_write(trans, path, b, true); + BUG_ON(ret); } diff --git a/libbcachefs/btree_types.h b/libbcachefs/btree_types.h index 892d123..cab3de0 100644 --- a/libbcachefs/btree_types.h +++ b/libbcachefs/btree_types.h @@ -326,7 +326,7 @@ struct btree_key_cache { struct bkey_cached_key { u32 btree_id; struct bpos pos; -} __attribute__((packed, aligned(4))); +} __packed __aligned(4); #define BKEY_CACHED_ACCESSED 0 #define BKEY_CACHED_DIRTY 1 diff --git a/libbcachefs/btree_update_interior.c b/libbcachefs/btree_update_interior.c index 40debf7..5ce91ae 100644 --- a/libbcachefs/btree_update_interior.c +++ b/libbcachefs/btree_update_interior.c @@ -665,7 +665,7 @@ static void btree_update_nodes_written(struct btree_update *as) bch2_trans_unlock(&trans); bch2_fs_fatal_err_on(ret && !bch2_journal_error(&c->journal), c, - "error %i in btree_update_nodes_written()", ret); + "%s(): error %s", __func__, bch2_err_str(ret)); err: if (as->b) { struct btree_path *path; @@ -1838,10 +1838,10 @@ int __bch2_foreground_maybe_merge(struct btree_trans *trans, bch2_bpos_to_text(&buf1, prev->data->max_key); bch2_bpos_to_text(&buf2, next->data->min_key); bch_err(c, - "btree topology error in btree merge:\n" + "%s(): btree topology error:\n" " prev ends at %s\n" " next starts at %s", - buf1.buf, buf2.buf); + __func__, buf1.buf, buf2.buf); printbuf_exit(&buf1); printbuf_exit(&buf2); bch2_topology_error(c); diff --git a/libbcachefs/buckets.c b/libbcachefs/buckets.c index 116711f..cd29794 100644 --- a/libbcachefs/buckets.c +++ b/libbcachefs/buckets.c @@ -575,7 +575,8 @@ int bch2_mark_alloc(struct btree_trans *trans, -((s64) old_a.cached_sectors), journal_seq, gc); if (ret) { - bch2_fs_fatal_error(c, "bch2_mark_alloc(): no replicas entry while updating cached sectors"); + bch2_fs_fatal_error(c, "%s(): no replicas entry while updating cached sectors", + __func__); return ret; } } @@ -959,7 +960,8 @@ int bch2_mark_extent(struct btree_trans *trans, ret = update_cached_sectors(c, k, p.ptr.dev, disk_sectors, journal_seq, true); if (ret) { - bch2_fs_fatal_error(c, "bch2_mark_extent(): no replicas entry while updating cached sectors"); + bch2_fs_fatal_error(c, "%s(): no replicas entry while updating cached sectors", + __func__); return ret; } } @@ -987,7 +989,7 @@ int bch2_mark_extent(struct btree_trans *trans, struct printbuf buf = PRINTBUF; bch2_bkey_val_to_text(&buf, c, k); - bch2_fs_fatal_error(c, "no replicas entry for %s", buf.buf); + bch2_fs_fatal_error(c, "%s(): no replicas entry for %s", __func__, buf.buf); printbuf_exit(&buf); return ret; } diff --git a/libbcachefs/checksum.h b/libbcachefs/checksum.h index c86c3c0..3d6d13b 100644 --- a/libbcachefs/checksum.h +++ b/libbcachefs/checksum.h @@ -78,15 +78,15 @@ 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(); + BUG(); } } diff --git a/libbcachefs/dirent.h b/libbcachefs/dirent.h index b146693..1a2c910 100644 --- a/libbcachefs/dirent.h +++ b/libbcachefs/dirent.h @@ -9,10 +9,10 @@ extern const struct bch_hash_desc bch2_dirent_hash_desc; int bch2_dirent_invalid(const struct bch_fs *, struct bkey_s_c, int, struct printbuf *); void bch2_dirent_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_dirent (struct bkey_ops) { \ +#define bch2_bkey_ops_dirent ((struct bkey_ops) { \ .key_invalid = bch2_dirent_invalid, \ .val_to_text = bch2_dirent_to_text, \ -} +}) struct qstr; struct file; diff --git a/libbcachefs/ec.h b/libbcachefs/ec.h index 3e2b22c..aba1e82 100644 --- a/libbcachefs/ec.h +++ b/libbcachefs/ec.h @@ -10,13 +10,13 @@ int bch2_stripe_invalid(const struct bch_fs *, struct bkey_s_c, void bch2_stripe_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_stripe (struct bkey_ops) { \ +#define bch2_bkey_ops_stripe ((struct bkey_ops) { \ .key_invalid = bch2_stripe_invalid, \ .val_to_text = bch2_stripe_to_text, \ .swab = bch2_ptr_swab, \ .trans_trigger = bch2_trans_mark_stripe, \ .atomic_trigger = bch2_mark_stripe, \ -} +}) static inline unsigned stripe_csums_per_device(const struct bch_stripe *s) { diff --git a/libbcachefs/errcode.c b/libbcachefs/errcode.c index cc9ce0b..dc906fc 100644 --- a/libbcachefs/errcode.c +++ b/libbcachefs/errcode.c @@ -23,6 +23,7 @@ static unsigned bch2_errcode_parents[] = { const char *bch2_err_str(int err) { const char *errstr; + err = abs(err); BUG_ON(err >= BCH_ERR_MAX); diff --git a/libbcachefs/extents.h b/libbcachefs/extents.h index 3c17b81..224df17 100644 --- a/libbcachefs/extents.h +++ b/libbcachefs/extents.h @@ -198,6 +198,7 @@ static inline struct bkey_ptrs_c bch2_bkey_ptrs_c(struct bkey_s_c k) switch (k.k->type) { case KEY_TYPE_btree_ptr: { struct bkey_s_c_btree_ptr e = bkey_s_c_to_btree_ptr(k); + return (struct bkey_ptrs_c) { to_entry(&e.v->start[0]), to_entry(extent_entry_last(e)) @@ -205,6 +206,7 @@ static inline struct bkey_ptrs_c bch2_bkey_ptrs_c(struct bkey_s_c k) } case KEY_TYPE_extent: { struct bkey_s_c_extent e = bkey_s_c_to_extent(k); + return (struct bkey_ptrs_c) { e.v->start, extent_entry_last(e) @@ -212,6 +214,7 @@ static inline struct bkey_ptrs_c bch2_bkey_ptrs_c(struct bkey_s_c k) } case KEY_TYPE_stripe: { struct bkey_s_c_stripe s = bkey_s_c_to_stripe(k); + return (struct bkey_ptrs_c) { to_entry(&s.v->ptrs[0]), to_entry(&s.v->ptrs[s.v->nr_blocks]), @@ -227,6 +230,7 @@ static inline struct bkey_ptrs_c bch2_bkey_ptrs_c(struct bkey_s_c k) } case KEY_TYPE_btree_ptr_v2: { struct bkey_s_c_btree_ptr_v2 e = bkey_s_c_to_btree_ptr_v2(k); + return (struct bkey_ptrs_c) { to_entry(&e.v->start[0]), to_entry(extent_entry_last(e)) @@ -342,7 +346,7 @@ out: \ #define extent_for_each_entry_from(_e, _entry, _start) \ __bkey_extent_entry_for_each_from(_start, \ - extent_entry_last(_e),_entry) + extent_entry_last(_e), _entry) #define extent_for_each_entry(_e, _entry) \ extent_for_each_entry_from(_e, _entry, (_e).v->start) @@ -376,28 +380,28 @@ void bch2_btree_ptr_v2_to_text(struct printbuf *, struct bch_fs *, struct bkey_s void bch2_btree_ptr_v2_compat(enum btree_id, unsigned, unsigned, int, struct bkey_s); -#define bch2_bkey_ops_btree_ptr (struct bkey_ops) { \ +#define bch2_bkey_ops_btree_ptr ((struct bkey_ops) { \ .key_invalid = bch2_btree_ptr_invalid, \ .val_to_text = bch2_btree_ptr_to_text, \ .swab = bch2_ptr_swab, \ .trans_trigger = bch2_trans_mark_extent, \ .atomic_trigger = bch2_mark_extent, \ -} +}) -#define bch2_bkey_ops_btree_ptr_v2 (struct bkey_ops) { \ +#define bch2_bkey_ops_btree_ptr_v2 ((struct bkey_ops) { \ .key_invalid = bch2_btree_ptr_v2_invalid, \ .val_to_text = bch2_btree_ptr_v2_to_text, \ .swab = bch2_ptr_swab, \ .compat = bch2_btree_ptr_v2_compat, \ .trans_trigger = bch2_trans_mark_extent, \ .atomic_trigger = bch2_mark_extent, \ -} +}) /* KEY_TYPE_extent: */ bool bch2_extent_merge(struct bch_fs *, struct bkey_s, struct bkey_s_c); -#define bch2_bkey_ops_extent (struct bkey_ops) { \ +#define bch2_bkey_ops_extent ((struct bkey_ops) { \ .key_invalid = bch2_bkey_ptrs_invalid, \ .val_to_text = bch2_bkey_ptrs_to_text, \ .swab = bch2_ptr_swab, \ @@ -405,7 +409,7 @@ bool bch2_extent_merge(struct bch_fs *, struct bkey_s, struct bkey_s_c); .key_merge = bch2_extent_merge, \ .trans_trigger = bch2_trans_mark_extent, \ .atomic_trigger = bch2_mark_extent, \ -} +}) /* KEY_TYPE_reservation: */ @@ -414,13 +418,13 @@ int bch2_reservation_invalid(const struct bch_fs *, struct bkey_s_c, void bch2_reservation_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); bool bch2_reservation_merge(struct bch_fs *, struct bkey_s, struct bkey_s_c); -#define bch2_bkey_ops_reservation (struct bkey_ops) { \ +#define bch2_bkey_ops_reservation ((struct bkey_ops) { \ .key_invalid = bch2_reservation_invalid, \ .val_to_text = bch2_reservation_to_text, \ .key_merge = bch2_reservation_merge, \ .trans_trigger = bch2_trans_mark_reservation, \ .atomic_trigger = bch2_mark_reservation, \ -} +}) /* Extent checksum entries: */ diff --git a/libbcachefs/fifo.h b/libbcachefs/fifo.h index cdb2727..66b945b 100644 --- a/libbcachefs/fifo.h +++ b/libbcachefs/fifo.h @@ -65,7 +65,7 @@ do { \ (((p) - (fifo)->data))) #define fifo_entry_idx(fifo, p) (((p) - &fifo_peek_front(fifo)) & (fifo)->mask) -#define fifo_idx_entry(fifo, i) (fifo)->data[((fifo)->front + (i)) & (fifo)->mask] +#define fifo_idx_entry(fifo, i) ((fifo)->data[((fifo)->front + (i)) & (fifo)->mask]) #define fifo_push_back_ref(f) \ (fifo_full((f)) ? NULL : &(f)->data[(f)->back++ & (f)->mask]) diff --git a/libbcachefs/fsck.c b/libbcachefs/fsck.c index ca95d85..f4f0e0c 100644 --- a/libbcachefs/fsck.c +++ b/libbcachefs/fsck.c @@ -321,7 +321,7 @@ static int __remove_dirent(struct btree_trans *trans, struct bpos pos) bch2_trans_iter_exit(trans, &iter); err: if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart)) - bch_err(c, "error from __remove_dirent(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -506,7 +506,7 @@ static int snapshots_seen_add(struct bch_fs *c, struct snapshots_seen *s, u32 id break; if (i->equiv == n.equiv) { - bch_err(c, "adding duplicate snapshot in snapshots_seen_add()"); + bch_err(c, "%s(): adding duplicate snapshot", __func__); return -EINVAL; } } @@ -848,8 +848,7 @@ out: printbuf_exit(&buf); return ret; bad_hash: - if (fsck_err(c, "hash table key at wrong offset: btree %s inode %llu offset %llu, " - "hashed to %llu\n%s", + if (fsck_err(c, "hash table key at wrong offset: btree %s inode %llu offset %llu, hashed to %llu\n%s", bch2_btree_ids[desc.btree_id], hash_k.k->p.inode, hash_k.k->p.offset, hash, (printbuf_reset(&buf), bch2_bkey_val_to_text(&buf, c, hash_k), buf.buf))) { @@ -1000,7 +999,7 @@ static int check_inode(struct btree_trans *trans, err: fsck_err: if (ret) - bch_err(c, "error from check_inode(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -1026,7 +1025,7 @@ static int check_inodes(struct bch_fs *c, bool full) bch2_trans_exit(&trans); snapshots_seen_exit(&s); if (ret) - bch_err(c, "error from check_inodes(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -1159,7 +1158,7 @@ static int check_i_sectors(struct btree_trans *trans, struct inode_walker *w) } fsck_err: if (ret) - bch_err(c, "error from check_i_sectors(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); if (!ret && trans_was_restarted(trans, restart_count)) ret = -BCH_ERR_transaction_restart_nested; return ret; @@ -1295,7 +1294,7 @@ fsck_err: printbuf_exit(&buf); if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart)) - bch_err(c, "error from check_extent(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -1337,7 +1336,7 @@ static int check_extents(struct bch_fs *c) snapshots_seen_exit(&s); if (ret) - bch_err(c, "error from check_extents(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -1376,7 +1375,7 @@ static int check_subdir_count(struct btree_trans *trans, struct inode_walker *w) } fsck_err: if (ret) - bch_err(c, "error from check_subdir_count(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); if (!ret && trans_was_restarted(trans, restart_count)) ret = -BCH_ERR_transaction_restart_nested; return ret; @@ -1497,7 +1496,7 @@ fsck_err: printbuf_exit(&buf); if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart)) - bch_err(c, "error from check_target(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -1667,7 +1666,7 @@ fsck_err: printbuf_exit(&buf); if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart)) - bch_err(c, "error from check_dirent(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -1706,7 +1705,7 @@ static int check_dirents(struct bch_fs *c) inode_walker_exit(&target); if (ret) - bch_err(c, "error from check_dirents(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -1742,7 +1741,7 @@ static int check_xattr(struct btree_trans *trans, struct btree_iter *iter, ret = hash_check_key(trans, bch2_xattr_hash_desc, hash_info, iter, k); fsck_err: if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart)) - bch_err(c, "error from check_xattr(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } @@ -1774,7 +1773,7 @@ static int check_xattrs(struct bch_fs *c) bch2_trans_exit(&trans); if (ret) - bch_err(c, "error from check_xattrs(): %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } diff --git a/libbcachefs/inode.h b/libbcachefs/inode.h index 2915f4f..a9742bb 100644 --- a/libbcachefs/inode.h +++ b/libbcachefs/inode.h @@ -12,26 +12,26 @@ int bch2_inode_v2_invalid(const struct bch_fs *, struct bkey_s_c, int, struct pr int bch2_inode_v3_invalid(const struct bch_fs *, struct bkey_s_c, int, struct printbuf *); void bch2_inode_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_inode (struct bkey_ops) { \ +#define bch2_bkey_ops_inode ((struct bkey_ops) { \ .key_invalid = bch2_inode_invalid, \ .val_to_text = bch2_inode_to_text, \ .trans_trigger = bch2_trans_mark_inode, \ .atomic_trigger = bch2_mark_inode, \ -} +}) -#define bch2_bkey_ops_inode_v2 (struct bkey_ops) { \ +#define bch2_bkey_ops_inode_v2 ((struct bkey_ops) { \ .key_invalid = bch2_inode_v2_invalid, \ .val_to_text = bch2_inode_to_text, \ .trans_trigger = bch2_trans_mark_inode, \ .atomic_trigger = bch2_mark_inode, \ -} +}) -#define bch2_bkey_ops_inode_v3 (struct bkey_ops) { \ +#define bch2_bkey_ops_inode_v3 ((struct bkey_ops) { \ .key_invalid = bch2_inode_v3_invalid, \ .val_to_text = bch2_inode_to_text, \ .trans_trigger = bch2_trans_mark_inode, \ .atomic_trigger = bch2_mark_inode, \ -} +}) static inline bool bkey_is_inode(const struct bkey *k) { @@ -44,10 +44,10 @@ int bch2_inode_generation_invalid(const struct bch_fs *, struct bkey_s_c, int, struct printbuf *); void bch2_inode_generation_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_inode_generation (struct bkey_ops) { \ +#define bch2_bkey_ops_inode_generation ((struct bkey_ops) { \ .key_invalid = bch2_inode_generation_invalid, \ .val_to_text = bch2_inode_generation_to_text, \ -} +}) #if 0 typedef struct { @@ -78,7 +78,7 @@ struct bkey_inode_buf { #define x(_name, _bits) + 8 + _bits / 8 u8 _pad[0 + BCH_INODE_FIELDS_v3()]; #undef x -} __attribute__((packed, aligned(8))); +} __packed __aligned(8); void bch2_inode_pack(struct bkey_inode_buf *, const struct bch_inode_unpacked *); int bch2_inode_unpack(struct bkey_s_c, struct bch_inode_unpacked *); diff --git a/libbcachefs/journal.h b/libbcachefs/journal.h index 9428f42..51d29a0 100644 --- a/libbcachefs/journal.h +++ b/libbcachefs/journal.h @@ -29,8 +29,8 @@ * * Synchronous updates are specified by passing a closure (@flush_cl) to * bch2_btree_insert() or bch_btree_insert_node(), which then pass that parameter - * down to the journalling code. That closure will will wait on the journal - * write to complete (via closure_wait()). + * down to the journalling code. That closure will wait on the journal write to + * complete (via closure_wait()). * * If the index update wasn't synchronous, the journal entry will be * written out after 10 ms have elapsed, by default (the delay_ms field diff --git a/libbcachefs/lru.h b/libbcachefs/lru.h index 3decb7b..925c29b 100644 --- a/libbcachefs/lru.h +++ b/libbcachefs/lru.h @@ -5,10 +5,10 @@ int bch2_lru_invalid(const struct bch_fs *, struct bkey_s_c, int, struct printbuf *); void bch2_lru_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_lru (struct bkey_ops) { \ +#define bch2_bkey_ops_lru ((struct bkey_ops) { \ .key_invalid = bch2_lru_invalid, \ .val_to_text = bch2_lru_to_text, \ -} +}) int bch2_lru_delete(struct btree_trans *, u64, u64, u64, struct bkey_s_c); int bch2_lru_set(struct btree_trans *, u64, u64, u64 *); diff --git a/libbcachefs/quota.h b/libbcachefs/quota.h index 8c67ae1..59bed11 100644 --- a/libbcachefs/quota.h +++ b/libbcachefs/quota.h @@ -10,10 +10,10 @@ extern const struct bch_sb_field_ops bch_sb_field_ops_quota; int bch2_quota_invalid(const struct bch_fs *, struct bkey_s_c, int, struct printbuf *); void bch2_quota_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_quota (struct bkey_ops) { \ +#define bch2_bkey_ops_quota ((struct bkey_ops) { \ .key_invalid = bch2_quota_invalid, \ .val_to_text = bch2_quota_to_text, \ -} +}) static inline struct bch_qid bch_qid(struct bch_inode_unpacked *u) { diff --git a/libbcachefs/recovery.c b/libbcachefs/recovery.c index ea7810a..6968f93 100644 --- a/libbcachefs/recovery.c +++ b/libbcachefs/recovery.c @@ -1251,6 +1251,20 @@ use_clean: goto err; bch_verbose(c, "done checking need_discard and freespace btrees"); + if (c->sb.version < bcachefs_metadata_version_snapshot_2) { + err = "error creating root snapshot node"; + ret = bch2_fs_initialize_subvolumes(c); + if (ret) + goto err; + } + + bch_verbose(c, "reading snapshots table"); + err = "error reading snapshots table"; + ret = bch2_fs_snapshots_start(c); + if (ret) + goto err; + bch_verbose(c, "reading snapshots done"); + set_bit(BCH_FS_MAY_GO_RW, &c->flags); bch_info(c, "starting journal replay, %zu keys", c->journal_keys.nr); @@ -1299,7 +1313,6 @@ use_clean: bch_verbose(c, "done checking alloc to lru refs"); set_bit(BCH_FS_CHECK_ALLOC_TO_LRU_REFS_DONE, &c->flags); } else { - set_bit(BCH_FS_MAY_GO_RW, &c->flags); set_bit(BCH_FS_INITIAL_GC_DONE, &c->flags); set_bit(BCH_FS_CHECK_LRUS_DONE, &c->flags); set_bit(BCH_FS_CHECK_BACKPOINTERS_DONE, &c->flags); @@ -1309,6 +1322,22 @@ use_clean: if (c->opts.norecovery) goto out; + if (c->sb.version < bcachefs_metadata_version_snapshot_2) { + err = "error creating root snapshot node"; + ret = bch2_fs_initialize_subvolumes(c); + if (ret) + goto err; + } + + bch_verbose(c, "reading snapshots table"); + err = "error reading snapshots table"; + ret = bch2_fs_snapshots_start(c); + if (ret) + goto err; + bch_verbose(c, "reading snapshots done"); + + set_bit(BCH_FS_MAY_GO_RW, &c->flags); + bch_verbose(c, "starting journal replay, %zu keys", c->journal_keys.nr); err = "journal replay failed"; ret = bch2_journal_replay(c); @@ -1323,22 +1352,6 @@ use_clean: if (ret) goto err; - if (c->sb.version < bcachefs_metadata_version_snapshot_2) { - bch2_fs_lazy_rw(c); - - err = "error creating root snapshot node"; - ret = bch2_fs_initialize_subvolumes(c); - if (ret) - goto err; - } - - bch_verbose(c, "reading snapshots table"); - err = "error reading snapshots table"; - ret = bch2_fs_snapshots_start(c); - if (ret) - goto err; - bch_verbose(c, "reading snapshots done"); - if (c->sb.version < bcachefs_metadata_version_snapshot_2) { /* set bi_subvol on root inode */ err = "error upgrade root inode for subvolumes"; @@ -1423,7 +1436,8 @@ out: set_bit(BCH_FS_FSCK_DONE, &c->flags); bch2_flush_fsck_errs(c); - if (!c->opts.keep_journal) { + if (!c->opts.keep_journal && + test_bit(JOURNAL_REPLAY_DONE, &c->journal.flags)) { bch2_journal_keys_free(&c->journal_keys); bch2_journal_entries_free(c); } @@ -1536,8 +1550,7 @@ int bch2_fs_initialize(struct bch_fs *c) goto err; bch_verbose(c, "reading snapshots done"); - bch2_inode_init(c, &root_inode, 0, 0, - S_IFDIR|S_IRWXU|S_IRUGO|S_IXUGO, 0, NULL); + bch2_inode_init(c, &root_inode, 0, 0, S_IFDIR|0755, 0, NULL); root_inode.bi_inum = BCACHEFS_ROOT_INO; root_inode.bi_subvol = BCACHEFS_ROOT_SUBVOL; bch2_inode_pack(&packed_inode, &root_inode); diff --git a/libbcachefs/reflink.h b/libbcachefs/reflink.h index f9848dc..ce0012a 100644 --- a/libbcachefs/reflink.h +++ b/libbcachefs/reflink.h @@ -8,13 +8,13 @@ void bch2_reflink_p_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); bool bch2_reflink_p_merge(struct bch_fs *, struct bkey_s, struct bkey_s_c); -#define bch2_bkey_ops_reflink_p (struct bkey_ops) { \ +#define bch2_bkey_ops_reflink_p ((struct bkey_ops) { \ .key_invalid = bch2_reflink_p_invalid, \ .val_to_text = bch2_reflink_p_to_text, \ .key_merge = bch2_reflink_p_merge, \ .trans_trigger = bch2_trans_mark_reflink_p, \ .atomic_trigger = bch2_mark_reflink_p, \ -} +}) int bch2_reflink_v_invalid(const struct bch_fs *, struct bkey_s_c, int, struct printbuf *); @@ -23,13 +23,13 @@ void bch2_reflink_v_to_text(struct printbuf *, struct bch_fs *, int bch2_trans_mark_reflink_v(struct btree_trans *, enum btree_id, unsigned, struct bkey_s_c, struct bkey_i *, unsigned); -#define bch2_bkey_ops_reflink_v (struct bkey_ops) { \ +#define bch2_bkey_ops_reflink_v ((struct bkey_ops) { \ .key_invalid = bch2_reflink_v_invalid, \ .val_to_text = bch2_reflink_v_to_text, \ .swab = bch2_ptr_swab, \ .trans_trigger = bch2_trans_mark_reflink_v, \ .atomic_trigger = bch2_mark_extent, \ -} +}) int bch2_indirect_inline_data_invalid(const struct bch_fs *, struct bkey_s_c, int, struct printbuf *); @@ -40,11 +40,11 @@ int bch2_trans_mark_indirect_inline_data(struct btree_trans *, struct bkey_s_c, struct bkey_i *, unsigned); -#define bch2_bkey_ops_indirect_inline_data (struct bkey_ops) { \ +#define bch2_bkey_ops_indirect_inline_data ((struct bkey_ops) { \ .key_invalid = bch2_indirect_inline_data_invalid, \ .val_to_text = bch2_indirect_inline_data_to_text, \ .trans_trigger = bch2_trans_mark_indirect_inline_data, \ -} +}) static inline const __le64 *bkey_refcount_c(struct bkey_s_c k) { diff --git a/libbcachefs/replicas_types.h b/libbcachefs/replicas_types.h index 0535b1d..f12a35b 100644 --- a/libbcachefs/replicas_types.h +++ b/libbcachefs/replicas_types.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _BCACHEFS_REPLICAS_TYPES_H #define _BCACHEFS_REPLICAS_TYPES_H diff --git a/libbcachefs/subvolume.c b/libbcachefs/subvolume.c index 8c98bac..1133783 100644 --- a/libbcachefs/subvolume.c +++ b/libbcachefs/subvolume.c @@ -158,6 +158,7 @@ static int bch2_snapshot_set_equiv(struct btree_trans *trans, struct bkey_s_c k) for (i = 0; i < 2; i++) { int ret = snapshot_live(trans, child[i]); + if (ret < 0) return ret; diff --git a/libbcachefs/subvolume.h b/libbcachefs/subvolume.h index 02a6366..c694c1c 100644 --- a/libbcachefs/subvolume.h +++ b/libbcachefs/subvolume.h @@ -9,10 +9,10 @@ void bch2_snapshot_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); int bch2_snapshot_invalid(const struct bch_fs *, struct bkey_s_c, int rw, struct printbuf *); -#define bch2_bkey_ops_snapshot (struct bkey_ops) { \ +#define bch2_bkey_ops_snapshot ((struct bkey_ops) { \ .key_invalid = bch2_snapshot_invalid, \ .val_to_text = bch2_snapshot_to_text, \ -} +}) int bch2_mark_snapshot(struct btree_trans *, struct bkey_s_c, struct bkey_s_c, unsigned); @@ -109,10 +109,10 @@ int bch2_subvolume_invalid(const struct bch_fs *, struct bkey_s_c, int rw, struct printbuf *); void bch2_subvolume_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_subvolume (struct bkey_ops) { \ +#define bch2_bkey_ops_subvolume ((struct bkey_ops) { \ .key_invalid = bch2_subvolume_invalid, \ .val_to_text = bch2_subvolume_to_text, \ -} +}) int bch2_subvolume_get(struct btree_trans *, unsigned, bool, int, struct bch_subvolume *); diff --git a/libbcachefs/sysfs.c b/libbcachefs/sysfs.c index 0f45aef..06b2924 100644 --- a/libbcachefs/sysfs.c +++ b/libbcachefs/sysfs.c @@ -90,9 +90,9 @@ static ssize_t fn ## _store_inner(struct kobject *kobj, struct attribute *attr,\ static struct attribute sysfs_##_name = \ { .name = #_name, .mode = _mode } -#define write_attribute(n) __sysfs_attribute(n, S_IWUSR) -#define read_attribute(n) __sysfs_attribute(n, S_IRUGO) -#define rw_attribute(n) __sysfs_attribute(n, S_IRUGO|S_IWUSR) +#define write_attribute(n) __sysfs_attribute(n, 0200) +#define read_attribute(n) __sysfs_attribute(n, 0444) +#define rw_attribute(n) __sysfs_attribute(n, 0644) #define sysfs_printf(file, fmt, ...) \ do { \ @@ -228,13 +228,13 @@ write_attribute(perf_test); #define x(_name) \ static struct attribute sysfs_time_stat_##_name = \ - { .name = #_name, .mode = S_IRUGO }; + { .name = #_name, .mode = 0444 }; BCH_TIME_STATS() #undef x static struct attribute sysfs_state_rw = { .name = "state", - .mode = S_IRUGO + .mode = 0444, }; static size_t bch2_btree_cache_size(struct bch_fs *c) @@ -613,12 +613,14 @@ struct attribute *bch2_fs_counters_files[] = { SHOW(bch2_fs_internal) { struct bch_fs *c = container_of(kobj, struct bch_fs, internal); + return bch2_fs_to_text(out, &c->kobj, attr); } STORE(bch2_fs_internal) { struct bch_fs *c = container_of(kobj, struct bch_fs, internal); + return bch2_fs_store(&c->kobj, attr, buf, size); } SYSFS_OPS(bch2_fs_internal); diff --git a/libbcachefs/tests.c b/libbcachefs/tests.c index d058861..43f974e 100644 --- a/libbcachefs/tests.c +++ b/libbcachefs/tests.c @@ -46,7 +46,7 @@ static int test_delete(struct bch_fs *c, u64 nr) bch2_btree_iter_traverse(&iter) ?: bch2_trans_update(&trans, &iter, &k.k_i, 0)); if (ret) { - bch_err(c, "update error in test_delete: %s", bch2_err_str(ret)); + bch_err(c, "%s(): update error in: %s", __func__, bch2_err_str(ret)); goto err; } @@ -55,7 +55,7 @@ static int test_delete(struct bch_fs *c, u64 nr) bch2_btree_iter_traverse(&iter) ?: bch2_btree_delete_at(&trans, &iter, 0)); if (ret) { - bch_err(c, "delete error (first) in test_delete: %s", bch2_err_str(ret)); + bch_err(c, "%s(): delete error (first): %s", __func__, bch2_err_str(ret)); goto err; } @@ -64,7 +64,7 @@ static int test_delete(struct bch_fs *c, u64 nr) bch2_btree_iter_traverse(&iter) ?: bch2_btree_delete_at(&trans, &iter, 0)); if (ret) { - bch_err(c, "delete error (second) in test_delete: %s", bch2_err_str(ret)); + bch_err(c, "%s(): delete error (second): %s", __func__, bch2_err_str(ret)); goto err; } err: @@ -92,7 +92,7 @@ static int test_delete_written(struct bch_fs *c, u64 nr) bch2_btree_iter_traverse(&iter) ?: bch2_trans_update(&trans, &iter, &k.k_i, 0)); if (ret) { - bch_err(c, "update error in test_delete_written: %s", bch2_err_str(ret)); + bch_err(c, "%s(): update error: %s", __func__, bch2_err_str(ret)); goto err; } @@ -103,7 +103,7 @@ static int test_delete_written(struct bch_fs *c, u64 nr) bch2_btree_iter_traverse(&iter) ?: bch2_btree_delete_at(&trans, &iter, 0)); if (ret) { - bch_err(c, "delete error in test_delete_written: %s", bch2_err_str(ret)); + bch_err(c, "%s(): delete error: %s", __func__, bch2_err_str(ret)); goto err; } err: @@ -136,7 +136,7 @@ static int test_iterate(struct bch_fs *c, u64 nr) ret = bch2_btree_insert(c, BTREE_ID_xattrs, &k.k_i, NULL, NULL, 0); if (ret) { - bch_err(c, "insert error in test_iterate: %s", bch2_err_str(ret)); + bch_err(c, "%s(): insert error: %s", __func__, bch2_err_str(ret)); goto err; } } @@ -202,7 +202,7 @@ static int test_iterate_extents(struct bch_fs *c, u64 nr) ret = bch2_btree_insert(c, BTREE_ID_extents, &k.k_i, NULL, NULL, 0); if (ret) { - bch_err(c, "insert error in test_iterate_extents: %s", bch2_err_str(ret)); + bch_err(c, "%s(): insert error: %s", __func__, bch2_err_str(ret)); goto err; } } @@ -269,7 +269,7 @@ static int test_iterate_slots(struct bch_fs *c, u64 nr) ret = bch2_btree_insert(c, BTREE_ID_xattrs, &k.k_i, NULL, NULL, 0); if (ret) { - bch_err(c, "insert error in test_iterate_slots: %s", bch2_err_str(ret)); + bch_err(c, "%s(): insert error: %s", __func__, bch2_err_str(ret)); goto err; } } @@ -342,7 +342,7 @@ static int test_iterate_slots_extents(struct bch_fs *c, u64 nr) ret = bch2_btree_insert(c, BTREE_ID_extents, &k.k_i, NULL, NULL, 0); if (ret) { - bch_err(c, "insert error in test_iterate_slots_extents: %s", bch2_err_str(ret)); + bch_err(c, "%s(): insert error: %s", __func__, bch2_err_str(ret)); goto err; } } @@ -456,7 +456,7 @@ static int insert_test_extent(struct bch_fs *c, ret = bch2_btree_insert(c, BTREE_ID_extents, &k.k_i, NULL, NULL, 0); if (ret) - bch_err(c, "insert error in insert_test_extent: %s", bch2_err_str(ret)); + bch_err(c, "%s(): insert error: %s", __func__, bch2_err_str(ret)); return ret; } @@ -555,7 +555,7 @@ static int test_snapshots(struct bch_fs *c, u64 nr) ret = test_snapshot_filter(c, snapids[0], snapids[1]); if (ret) { - bch_err(c, "err from test_snapshot_filter: %s", bch2_err_str(ret)); + bch_err(c, "%s(): err from test_snapshot_filter: %s", __func__, bch2_err_str(ret)); return ret; } @@ -567,11 +567,8 @@ static int test_snapshots(struct bch_fs *c, u64 nr) static u64 test_rand(void) { u64 v; -#if 0 - v = prandom_u32(); -#else + prandom_bytes(&v, sizeof(v)); -#endif return v; } @@ -592,7 +589,7 @@ static int rand_insert(struct bch_fs *c, u64 nr) ret = commit_do(&trans, NULL, NULL, 0, __bch2_btree_insert(&trans, BTREE_ID_xattrs, &k.k_i)); if (ret) { - bch_err(c, "error in rand_insert: %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); break; } } @@ -628,7 +625,7 @@ static int rand_insert_multi(struct bch_fs *c, u64 nr) __bch2_btree_insert(&trans, BTREE_ID_xattrs, &k[6].k_i) ?: __bch2_btree_insert(&trans, BTREE_ID_xattrs, &k[7].k_i)); if (ret) { - bch_err(c, "error in rand_insert_multi: %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); break; } } @@ -655,7 +652,7 @@ static int rand_lookup(struct bch_fs *c, u64 nr) lockrestart_do(&trans, bkey_err(k = bch2_btree_iter_peek(&iter))); ret = bkey_err(k); if (ret) { - bch_err(c, "error in rand_lookup: %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); break; } } @@ -678,7 +675,7 @@ static int rand_mixed_trans(struct btree_trans *trans, k = bch2_btree_iter_peek(iter); ret = bkey_err(k); if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart)) - bch_err(trans->c, "lookup error in rand_mixed: %s", bch2_err_str(ret)); + bch_err(trans->c, "%s(): lookup error: %s", __func__, bch2_err_str(ret)); if (ret) return ret; @@ -708,7 +705,7 @@ static int rand_mixed(struct bch_fs *c, u64 nr) ret = commit_do(&trans, NULL, NULL, 0, rand_mixed_trans(&trans, &iter, &cookie, i, rand)); if (ret) { - bch_err(c, "update error in rand_mixed: %s", bch2_err_str(ret)); + bch_err(c, "%s(): update error: %s", __func__, bch2_err_str(ret)); break; } } @@ -754,7 +751,7 @@ static int rand_delete(struct bch_fs *c, u64 nr) ret = commit_do(&trans, NULL, NULL, 0, __do_delete(&trans, pos)); if (ret) { - bch_err(c, "error in rand_delete: %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); break; } } @@ -786,7 +783,7 @@ static int seq_insert(struct bch_fs *c, u64 nr) bch2_trans_update(&trans, &iter, &insert.k_i, 0); })); if (ret) - bch_err(c, "error in %s(): %s", __func__, bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); bch2_trans_exit(&trans); return ret; @@ -805,7 +802,7 @@ static int seq_lookup(struct bch_fs *c, u64 nr) SPOS(0, 0, U32_MAX), 0, k, 0); if (ret) - bch_err(c, "error in %s(): %s", __func__, bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); bch2_trans_exit(&trans); return ret; @@ -831,7 +828,7 @@ static int seq_overwrite(struct bch_fs *c, u64 nr) bch2_trans_update(&trans, &iter, &u.k_i, 0); })); if (ret) - bch_err(c, "error in %s(): %s", __func__, bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); bch2_trans_exit(&trans); return ret; @@ -845,7 +842,7 @@ static int seq_delete(struct bch_fs *c, u64 nr) SPOS(0, 0, U32_MAX), SPOS_MAX, 0, NULL); if (ret) - bch_err(c, "error in seq_delete: %s", bch2_err_str(ret)); + bch_err(c, "%s(): error %s", __func__, bch2_err_str(ret)); return ret; } diff --git a/libbcachefs/xattr.h b/libbcachefs/xattr.h index 66d7a1e..03f1b73 100644 --- a/libbcachefs/xattr.h +++ b/libbcachefs/xattr.h @@ -9,10 +9,10 @@ extern const struct bch_hash_desc bch2_xattr_hash_desc; int bch2_xattr_invalid(const struct bch_fs *, struct bkey_s_c, int, struct printbuf *); void bch2_xattr_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c); -#define bch2_bkey_ops_xattr (struct bkey_ops) { \ +#define bch2_bkey_ops_xattr ((struct bkey_ops) { \ .key_invalid = bch2_xattr_invalid, \ .val_to_text = bch2_xattr_to_text, \ -} +}) static inline unsigned xattr_val_u64s(unsigned name_len, unsigned val_len) { -- 2.39.2