bcachefs stack usage improvements
cover bcachefs stack usage improvements
We overran the stack in a kmsan replication test.
Stack usage in non kmsan builds isn't critical; it appears that our kmsan builds are particularly bad for stack usage because it inserts additional function calls between each real function call, and we do have some very deeply nested call stacks. The deepest I observed was:
- transaction commit
- btree split
- btree node allocation
- sector allocator, bucket allocator
- runtime alloc info fsck checks (we don't actually do repair inline, fortunately).
- btree_iter_peek_slot
- key cache traverse, fill
- btree_iter_peek_slot and pathwalk for normal btree lookup
This series is sufficient for now, and might go into 6.15 if I'm happy with how the test dashboard looks. Later on I'll be moving more things into alloc_request and moving it off the stack entirely, allocating it with the btree_trans bump allocator.
Some items for btree node pathwalk might get moved into btree_trans as well.
Kent Overstreet (8):
bcachefs: Kill unnecessary bch2_dev_usage_read()
bcachefs: Kill btree_iter.trans
bcachefs: do_trace_key_cache_fill()
bcachefs: bch2_alloc_to_v4() no longer converts on stack
bcachefs: Move cycle detector state to btree_trans
bcachefs: struct alloc_request
bcachefs: alloc_request.data_type
bcachefs: bch2_bucket_alloc_trans() takes alloc_request
fs/bcachefs/acl.c | 4 +- fs/bcachefs/alloc_background.c | 132 ++++++----- fs/bcachefs/alloc_background.h | 23 +- fs/bcachefs/alloc_foreground.c | 342 +++++++++++----------------- fs/bcachefs/alloc_foreground.h | 25 +- fs/bcachefs/backpointers.c | 12 +- fs/bcachefs/btree_gc.c | 8 +- fs/bcachefs/btree_io.c | 3 +- fs/bcachefs/btree_iter.c | 184 +++++++-------- fs/bcachefs/btree_iter.h | 122 +++++----- fs/bcachefs/btree_key_cache.c | 32 +-- fs/bcachefs/btree_locking.c | 43 +--- fs/bcachefs/btree_locking_types.h | 28 +++ fs/bcachefs/btree_types.h | 3 +- fs/bcachefs/btree_update.c | 26 +-- fs/bcachefs/btree_update_interior.c | 12 +- fs/bcachefs/btree_write_buffer.c | 10 +- fs/bcachefs/buckets.c | 2 +- fs/bcachefs/data_update.c | 8 +- fs/bcachefs/dirent.c | 16 +- fs/bcachefs/disk_accounting.c | 4 +- fs/bcachefs/ec.c | 64 +++--- fs/bcachefs/extent_update.c | 6 +- fs/bcachefs/fs-io-buffered.c | 6 +- fs/bcachefs/fs-io.c | 10 +- fs/bcachefs/fs.c | 22 +- fs/bcachefs/fsck.c | 30 +-- fs/bcachefs/inode.c | 18 +- fs/bcachefs/io_misc.c | 18 +- fs/bcachefs/io_read.c | 8 +- fs/bcachefs/io_write.c | 12 +- fs/bcachefs/io_write.h | 28 --- fs/bcachefs/io_write_types.h | 28 +++ fs/bcachefs/lru.c | 9 +- fs/bcachefs/migrate.c | 4 +- fs/bcachefs/move.c | 12 +- fs/bcachefs/movinggc.c | 2 +- fs/bcachefs/namei.c | 38 ++-- fs/bcachefs/quota.c | 2 +- fs/bcachefs/rebalance.c | 12 +- fs/bcachefs/recovery.c | 6 +- fs/bcachefs/reflink.c | 23 +- fs/bcachefs/snapshot.c | 10 +- fs/bcachefs/str_hash.c | 2 +- fs/bcachefs/str_hash.h | 8 +- fs/bcachefs/subvolume.c | 4 +- fs/bcachefs/subvolume.h | 14 +- fs/bcachefs/tests.c | 30 +-- fs/bcachefs/xattr.c | 2 +- 49 files changed, 736 insertions(+), 731 deletions(-) create mode 100644 fs/bcachefs/btree_locking_types.h
Signature · 1 line
2.49.0
PATCH 1/8 bcachefs: Kill unnecessary bch2_dev_usage_read()
bch2_dev_usage_read() is fairly expensive, we should optimize this more.
--- fs/bcachefs/alloc_foreground.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/bcachefs/alloc_foreground.c +1 -1
@@ -631,7 +631,7 @@ static inline void bch2_dev_stripe_increment_inlined(struct bch_dev *ca, struct bch_dev_usage *usage) {u64 *v = stripe->next_alloc + ca->dev_idx; -u64 free_space =dev_buckets_available (ca, BCH_WATERMARK_normal); +u64 free_space =__dev_buckets_available (ca, *usage, BCH_WATERMARK_normal);u64 free_space_inv = free_space ?div64_u64 (1ULL <<48 , free_space) :1ULL <<48 ;
Signature · 1 line
2.49.0
PATCH 2/8 bcachefs: Kill btree_iter.trans
In reply to Kent OverstreetThis was planned to be done ages ago, now finally completed; there are places where we have quite a few btree_trans objects on the stack, so this reduces stack usage somewhat.
--- fs/bcachefs/acl.c | 4 +- fs/bcachefs/alloc_background.c | 78 ++++++------ fs/bcachefs/alloc_foreground.c | 8 +- fs/bcachefs/backpointers.c | 10 +- fs/bcachefs/btree_gc.c | 4 +- fs/bcachefs/btree_io.c | 3 +- fs/bcachefs/btree_iter.c | 184 +++++++++++++--------------- fs/bcachefs/btree_iter.h | 122 +++++++++--------- fs/bcachefs/btree_key_cache.c | 8 +- fs/bcachefs/btree_types.h | 1 - fs/bcachefs/btree_update.c | 26 ++-- fs/bcachefs/btree_update_interior.c | 12 +- fs/bcachefs/btree_write_buffer.c | 10 +- fs/bcachefs/buckets.c | 2 +- fs/bcachefs/data_update.c | 8 +- fs/bcachefs/dirent.c | 16 +-- fs/bcachefs/disk_accounting.c | 4 +- fs/bcachefs/ec.c | 4 +- fs/bcachefs/extent_update.c | 6 +- fs/bcachefs/fs-io-buffered.c | 6 +- fs/bcachefs/fs-io.c | 10 +- fs/bcachefs/fs.c | 22 ++-- fs/bcachefs/fsck.c | 30 ++--- fs/bcachefs/inode.c | 18 +-- fs/bcachefs/io_misc.c | 18 +-- fs/bcachefs/io_read.c | 8 +- fs/bcachefs/io_write.c | 12 +- fs/bcachefs/migrate.c | 4 +- fs/bcachefs/move.c | 12 +- fs/bcachefs/namei.c | 38 +++--- fs/bcachefs/quota.c | 2 +- fs/bcachefs/rebalance.c | 12 +- fs/bcachefs/recovery.c | 6 +- fs/bcachefs/reflink.c | 23 ++-- fs/bcachefs/snapshot.c | 10 +- fs/bcachefs/str_hash.c | 2 +- fs/bcachefs/str_hash.h | 8 +- fs/bcachefs/subvolume.c | 4 +- fs/bcachefs/subvolume.h | 14 +-- fs/bcachefs/tests.c | 30 ++--- fs/bcachefs/xattr.c | 2 +- 41 files changed, 400 insertions(+), 401 deletions(-)
fs/bcachefs/acl.c +2 -2
@@ -273,7 +273,7 @@ struct posix_acl *bch2_get_acl(struct inode *vinode, int type, bool rcu)struct bch_fs *c = inode->v.i_sb->s_fs_info;struct bch_hash_info hash =bch2_hash_info_init (c, &inode->ei_inode);struct xattr_search_key search =X_SEARCH (acl_to_xattr_type (type),"" ,0 ); -struct btree_iter iter = {NULL }; +struct btree_iter iter = {};struct posix_acl *acl =NULL ;if (rcu)
@@ -344,7 +344,7 @@ int bch2_set_acl(struct mnt_idmap *idmap, {struct bch_inode_info *inode =to_bch_ei (dentry->d_inode);struct bch_fs *c = inode->v.i_sb->s_fs_info; -struct btree_iter inode_iter = {NULL }; +struct btree_iter inode_iter = {};struct bch_inode_unpacked inode_u;struct posix_acl *acl;umode_t mode;
fs/bcachefs/alloc_background.c +40 -38
239 lines not on this page · raw message
fs/bcachefs/alloc_foreground.c +4 -4
@@ -327,7 +327,7 @@ bch2_bucket_alloc_early(struct btree_trans *trans, bucket =sector_to_bucket (ca,round_up (bucket_to_sector (ca, bucket) +1 ,1ULL << ca->mi.btree_bitmap_shift)); -bch2_btree_iter_set_pos (&iter,POS (ca->dev_idx, bucket)); +bch2_btree_iter_set_pos (trans, &iter,POS (ca->dev_idx, bucket)); s->buckets_seen++; s->skipped_mi_btree_bitmap++;continue ;
@@ -355,7 +355,7 @@ bch2_bucket_alloc_early(struct btree_trans *trans, watermark, s, cl) : NULL; next: -bch2_set_btree_iter_dontneed (&citer); +bch2_set_btree_iter_dontneed (trans, &citer);bch2_trans_iter_exit (trans, &citer);if (ob)break ;
@@ -417,7 +417,7 @@ static struct open_bucket *bch2_bucket_alloc_freelist(struct btree_trans *trans, 1ULL << ca->mi.btree_bitmap_shift)); alloc_cursor = bucket|(iter.pos.offset & (~0ULL <<56 )); -bch2_btree_iter_set_pos (&iter,POS (ca->dev_idx, alloc_cursor)); +bch2_btree_iter_set_pos (trans, &iter,POS (ca->dev_idx, alloc_cursor)); s->skipped_mi_btree_bitmap++; goto next; }
@@ -426,7 +426,7 @@ static struct open_bucket *bch2_bucket_alloc_freelist(struct btree_trans *trans,if (ob) {if (!IS_ERR (ob)) *dev_alloc_cursor = iter.pos.offset; -bch2_set_btree_iter_dontneed (&iter); +bch2_set_btree_iter_dontneed (trans, &iter);break ; }
fs/bcachefs/backpointers.c +5 -5
@@ -253,7 +253,7 @@ struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,0 , bp.v->level, iter_flags); -struct bkey_s_c k =bch2_btree_iter_peek_slot (iter); +struct bkey_s_c k =bch2_btree_iter_peek_slot (trans, iter);if (bkey_err (k)) {bch2_trans_iter_exit (trans, iter);return k;
@@ -294,7 +294,7 @@ struct btree *bch2_backpointer_get_node(struct btree_trans *trans,0 , bp.v->level -1 , 0); -struct btree *b =bch2_btree_iter_peek_node (iter); +struct btree *b =bch2_btree_iter_peek_node (trans, iter);if (IS_ERR_OR_NULL (b)) goto err;
@@ -322,7 +322,7 @@ static int bch2_check_backpointer_has_valid_bucket(struct btree_trans *trans, streturn 0 ;struct bch_fs *c = trans->c; -struct btree_iter alloc_iter = {NULL }; +struct btree_iter alloc_iter = {};struct bkey_s_c alloc_k;struct printbuf buf =PRINTBUF ;int ret =0 ;
@@ -652,7 +652,7 @@ static int check_btree_root_to_backpointers(struct btree_trans *trans, retry:bch2_trans_node_iter_init (trans, &iter, btree_id,POS_MIN ,0 ,bch2_btree_id_root (c, btree_id)->b->c.level,0 ); - b =bch2_btree_iter_peek_node (&iter); + b =bch2_btree_iter_peek_node (trans, &iter); ret =PTR_ERR_OR_ZERO (b);if (ret) goto err;
@@ -936,7 +936,7 @@ static int btree_node_get_and_pin(struct btree_trans *trans, struct bkey_i *k, {struct btree_iter iter;bch2_trans_node_iter_init (trans, &iter, btree, k->k.p,0 , level,0 ); -struct btree *b =bch2_btree_iter_peek_node (&iter); +struct btree *b =bch2_btree_iter_peek_node (trans, &iter);int ret =PTR_ERR_OR_ZERO (b);if (ret) goto err;
fs/bcachefs/btree_gc.c +2 -2
@@ -692,7 +692,7 @@ static int bch2_gc_btree(struct btree_trans *trans,struct btree_iter iter;bch2_trans_node_iter_init (trans, &iter, btree,POS_MIN ,0 ,bch2_btree_id_root (c, btree)->b->c.level,0 ); -struct btree *b =bch2_btree_iter_peek_node (&iter); +struct btree *b =bch2_btree_iter_peek_node (trans, &iter); ret =PTR_ERR_OR_ZERO (b);if (ret) goto err_root;
@@ -1200,7 +1200,7 @@ int bch2_gc_gens(struct bch_fs *c) BCH_TRANS_COMMIT_no_enospc, ({ ca = bch2_dev_iterate(c, ca, k.k->p.inode); if (!ca) { - bch2_btree_iter_set_pos(&iter, POS(k.k->p.inode + 1, 0)); + bch2_btree_iter_set_pos(trans, &iter, POS(k.k->p.inode + 1, 0)); continue; } bch2_alloc_write_oldest_gen(trans, ca, &iter, k);
fs/bcachefs/btree_io.c +2 -1
@@ -1907,7 +1907,8 @@ static void btree_node_scrub_work(struct work_struct *work) scrub->key.k->k.p, 0, scrub->level - 1, 0);struct btree *b; -int ret =lockrestart_do (trans,PTR_ERR_OR_ZERO (b =bch2_btree_iter_peek_node (&iter))); +int ret =lockrestart_do (trans, +PTR_ERR_OR_ZERO (b =bch2_btree_iter_peek_node (trans, &iter)));if (ret) goto err;
fs/bcachefs/btree_iter.c +88 -96
533 lines not on this page · raw message
fs/bcachefs/btree_iter.h +63 -59
255 lines not on this page · raw message
fs/bcachefs/btree_key_cache.c +4 -4
@@ -306,7 +306,7 @@ static noinline int btree_key_cache_fill(struct btree_trans *trans, BTREE_ITER_key_cache_fill| BTREE_ITER_cached_nofill); iter.flags &= ~BTREE_ITER_with_journal; - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter); ret =bkey_err (k);if (ret) goto err;
@@ -331,7 +331,7 @@ static noinline int btree_key_cache_fill(struct btree_trans *trans, } out:/* We're not likely to need this iterator again: */ -bch2_set_btree_iter_dontneed (&iter); +bch2_set_btree_iter_dontneed (trans, &iter); err:bch2_trans_iter_exit (trans, &iter);return ret;
@@ -412,7 +412,7 @@ static int btree_key_cache_flush_pos(struct btree_trans *trans, BTREE_ITER_intent); b_iter.flags &= ~BTREE_ITER_with_key_cache; - ret =bch2_btree_iter_traverse (&c_iter); + ret =bch2_btree_iter_traverse (trans, &c_iter);if (ret) goto out;
@@ -444,7 +444,7 @@ static int btree_key_cache_flush_pos(struct btree_trans *trans, !test_bit(JOURNAL_space_low, &c->journal.flags)) commit_flags |= BCH_TRANS_COMMIT_no_journal_res; -struct bkey_s_c btree_k =bch2_btree_iter_peek_slot (&b_iter); +struct bkey_s_c btree_k =bch2_btree_iter_peek_slot (trans, &b_iter); ret =bkey_err (btree_k);if (ret) goto err;
fs/bcachefs/btree_types.h +0 -1
@@ -367,7 +367,6 @@ static inline unsigned long btree_path_ip_allocated(struct btree_path *path)* @nodes_intent_locked - bitmask indicating which locks are intent locks */ struct btree_iter { -struct btree_trans *trans;btree_path_idx_t path;btree_path_idx_t update_path;btree_path_idx_t key_cache_path;
fs/bcachefs/btree_update.c +13 -13
@@ -126,7 +126,7 @@ int __bch2_insert_snapshot_whiteouts(struct btree_trans *trans, struct bpos new_pos) {struct bch_fs *c = trans->c; -struct btree_iter old_iter, new_iter = {NULL }; +struct btree_iter old_iter, new_iter = {};struct bkey_s_c old_k, new_k;snapshot_id_list s;struct bkey_i *update;
@@ -140,7 +140,7 @@ int __bch2_insert_snapshot_whiteouts(struct btree_trans *trans,bch2_trans_iter_init (trans, &old_iter, id, old_pos, BTREE_ITER_not_extents| BTREE_ITER_all_snapshots); -while ((old_k =bch2_btree_iter_prev (&old_iter)).k && +while ((old_k =bch2_btree_iter_prev (trans, &old_iter)).k && !(ret =bkey_err (old_k)) &&bkey_eq (old_pos, old_k.k->p)) { struct bpos whiteout_pos =
@@ -296,7 +296,7 @@ static int bch2_trans_update_extent(struct btree_trans *trans, BTREE_ITER_intent| BTREE_ITER_with_updates| BTREE_ITER_not_extents); - k =bch2_btree_iter_peek_max (&iter,POS (insert->k.p.inode,U64_MAX )); + k =bch2_btree_iter_peek_max (trans, &iter,POS (insert->k.p.inode,U64_MAX ));if ((ret =bkey_err (k))) goto err;if (!k.k)
@@ -322,8 +322,8 @@ static int bch2_trans_update_extent(struct btree_trans *trans,if (done) goto out; next: -bch2_btree_iter_advance (&iter); - k =bch2_btree_iter_peek_max (&iter,POS (insert->k.p.inode,U64_MAX )); +bch2_btree_iter_advance (trans, &iter); + k =bch2_btree_iter_peek_max (trans, &iter,POS (insert->k.p.inode,U64_MAX ));if ((ret =bkey_err (k))) goto err;if (!k.k)
@@ -592,13 +592,13 @@ int bch2_bkey_get_empty_slot(struct btree_trans *trans, struct btree_iter *iter, enum btree_id btree, struct bpos end) {bch2_trans_iter_init (trans ,iter ,btree ,end ,BTREE_ITER_intent ); -struct bkey_s_c k =bch2_btree_iter_peek_prev (iter); +struct bkey_s_c k =bch2_btree_iter_peek_prev (trans, iter);int ret =bkey_err (k);if (ret) goto err; -bch2_btree_iter_advance (iter); - k =bch2_btree_iter_peek_slot (iter); +bch2_btree_iter_advance (trans, iter); + k =bch2_btree_iter_peek_slot (trans, iter); ret =bkey_err (k);if (ret) goto err;
@@ -634,7 +634,7 @@ int bch2_btree_insert_nonextent(struct btree_trans *trans, BTREE_ITER_cached| BTREE_ITER_not_extents| BTREE_ITER_intent); - ret =bch2_btree_iter_traverse (&iter) ?: + ret =bch2_btree_iter_traverse (trans, &iter) ?:bch2_trans_update (trans, &iter, k, flags);bch2_trans_iter_exit (trans, &iter);return ret;
@@ -646,7 +646,7 @@ int bch2_btree_insert_trans(struct btree_trans *trans, enum btree_id id,struct btree_iter iter;bch2_trans_iter_init (trans, &iter, id,bkey_start_pos (&k->k), BTREE_ITER_intent|flags); -int ret =bch2_btree_iter_traverse (&iter) ?: +int ret =bch2_btree_iter_traverse (trans, &iter) ?:bch2_trans_update (trans, &iter, k, flags);bch2_trans_iter_exit (trans, &iter);return ret;
@@ -695,7 +695,7 @@ int bch2_btree_delete(struct btree_trans *trans,bch2_trans_iter_init (trans, &iter, btree, pos, BTREE_ITER_cached| BTREE_ITER_intent); - ret =bch2_btree_iter_traverse (&iter) ?: + ret =bch2_btree_iter_traverse (trans, &iter) ?:bch2_btree_delete_at (trans, &iter, update_flags);bch2_trans_iter_exit (trans, &iter);
@@ -713,7 +713,7 @@ int bch2_btree_delete_range_trans(struct btree_trans *trans, enum btree_id id,int ret =0 ;bch2_trans_iter_init (trans, &iter, id, start, BTREE_ITER_intent); -while ((k =bch2_btree_iter_peek_max (&iter, end)).k) { +while ((k =bch2_btree_iter_peek_max (trans, &iter, end)).k) {struct disk_reservation disk_res =bch2_disk_reservation_init (trans->c,0 );struct bkey_i delete;
@@ -808,7 +808,7 @@ int bch2_btree_bit_mod(struct btree_trans *trans, enum btree_id btree,struct btree_iter iter;bch2_trans_iter_init (trans, &iter, btree, pos, BTREE_ITER_intent); -int ret =bch2_btree_iter_traverse (&iter) ?: +int ret =bch2_btree_iter_traverse (trans, &iter) ?:bch2_btree_bit_mod_iter (trans, &iter, set);bch2_trans_iter_exit (trans, &iter);return ret;
fs/bcachefs/btree_update_interior.c +6 -6
@@ -2132,7 +2132,7 @@ static int get_iter_to_node(struct btree_trans *trans, struct btree_iter *iter,bch2_trans_node_iter_init (trans, iter, b->c.btree_id, b->key.k.p,BTREE_MAX_DEPTH , b->c.level, BTREE_ITER_intent); -int ret =bch2_btree_iter_traverse (iter); +int ret =bch2_btree_iter_traverse (trans, iter);if (ret) goto err;
@@ -2224,7 +2224,7 @@ static int bch2_btree_node_rewrite_key(struct btree_trans *trans,bch2_trans_node_iter_init (trans, &iter, btree, k->k.p,BTREE_MAX_DEPTH , level,0 ); -struct btree *b =bch2_btree_iter_peek_node (&iter); +struct btree *b =bch2_btree_iter_peek_node (trans, &iter);int ret =PTR_ERR_OR_ZERO (b);if (ret) goto out;
@@ -2247,7 +2247,7 @@ int bch2_btree_node_rewrite_pos(struct btree_trans *trans,/* Traverse one depth lower to get a pointer to the node itself: */ struct btree_iter iter;bch2_trans_node_iter_init (trans, &iter, btree, pos,0 , level -1 ,0 ); -struct btree *b =bch2_btree_iter_peek_node (&iter); +struct btree *b =bch2_btree_iter_peek_node (trans, &iter);int ret =PTR_ERR_OR_ZERO (b);if (ret) goto err;
@@ -2389,7 +2389,7 @@ static int __bch2_btree_node_update_key(struct btree_trans *trans, bool skip_triggers) {struct bch_fs *c = trans->c; -struct btree_iter iter2 = {NULL }; +struct btree_iter iter2 = {};struct btree *parent;int ret;
@@ -2413,7 +2413,7 @@ static int __bch2_btree_node_update_key(struct btree_trans *trans, parent =btree_node_parent (btree_iter_path (trans, iter), b);if (parent) { -bch2_trans_copy_iter (&iter2, iter); +bch2_trans_copy_iter (trans, &iter2, iter); iter2.path = bch2_btree_path_make_mut(trans, iter2.path, iter2.flags & BTREE_ITER_intent,
@@ -2427,7 +2427,7 @@ static int __bch2_btree_node_update_key(struct btree_trans *trans, trans->paths_sorted = false; - ret =bch2_btree_iter_traverse (&iter2) ?: + ret =bch2_btree_iter_traverse (trans, &iter2) ?:bch2_trans_update (trans, &iter2, new_key, BTREE_TRIGGER_norun);if (ret) goto err;
fs/bcachefs/btree_write_buffer.c +5 -5
@@ -144,7 +144,7 @@ static inline int wb_flush_one(struct btree_trans *trans, struct btree_iter *iteEBUG_ON (!trans->c->btree_write_buffer.flushing.pin.seq);EBUG_ON (trans->c->btree_write_buffer.flushing.pin.seq > wb->journal_seq); - ret =bch2_btree_iter_traverse (iter); + ret =bch2_btree_iter_traverse (trans, iter);if (ret)return ret;
@@ -208,7 +208,7 @@ btree_write_buffered_insert(struct btree_trans *trans, trans->journal_res.seq = wb->journal_seq; - ret =bch2_btree_iter_traverse (&iter) ?: + ret =bch2_btree_iter_traverse (trans, &iter) ?:bch2_trans_update (trans, &iter, &wb->k, BTREE_UPDATE_internal_snapshot_node);bch2_trans_iter_exit (trans, &iter);
@@ -285,7 +285,7 @@ static int bch2_btree_write_buffer_flush_locked(struct btree_trans *trans)struct bch_fs *c = trans->c;struct journal *j = &c->journal;struct btree_write_buffer *wb = &c->btree_write_buffer; -struct btree_iter iter = {NULL }; +struct btree_iter iter = {};size_t overwritten =0 , fast =0 , slowpath =0 , could_not_insert =0 ;bool write_locked = false;bool accounting_replay_done =test_bit (BCH_FS_accounting_replay_done, &c->flags);
@@ -368,7 +368,7 @@ static int bch2_btree_write_buffer_flush_locked(struct btree_trans *trans) write_locked = false; ret =lockrestart_do (trans, -bch2_btree_iter_traverse (&iter) ?: +bch2_btree_iter_traverse (trans, &iter) ?: bch2_foreground_maybe_merge(trans, iter.path, 0, BCH_WATERMARK_reclaim| BCH_TRANS_COMMIT_journal_reclaim|
@@ -385,7 +385,7 @@ static int bch2_btree_write_buffer_flush_locked(struct btree_trans *trans) BTREE_ITER_intent|BTREE_ITER_all_snapshots); } -bch2_btree_iter_set_pos (&iter, k->k.k.p); +bch2_btree_iter_set_pos (trans, &iter, k->k.k.p);btree_iter_path (trans, &iter)->preserve = false;bool accounting_accumulated = false;
fs/bcachefs/buckets.c +1 -1
@@ -365,7 +365,7 @@ int bch2_check_fix_ptrs(struct btree_trans *trans,struct btree_iter iter;bch2_trans_node_iter_init (trans, &iter, btree, new->k.p,0 , level, BTREE_ITER_intent|BTREE_ITER_all_snapshots); - ret =bch2_btree_iter_traverse (&iter) ?: + ret =bch2_btree_iter_traverse (trans, &iter) ?:bch2_trans_update (trans, &iter, new, BTREE_UPDATE_internal_snapshot_node| BTREE_TRIGGER_norun);
fs/bcachefs/data_update.c +4 -4
@@ -208,7 +208,7 @@ static int __bch2_data_update_index_update(struct btree_trans *trans,bch2_trans_begin (trans); - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter); ret =bkey_err (k);if (ret) goto err;
@@ -385,7 +385,7 @@ static int __bch2_data_update_index_update(struct btree_trans *trans, BCH_TRANS_COMMIT_no_enospc| m->data_opts.btree_insert_flags);if (!ret) { -bch2_btree_iter_set_pos (&iter, next_pos); +bch2_btree_iter_set_pos (trans, &iter, next_pos);this_cpu_add (c->counters[BCH_COUNTER_io_move_finish], new->k.size);if (trace_io_move_finish_enabled ())
@@ -413,7 +413,7 @@ static int __bch2_data_update_index_update(struct btree_trans *trans,count_event (c, io_move_fail); -bch2_btree_iter_advance (&iter); +bch2_btree_iter_advance (trans, &iter); goto next; } out:
@@ -483,7 +483,7 @@ static int bch2_update_unwritten_extent(struct btree_trans *trans,bch2_trans_iter_init (trans, &iter, update->btree_id, update->op.pos, BTREE_ITER_slots); ret =lockrestart_do (trans, ({ - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter);bkey_err (k); }));bch2_trans_iter_exit (trans, &iter);
fs/bcachefs/dirent.c +8 -8
@@ -417,8 +417,8 @@ int bch2_dirent_rename(struct btree_trans *trans, enum bch_rename_mode mode) {struct qstr src_name_lookup, dst_name_lookup; -struct btree_iter src_iter = {NULL }; -struct btree_iter dst_iter = {NULL }; +struct btree_iter src_iter = {}; +struct btree_iter dst_iter = {};struct bkey_s_c old_src, old_dst = bkey_s_c_null;struct bkey_i_dirent *new_src =NULL , *new_dst =NULL ; struct bpos dst_pos =
@@ -586,16 +586,16 @@ int bch2_dirent_rename(struct btree_trans *trans, }if (delete_src) { -bch2_btree_iter_set_snapshot (&src_iter, old_src.k->p.snapshot); - ret =bch2_btree_iter_traverse (&src_iter) ?: +bch2_btree_iter_set_snapshot (trans, &src_iter, old_src.k->p.snapshot); + ret =bch2_btree_iter_traverse (trans, &src_iter) ?:bch2_btree_delete_at (trans, &src_iter, BTREE_UPDATE_internal_snapshot_node);if (ret) goto out; }if (delete_dst) { -bch2_btree_iter_set_snapshot (&dst_iter, old_dst.k->p.snapshot); - ret =bch2_btree_iter_traverse (&dst_iter) ?: +bch2_btree_iter_set_snapshot (trans, &dst_iter, old_dst.k->p.snapshot); + ret =bch2_btree_iter_traverse (trans, &dst_iter) ?:bch2_btree_delete_at (trans, &dst_iter, BTREE_UPDATE_internal_snapshot_node);if (ret) goto out;
@@ -642,7 +642,7 @@ u64 bch2_dirent_lookup(struct bch_fs *c, subvol_inum dir, const struct qstr *name, subvol_inum *inum) { struct btree_trans *trans = bch2_trans_get(c); -struct btree_iter iter = {NULL }; +struct btree_iter iter = {};int ret =lockrestart_do (trans,bch2_dirent_lookup_trans (trans, &iter, dir, hash_info, name, inum,0 ));
@@ -771,7 +771,7 @@ int bch2_fsck_remove_dirent(struct btree_trans *trans, struct bpos pos)bch2_trans_iter_init (trans, &iter, BTREE_ID_dirents, pos, BTREE_ITER_intent); - ret =bch2_btree_iter_traverse (&iter) ?: + ret =bch2_btree_iter_traverse (trans, &iter) ?:bch2_hash_delete_at (trans, bch2_dirent_hash_desc, &dir_hash_info, &iter, BTREE_UPDATE_internal_snapshot_node);
fs/bcachefs/disk_accounting.c +2 -2
@@ -727,7 +727,7 @@ int bch2_accounting_read(struct bch_fs *c)if (!bch2_accounting_is_mem (acc_k)) {struct disk_accounting_pos next = { .type = acc_k.type +1 }; -bch2_btree_iter_set_pos (&iter,disk_accounting_pos_to_bpos (&next)); +bch2_btree_iter_set_pos (trans, &iter,disk_accounting_pos_to_bpos (&next));continue ; }
@@ -918,7 +918,7 @@ void bch2_verify_accounting_clean(struct bch_fs *c)if (!bch2_accounting_is_mem (acc_k)) {struct disk_accounting_pos next = { .type = acc_k.type +1 }; -bch2_btree_iter_set_pos (&iter,disk_accounting_pos_to_bpos (&next)); +bch2_btree_iter_set_pos (trans, &iter,disk_accounting_pos_to_bpos (&next));continue ; }
fs/bcachefs/ec.c +2 -2
@@ -1836,7 +1836,7 @@ static int __get_existing_stripe(struct btree_trans *trans, ret =1 ; } out: -bch2_set_btree_iter_dontneed (&iter); +bch2_set_btree_iter_dontneed (trans, &iter); err:bch2_trans_iter_exit (trans, &iter);return ret;
@@ -1949,7 +1949,7 @@ static int __bch2_ec_stripe_head_reserve(struct btree_trans *trans, struct ec_stif (bkey_gt (k.k->p,POS (0 ,U32_MAX ))) {if (start_pos.offset) { start_pos = min_pos; -bch2_btree_iter_set_pos (&iter, start_pos); +bch2_btree_iter_set_pos (trans, &iter, start_pos);continue ; }
fs/bcachefs/extent_update.c +3 -3
@@ -112,7 +112,7 @@ int bch2_extent_atomic_end(struct btree_trans *trans,unsigned nr_iters =0 ;int ret; - ret =bch2_btree_iter_traverse (iter); + ret =bch2_btree_iter_traverse (trans, iter);if (ret)return ret;
@@ -126,9 +126,9 @@ int bch2_extent_atomic_end(struct btree_trans *trans,if (ret <0 )return ret; -bch2_trans_copy_iter (©, iter); +bch2_trans_copy_iter (trans, ©, iter); -for_each_btree_key_max_continue_norestart (copy, insert->k.p,0 , k, ret) { +for_each_btree_key_max_continue_norestart (trans, copy, insert->k.p,0 , k, ret) {unsigned offset =0 ;if (bkey_gt (bkey_start_pos (&insert->k),bkey_start_pos (k.k)))
fs/bcachefs/fs-io-buffered.c +3 -3
@@ -183,12 +183,12 @@ static void bchfs_read(struct btree_trans *trans,if (ret) goto err; -bch2_btree_iter_set_snapshot (&iter, snapshot); +bch2_btree_iter_set_snapshot (trans, &iter, snapshot); -bch2_btree_iter_set_pos (&iter, +bch2_btree_iter_set_pos (trans, &iter,POS (inum.inum, rbio->bio.bi_iter.bi_sector)); - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter); ret =bkey_err (k);if (ret) goto err;
fs/bcachefs/fs-io.c +5 -5
@@ -636,9 +636,9 @@ static noinline int __bchfs_fallocate(struct bch_inode_info *inode, int mode,if (ret) goto bkey_err; -bch2_btree_iter_set_snapshot (&iter, snapshot); +bch2_btree_iter_set_snapshot (trans, &iter, snapshot); - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter);if ((ret =bkey_err (k))) goto bkey_err;
@@ -649,13 +649,13 @@ static noinline int __bchfs_fallocate(struct bch_inode_info *inode, int mode,/* already reserved */ if (bkey_extent_is_reservation (k) &&bch2_bkey_nr_ptrs_fully_allocated (k) >= opts.data_replicas) { -bch2_btree_iter_advance (&iter); +bch2_btree_iter_advance (trans, &iter);continue ; }if (bkey_extent_is_data (k.k) && !(mode &FALLOC_FL_ZERO_RANGE )) { -bch2_btree_iter_advance (&iter); +bch2_btree_iter_advance (trans, &iter);continue ; }
@@ -676,7 +676,7 @@ static noinline int __bchfs_fallocate(struct bch_inode_info *inode, int mode,if (ret) goto bkey_err; } -bch2_btree_iter_set_pos (&iter,POS (iter.pos.inode, hole_start)); +bch2_btree_iter_set_pos (trans, &iter,POS (iter.pos.inode, hole_start));if (ret) goto bkey_err;
fs/bcachefs/fs.c +11 -11
@@ -88,7 +88,7 @@ int __must_check bch2_write_inode(struct bch_fs *c, void *p, unsigned fields) {struct btree_trans *trans =bch2_trans_get (c); -struct btree_iter iter = {NULL }; +struct btree_iter iter = {};struct bch_inode_unpacked inode_u;int ret; retry:
@@ -1075,7 +1075,7 @@ int bch2_setattr_nonsize(struct mnt_idmap *idmap,struct bch_fs *c = inode->v.i_sb->s_fs_info;struct bch_qid qid;struct btree_trans *trans; -struct btree_iter inode_iter = {NULL }; +struct btree_iter inode_iter = {};struct bch_inode_unpacked inode_u;struct posix_acl *acl =NULL ;kuid_t kuid;
@@ -1330,9 +1330,9 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,if (ret)continue ; -bch2_btree_iter_set_snapshot (&iter, snapshot); +bch2_btree_iter_set_snapshot (trans, &iter, snapshot); - k =bch2_btree_iter_peek_max (&iter, end); + k =bch2_btree_iter_peek_max (trans, &iter, end); ret =bkey_err (k);if (ret)continue ;
@@ -1342,7 +1342,7 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,if (!bkey_extent_is_data (k.k) && k.k->type != KEY_TYPE_reservation) { -bch2_btree_iter_advance (&iter); +bch2_btree_iter_advance (trans, &iter);continue ; }
@@ -1380,7 +1380,7 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,bkey_copy (prev.k, cur.k); have_extent = true; -bch2_btree_iter_set_pos (&iter, +bch2_btree_iter_set_pos (trans, &iter,POS (iter.pos.inode, iter.pos.offset + sectors)); }bch2_trans_iter_exit (trans, &iter);
@@ -1697,17 +1697,17 @@ static int bch2_get_name(struct dentry *parent, char *name, struct dentry *childif (ret) goto err; -bch2_btree_iter_set_snapshot (&iter1, snapshot); -bch2_btree_iter_set_snapshot (&iter2, snapshot); +bch2_btree_iter_set_snapshot (trans, &iter1, snapshot); +bch2_btree_iter_set_snapshot (trans, &iter2, snapshot); ret =bch2_inode_find_by_inum_trans (trans,inode_inum (inode), &inode_u);if (ret) goto err;if (inode_u.bi_dir == dir->ei_inode.bi_inum) { -bch2_btree_iter_set_pos (&iter1,POS (inode_u.bi_dir, inode_u.bi_dir_offset)); +bch2_btree_iter_set_pos (trans, &iter1,POS (inode_u.bi_dir, inode_u.bi_dir_offset)); - k =bch2_btree_iter_peek_slot (&iter1); + k =bch2_btree_iter_peek_slot (trans, &iter1); ret =bkey_err (k);if (ret) goto err;
@@ -1731,7 +1731,7 @@ static int bch2_get_name(struct dentry *parent, char *name, struct dentry *child* File with multiple hardlinks and our backref is to the wrong * directory - linear search: */ -for_each_btree_key_continue_norestart (iter2,0 , k, ret) { +for_each_btree_key_continue_norestart (trans, iter2,0 , k, ret) {if (k.k->p.inode > dir->ei_inode.bi_inum)break ;
fs/bcachefs/fsck.c +15 -15
@@ -186,7 +186,7 @@ static int lookup_lostfound(struct btree_trans *trans, u32 snapshot, {struct bch_fs *c = trans->c;struct qstr lostfound_str =QSTR ("lost+found" ); -struct btree_iter lostfound_iter = {NULL }; +struct btree_iter lostfound_iter = {};u64 inum =0 ;unsigned d_type =0 ;int ret;
@@ -295,8 +295,8 @@ static int lookup_lostfound(struct btree_trans *trans, u32 snapshot,if (ret) goto err; -bch2_btree_iter_set_snapshot (&lostfound_iter, snapshot); - ret =bch2_btree_iter_traverse (&lostfound_iter); +bch2_btree_iter_set_snapshot (trans, &lostfound_iter, snapshot); + ret =bch2_btree_iter_traverse (trans, &lostfound_iter);if (ret) goto err;
@@ -544,7 +544,7 @@ static int reconstruct_subvol(struct btree_trans *trans, u32 snapshotid, u32 sub new_inode.bi_subvol = subvolid;int ret =bch2_inode_create (trans, &inode_iter, &new_inode, snapshotid, cpu) ?: -bch2_btree_iter_traverse (&inode_iter) ?: +bch2_btree_iter_traverse (trans, &inode_iter) ?:bch2_inode_write (trans, &inode_iter, &new_inode);bch2_trans_iter_exit (trans, &inode_iter);if (ret)
@@ -609,7 +609,7 @@ static int reconstruct_inode(struct btree_trans *trans, enum btree_id btree, u32struct btree_iter iter = {};bch2_trans_iter_init (trans, &iter, BTREE_ID_extents,SPOS (inum,U64_MAX , snapshot),0 ); -struct bkey_s_c k =bch2_btree_iter_peek_prev_min (&iter,POS (inum,0 )); +struct bkey_s_c k =bch2_btree_iter_peek_prev_min (trans, &iter,POS (inum,0 ));bch2_trans_iter_exit (trans, &iter);int ret =bkey_err (k);if (ret)
@@ -1557,7 +1557,7 @@ static int overlapping_extents_found(struct btree_trans *trans, {struct bch_fs *c = trans->c;struct printbuf buf =PRINTBUF ; -struct btree_iter iter1, iter2 = {NULL }; +struct btree_iter iter1, iter2 = {};struct bkey_s_c k1, k2;int ret;
@@ -1566,7 +1566,7 @@ static int overlapping_extents_found(struct btree_trans *trans,bch2_trans_iter_init (trans, &iter1, btree, pos1, BTREE_ITER_all_snapshots| BTREE_ITER_not_extents); - k1 =bch2_btree_iter_peek_max (&iter1,POS (pos1.inode,U64_MAX )); + k1 =bch2_btree_iter_peek_max (trans, &iter1,POS (pos1.inode,U64_MAX )); ret =bkey_err (k1);if (ret) goto err;
@@ -1586,12 +1586,12 @@ static int overlapping_extents_found(struct btree_trans *trans, goto err; } -bch2_trans_copy_iter (&iter2, &iter1); +bch2_trans_copy_iter (trans, &iter2, &iter1);while (1 ) { -bch2_btree_iter_advance (&iter2); +bch2_btree_iter_advance (trans, &iter2); - k2 =bch2_btree_iter_peek_max (&iter2,POS (pos1.inode,U64_MAX )); + k2 =bch2_btree_iter_peek_max (trans, &iter2,POS (pos1.inode,U64_MAX )); ret =bkey_err (k2);if (ret) goto err;
@@ -1789,9 +1789,9 @@ static int check_extent(struct btree_trans *trans, struct btree_iter *iter, (bch2_bkey_val_to_text(&buf, c, k), buf.buf))) {struct btree_iter iter2; -bch2_trans_copy_iter (&iter2, iter); -bch2_btree_iter_set_snapshot (&iter2, i->snapshot); - ret =bch2_btree_iter_traverse (&iter2) ?: +bch2_trans_copy_iter (trans, &iter2, iter); +bch2_btree_iter_set_snapshot (trans, &iter2, i->snapshot); + ret =bch2_btree_iter_traverse (trans, &iter2) ?:bch2_btree_delete_at (trans, &iter2, BTREE_UPDATE_internal_snapshot_node);bch2_trans_iter_exit (trans, &iter2);
@@ -2183,7 +2183,7 @@ static int check_dirent(struct btree_trans *trans, struct btree_iter *iter, BTREE_ID_dirents,SPOS (k.k->p.inode, k.k->p.offset, *i), BTREE_ITER_intent); - ret =bch2_btree_iter_traverse (&delete_iter) ?: + ret =bch2_btree_iter_traverse (trans, &delete_iter) ?: bch2_hash_delete_at(trans, bch2_dirent_hash_desc, hash_info, &delete_iter,
@@ -2410,7 +2410,7 @@ static int check_subvol_path(struct btree_trans *trans, struct btree_iter *iter,bch2_trans_iter_exit (trans, &parent_iter);bch2_trans_iter_init (trans, &parent_iter, BTREE_ID_subvolumes,POS (0 , parent),0 ); - k =bch2_btree_iter_peek_slot (&parent_iter); + k =bch2_btree_iter_peek_slot (trans, &parent_iter); ret =bkey_err (k);if (ret) goto err;
fs/bcachefs/inode.c +9 -9
@@ -940,7 +940,7 @@ int bch2_inode_create(struct btree_trans *trans, BTREE_ITER_intent);struct bkey_s_c k; again: -while ((k =bch2_btree_iter_peek (iter)).k && +while ((k =bch2_btree_iter_peek (trans, iter)).k && !(ret =bkey_err (k)) &&bkey_lt (k.k->p,POS (0 , max))) {if (pos < iter->pos.offset)
@@ -951,7 +951,7 @@ int bch2_inode_create(struct btree_trans *trans,* we've found just one: */ pos = iter->pos.offset +1 ; -bch2_btree_iter_set_pos (iter,POS (0 , pos)); +bch2_btree_iter_set_pos (trans, iter,POS (0 , pos)); }if (!ret && pos < max)
@@ -967,12 +967,12 @@ int bch2_inode_create(struct btree_trans *trans,/* Retry from start */ pos = start = min; -bch2_btree_iter_set_pos (iter,POS (0 , pos)); +bch2_btree_iter_set_pos (trans, iter,POS (0 , pos));le32_add_cpu (&cursor->v.gen,1 ); goto again; found_slot: -bch2_btree_iter_set_pos (iter,SPOS (0 , pos, snapshot)); - k =bch2_btree_iter_peek_slot (iter); +bch2_btree_iter_set_pos (trans, iter,SPOS (0 , pos, snapshot)); + k =bch2_btree_iter_peek_slot (trans, iter); ret =bkey_err (k);if (ret) {bch2_trans_iter_exit (trans, iter);
@@ -1009,9 +1009,9 @@ static int bch2_inode_delete_keys(struct btree_trans *trans,if (ret) goto err; -bch2_btree_iter_set_snapshot (&iter, snapshot); +bch2_btree_iter_set_snapshot (trans, &iter, snapshot); - k =bch2_btree_iter_peek_max (&iter, end); + k =bch2_btree_iter_peek_max (trans, &iter, end); ret =bkey_err (k);if (ret) goto err;
@@ -1042,7 +1042,7 @@ static int bch2_inode_delete_keys(struct btree_trans *trans,int bch2_inode_rm (struct bch_fs *c,subvol_inum inum) {struct btree_trans *trans =bch2_trans_get (c); -struct btree_iter iter = {NULL }; +struct btree_iter iter = {};struct bkey_s_c k;u32 snapshot;int ret;
@@ -1207,7 +1207,7 @@ int bch2_inum_opts_get(struct btree_trans *trans, subvol_inum inum, struct bch_i static noinline int __bch2_inode_rm_snapshot(struct btree_trans *trans, u64 inum, u32 snapshot) {struct bch_fs *c = trans->c; -struct btree_iter iter = {NULL }; +struct btree_iter iter = {};struct bkey_i_inode_generation delete;struct bch_inode_unpacked inode_u;struct bkey_s_c k;
fs/bcachefs/io_misc.c +9 -9
@@ -43,7 +43,7 @@ int bch2_extent_fallocate(struct btree_trans *trans,bch2_bkey_buf_init (&new);closure_init_stack (&cl); - k =bch2_btree_iter_peek_slot (iter); + k =bch2_btree_iter_peek_slot (trans, iter); ret =bkey_err (k);if (ret)return ret;
@@ -164,12 +164,12 @@ int bch2_fpunch_at(struct btree_trans *trans, struct btree_iter *iter,if (ret)continue ; -bch2_btree_iter_set_snapshot (iter, snapshot); +bch2_btree_iter_set_snapshot (trans, iter, snapshot);/* * peek_max() doesn't have ideal semantics for extents: */ - k =bch2_btree_iter_peek_max (iter, end_pos); + k =bch2_btree_iter_peek_max (trans, iter, end_pos);if (!k.k)break ;
@@ -230,7 +230,7 @@ static int truncate_set_isize(struct btree_trans *trans, u64 new_i_size, bool warn) { -struct btree_iter iter = {NULL }; +struct btree_iter iter = {};struct bch_inode_unpacked inode_u;int ret;
@@ -399,7 +399,7 @@ case LOGGED_OP_FINSERT_start:if (ret) goto err; }else { -bch2_btree_iter_set_pos (&iter,POS (inum.inum, src_offset)); +bch2_btree_iter_set_pos (trans, &iter,POS (inum.inum, src_offset)); ret =bch2_fpunch_at (trans, &iter, inum, src_offset + len, i_sectors_delta);if (ret && !bch2_err_matches (ret, BCH_ERR_transaction_restart))
@@ -425,12 +425,12 @@ case LOGGED_OP_FINSERT_shift_extents:if (ret) goto btree_err; -bch2_btree_iter_set_snapshot (&iter, snapshot); -bch2_btree_iter_set_pos (&iter,SPOS (inum.inum, pos, snapshot)); +bch2_btree_iter_set_snapshot (trans, &iter, snapshot); +bch2_btree_iter_set_pos (trans, &iter,SPOS (inum.inum, pos, snapshot)); k = insert - ?bch2_btree_iter_peek_prev_min (&iter,POS (inum.inum,0 )) - :bch2_btree_iter_peek_max (&iter,POS (inum.inum,U64_MAX )); + ?bch2_btree_iter_peek_prev_min (trans, &iter,POS (inum.inum,0 )) + :bch2_btree_iter_peek_max (trans, &iter,POS (inum.inum,U64_MAX ));if ((ret =bkey_err (k))) goto btree_err;
fs/bcachefs/io_read.c +4 -4
@@ -908,7 +908,7 @@ static noinline void read_from_stale_dirty_pointer(struct btree_trans *trans,prt_printf (&buf,"memory gen: %u" , gen); - ret =lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_slot (&iter))); + ret =lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_slot (trans, &iter)));if (!ret) {prt_newline (&buf);bch2_bkey_val_to_text (&buf, c, k);
@@ -1288,12 +1288,12 @@ int __bch2_read(struct btree_trans *trans, struct bch_read_bio *rbio,if (ret) goto err; -bch2_btree_iter_set_snapshot (&iter, snapshot); +bch2_btree_iter_set_snapshot (trans, &iter, snapshot); -bch2_btree_iter_set_pos (&iter, +bch2_btree_iter_set_pos (trans, &iter,POS (inum.inum, bvec_iter.bi_sector)); - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter); ret =bkey_err (k);if (ret) goto err;
fs/bcachefs/io_write.c +6 -6
@@ -168,9 +168,9 @@ int bch2_sum_sector_overwrites(struct btree_trans *trans, *i_sectors_delta =0 ; *disk_sectors_delta =0 ; -bch2_trans_copy_iter (&iter, extent_iter); +bch2_trans_copy_iter (trans, &iter, extent_iter); -for_each_btree_key_max_continue_norestart (iter, +for_each_btree_key_max_continue_norestart (trans, iter, new->k.p, BTREE_ITER_slots, old, ret) {s64 sectors =min (new->k.p.offset, old.k->p.offset) - max(bkey_start_offset(&new->k),
@@ -292,7 +292,7 @@ int bch2_extent_update(struct btree_trans *trans,* path already traversed at iter->pos because * bch2_trans_extent_update() will use it to attempt extent merging */ - ret =__bch2_btree_iter_traverse (iter); + ret =__bch2_btree_iter_traverse (trans, iter);if (ret)return ret;
@@ -337,7 +337,7 @@ int bch2_extent_update(struct btree_trans *trans,if (i_sectors_delta_total) *i_sectors_delta_total += i_sectors_delta; -bch2_btree_iter_set_pos (iter, next_pos); +bch2_btree_iter_set_pos (trans, iter, next_pos);return 0 ; }
@@ -1287,7 +1287,7 @@ static void bch2_nocow_write(struct bch_write_op *op)if (ret)break ; - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter); ret =bkey_err (k);if (ret)break ;
@@ -1371,7 +1371,7 @@ static void bch2_nocow_write(struct bch_write_op *op)bch2_keylist_push (&op->insert_keys);if (op->flags & BCH_WRITE_submitted)break ; -bch2_btree_iter_advance (&iter); +bch2_btree_iter_advance (trans, &iter); } out:bch2_trans_iter_exit (trans, &iter);
fs/bcachefs/migrate.c +2 -2
@@ -130,7 +130,7 @@ static int bch2_dev_metadata_drop(struct bch_fs *c, retry: ret =0 ;while (bch2_trans_begin (trans), - (b =bch2_btree_iter_peek_node (&iter)) && + (b =bch2_btree_iter_peek_node (trans, &iter)) && !(ret =PTR_ERR_OR_ZERO (b))) {bch2_progress_update_iter (trans, progress, &iter,"dropping metadata" );
@@ -154,7 +154,7 @@ static int bch2_dev_metadata_drop(struct bch_fs *c,if (ret)break ; next: -bch2_btree_iter_next_node (&iter); +bch2_btree_iter_next_node (trans, &iter); }if (bch2_err_matches (ret, BCH_ERR_transaction_restart)) goto retry;
fs/bcachefs/move.c +6 -6
@@ -572,7 +572,7 @@ static int bch2_move_data_btree(struct moving_context *ctxt,bch2_trans_begin (trans); - k =bch2_btree_iter_peek (&iter); + k =bch2_btree_iter_peek (trans, &iter);if (!k.k)break ;
@@ -652,7 +652,7 @@ static int bch2_move_data_btree(struct moving_context *ctxt,if (ctxt->stats)atomic64_add (k.k->size, &ctxt->stats->sectors_seen); next_nondata: -bch2_btree_iter_advance (&iter); +bch2_btree_iter_advance (trans, &iter); }bch2_trans_iter_exit (trans, &reflink_iter);
@@ -765,7 +765,7 @@ static int __bch2_move_data_phys(struct moving_context *ctxt,bch2_trans_begin (trans); - k =bch2_btree_iter_peek (&bp_iter); + k =bch2_btree_iter_peek (trans, &bp_iter); ret =bkey_err (k);if (bch2_err_matches (ret, BCH_ERR_transaction_restart))continue ;
@@ -847,7 +847,7 @@ static int __bch2_move_data_phys(struct moving_context *ctxt,if (ctxt->stats)atomic64_add (sectors, &ctxt->stats->sectors_seen); next: -bch2_btree_iter_advance (&bp_iter); +bch2_btree_iter_advance (trans, &bp_iter); } err:bch2_trans_iter_exit (trans, &bp_iter);
@@ -962,7 +962,7 @@ static int bch2_move_btree(struct bch_fs *c, retry: ret =0 ;while (bch2_trans_begin (trans), - (b =bch2_btree_iter_peek_node (&iter)) && + (b =bch2_btree_iter_peek_node (trans, &iter)) && !(ret =PTR_ERR_OR_ZERO (b))) {if (kthread &&kthread_should_stop ())break ;
@@ -982,7 +982,7 @@ static int bch2_move_btree(struct bch_fs *c,if (ret)break ; next: -bch2_btree_iter_next_node (&iter); +bch2_btree_iter_next_node (trans, &iter); }if (bch2_err_matches (ret, BCH_ERR_transaction_restart)) goto retry;
fs/bcachefs/namei.c +19 -19
@@ -28,8 +28,8 @@ int bch2_create_trans(struct btree_trans *trans, unsigned flags) {struct bch_fs *c = trans->c; -struct btree_iter dir_iter = {NULL }; -struct btree_iter inode_iter = {NULL }; +struct btree_iter dir_iter = {}; +struct btree_iter inode_iter = {};subvol_inum new_inum = dir;u64 now =bch2_current_time (c);u64 cpu =raw_smp_processor_id ();
@@ -127,8 +127,8 @@ int bch2_create_trans(struct btree_trans *trans,if (ret) goto err; -bch2_btree_iter_set_snapshot (&dir_iter, dir_snapshot); - ret =bch2_btree_iter_traverse (&dir_iter); +bch2_btree_iter_set_snapshot (trans, &dir_iter, dir_snapshot); + ret =bch2_btree_iter_traverse (trans, &dir_iter);if (ret) goto err; }
@@ -177,9 +177,9 @@ int bch2_create_trans(struct btree_trans *trans, new_inode->bi_depth = dir_u->bi_depth +1 ; inode_iter.flags &= ~BTREE_ITER_all_snapshots; -bch2_btree_iter_set_snapshot (&inode_iter, snapshot); +bch2_btree_iter_set_snapshot (trans, &inode_iter, snapshot); - ret =bch2_btree_iter_traverse (&inode_iter) ?: + ret =bch2_btree_iter_traverse (trans, &inode_iter) ?:bch2_inode_write (trans, &inode_iter, new_inode); err:bch2_trans_iter_exit (trans, &inode_iter);
@@ -193,8 +193,8 @@ int bch2_link_trans(struct btree_trans *trans, const struct qstr *name) {struct bch_fs *c = trans->c; -struct btree_iter dir_iter = {NULL }; -struct btree_iter inode_iter = {NULL }; +struct btree_iter dir_iter = {}; +struct btree_iter inode_iter = {};struct bch_hash_info dir_hash;u64 now =bch2_current_time (c);u64 dir_offset =0 ;
@@ -253,9 +253,9 @@ int bch2_unlink_trans(struct btree_trans *trans, bool deleting_subvol) {struct bch_fs *c = trans->c; -struct btree_iter dir_iter = {NULL }; -struct btree_iter dirent_iter = {NULL }; -struct btree_iter inode_iter = {NULL }; +struct btree_iter dir_iter = {}; +struct btree_iter dirent_iter = {}; +struct btree_iter inode_iter = {};struct bch_hash_info dir_hash;subvol_inum inum;u64 now =bch2_current_time (c);
@@ -301,7 +301,7 @@ int bch2_unlink_trans(struct btree_trans *trans,if (ret) goto err; - k =bch2_btree_iter_peek_slot (&dirent_iter); + k =bch2_btree_iter_peek_slot (trans, &dirent_iter); ret =bkey_err (k);if (ret) goto err;
@@ -310,8 +310,8 @@ int bch2_unlink_trans(struct btree_trans *trans,* If we're deleting a subvolume, we need to really delete the * dirent, not just emit a whiteout in the current snapshot: */ -bch2_btree_iter_set_snapshot (&dirent_iter, k.k->p.snapshot); - ret =bch2_btree_iter_traverse (&dirent_iter); +bch2_btree_iter_set_snapshot (trans, &dirent_iter, k.k->p.snapshot); + ret =bch2_btree_iter_traverse (trans, &dirent_iter);if (ret) goto err; }else {
@@ -390,10 +390,10 @@ int bch2_rename_trans(struct btree_trans *trans, enum bch_rename_mode mode) {struct bch_fs *c = trans->c; -struct btree_iter src_dir_iter = {NULL }; -struct btree_iter dst_dir_iter = {NULL }; -struct btree_iter src_inode_iter = {NULL }; -struct btree_iter dst_inode_iter = {NULL }; +struct btree_iter src_dir_iter = {}; +struct btree_iter dst_dir_iter = {}; +struct btree_iter src_inode_iter = {}; +struct btree_iter dst_inode_iter = {};struct bch_hash_info src_hash, dst_hash;subvol_inum src_inum, dst_inum;u64 src_offset, dst_offset;
@@ -666,7 +666,7 @@ static int bch2_check_dirent_inode_dirent(struct btree_trans *trans, {struct bch_fs *c = trans->c;struct printbuf buf =PRINTBUF ; -struct btree_iter bp_iter = {NULL }; +struct btree_iter bp_iter = {};int ret =0 ;if (inode_points_to_dirent (target, d))
fs/bcachefs/quota.c +1 -1
@@ -516,7 +516,7 @@ static int bch2_fs_quota_read_inode(struct btree_trans *trans,bch2_quota_acct (c,bch_qid (&u),Q_INO ,1 ,KEY_TYPE_QUOTA_NOCHECK ); advance: -bch2_btree_iter_set_pos (iter,bpos_nosnap_successor (iter->pos)); +bch2_btree_iter_set_pos (trans, iter,bpos_nosnap_successor (iter->pos));return 0 ; }
fs/bcachefs/rebalance.c +6 -6
@@ -233,7 +233,7 @@ int bch2_set_rebalance_needs_scan_trans(struct btree_trans *trans, u64 inum)bch2_trans_iter_init (trans, &iter, BTREE_ID_rebalance_work,SPOS (inum,REBALANCE_WORK_SCAN_OFFSET ,U32_MAX ), BTREE_ITER_intent); - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter); ret =bkey_err (k);if (ret) goto err;
@@ -281,7 +281,7 @@ static int bch2_clear_rebalance_needs_scan(struct btree_trans *trans, u64 inum,bch2_trans_iter_init (trans, &iter, BTREE_ID_rebalance_work,SPOS (inum,REBALANCE_WORK_SCAN_OFFSET ,U32_MAX ), BTREE_ITER_intent); - k =bch2_btree_iter_peek_slot (&iter); + k =bch2_btree_iter_peek_slot (trans, &iter); ret =bkey_err (k);if (ret) goto err;
@@ -301,7 +301,7 @@ static struct bkey_s_c next_rebalance_entry(struct btree_trans *trans, struct btree_iter *work_iter) {return !kthread_should_stop () - ?bch2_btree_iter_peek (work_iter) + ?bch2_btree_iter_peek (trans, work_iter) : bkey_s_c_null; }
@@ -335,7 +335,7 @@ static struct bkey_s_c next_rebalance_extent(struct btree_trans *trans, work_pos.inode ? BTREE_ID_extents : BTREE_ID_reflink, work_pos, BTREE_ITER_all_snapshots); -struct bkey_s_c k =bch2_btree_iter_peek_slot (extent_iter); +struct bkey_s_c k =bch2_btree_iter_peek_slot (trans, extent_iter);if (bkey_err (k))return k;
@@ -511,7 +511,7 @@ static int do_rebalance(struct moving_context *ctxt)struct btree_trans *trans = ctxt->trans;struct bch_fs *c = trans->c;struct bch_fs_rebalance *r = &c->rebalance; -struct btree_iter rebalance_work_iter, extent_iter = {NULL }; +struct btree_iter rebalance_work_iter, extent_iter = {};struct bkey_s_c k;int ret =0 ;
@@ -552,7 +552,7 @@ static int do_rebalance(struct moving_context *ctxt)if (ret)break ; -bch2_btree_iter_advance (&rebalance_work_iter); +bch2_btree_iter_advance (trans, &rebalance_work_iter); }bch2_trans_iter_exit (trans, &extent_iter);
fs/bcachefs/recovery.c +3 -3
@@ -198,7 +198,7 @@ static int bch2_journal_replay_accounting_key(struct btree_trans *trans,bch2_trans_node_iter_init (trans, &iter, k->btree_id, k->k->k.p,BTREE_MAX_DEPTH , k->level, BTREE_ITER_intent); -int ret =bch2_btree_iter_traverse (&iter); +int ret =bch2_btree_iter_traverse (trans, &iter);if (ret) goto out;
@@ -261,7 +261,7 @@ static int bch2_journal_replay_key(struct btree_trans *trans,bch2_trans_node_iter_init (trans, &iter, k->btree_id, k->k->k.p,BTREE_MAX_DEPTH , k->level, iter_flags); - ret =bch2_btree_iter_traverse (&iter); + ret =bch2_btree_iter_traverse (trans, &iter);if (ret) goto out;
@@ -270,7 +270,7 @@ static int bch2_journal_replay_key(struct btree_trans *trans,bch2_trans_iter_exit (trans, &iter);bch2_trans_node_iter_init (trans, &iter, k->btree_id, k->k->k.p,BTREE_MAX_DEPTH ,0 , iter_flags); - ret =bch2_btree_iter_traverse (&iter) ?: + ret =bch2_btree_iter_traverse (trans, &iter) ?:bch2_btree_increase_depth (trans, iter.path,0 ) ?: -BCH_ERR_transaction_restart_nested; goto out;
fs/bcachefs/reflink.c +12 -11
@@ -495,7 +495,7 @@ static int bch2_make_extent_indirect(struct btree_trans *trans, bool reflink_p_may_update_opts_field) {struct bch_fs *c = trans->c; -struct btree_iter reflink_iter = {NULL }; +struct btree_iter reflink_iter = {};struct bkey_s_c k;struct bkey_i *r_v;struct bkey_i_reflink_p *r_p;
@@ -507,7 +507,7 @@ static int bch2_make_extent_indirect(struct btree_trans *trans,bch2_trans_iter_init (trans, &reflink_iter, BTREE_ID_reflink,POS_MAX , BTREE_ITER_intent); - k =bch2_btree_iter_peek_prev (&reflink_iter); + k =bch2_btree_iter_peek_prev (trans, &reflink_iter); ret =bkey_err (k);if (ret) goto err;
@@ -569,12 +569,13 @@ static int bch2_make_extent_indirect(struct btree_trans *trans,return ret; } -static struct bkey_s_c get_next_src (struct btree_iter *iter,struct bpos end) +static struct bkey_s_c get_next_src (struct btree_trans *trans, +struct btree_iter *iter,struct bpos end) {struct bkey_s_c k;int ret; -for_each_btree_key_max_continue_norestart (*iter, end,0 , k, ret) { +for_each_btree_key_max_continue_norestart (trans, *iter, end,0 , k, ret) {if (bkey_extent_is_unwritten (k))continue ;
@@ -583,7 +584,7 @@ static struct bkey_s_c get_next_src(struct btree_iter *iter, struct bpos end) }if (bkey_ge (iter->pos, end)) -bch2_btree_iter_set_pos (iter, end); +bch2_btree_iter_set_pos (trans, iter, end);return ret ?bkey_s_c_err (ret) : bkey_s_c_null; }
@@ -647,27 +648,27 @@ s64 bch2_remap_range(struct bch_fs *c,if (ret)continue ; -bch2_btree_iter_set_snapshot (&src_iter, src_snapshot); +bch2_btree_iter_set_snapshot (trans, &src_iter, src_snapshot); ret =bch2_subvolume_get_snapshot (trans, dst_inum.subvol, &dst_snapshot);if (ret)continue ; -bch2_btree_iter_set_snapshot (&dst_iter, dst_snapshot); +bch2_btree_iter_set_snapshot (trans, &dst_iter, dst_snapshot);if (dst_inum.inum < src_inum.inum) {/* Avoid some lock cycle transaction restarts */ - ret =bch2_btree_iter_traverse (&dst_iter); + ret =bch2_btree_iter_traverse (trans, &dst_iter);if (ret)continue ; } dst_done = dst_iter.pos.offset - dst_start.offset; src_want =POS (src_start.inode, src_start.offset + dst_done); -bch2_btree_iter_set_pos (&src_iter, src_want); +bch2_btree_iter_set_pos (trans, &src_iter, src_want); - src_k =get_next_src (&src_iter, src_end); + src_k =get_next_src (trans, &src_iter, src_end); ret =bkey_err (src_k);if (ret)continue ;
@@ -738,7 +739,7 @@ s64 bch2_remap_range(struct bch_fs *c, do { struct bch_inode_unpacked inode_u; - struct btree_iter inode_iter = { NULL }; + struct btree_iter inode_iter = {}; bch2_trans_begin(trans);
fs/bcachefs/snapshot.c +5 -5
@@ -1074,9 +1074,9 @@ static inline void normalize_snapshot_child_pointers(struct bch_snapshot *s)static int bch2_snapshot_node_delete (struct btree_trans *trans,u32 id) {struct bch_fs *c = trans->c; -struct btree_iter iter, p_iter = (struct btree_iter ) {NULL }; -struct btree_iter c_iter = (struct btree_iter ) {NULL }; -struct btree_iter tree_iter = (struct btree_iter ) {NULL }; +struct btree_iter iter, p_iter = {}; +struct btree_iter c_iter = {}; +struct btree_iter tree_iter = {};struct bkey_s_c_snapshot s;u32 parent_id, child_id;unsigned i;
@@ -1193,13 +1193,13 @@ static int create_snapids(struct btree_trans *trans, u32 parent, u32 tree,bch2_trans_iter_init (trans, &iter, BTREE_ID_snapshots,POS_MIN , BTREE_ITER_intent); - k =bch2_btree_iter_peek (&iter); + k =bch2_btree_iter_peek (trans, &iter); ret =bkey_err (k);if (ret) goto err;for (i =0 ; i < nr_snapids; i++) { - k =bch2_btree_iter_prev_slot (&iter); + k =bch2_btree_iter_prev_slot (trans, &iter); ret =bkey_err (k);if (ret) goto err;
fs/bcachefs/str_hash.c +1 -1
@@ -195,7 +195,7 @@ int __bch2_str_hash_check_key(struct btree_trans *trans, struct btree_iter *k_iter, struct bkey_s_c hash_k) {struct bch_fs *c = trans->c; -struct btree_iter iter = {NULL }; +struct btree_iter iter = {};struct printbuf buf =PRINTBUF ;struct bkey_s_c k;int ret =0 ;
fs/bcachefs/str_hash.h +4 -4
@@ -231,11 +231,11 @@ int bch2_hash_needs_whiteout(struct btree_trans *trans,struct bkey_s_c k;int ret; -bch2_trans_copy_iter (&iter, start); +bch2_trans_copy_iter (trans, &iter, start); -bch2_btree_iter_advance (&iter); +bch2_btree_iter_advance (trans, &iter); -for_each_btree_key_continue_norestart (iter, BTREE_ITER_slots, k, ret) { +for_each_btree_key_continue_norestart (trans, iter, BTREE_ITER_slots, k, ret) {if (k.k->type != desc.key_type && k.k->type != KEY_TYPE_hash_whiteout)break ;
@@ -280,7 +280,7 @@ struct bkey_s_c bch2_hash_set_or_get_in_snapshot(struct btree_trans *trans, }if (!slot.path && !(flags & STR_HASH_must_replace)) -bch2_trans_copy_iter (&slot, iter); +bch2_trans_copy_iter (trans, &slot, iter);if (k.k->type != KEY_TYPE_hash_whiteout) goto not_found;
fs/bcachefs/subvolume.c +2 -2
@@ -275,7 +275,7 @@ int bch2_subvol_has_children(struct btree_trans *trans, u32 subvol)struct btree_iter iter;bch2_trans_iter_init (trans, &iter, BTREE_ID_subvolume_children,POS (subvol,0 ),0 ); -struct bkey_s_c k =bch2_btree_iter_peek (&iter); +struct bkey_s_c k =bch2_btree_iter_peek (trans, &iter);bch2_trans_iter_exit (trans, &iter);return bkey_err (k) ?: k.k && k.k->p.inode == subvol
@@ -573,7 +573,7 @@ int bch2_subvolume_create(struct btree_trans *trans, u64 inode, bool ro) {struct bch_fs *c = trans->c; -struct btree_iter dst_iter, src_iter = (struct btree_iter ) {NULL }; +struct btree_iter dst_iter, src_iter = {};struct bkey_i_subvolume *new_subvol =NULL ;struct bkey_i_subvolume *src_subvol =NULL ;u32 parent =0 , new_nodes[2 ], snapshot_subvols[2 ];
fs/bcachefs/subvolume.h +7 -7
@@ -33,16 +33,16 @@ int bch2_subvol_is_ro_trans(struct btree_trans *, u32);int bch2_subvol_is_ro (struct bch_fs *,u32 );static inline struct bkey_s_c -bch2_btree_iter_peek_in_subvolume_max_type (struct btree_iter *iter,struct bpos end, -u32 subvolid,unsigned flags) +bch2_btree_iter_peek_in_subvolume_max_type (struct btree_trans *trans,struct btree_iter *iter, +struct bpos end,u32 subvolid,unsigned flags) {u32 snapshot; -int ret =bch2_subvolume_get_snapshot (iter->trans, subvolid, &snapshot); +int ret =bch2_subvolume_get_snapshot (trans, subvolid, &snapshot);if (ret)return bkey_s_c_err (ret); -bch2_btree_iter_set_snapshot (iter, snapshot); -return bch2_btree_iter_peek_max_type (iter, end, flags); +bch2_btree_iter_set_snapshot (trans, iter, snapshot); +return bch2_btree_iter_peek_max_type (trans, iter, end, flags); } #define for_each_btree_key_in_subvolume_max_continue(_trans, _iter, \
@@ -53,14 +53,14 @@ bch2_btree_iter_peek_in_subvolume_max_type(struct btree_iter *iter, struct bpos \do { \ _ret3 =lockrestart_do (_trans, ({ \ - (_k) =bch2_btree_iter_peek_in_subvolume_max_type (&(_iter), \ + (_k) =bch2_btree_iter_peek_in_subvolume_max_type (trans, &(_iter),\ _end, _subvolid, (_flags)); \if (!(_k).k) \break ; \ \bkey_err (_k) ?: (_do); \ })); \ - }while (!_ret3 &&bch2_btree_iter_advance (&(_iter))); \ + }while (!_ret3 &&bch2_btree_iter_advance (_trans, &(_iter))); \ \bch2_trans_iter_exit ((_trans), &(_iter)); \ _ret3; \
fs/bcachefs/tests.c +15 -15
@@ -43,7 +43,7 @@ static int test_delete(struct bch_fs *c, u64 nr) BTREE_ITER_intent); ret =commit_do (trans,NULL ,NULL ,0 , -bch2_btree_iter_traverse (&iter) ?: +bch2_btree_iter_traverse (trans, &iter) ?:bch2_trans_update (trans, &iter, &k.k_i,0 ));bch_err_msg (c, ret,"update error" );if (ret)
@@ -51,7 +51,7 @@ static int test_delete(struct bch_fs *c, u64 nr)pr_info ("deleting once" ); ret =commit_do (trans,NULL ,NULL ,0 , -bch2_btree_iter_traverse (&iter) ?: +bch2_btree_iter_traverse (trans, &iter) ?:bch2_btree_delete_at (trans, &iter,0 ));bch_err_msg (c, ret,"delete error (first)" );if (ret)
@@ -59,7 +59,7 @@ static int test_delete(struct bch_fs *c, u64 nr)pr_info ("deleting twice" ); ret =commit_do (trans,NULL ,NULL ,0 , -bch2_btree_iter_traverse (&iter) ?: +bch2_btree_iter_traverse (trans, &iter) ?:bch2_btree_delete_at (trans, &iter,0 ));bch_err_msg (c, ret,"delete error (second)" );if (ret)
@@ -84,7 +84,7 @@ static int test_delete_written(struct bch_fs *c, u64 nr) BTREE_ITER_intent); ret =commit_do (trans,NULL ,NULL ,0 , -bch2_btree_iter_traverse (&iter) ?: +bch2_btree_iter_traverse (trans, &iter) ?:bch2_trans_update (trans, &iter, &k.k_i,0 ));bch_err_msg (c, ret,"update error" );if (ret)
@@ -94,7 +94,7 @@ static int test_delete_written(struct bch_fs *c, u64 nr)bch2_journal_flush_all_pins (&c->journal); ret =commit_do (trans,NULL ,NULL ,0 , -bch2_btree_iter_traverse (&iter) ?: +bch2_btree_iter_traverse (trans, &iter) ?:bch2_btree_delete_at (trans, &iter,0 ));bch_err_msg (c, ret,"delete error" );if (ret)
@@ -349,10 +349,10 @@ static int test_peek_end(struct bch_fs *c, u64 nr)bch2_trans_iter_init (trans, &iter, BTREE_ID_xattrs,SPOS (0 ,0 ,U32_MAX ),0 ); -lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (trans, &iter,POS (0 ,U64_MAX ))));BUG_ON (k.k); -lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (trans, &iter,POS (0 ,U64_MAX ))));BUG_ON (k.k);bch2_trans_iter_exit (trans, &iter);
@@ -369,10 +369,10 @@ static int test_peek_end_extents(struct bch_fs *c, u64 nr)bch2_trans_iter_init (trans, &iter, BTREE_ID_extents,SPOS (0 ,0 ,U32_MAX ),0 ); -lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (trans, &iter,POS (0 ,U64_MAX ))));BUG_ON (k.k); -lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (trans, &iter,POS (0 ,U64_MAX ))));BUG_ON (k.k);bch2_trans_iter_exit (trans, &iter);
@@ -488,7 +488,7 @@ static int test_snapshot_filter(struct bch_fs *c, u32 snapid_lo, u32 snapid_hi) trans =bch2_trans_get (c);bch2_trans_iter_init (trans, &iter, BTREE_ID_xattrs,SPOS (0 ,0 , snapid_lo),0 ); -lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (trans, &iter,POS (0 ,U64_MAX ))));BUG_ON (k.k->p.snapshot !=U32_MAX );
@@ -602,9 +602,9 @@ static int rand_lookup(struct bch_fs *c, u64 nr) SPOS(0, 0, U32_MAX), 0);for (i =0 ; i < nr; i++) { -bch2_btree_iter_set_pos (&iter,SPOS (0 ,test_rand (),U32_MAX )); +bch2_btree_iter_set_pos (trans, &iter,SPOS (0 ,test_rand (),U32_MAX )); -lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek (&iter))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek (trans, &iter))); ret =bkey_err (k);if (ret)break ;
@@ -623,9 +623,9 @@ static int rand_mixed_trans(struct btree_trans *trans,struct bkey_s_c k;int ret; -bch2_btree_iter_set_pos (iter,SPOS (0 , pos,U32_MAX )); +bch2_btree_iter_set_pos (trans, iter,SPOS (0 , pos,U32_MAX )); - k =bch2_btree_iter_peek (iter); + k =bch2_btree_iter_peek (trans, iter); ret =bkey_err (k);bch_err_msg (trans->c, ret,"lookup error" );if (ret)
@@ -672,7 +672,7 @@ static int __do_delete(struct btree_trans *trans, struct bpos pos)bch2_trans_iter_init (trans, &iter, BTREE_ID_xattrs, pos, BTREE_ITER_intent); - k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX )); + k =bch2_btree_iter_peek_max (trans, &iter,POS (0 ,U64_MAX )); ret =bkey_err (k);if (ret) goto err;
fs/bcachefs/xattr.c +1 -1
@@ -168,7 +168,7 @@ int bch2_xattr_set(struct btree_trans *trans, subvol_inum inum, int type, int flags) {struct bch_fs *c = trans->c; -struct btree_iter inode_iter = {NULL }; +struct btree_iter inode_iter = {};int ret; ret = bch2_subvol_is_ro_trans(trans, inum.subvol) ?:
Signature · 1 line
2.49.0
PATCH 3/8 bcachefs: do_trace_key_cache_fill()
In reply to Kent OverstreetReducing stack frame usage; this moves the printbuf out of the main stack frame.
--- fs/bcachefs/btree_key_cache.c | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-)
fs/bcachefs/btree_key_cache.c +15 -9
@@ -287,6 +287,19 @@ static int btree_key_cache_create(struct btree_trans *trans,return ret; } +static noinline_for_stack void do_trace_key_cache_fill(struct btree_trans *trans, +struct btree_path *ck_path, +struct bkey_s_c k) +{ +struct printbuf buf =PRINTBUF ; + +bch2_bpos_to_text (&buf, ck_path->pos); +prt_char (&buf,' ' ); +bch2_bkey_val_to_text (&buf, trans->c, k); +trace_key_cache_fill (trans, buf.buf); +printbuf_exit (&buf); +} + static noinline int btree_key_cache_fill(struct btree_trans *trans,struct btree_path *ck_path,unsigned flags)
@@ -320,15 +333,8 @@ static noinline int btree_key_cache_fill(struct btree_trans *trans,if (ret) goto err; -if (trace_key_cache_fill_enabled ()) { -struct printbuf buf =PRINTBUF ; - -bch2_bpos_to_text (&buf, ck_path->pos); -prt_char (&buf,' ' ); -bch2_bkey_val_to_text (&buf, trans->c, k); -trace_key_cache_fill (trans, buf.buf); -printbuf_exit (&buf); - } +if (trace_key_cache_fill_enabled ()) +do_trace_key_cache_fill (trans, ck_path, k); out:/* We're not likely to need this iterator again: */ bch2_set_btree_iter_dontneed (trans, &iter);
Signature · 1 line
2.49.0
PATCH 4/8 bcachefs: bch2_alloc_to_v4() no longer converts on stack
In reply to Kent OverstreetKMSAN builds have been overflowing the stack:
transaction commit
btree split
allocator - sector/bucket
runtime fsck checks - bch2_check_discard_freespace_key
bch2_alloc_to_v4() exists for compatibility with ancient versions, it's generally a noop but will convert old alloc keys into the new format.
This gets rid of the stack allocated bch_alloc_v4 in those codepaths; we allocate it with the btree_trans bump allocator if needed.
--- fs/bcachefs/alloc_background.c | 54 ++++++++++++++++++++++++---------- fs/bcachefs/alloc_background.h | 23 +++++++++++++-- fs/bcachefs/alloc_foreground.c | 15 ++++++++-- fs/bcachefs/backpointers.c | 2 +- fs/bcachefs/btree_gc.c | 4 +-- fs/bcachefs/ec.c | 2 +- fs/bcachefs/lru.c | 9 ++++-- fs/bcachefs/movinggc.c | 2 +- 8 files changed, 82 insertions(+), 29 deletions(-)
fs/bcachefs/alloc_background.c +38 -16
@@ -338,7 +338,7 @@ void bch2_alloc_v4_swab(struct bkey_s k)void bch2_alloc_to_text (struct printbuf *out,struct bch_fs *c,struct bkey_s_c k) {struct bch_alloc_v4 _a; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (k, &_a); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4_onstack (k, &_a);struct bch_dev *ca = c ?bch2_dev_bucket_tryget_noerror (c, k.k->p) :NULL ;prt_newline (out);
@@ -367,7 +367,7 @@ void bch2_alloc_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_cbch2_dev_put (ca); } -void __bch2_alloc_to_v4 (struct bkey_s_c k,struct bch_alloc_v4 *out) +void __bch2_alloc_to_v4_copy (struct bkey_s_c k,struct bch_alloc_v4 *out) {if (k.k->type == KEY_TYPE_alloc_v4) {void *src, *dst;
@@ -403,6 +403,15 @@ void __bch2_alloc_to_v4(struct bkey_s_c k, struct bch_alloc_v4 *out) } } +const struct bch_alloc_v4 *__bch2_alloc_to_v4 (struct btree_trans *trans,struct bkey_s_c k) +{ +struct bch_alloc_v4 *out =bch2_trans_kmalloc (trans,sizeof (*out)); +if (!IS_ERR (out)) +__bch2_alloc_to_v4_copy (k, out); + +return out; +} + static noinline struct bkey_i_alloc_v4 *__bch2_alloc_to_v4_mut (struct btree_trans *trans,struct bkey_s_c k) {
@@ -429,7 +438,7 @@ __bch2_alloc_to_v4_mut(struct btree_trans *trans, struct bkey_s_c k) }else {bkey_alloc_v4_init (&ret->k_i); ret->k.p = k.k->p; -bch2_alloc_to_v4 (k, &ret->v); +__bch2_alloc_to_v4_copy (k, &ret->v); }return ret; }
@@ -552,7 +561,7 @@ int bch2_bucket_gens_init(struct bch_fs *c)continue ;struct bch_alloc_v4 a; -u8 gen =bch2_alloc_to_v4 (k, &a)->gen; +u8 gen =bch2_alloc_to_v4_onstack (k, &a)->gen;unsigned offset;struct bpos pos =alloc_gens_pos (iter.pos, &offset);int ret2 =0 ;
@@ -644,7 +653,7 @@ int bch2_alloc_read(struct bch_fs *c) }struct bch_alloc_v4 a; - *bucket_gen (ca, k.k->p.offset) =bch2_alloc_to_v4 (k, &a)->gen; + *bucket_gen (ca, k.k->p.offset) =bch2_alloc_to_v4_onstack (k, &a)->gen;0 ; })); }
@@ -837,8 +846,12 @@ int bch2_trigger_alloc(struct btree_trans *trans,if (!ca)return -BCH_ERR_trigger_alloc; +/* +* We have to use the _onstack version here as we're called for atomic +* triggers where we can't take a transaction restart: +*/ struct bch_alloc_v4 old_a_convert; -const struct bch_alloc_v4 *old_a =bch2_alloc_to_v4 (old, &old_a_convert); +const struct bch_alloc_v4 *old_a =bch2_alloc_to_v4_onstack (old, &old_a_convert);struct bch_alloc_v4 *new_a;if (likely (new.k->type == KEY_TYPE_alloc_v4)) {
@@ -1146,7 +1159,6 @@ int bch2_check_alloc_key(struct btree_trans *trans, struct btree_iter *bucket_gens_iter) {struct bch_fs *c = trans->c; -struct bch_alloc_v4 a_convert;const struct bch_alloc_v4 *a;unsigned gens_offset;struct bkey_s_c k;
@@ -1165,7 +1177,10 @@ int bch2_check_alloc_key(struct btree_trans *trans,if (!ca->mi.freespace_initialized) goto out; - a =bch2_alloc_to_v4 (alloc_k, &a_convert); + a =bch2_alloc_to_v4 (trans, alloc_k); + ret =PTR_ERR_OR_ZERO (a); +if (unlikely (ret)) + goto err;bch2_btree_iter_set_pos (trans, discard_iter, alloc_k.k->p); k =bch2_btree_iter_peek_slot (trans, discard_iter);
@@ -1414,8 +1429,10 @@ int bch2_check_discard_freespace_key(struct btree_trans *trans, struct btree_ite goto out; } -struct bch_alloc_v4 a_convert; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (alloc_k, &a_convert); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (trans, alloc_k); + ret =PTR_ERR_OR_ZERO (a); +if (unlikely (ret)) + goto err; if (a->data_type != state || (state == BCH_DATA_free &&
@@ -1435,6 +1452,7 @@ int bch2_check_discard_freespace_key(struct btree_trans *trans, struct btree_ite *gen = a->gen; out: +err: fsck_err:bch2_set_btree_iter_dontneed (trans, &alloc_iter);bch2_trans_iter_exit (trans, &alloc_iter);
@@ -1680,8 +1698,6 @@ static int bch2_check_alloc_to_lru_ref(struct btree_trans *trans, struct bkey_buf *last_flushed) {struct bch_fs *c = trans->c; -struct bch_alloc_v4 a_convert; -const struct bch_alloc_v4 *a;struct bkey_s_c alloc_k;struct printbuf buf =PRINTBUF ;int ret;
@@ -1698,7 +1714,10 @@ static int bch2_check_alloc_to_lru_ref(struct btree_trans *trans,if (!ca)return 0 ; - a =bch2_alloc_to_v4 (alloc_k, &a_convert); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (trans, alloc_k); + ret =PTR_ERR_OR_ZERO (a); +if (unlikely (ret)) + goto err;u64 lru_idx =alloc_lru_idx_fragmentation (*a, ca);if (lru_idx) {
@@ -2160,8 +2179,10 @@ static int invalidate_one_bucket(struct btree_trans *trans,if (ret)return ret; -struct bch_alloc_v4 a_convert; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (alloc_k, &a_convert); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (trans, alloc_k); + ret =PTR_ERR_OR_ZERO (a); +if (unlikely (ret)) + goto err;/* We expect harmless races here due to the btree write buffer: */ if (lru_pos_time (lru_iter->pos) !=alloc_lru_idx_read (*a))
@@ -2190,6 +2211,7 @@ static int invalidate_one_bucket(struct btree_trans *trans,trace_and_count (c, bucket_invalidate, c, bucket.inode, bucket.offset, cached_sectors); --*nr_to_invalidate; out: +err: fsck_err:bch2_trans_iter_exit (trans, &alloc_iter);printbuf_exit (&buf);
@@ -2334,7 +2356,7 @@ int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca,* time: */ struct bch_alloc_v4 a_convert; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (k, &a_convert); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4_onstack (k, &a_convert); ret =bch2_bucket_do_index (trans, ca, k, a, true) ?: bch2_trans_commit(trans, NULL, NULL,
fs/bcachefs/alloc_background.h +20 -3
@@ -220,9 +220,10 @@ struct bkey_i_alloc_v4 * bch2_trans_start_alloc_update(struct btree_trans *, struct bpos,enum btree_iter_update_trigger_flags ); -void __bch2_alloc_to_v4 (struct bkey_s_c ,struct bch_alloc_v4 *); +void __bch2_alloc_to_v4_copy (struct bkey_s_c ,struct bch_alloc_v4 *); +const struct bch_alloc_v4 *__bch2_alloc_to_v4 (struct btree_trans *,struct bkey_s_c ); -static inline const struct bch_alloc_v4 *bch2_alloc_to_v4 (struct bkey_s_c k,struct bch_alloc_v4 *convert) +static inline const struct bch_alloc_v4 *bch2_alloc_to_v4 (struct btree_trans *trans,struct bkey_s_c k) {const struct bch_alloc_v4 *ret;
@@ -235,7 +236,23 @@ static inline const struct bch_alloc_v4 *bch2_alloc_to_v4(struct bkey_s_c k, strreturn ret; slowpath: -__bch2_alloc_to_v4 (k, convert); +return __bch2_alloc_to_v4 (trans, k); +} + +static inline const struct bch_alloc_v4 *bch2_alloc_to_v4_onstack (struct bkey_s_c k,struct bch_alloc_v4 *convert) +{ +const struct bch_alloc_v4 *ret; + +if (unlikely (k.k->type != KEY_TYPE_alloc_v4)) + goto slowpath; + + ret =bkey_s_c_to_alloc_v4 (k).v; +if (BCH_ALLOC_V4_BACKPOINTERS_START (ret) != BCH_ALLOC_V4_U64s) + goto slowpath; + +return ret; +slowpath: +__bch2_alloc_to_v4_copy (k, convert);return convert; }
fs/bcachefs/alloc_foreground.c +12 -3
@@ -333,8 +333,11 @@ bch2_bucket_alloc_early(struct btree_trans *trans,continue ; } -struct bch_alloc_v4 a_convert; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (k, &a_convert); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (trans, k); + ret =PTR_ERR_OR_ZERO (a); +if (unlikely (ret)) +break ; +if (a->data_type != BCH_DATA_free)continue ;
@@ -344,7 +347,13 @@ bch2_bucket_alloc_early(struct btree_trans *trans,if (ret)break ; - a =bch2_alloc_to_v4 (ck, &a_convert); + a =bch2_alloc_to_v4 (trans, ck); + ret =PTR_ERR_OR_ZERO (a); +if (unlikely (ret)) { +bch2_trans_iter_exit (trans, &citer); +break ; + } +if (a->data_type != BCH_DATA_free) goto next;
fs/bcachefs/backpointers.c +1 -1
@@ -807,7 +807,7 @@ static int check_bucket_backpointer_mismatch(struct btree_trans *trans, struct b {struct bch_fs *c = trans->c;struct bch_alloc_v4 a_convert; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (alloc_k, &a_convert); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4_onstack (alloc_k, &a_convert);bool need_commit = false; if (a->data_type == BCH_DATA_sb ||
fs/bcachefs/btree_gc.c +2 -2
@@ -806,7 +806,7 @@ static int bch2_alloc_write_key(struct btree_trans *trans,if (!bucket_valid (ca, k.k->p.offset))return 0 ; - old =bch2_alloc_to_v4 (k, &old_convert); + old =bch2_alloc_to_v4_onstack (k, &old_convert); gc = new = *old;__bucket_m_to_alloc (&gc, *gc_bucket (ca, iter->pos.offset));
@@ -1119,7 +1119,7 @@ static int bch2_alloc_write_oldest_gen(struct btree_trans *trans, struct bch_dev struct btree_iter *iter, struct bkey_s_c k) {struct bch_alloc_v4 a_convert; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (k, &a_convert); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4_onstack (k, &a_convert);struct bkey_i_alloc_v4 *a_mut;int ret;
fs/bcachefs/ec.c +1 -1
@@ -2092,7 +2092,7 @@ struct ec_stripe_head *bch2_ec_stripe_head_get(struct btree_trans *trans,static int bch2_invalidate_stripe_to_dev (struct btree_trans *trans,struct bkey_s_c k_a) {struct bch_alloc_v4 a_convert; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (k_a, &a_convert); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4_onstack (k_a, &a_convert);if (!a->stripe)return 0 ;
fs/bcachefs/lru.c +7 -2
@@ -139,12 +139,17 @@ static u64 bkey_lru_type_idx(struct bch_fs *c,struct bch_alloc_v4 a_convert;const struct bch_alloc_v4 *a; +/* +* XXX: if we ever start calling bch2_check_lru_key() at runtime, not +* just during fsck, this needs tobe converted to bch2_alloc_to_v4() +*/ +switch (type) {case BCH_LRU_read: - a =bch2_alloc_to_v4 (k, &a_convert); + a =bch2_alloc_to_v4_onstack (k, &a_convert);return alloc_lru_idx_read (*a);case BCH_LRU_fragmentation: { - a =bch2_alloc_to_v4 (k, &a_convert); + a =bch2_alloc_to_v4_onstack (k, &a_convert);rcu_read_lock ();struct bch_dev *ca =bch2_dev_rcu_noerror (c, k.k->p.inode);
fs/bcachefs/movinggc.c +1 -1
@@ -94,7 +94,7 @@ static int bch2_bucket_is_movable(struct btree_trans *trans, goto out_put;struct bch_alloc_v4 _a; -const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (k, &_a); +const struct bch_alloc_v4 *a =bch2_alloc_to_v4_onstack (k, &_a); b->k.gen = a->gen; b->sectors =bch2_bucket_sectors_dirty (*a);u64 lru_idx =alloc_lru_idx_fragmentation (*a, ca);
Signature · 1 line
2.49.0
PATCH 5/8 bcachefs: Move cycle detector state to btree_trans
In reply to Kent OverstreetWe need to prune our stack usage; this saves 260 bytes.
--- fs/bcachefs/btree_locking.c | 43 +++++++++---------------------- fs/bcachefs/btree_locking_types.h | 28 ++++++++++++++++++++ fs/bcachefs/btree_types.h | 2 ++ 3 files changed, 42 insertions(+), 31 deletions(-) create mode 100644 fs/bcachefs/btree_locking_types.h
fs/bcachefs/btree_locking.c +12 -31
@@ -51,25 +51,6 @@ void bch2_btree_node_unlock_write(struct btree_trans *trans,/* lock */ -/* -* @trans wants to lock @b with type @type -*/ -struct trans_waiting_for_lock { -struct btree_trans *trans; -struct btree_bkey_cached_common *node_want; -enum six_lock_type lock_want; - -/* for iterating over held locks :*/ -u8 path_idx; -u8 level; -u64 lock_start_time; -}; - -struct lock_graph { -struct trans_waiting_for_lock g[8 ]; -unsigned nr; -}; - static noinline void print_cycle(struct printbuf *out, struct lock_graph *g) {struct trans_waiting_for_lock *i;
@@ -288,33 +269,33 @@ static bool lock_type_conflicts(enum six_lock_type t1, enum six_lock_type t2)int bch2_check_for_deadlock (struct btree_trans *trans,struct printbuf *cycle) { -struct lock_graph g; +struct lock_graph *g = &trans->cycle_detector_graph;struct trans_waiting_for_lock *top;struct btree_bkey_cached_common *b;btree_path_idx_t path_idx;int ret =0 ; - g.nr =0 ; + g->nr =0 ;if (trans->lock_must_abort && !trans->lock_may_not_fail) {if (cycle)return -1 ; -trace_would_deadlock (&g, trans); +trace_would_deadlock (g, trans);return btree_trans_restart (trans, BCH_ERR_transaction_restart_would_deadlock); } -lock_graph_down (&g, trans); +lock_graph_down (g, trans);/* trans->paths is rcu protected vs. freeing */ rcu_read_lock ();if (cycle) cycle->atomic++; next: -if (!g.nr) +if (!g->nr) goto out; - top = &g.g[g.nr -1 ]; + top = &g->g[g->nr -1 ];struct btree_path *paths =rcu_dereference (top->trans->paths);if (!paths)
@@ -351,7 +332,7 @@ int bch2_check_for_deadlock(struct btree_trans *trans, struct printbuf *cycle)* structures - which means it can't be blocked * waiting on a lock: */ -if (!lock_graph_remove_non_waiters (&g, g.g)) { +if (!lock_graph_remove_non_waiters (g, g->g)) {/* * If lock_graph_remove_non_waiters() * didn't do anything, it must be
@@ -361,7 +342,7 @@ int bch2_check_for_deadlock(struct btree_trans *trans, struct printbuf *cycle)* aren't actually waiting on anything. * Just bail out: */ -lock_graph_pop_all (&g); +lock_graph_pop_all (g); } goto next;
@@ -388,7 +369,7 @@ int bch2_check_for_deadlock(struct btree_trans *trans, struct printbuf *cycle)closure_get (&trans->ref);raw_spin_unlock (&b->lock.wait_lock); - ret =lock_graph_descend (&g, trans, cycle); + ret =lock_graph_descend (g, trans, cycle);if (ret) goto out; goto next;
@@ -398,9 +379,9 @@ int bch2_check_for_deadlock(struct btree_trans *trans, struct printbuf *cycle) } } up: -if (g.nr >1 && cycle) -print_chain (cycle, &g); -lock_graph_up (&g); +if (g->nr >1 && cycle) +print_chain (cycle, g); +lock_graph_up (g); goto next; out:if (cycle)
fs/bcachefs/btree_locking_types.h new file +28 -0
@@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _BCACHEFS_BTREE_LOCKING_TYPES_H +#define _BCACHEFS_BTREE_LOCKING_TYPES_H + +#include "six.h" + +/* State used for the cycle detector */ + +/* +* @trans wants to lock @b with type @type +*/ +struct trans_waiting_for_lock { +struct btree_trans *trans; +struct btree_bkey_cached_common *node_want; +enum six_lock_type lock_want; + +/* for iterating over held locks :*/ +u8 path_idx; +u8 level; +u64 lock_start_time; +}; + +struct lock_graph { +struct trans_waiting_for_lock g[6 ]; +unsigned nr; +}; + +#endif /* _BCACHEFS_BTREE_LOCKING_TYPES_H */
fs/bcachefs/btree_types.h +2 -0
@@ -7,6 +7,7 @@#include "bbpos_types.h" #include "btree_key_cache_types.h" +#include "btree_locking_types.h" #include "buckets_types.h" #include "darray.h" #include "errcode.h"
@@ -526,6 +527,7 @@ struct btree_trans {struct btree_bkey_cached_common *locking;struct six_lock_waiter locking_wait;int srcu_idx; +struct lock_graph cycle_detector_graph;/* update path: */ u16 journal_entries_u64s;
Signature · 1 line
2.49.0
PATCH 6/8 bcachefs: struct alloc_request
In reply to Kent OverstreetAdd a struct for common state for satisfying an on disk allocation, instead of passing the same long list of items to every function.
This will help with stack usage, performance, and perhaps enable some code cleanups.
--- fs/bcachefs/alloc_foreground.c | 286 ++++++++++++--------------------- fs/bcachefs/alloc_foreground.h | 25 ++- fs/bcachefs/ec.c | 46 +++--- fs/bcachefs/io_write.h | 28 ---- fs/bcachefs/io_write_types.h | 28 ++++ 5 files changed, 176 insertions(+), 237 deletions(-)
fs/bcachefs/alloc_foreground.c +105 -181
@@ -666,24 +666,20 @@ void bch2_dev_stripe_increment(struct bch_dev *ca, }static int add_new_bucket (struct bch_fs *c, -struct open_buckets *ptrs, -struct bch_devs_mask *devs_may_alloc, -unsigned nr_replicas, -unsigned *nr_effective, -bool *have_cache, -struct open_bucket *ob) +struct alloc_request *req, +struct open_bucket *ob) {unsigned durability =ob_dev (c, ob)->mi.durability; -BUG_ON (*nr_effective >= nr_replicas); +BUG_ON (req->nr_effective >= req->nr_replicas); -__clear_bit (ob->dev, devs_may_alloc->d); - *nr_effective += durability; - *have_cache |= !durability; +__clear_bit (ob->dev, req->devs_may_alloc.d); + req->nr_effective += durability; + req->have_cache |= !durability; -ob_push (c, ptrs, ob); +ob_push (c, &req->ptrs, ob); -if (*nr_effective >= nr_replicas) +if (req->nr_effective >= req->nr_replicas)return 1 ;if (ob->ec)return 1 ;
@@ -691,36 +687,32 @@ static int add_new_bucket(struct bch_fs *c, }int bch2_bucket_alloc_set_trans (struct btree_trans *trans, -struct open_buckets *ptrs, -struct dev_stripe_state *stripe, -struct bch_devs_mask *devs_may_alloc, -unsigned nr_replicas, -unsigned *nr_effective, -bool *have_cache, -enum bch_write_flags flags, -enum bch_data_type data_type, -enum bch_watermark watermark, -struct closure *cl) +struct alloc_request *req, +struct dev_stripe_state *stripe, +enum bch_data_type data_type, +struct closure *cl) {struct bch_fs *c = trans->c;int ret = -BCH_ERR_insufficient_devices; -BUG_ON (*nr_effective >= nr_replicas); +BUG_ON (req->nr_effective >= req->nr_replicas); -struct dev_alloc_list devs_sorted =bch2_dev_alloc_list (c, stripe, devs_may_alloc); +struct dev_alloc_list devs_sorted =bch2_dev_alloc_list (c, stripe, &req->devs_may_alloc);darray_for_each (devs_sorted, i) {struct bch_dev *ca =bch2_dev_tryget_noerror (c, *i);if (!ca)continue ; -if (!ca->mi.durability && *have_cache) { +if (!ca->mi.durability && req->have_cache) {bch2_dev_put (ca);continue ; }struct bch_dev_usage usage; -struct open_bucket *ob =bch2_bucket_alloc_trans (trans, ca, watermark, data_type, - cl, flags & BCH_WRITE_alloc_nowait, &usage); +struct open_bucket *ob =bch2_bucket_alloc_trans (trans, ca, + req->watermark, data_type, + cl, req->flags & BCH_WRITE_alloc_nowait, + &usage);if (!IS_ERR (ob))bch2_dev_stripe_increment_inlined (ca, stripe, &usage);bch2_dev_put (ca);
@@ -732,9 +724,7 @@ int bch2_bucket_alloc_set_trans(struct btree_trans *trans,continue ; } -if (add_new_bucket (c, ptrs, devs_may_alloc, - nr_replicas, nr_effective, - have_cache, ob)) { +if (add_new_bucket (c, req, ob)) { ret =0 ;break ; }
@@ -752,34 +742,27 @@ int bch2_bucket_alloc_set_trans(struct btree_trans *trans,*/ static int bucket_alloc_from_stripe (struct btree_trans *trans, -struct open_buckets *ptrs, -struct write_point *wp, -struct bch_devs_mask *devs_may_alloc, -u16 target, -unsigned nr_replicas, -unsigned *nr_effective, -bool *have_cache, -enum bch_watermark watermark, -enum bch_write_flags flags, -struct closure *cl) +struct alloc_request *req, +struct closure *cl) {struct bch_fs *c = trans->c;int ret =0 ; -if (nr_replicas <2 ) +if (req->nr_replicas <2 )return 0 ; -if (ec_open_bucket (c, ptrs)) +if (ec_open_bucket (c, &req->ptrs))return 0 ;struct ec_stripe_head *h = -bch2_ec_stripe_head_get (trans, target,0 , nr_replicas -1 , watermark, cl); +bch2_ec_stripe_head_get (trans, req->target,0 , req->nr_replicas -1 , req->watermark, cl);if (IS_ERR (h))return PTR_ERR (h);if (!h)return 0 ; -struct dev_alloc_list devs_sorted =bch2_dev_alloc_list (c, &wp->stripe, devs_may_alloc); +struct dev_alloc_list devs_sorted = +bch2_dev_alloc_list (c, &req->wp->stripe, &req->devs_may_alloc);darray_for_each (devs_sorted, i)for (unsigned ec_idx =0 ; ec_idx < h->s->nr_data; ec_idx++) {if (!h->s->blocks[ec_idx])
@@ -791,9 +774,7 @@ static int bucket_alloc_from_stripe(struct btree_trans *trans, ob->ec = h->s;ec_stripe_new_get (h->s, STRIPE_REF_io); - ret =add_new_bucket (c, ptrs, devs_may_alloc, - nr_replicas, nr_effective, - have_cache, ob); + ret =add_new_bucket (c, req, ob); goto out; } }
@@ -805,65 +786,48 @@ static int bucket_alloc_from_stripe(struct btree_trans *trans,/* Sector allocator */ static bool want_bucket (struct bch_fs *c, -struct write_point *wp, -struct bch_devs_mask *devs_may_alloc, -bool *have_cache,bool ec, +struct alloc_request *req,struct open_bucket *ob) {struct bch_dev *ca =ob_dev (c, ob); -if (!test_bit (ob->dev, devs_may_alloc->d)) +if (!test_bit (ob->dev, req->devs_may_alloc.d))return false; -if (ob->data_type != wp->data_type) +if (ob->data_type != req->wp->data_type)return false;if (!ca->mi.durability && - (wp->data_type == BCH_DATA_btree || ec || *have_cache)) + (req->wp->data_type == BCH_DATA_btree || req->ec || req->have_cache))return false; -if (ec != (ob->ec !=NULL )) +if (req->ec != (ob->ec !=NULL ))return false;return true; }static int bucket_alloc_set_writepoint (struct bch_fs *c, -struct open_buckets *ptrs, -struct write_point *wp, -struct bch_devs_mask *devs_may_alloc, -unsigned nr_replicas, -unsigned *nr_effective, -bool *have_cache, -bool ec) +struct alloc_request *req) {struct open_buckets ptrs_skip = { .nr =0 };struct open_bucket *ob;unsigned i;int ret =0 ; -open_bucket_for_each (c, &wp->ptrs, ob, i) { -if (!ret &&want_bucket (c, wp, devs_may_alloc, - have_cache, ec, ob)) - ret =add_new_bucket (c, ptrs, devs_may_alloc, - nr_replicas, nr_effective, - have_cache, ob); +open_bucket_for_each (c, &req->wp->ptrs, ob, i) { +if (!ret &&want_bucket (c, req, ob)) + ret =add_new_bucket (c, req, ob);else ob_push (c, &ptrs_skip, ob); } - wp->ptrs = ptrs_skip; + req->wp->ptrs = ptrs_skip;return ret; }static int bucket_alloc_set_partial (struct bch_fs *c, -struct open_buckets *ptrs, -struct write_point *wp, -struct bch_devs_mask *devs_may_alloc, -unsigned nr_replicas, -unsigned *nr_effective, -bool *have_cache,bool ec, -enum bch_watermark watermark) +struct alloc_request *req) {int i, ret =0 ;
@@ -878,13 +842,13 @@ static int bucket_alloc_set_partial(struct bch_fs *c,for (i = c->open_buckets_partial_nr -1 ; i >=0 ; --i) {struct open_bucket *ob = c->open_buckets + c->open_buckets_partial[i]; -if (want_bucket (c, wp, devs_may_alloc, have_cache, ec, ob)) { +if (want_bucket (c, req, ob)) {struct bch_dev *ca =ob_dev (c, ob);struct bch_dev_usage usage;u64 avail;bch2_dev_usage_read_fast (ca, &usage); - avail =dev_buckets_free (ca, usage, watermark) + ca->nr_partial_buckets; + avail =dev_buckets_free (ca, usage, req->watermark) + ca->nr_partial_buckets;if (!avail)continue ;
@@ -897,9 +861,7 @@ static int bucket_alloc_set_partial(struct bch_fs *c,bch2_dev_rcu (c, ob->dev)->nr_partial_buckets--;rcu_read_unlock (); - ret =add_new_bucket (c, ptrs, devs_may_alloc, - nr_replicas, nr_effective, - have_cache, ob); + ret =add_new_bucket (c, req, ob);if (ret)break ; }
@@ -910,61 +872,42 @@ static int bucket_alloc_set_partial(struct bch_fs *c, }static int __open_bucket_add_buckets (struct btree_trans *trans, -struct open_buckets *ptrs, -struct write_point *wp, -struct bch_devs_list *devs_have, -u16 target, -bool erasure_code, -unsigned nr_replicas, -unsigned *nr_effective, -bool *have_cache, -enum bch_watermark watermark, -enum bch_write_flags flags, -struct closure *_cl) +struct alloc_request *req, +struct closure *_cl) {struct bch_fs *c = trans->c; -struct bch_devs_mask devs;struct open_bucket *ob;struct closure *cl =NULL ;unsigned i;int ret; - devs =target_rw_devs (c, wp->data_type, target); + req->devs_may_alloc =target_rw_devs (c, req->wp->data_type, req->target);/* Don't allocate from devices we already have pointers to: */ -darray_for_each (*devs_have, i) -__clear_bit (*i, devs.d); +darray_for_each (*req->devs_have, i) +__clear_bit (*i, req->devs_may_alloc.d); -open_bucket_for_each (c, ptrs, ob, i) -__clear_bit (ob->dev, devs.d); +open_bucket_for_each (c, &req->ptrs, ob, i) +__clear_bit (ob->dev, req->devs_may_alloc.d); - ret =bucket_alloc_set_writepoint (c, ptrs, wp, &devs, - nr_replicas, nr_effective, - have_cache, erasure_code); + ret =bucket_alloc_set_writepoint (c, req);if (ret)return ret; - ret =bucket_alloc_set_partial (c, ptrs, wp, &devs, - nr_replicas, nr_effective, - have_cache, erasure_code, watermark); + ret =bucket_alloc_set_partial (c, req);if (ret)return ret; -if (erasure_code) { - ret =bucket_alloc_from_stripe (trans, ptrs, wp, &devs, - target, - nr_replicas, nr_effective, - have_cache, - watermark, flags, _cl); +if (req->ec) { + ret =bucket_alloc_from_stripe (trans, req, _cl); }else { retry_blocking:/* * Try nonblocking first, so that if one device is full we'll try from * other devices: */ - ret =bch2_bucket_alloc_set_trans (trans, ptrs, &wp->stripe, &devs, - nr_replicas, nr_effective, have_cache, - flags, wp->data_type, watermark, cl); + ret =bch2_bucket_alloc_set_trans (trans, req, &req->wp->stripe, + req->wp->data_type, cl); if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart) && !bch2_err_matches(ret, BCH_ERR_insufficient_devices) &&
@@ -978,38 +921,27 @@ static int __open_bucket_add_buckets(struct btree_trans *trans, }static int open_bucket_add_buckets (struct btree_trans *trans, -struct open_buckets *ptrs, -struct write_point *wp, -struct bch_devs_list *devs_have, -u16 target, -unsigned erasure_code, -unsigned nr_replicas, -unsigned *nr_effective, -bool *have_cache, -enum bch_watermark watermark, -enum bch_write_flags flags, -struct closure *cl) +struct alloc_request *req, +struct closure *cl) {int ret; -if (erasure_code && !ec_open_bucket (trans->c, ptrs)) { - ret =__open_bucket_add_buckets (trans, ptrs, wp, - devs_have, target, erasure_code, - nr_replicas, nr_effective, have_cache, - watermark, flags, cl); +if (req->ec && !ec_open_bucket (trans->c, &req->ptrs)) { + ret =__open_bucket_add_buckets (trans, req, cl);if (bch2_err_matches (ret, BCH_ERR_transaction_restart) ||bch2_err_matches (ret, BCH_ERR_operation_blocked) ||bch2_err_matches (ret, BCH_ERR_freelist_empty) ||bch2_err_matches (ret, BCH_ERR_open_buckets_empty))return ret; -if (*nr_effective >= nr_replicas) +if (req->nr_effective >= req->nr_replicas)return 0 ; } - ret =__open_bucket_add_buckets (trans, ptrs, wp, - devs_have, target, false, - nr_replicas, nr_effective, have_cache, - watermark, flags, cl); +bool ec = false; +swap (ec, req->ec); + ret =__open_bucket_add_buckets (trans, req, cl); +swap (ec, req->ec); +return ret <0 ? ret :0 ; }
@@ -1300,51 +1232,49 @@ int bch2_alloc_sectors_start_trans(struct btree_trans *trans, struct write_point **wp_ret) {struct bch_fs *c = trans->c; -struct write_point *wp;struct open_bucket *ob; -struct open_buckets ptrs; -unsigned nr_effective, write_points_nr; -bool have_cache; +unsigned write_points_nr;int ret;int i; +struct alloc_request req = { + .nr_replicas = nr_replicas, + .target = target, + .ec = erasure_code, + .watermark = watermark, + .flags = flags, + .devs_have = devs_have, + }; +if (!IS_ENABLED (CONFIG_BCACHEFS_ERASURE_CODING )) erasure_code = false;BUG_ON (!nr_replicas || !nr_replicas_required); retry: - ptrs.nr =0 ; - nr_effective =0 ; - write_points_nr = c->write_points_nr; - have_cache = false; + req.ptrs.nr =0 ; + req.nr_effective =0 ; + req.have_cache = false; + write_points_nr = c->write_points_nr; - *wp_ret = wp =writepoint_find (trans, write_point.v); + *wp_ret = req.wp =writepoint_find (trans, write_point.v); ret =bch2_trans_relock (trans);if (ret) goto err;/* metadata may not allocate on cache devices: */ -if (wp->data_type != BCH_DATA_user) - have_cache = true; +if (req.wp->data_type != BCH_DATA_user) + req.have_cache = true;if (target && !(flags & BCH_WRITE_only_specified_devs)) { - ret =open_bucket_add_buckets (trans, &ptrs, wp, devs_have, - target, erasure_code, - nr_replicas, &nr_effective, - &have_cache, watermark, - flags,NULL ); + ret =open_bucket_add_buckets (trans, &req,NULL );if (!ret ||bch2_err_matches (ret, BCH_ERR_transaction_restart)) goto alloc_done;/* Don't retry from all devices if we're out of open buckets: */ if (bch2_err_matches (ret, BCH_ERR_open_buckets_empty)) { -int ret2 =open_bucket_add_buckets (trans, &ptrs, wp, devs_have, - target, erasure_code, - nr_replicas, &nr_effective, - &have_cache, watermark, - flags, cl); +int ret2 =open_bucket_add_buckets (trans, &req, cl);if (!ret2 ||bch2_err_matches (ret2, BCH_ERR_transaction_restart) ||bch2_err_matches (ret2, BCH_ERR_open_buckets_empty)) {
@@ -1357,59 +1287,53 @@ int bch2_alloc_sectors_start_trans(struct btree_trans *trans,* Only try to allocate cache (durability = 0 devices) from the * specified target: */ - have_cache = true; + req.have_cache = true; + req.target =0 ; - ret =open_bucket_add_buckets (trans, &ptrs, wp, devs_have, -0 , erasure_code, - nr_replicas, &nr_effective, - &have_cache, watermark, - flags, cl); + ret =open_bucket_add_buckets (trans, &req, cl); }else { - ret =open_bucket_add_buckets (trans, &ptrs, wp, devs_have, - target, erasure_code, - nr_replicas, &nr_effective, - &have_cache, watermark, - flags, cl); + ret =open_bucket_add_buckets (trans, &req, cl); } alloc_done: -BUG_ON (!ret && nr_effective < nr_replicas); +BUG_ON (!ret && req.nr_effective < req.nr_replicas); -if (erasure_code && !ec_open_bucket (c, &ptrs)) +if (erasure_code && !ec_open_bucket (c, &req.ptrs))pr_debug ("failed to get ec bucket: ret %u" , ret);if (ret == -BCH_ERR_insufficient_devices && - nr_effective >= nr_replicas_required) + req.nr_effective >= nr_replicas_required) ret =0 ;if (ret) goto err; -if (nr_effective > nr_replicas) -deallocate_extra_replicas (c, &ptrs, &wp->ptrs, nr_effective - nr_replicas); +if (req.nr_effective > req.nr_replicas) +deallocate_extra_replicas (c, &req.ptrs, &req.wp->ptrs, + req.nr_effective - req.nr_replicas);/* Free buckets we didn't use: */ -open_bucket_for_each (c, &wp->ptrs, ob, i) +open_bucket_for_each (c, &req.wp->ptrs, ob, i)open_bucket_free_unused (c, ob); - wp->ptrs = ptrs; + req.wp->ptrs = req.ptrs; - wp->sectors_free =UINT_MAX ; + req.wp->sectors_free =UINT_MAX ; -open_bucket_for_each (c, &wp->ptrs, ob, i) - wp->sectors_free =min (wp->sectors_free, ob->sectors_free); +open_bucket_for_each (c, &req.wp->ptrs, ob, i) + req.wp->sectors_free =min (req.wp->sectors_free, ob->sectors_free); -BUG_ON (!wp->sectors_free || wp->sectors_free ==UINT_MAX ); +BUG_ON (!req.wp->sectors_free || req.wp->sectors_free ==UINT_MAX );return 0 ; err: -open_bucket_for_each (c, &wp->ptrs, ob, i) -if (ptrs.nr <ARRAY_SIZE (ptrs.v)) -ob_push (c, &ptrs, ob); +open_bucket_for_each (c, &req.wp->ptrs, ob, i) +if (req.ptrs.nr <ARRAY_SIZE (req.ptrs.v)) +ob_push (c, &req.ptrs, ob);else open_bucket_free_unused (c, ob); - wp->ptrs = ptrs; + req.wp->ptrs = req.ptrs; -mutex_unlock (&wp->lock); +mutex_unlock (&req.wp->lock);if (bch2_err_matches (ret, BCH_ERR_freelist_empty) &&try_decrease_writepoints (trans, write_points_nr))
fs/bcachefs/alloc_foreground.h +20 -5
@@ -5,6 +5,7 @@#include "bcachefs.h" #include "alloc_types.h" #include "extents.h" +#include "io_write_types.h" #include "sb-members.h" #include <linux/hash.h>
@@ -23,6 +24,22 @@ struct dev_alloc_list {u8 data[BCH_SB_MEMBERS_MAX ]; }; +struct alloc_request { +unsigned nr_replicas; +unsigned target; +bool ec; +enum bch_watermark watermark; +enum bch_write_flags flags; +struct bch_devs_list *devs_have; + +struct write_point *wp; +struct open_buckets ptrs; +unsigned nr_effective; +bool have_cache; + +struct bch_devs_mask devs_may_alloc; +}; +struct dev_alloc_list bch2_dev_alloc_list (struct bch_fs *,struct dev_stripe_state *,struct bch_devs_mask *);
@@ -171,11 +188,9 @@ static inline bool bch2_bucket_is_open_safe(struct bch_fs *c, unsigned dev, u64 }enum bch_write_flags ; -int bch2_bucket_alloc_set_trans (struct btree_trans *,struct open_buckets *, -struct dev_stripe_state *,struct bch_devs_mask *, -unsigned ,unsigned *,bool *,enum bch_write_flags , -enum bch_data_type ,enum bch_watermark , -struct closure *); +int bch2_bucket_alloc_set_trans (struct btree_trans *,struct alloc_request *, +struct dev_stripe_state *,enum bch_data_type , +struct closure *); int bch2_alloc_sectors_start_trans(struct btree_trans *, unsigned, unsigned,
fs/bcachefs/ec.c +23 -23
98 lines not on this page · raw message
fs/bcachefs/io_write.h +0 -28
@@ -17,34 +17,6 @@ void bch2_submit_wbio_replicas(struct bch_write_bio *, struct bch_fs *, __printf(3, 4)void bch2_write_op_error (struct bch_write_op *op,u64 ,const char *, ...); -#define BCH_WRITE_FLAGS () \ - x(alloc_nowait) \ - x(cached) \ - x(data_encoded) \ - x(pages_stable) \ - x(pages_owned) \ - x(only_specified_devs) \ - x(wrote_data_inline) \ - x(check_enospc) \ - x(sync) \ - x(move) \ - x(in_worker) \ - x(submitted) \ - x(io_error) \ - x(convert_unwritten) - -enum __bch_write_flags { -#define x(f) __BCH_WRITE_##f, - BCH_WRITE_FLAGS() -#undef x -}; - -enum bch_write_flags { -#define x(f) BCH_WRITE_##f = BIT(__BCH_WRITE_##f), - BCH_WRITE_FLAGS() -#undef x -}; -static inline struct workqueue_struct *index_update_wq (struct bch_write_op *op) {return op->watermark == BCH_WATERMARK_copygc
fs/bcachefs/io_write_types.h +28 -0
@@ -13,6 +13,34 @@#include <linux/llist.h> #include <linux/workqueue.h> +#define BCH_WRITE_FLAGS () \ + x(alloc_nowait) \ + x(cached) \ + x(data_encoded) \ + x(pages_stable) \ + x(pages_owned) \ + x(only_specified_devs) \ + x(wrote_data_inline) \ + x(check_enospc) \ + x(sync) \ + x(move) \ + x(in_worker) \ + x(submitted) \ + x(io_error) \ + x(convert_unwritten) + +enum __bch_write_flags { +#define x(f) __BCH_WRITE_##f, + BCH_WRITE_FLAGS() +#undef x +}; + +enum bch_write_flags { +#define x(f) BCH_WRITE_##f = BIT(__BCH_WRITE_##f), + BCH_WRITE_FLAGS() +#undef x +}; +struct bch_write_bio { struct_group(wbio, struct bch_fs *c;
Signature · 1 line
2.49.0
PATCH 7/8 bcachefs: alloc_request.data_type
In reply to Kent Overstreet--- fs/bcachefs/alloc_foreground.c | 10 +++++----- fs/bcachefs/alloc_foreground.h | 4 ++-- fs/bcachefs/ec.c | 12 ++++-------- 3 files changed, 11 insertions(+), 15 deletions(-)
fs/bcachefs/alloc_foreground.c +5 -5
@@ -689,7 +689,6 @@ static int add_new_bucket(struct bch_fs *c,int bch2_bucket_alloc_set_trans (struct btree_trans *trans,struct alloc_request *req,struct dev_stripe_state *stripe, -enum bch_data_type data_type,struct closure *cl) {struct bch_fs *c = trans->c;
@@ -710,7 +709,7 @@ int bch2_bucket_alloc_set_trans(struct btree_trans *trans,struct bch_dev_usage usage;struct open_bucket *ob =bch2_bucket_alloc_trans (trans, ca, - req->watermark, data_type, + req->watermark, req->data_type, cl, req->flags & BCH_WRITE_alloc_nowait, &usage);if (!IS_ERR (ob))
@@ -906,8 +905,7 @@ static int __open_bucket_add_buckets(struct btree_trans *trans,* Try nonblocking first, so that if one device is full we'll try from * other devices: */ - ret =bch2_bucket_alloc_set_trans (trans, req, &req->wp->stripe, - req->wp->data_type, cl); + ret =bch2_bucket_alloc_set_trans (trans, req, &req->wp->stripe, cl); if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart) && !bch2_err_matches(ret, BCH_ERR_insufficient_devices) &&
@@ -1258,12 +1256,14 @@ int bch2_alloc_sectors_start_trans(struct btree_trans *trans, *wp_ret = req.wp =writepoint_find (trans, write_point.v); + req.data_type = req.wp->data_type; + ret =bch2_trans_relock (trans);if (ret) goto err;/* metadata may not allocate on cache devices: */ -if (req.wp->data_type != BCH_DATA_user) +if (req.data_type != BCH_DATA_user) req.have_cache = true;if (target && !(flags & BCH_WRITE_only_specified_devs)) {
fs/bcachefs/alloc_foreground.h +2 -2
@@ -30,6 +30,7 @@ struct alloc_request {bool ec;enum bch_watermark watermark;enum bch_write_flags flags; +enum bch_data_type data_type;struct bch_devs_list *devs_have;struct write_point *wp;
@@ -189,8 +190,7 @@ static inline bool bch2_bucket_is_open_safe(struct bch_fs *c, unsigned dev, u64enum bch_write_flags ;int bch2_bucket_alloc_set_trans (struct btree_trans *,struct alloc_request *, -struct dev_stripe_state *,enum bch_data_type , -struct closure *); +struct dev_stripe_state *,struct closure *); int bch2_alloc_sectors_start_trans(struct btree_trans *, unsigned, unsigned,
fs/bcachefs/ec.c +4 -8
@@ -1757,11 +1757,9 @@ static int new_stripe_alloc_buckets(struct btree_trans *trans,if (nr_have_parity < s->nr_parity) { req.nr_replicas = s->nr_parity; req.nr_effective = nr_have_parity; + req.data_type = BCH_DATA_parity; - ret =bch2_bucket_alloc_set_trans (trans, &req, - &h->parity_stripe, - BCH_DATA_parity, - cl); + ret =bch2_bucket_alloc_set_trans (trans, &req, &h->parity_stripe, cl);open_bucket_for_each (c, &req.ptrs, ob, i) { j = find_next_zero_bit(s->blocks_gotten,
@@ -1782,11 +1780,9 @@ static int new_stripe_alloc_buckets(struct btree_trans *trans,if (nr_have_data < s->nr_data) { req.nr_replicas = s->nr_data; req.nr_effective = nr_have_data; + req.data_type = BCH_DATA_user; - ret =bch2_bucket_alloc_set_trans (trans, &req, - &h->block_stripe, - BCH_DATA_user, - cl); + ret =bch2_bucket_alloc_set_trans (trans, &req, &h->block_stripe, cl);open_bucket_for_each (c, &req.ptrs, ob, i) { j = find_next_zero_bit(s->blocks_gotten,
Signature · 1 line
2.49.0
PATCH 8/8 bcachefs: bch2_bucket_alloc_trans() takes alloc_request
In reply to Kent Overstreet--- fs/bcachefs/alloc_foreground.c | 37 +++++++++++++++++----------------- 1 file changed, 19 insertions(+), 18 deletions(-)
fs/bcachefs/alloc_foreground.c +19 -18
@@ -514,24 +514,23 @@ static noinline void trace_bucket_alloc2(struct bch_fs *c, struct bch_dev *ca,* Returns: an open_bucket on success, or an ERR_PTR() on failure. */ static struct open_bucket *bch2_bucket_alloc_trans (struct btree_trans *trans, -struct bch_dev *ca, -enum bch_watermark watermark, -enum bch_data_type data_type, -struct closure *cl, -bool nowait, -struct bch_dev_usage *usage) +struct alloc_request *req, +struct bch_dev *ca, +struct closure *cl, +bool nowait, +struct bch_dev_usage *usage) {struct bch_fs *c = trans->c;struct open_bucket *ob =NULL ;bool freespace =READ_ONCE (ca->mi.freespace_initialized);u64 avail;struct bucket_alloc_state s = { - .btree_bitmap = data_type == BCH_DATA_btree, + .btree_bitmap = req->data_type == BCH_DATA_btree, };bool waiting = nowait; again:bch2_dev_usage_read_fast (ca, usage); - avail =dev_buckets_free (ca, *usage, watermark); + avail =dev_buckets_free (ca, *usage, req->watermark);if (usage->d[BCH_DATA_need_discard].buckets > avail)bch2_dev_do_discards (ca);
@@ -543,7 +542,7 @@ static struct open_bucket *bch2_bucket_alloc_trans(struct btree_trans *trans,bch2_dev_do_invalidates (ca);if (!avail) { -if (watermark > BCH_WATERMARK_normal && +if (req->watermark > BCH_WATERMARK_normal && c->curr_recovery_pass <= BCH_RECOVERY_PASS_check_allocations) goto alloc;
@@ -563,8 +562,8 @@ static struct open_bucket *bch2_bucket_alloc_trans(struct btree_trans *trans,closure_wake_up (&c->freelist_wait); alloc: ob =likely (freespace) - ?bch2_bucket_alloc_freelist (trans, ca, watermark, &s, cl) - :bch2_bucket_alloc_early (trans, ca, watermark, &s, cl); + ?bch2_bucket_alloc_freelist (trans, ca, req->watermark, &s, cl) + :bch2_bucket_alloc_early (trans, ca, req->watermark, &s, cl);if (s.need_journal_commit *2 > avail)bch2_journal_flush_async (&c->journal,NULL );
@@ -583,7 +582,7 @@ static struct open_bucket *bch2_bucket_alloc_trans(struct btree_trans *trans, ob =ERR_PTR (-BCH_ERR_no_buckets_found);if (!IS_ERR (ob)) - ob->data_type = data_type; + ob->data_type = req->data_type;if (!IS_ERR (ob))count_event (c, bucket_alloc);
@@ -593,7 +592,7 @@ static struct open_bucket *bch2_bucket_alloc_trans(struct btree_trans *trans,if (!IS_ERR (ob) ?trace_bucket_alloc_enabled () :trace_bucket_alloc_fail_enabled ()) -trace_bucket_alloc2 (c, ca, watermark, data_type, cl, usage, &s, ob); +trace_bucket_alloc2 (c, ca, req->watermark, req->data_type, cl, usage, &s, ob);return ob; }
@@ -605,10 +604,13 @@ struct open_bucket *bch2_bucket_alloc(struct bch_fs *c, struct bch_dev *ca, {struct bch_dev_usage usage;struct open_bucket *ob; +struct alloc_request req = { + .watermark = watermark, + .data_type = data_type, + };bch2_trans_do (c, -PTR_ERR_OR_ZERO (ob =bch2_bucket_alloc_trans (trans, ca, watermark, - data_type, cl, false, &usage))); +PTR_ERR_OR_ZERO (ob =bch2_bucket_alloc_trans (trans, &req, ca, cl, false, &usage)));return ob; }
@@ -708,9 +710,8 @@ int bch2_bucket_alloc_set_trans(struct btree_trans *trans, }struct bch_dev_usage usage; -struct open_bucket *ob =bch2_bucket_alloc_trans (trans, ca, - req->watermark, req->data_type, - cl, req->flags & BCH_WRITE_alloc_nowait, +struct open_bucket *ob =bch2_bucket_alloc_trans (trans, req, ca, cl, + req->flags & BCH_WRITE_alloc_nowait, &usage);if (!IS_ERR (ob))bch2_dev_stripe_increment_inlined (ca, stripe, &usage);
Signature · 1 line
2.49.0