transaction restarts and other iterator work
cover transaction restarts and other iterator work
batch of various btree iterator patches
- transaction restart injection, asserts: there were some mishandled transaction restarts, now all fixed, and this is the debug code I used to find them.
The tests now run with transaction restart injection on, so any new bugs will be quickly caught in the future.
- btree_iter_peek_prev() improvements: it now works with the journal keys overlay, which means we now should have the option of doing journal replay in the background should we ever need to,
More importantly it now supports an "end of iteration range" argument; this is required for correctness in BTREE_ITER_filter_snapshots mode, otherwise we could keep going into the next inode, which might belong to a different snapshot tree, and we never find any keys that are visible that we can return.
This fixes a bug in reconstruct_inode(), in fsck.
Kent Overstreet (9):
bcachefs: Assert we're not in a restart in bch2_trans_put()
bcachefs: Better in_restart error
bcachefs: CONFIG_BCACHEFS_INJECT_TRANSACTION_RESTARTS
bcachefs: Assert that we're not violating key cache coherency rules
bcachefs: Rename btree_iter_peek_upto() -> btree_iter_peek_max()
bcachefs: Simplify btree_iter_peek() filter_snapshots
bcachefs: Kill unnecessary iter_rewind() in bkey_get_empty_slot()
bcachefs: Implement bch2_btree_iter_prev_min()
bcachefs: peek_prev_min(): Search forwards for extents, snapshots
fs/bcachefs/Kconfig | 7 + fs/bcachefs/alloc_background.c | 6 +- fs/bcachefs/btree_gc.c | 2 +- fs/bcachefs/btree_iter.c | 459 ++++++++++++++++++++----------- fs/bcachefs/btree_iter.h | 60 ++-- fs/bcachefs/btree_journal_iter.c | 50 +++- fs/bcachefs/btree_journal_iter.h | 4 +- fs/bcachefs/btree_key_cache.c | 13 +- fs/bcachefs/btree_trans_commit.c | 4 + fs/bcachefs/btree_types.h | 6 + fs/bcachefs/btree_update.c | 13 +- fs/bcachefs/dirent.c | 4 +- fs/bcachefs/ec.c | 2 +- fs/bcachefs/errcode.h | 1 - fs/bcachefs/extent_update.c | 2 +- fs/bcachefs/fs-io-pagecache.c | 2 +- fs/bcachefs/fs-io.c | 8 +- fs/bcachefs/fs.c | 2 +- fs/bcachefs/fsck.c | 12 +- fs/bcachefs/inode.c | 6 +- fs/bcachefs/io_misc.c | 8 +- fs/bcachefs/io_write.c | 4 +- fs/bcachefs/movinggc.c | 2 +- fs/bcachefs/reflink.c | 2 +- fs/bcachefs/str_hash.h | 6 +- fs/bcachefs/subvolume.h | 12 +- fs/bcachefs/tests.c | 26 +- fs/bcachefs/xattr.c | 2 +- 28 files changed, 482 insertions(+), 243 deletions(-)
Signature · 1 line
2.45.2
PATCH 1/9 bcachefs: Assert we're not in a restart in bch2_trans_put()
This always indicates a transaction restart handling bug
--- fs/bcachefs/btree_iter.c | 3 +++ 1 file changed, 3 insertions(+)
fs/bcachefs/btree_iter.c +3 -0
@@ -3248,6 +3248,9 @@ void bch2_trans_put(struct btree_trans *trans) {struct bch_fs *c = trans->c; +if (trans->restarted) +bch2_trans_in_restart_error (trans); +bch2_trans_unlock (trans);trans_for_each_update (trans, i)
Signature · 1 line
2.45.2
PATCH 2/9 bcachefs: Better in_restart error
In reply to Kent OverstreetWe're ramping up on checking transaction restart handling correctness - so, in debug mode we now save a backtrace for where the restart was emitted, which makes it much easier to track down the incorrect handling.
--- fs/bcachefs/btree_iter.c | 12 ++++++++++++ fs/bcachefs/btree_iter.h | 4 ++++ fs/bcachefs/btree_types.h | 3 +++ 3 files changed, 19 insertions(+)
fs/bcachefs/btree_iter.c +12 -0
@@ -1414,9 +1414,17 @@ void __noreturn bch2_trans_restart_error(struct btree_trans *trans, u32 restart_void __noreturn bch2_trans_in_restart_error (struct btree_trans *trans) { +#ifdef CONFIG_BCACHEFS_DEBUG +struct printbuf buf =PRINTBUF ; +bch2_prt_backtrace (&buf, &trans->last_restarted_trace); +panic ("in transaction restart: %s, last restarted by\n%s" , +bch2_err_str (trans->restarted), + buf.buf); +#else panic ("in transaction restart: %s, last restarted by %pS\n" ,bch2_err_str (trans->restarted), (void *) trans->last_restarted_ip); +#endif }void __noreturn bch2_trans_unlocked_error (struct btree_trans *trans)
@@ -3274,6 +3282,10 @@ void bch2_trans_put(struct btree_trans *trans)closure_return_sync (&trans->ref); trans->locking_wait.task =NULL ; +#ifdef CONFIG_BCACHEFS_DEBUG +darray_exit (&trans->last_restarted_trace); +#endif +unsigned long *paths_allocated = trans->paths_allocated; trans->paths_allocated =NULL ; trans->paths =NULL ;
fs/bcachefs/btree_iter.h +4 -0
@@ -350,6 +350,10 @@ static int btree_trans_restart_ip(struct btree_trans *trans, int err, unsigned l trans->restarted = err; trans->last_restarted_ip = ip; +#ifdef CONFIG_BCACHEFS_DEBUG +darray_exit (&trans->last_restarted_trace); +bch2_save_backtrace (&trans->last_restarted_trace, current,0 ,GFP_NOWAIT ); +#endif return -err; }
fs/bcachefs/btree_types.h +3 -0
@@ -513,6 +513,9 @@ struct btree_trans {u64 last_begin_time;unsigned long last_begin_ip;unsigned long last_restarted_ip; +#ifdef CONFIG_BCACHEFS_DEBUG +bch_stacktrace last_restarted_trace; +#endif unsigned long last_unlock_ip;unsigned long srcu_lock_time;
Signature · 1 line
2.45.2
PATCH 3/9 bcachefs: CONFIG_BCACHEFS_INJECT_TRANSACTION_RESTARTS
In reply to Kent OverstreetIncorrectly handled transaction restarts can be a source of heisenbugs; add a mode where we randomly inject them to shake them out.
--- fs/bcachefs/Kconfig | 7 +++++++ fs/bcachefs/btree_iter.c | 31 ++++++++++++++++++++++++++++++- fs/bcachefs/btree_iter.h | 12 ++++++++++++ fs/bcachefs/btree_trans_commit.c | 4 ++++ fs/bcachefs/btree_types.h | 3 +++ 5 files changed, 56 insertions(+), 1 deletion(-)
fs/bcachefs/Kconfig +7 -0
@@ -60,6 +60,13 @@ config BCACHEFS_DEBUG The resulting code will be significantly slower than normal; you probably shouldn't select this option unless you're a developer. +config BCACHEFS_INJECT_TRANSACTION_RESTARTS + bool "Randomly inject transaction restarts" + depends on BCACHEFS_DEBUG + help + Randomly inject transaction restarts in a few core paths - may have a + significant performance penalty + config BCACHEFS_TESTS bool "bcachefs unit and performance tests" depends on BCACHEFS_FS
fs/bcachefs/btree_iter.c +30 -1
@@ -2292,6 +2292,12 @@ struct bkey_s_c bch2_btree_iter_peek_upto(struct btree_iter *iter, struct bpos ebch2_trans_verify_not_unlocked (trans);EBUG_ON ((iter->flags & BTREE_ITER_filter_snapshots) &&bkey_eq (end,POS_MAX )); + ret =trans_maybe_inject_restart (trans, _RET_IP_); +if (unlikely (ret)) { + k =bkey_s_c_err (ret); + goto out_no_locked; + } +if (iter->update_path) {bch2_path_put_nokeep (trans, iter->update_path, iter->flags & BTREE_ITER_intent);
@@ -2472,6 +2478,10 @@ struct bkey_s_c bch2_btree_iter_peek_prev(struct btree_iter *iter)bch2_btree_iter_verify (iter);bch2_btree_iter_verify_entry_exit (iter); + ret =trans_maybe_inject_restart (trans, _RET_IP_); +if (unlikely (ret)) +return bkey_s_c_err (ret); +if (iter->flags & BTREE_ITER_filter_snapshots) search_key.snapshot =U32_MAX ;
@@ -2606,6 +2616,12 @@ struct bkey_s_c bch2_btree_iter_peek_slot(struct btree_iter *iter)bch2_btree_iter_verify_entry_exit (iter);EBUG_ON (btree_iter_path (trans, iter)->level && (iter->flags & BTREE_ITER_with_key_cache)); + ret =trans_maybe_inject_restart (trans, _RET_IP_); +if (unlikely (ret)) { + k =bkey_s_c_err (ret); + goto out_no_locked; + } +/* extents can't span inode numbers: */ if ((iter->flags & BTREE_ITER_is_extents) &&unlikely (iter->pos.offset ==KEY_OFFSET_MAX )) {
@@ -2951,6 +2967,10 @@ void *__bch2_trans_kmalloc(struct btree_trans *trans, size_t size)WARN_ON_ONCE (new_bytes >BTREE_TRANS_MEM_MAX ); + ret =trans_maybe_inject_restart (trans, _RET_IP_); +if (ret) +return ERR_PTR (ret); +struct btree_transaction_stats *s =btree_trans_stats (trans); s->max_mem =max (s->max_mem, new_bytes);
@@ -3008,7 +3028,8 @@ void *__bch2_trans_kmalloc(struct btree_trans *trans, size_t size)if (old_bytes) {trace_and_count (c, trans_restart_mem_realloced, trans, _RET_IP_, new_bytes); -return ERR_PTR (btree_trans_restart (trans, BCH_ERR_transaction_restart_mem_realloced)); +return ERR_PTR (btree_trans_restart_ip (trans, + BCH_ERR_transaction_restart_mem_realloced, _RET_IP_)); } out_change_top: p = trans->mem + trans->mem_top;
@@ -3116,6 +3137,14 @@ u32 bch2_trans_begin(struct btree_trans *trans) trans->last_begin_ip = _RET_IP_; +#ifdef CONFIG_BCACHEFS_INJECT_TRANSACTION_RESTARTS +if (trans->restarted) { + trans->restart_count_this_trans++; + }else { + trans->restart_count_this_trans =0 ; + } +#endif +trans_set_locked (trans);if (trans->restarted) {
fs/bcachefs/btree_iter.h +12 -0
@@ -363,6 +363,18 @@ static int btree_trans_restart(struct btree_trans *trans, int err)return btree_trans_restart_ip (trans, err, _THIS_IP_); } +static inline int trans_maybe_inject_restart (struct btree_trans *trans,unsigned long ip) +{ +#ifdef CONFIG_BCACHEFS_INJECT_TRANSACTION_RESTARTS +if (!(ktime_get_ns () & ~(~0ULL <<min (63 , (10 + trans->restart_count_this_trans))))) { +trace_and_count (trans->c, trans_restart_injected, trans, ip); +return btree_trans_restart_ip (trans, + BCH_ERR_transaction_restart_fault_inject, ip); + } +#endif +return 0 ; +} +bool bch2_btree_node_upgrade (struct btree_trans *,struct btree_path *,unsigned );
fs/bcachefs/btree_trans_commit.c +4 -0
@@ -1027,6 +1027,10 @@ int __bch2_trans_commit(struct btree_trans *trans, unsigned flags)bch2_trans_verify_not_unlocked (trans);bch2_trans_verify_not_in_restart (trans); + ret =trans_maybe_inject_restart (trans, _RET_IP_); +if (unlikely (ret)) + goto out_reset; +if (!trans->nr_updates && !trans->journal_entries_u64s) goto out_reset;
fs/bcachefs/btree_types.h +3 -0
@@ -509,6 +509,9 @@ struct btree_trans { bool notrace_relock_fail:1; enum bch_errcode restarted:16;u32 restart_count; +#ifdef CONFIG_BCACHEFS_INJECT_TRANSACTION_RESTARTS +u32 restart_count_this_trans; +#endif u64 last_begin_time;unsigned long last_begin_ip;
Signature · 1 line
2.45.2
PATCH 4/9 bcachefs: Assert that we're not violating key cache coherency rules
In reply to Kent Overstreet--- fs/bcachefs/btree_key_cache.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
fs/bcachefs/btree_key_cache.c +10 -3
@@ -424,8 +424,15 @@ 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; - ret =bch2_btree_iter_traverse (&b_iter) ?: -bch2_trans_update (trans, &b_iter, ck->k, +struct bkey_s_c btree_k =bch2_btree_iter_peek_slot (&b_iter); + ret =bkey_err (btree_k); +if (ret) + goto err; + +/* * Check that we're not violating cache coherency rules: */ +BUG_ON (bkey_deleted (btree_k.k)); + + ret =bch2_trans_update (trans, &b_iter, ck->k, BTREE_UPDATE_key_cache_reclaim| BTREE_UPDATE_internal_snapshot_node| BTREE_TRIGGER_norun) ?:
@@ -433,7 +440,7 @@ static int btree_key_cache_flush_pos(struct btree_trans *trans, BCH_TRANS_COMMIT_no_check_rw| BCH_TRANS_COMMIT_no_enospc| commit_flags); - +err: bch2_fs_fatal_err_on(ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart) && !bch2_err_matches(ret, BCH_ERR_journal_reclaim_would_deadlock) &&
Signature · 1 line
2.45.2
PATCH 5/9 bcachefs: Rename btree_iter_peek_upto() -> btree_iter_peek_max()
In reply to Kent OverstreetWe'll be introducing btree_iter_peek_prev_min(), so rename for consistency.
--- fs/bcachefs/alloc_background.c | 6 +++--- fs/bcachefs/btree_gc.c | 2 +- fs/bcachefs/btree_iter.c | 10 ++++----- fs/bcachefs/btree_iter.h | 36 ++++++++++++++++---------------- fs/bcachefs/btree_journal_iter.c | 4 ++-- fs/bcachefs/btree_journal_iter.h | 2 +- fs/bcachefs/btree_update.c | 6 +++--- fs/bcachefs/dirent.c | 4 ++-- fs/bcachefs/ec.c | 2 +- fs/bcachefs/extent_update.c | 2 +- fs/bcachefs/fs-io-pagecache.c | 2 +- fs/bcachefs/fs-io.c | 8 +++---- fs/bcachefs/fs.c | 2 +- fs/bcachefs/fsck.c | 8 +++---- fs/bcachefs/inode.c | 6 +++--- fs/bcachefs/io_misc.c | 6 +++--- fs/bcachefs/io_write.c | 4 ++-- fs/bcachefs/movinggc.c | 2 +- fs/bcachefs/reflink.c | 2 +- fs/bcachefs/str_hash.h | 6 +++--- fs/bcachefs/subvolume.h | 12 +++++------ fs/bcachefs/tests.c | 26 +++++++++++------------ fs/bcachefs/xattr.c | 2 +- 23 files changed, 80 insertions(+), 80 deletions(-)
fs/bcachefs/alloc_background.c +3 -3
@@ -1045,7 +1045,7 @@ static struct bkey_s_c bch2_get_key_or_hole(struct btree_iter *iter, struct bpos* btree node min/max is a closed interval, upto takes a half * open interval: */ - k =bch2_btree_iter_peek_upto (&iter2, end); + k =bch2_btree_iter_peek_max (&iter2, end); next = iter2.pos;bch2_trans_iter_exit (iter->trans, &iter2);
@@ -1886,7 +1886,7 @@ static void bch2_do_discards_work(struct work_struct *work)* successful commit: */ ret = bch2_trans_run(c, - for_each_btree_key_upto(trans, iter, + for_each_btree_key_max(trans, iter, BTREE_ID_need_discard, POS(ca->dev_idx, 0), POS(ca->dev_idx, U64_MAX), 0, k,
@@ -2101,7 +2101,7 @@ static struct bkey_s_c next_lru_key(struct btree_trans *trans, struct btree_iter {struct bkey_s_c k; again: - k =bch2_btree_iter_peek_upto (iter,lru_pos (ca->dev_idx,U64_MAX ,LRU_TIME_MAX )); + k =bch2_btree_iter_peek_max (iter,lru_pos (ca->dev_idx,U64_MAX ,LRU_TIME_MAX ));if (!k.k && !*wrapped) {bch2_btree_iter_set_pos (iter,lru_pos (ca->dev_idx,0 ,0 )); *wrapped = true;
fs/bcachefs/btree_gc.c +1 -1
@@ -904,7 +904,7 @@ static int bch2_gc_alloc_done(struct bch_fs *c)for_each_member_device (c, ca) { ret = bch2_trans_run(c, - for_each_btree_key_upto_commit(trans, iter, BTREE_ID_alloc, + for_each_btree_key_max_commit(trans, iter, BTREE_ID_alloc, POS(ca->dev_idx, ca->mi.first_bucket), POS(ca->dev_idx, ca->mi.nbuckets - 1), BTREE_ITER_slots|BTREE_ITER_prefetch, k,
fs/bcachefs/btree_iter.c +5 -5
@@ -2095,7 +2095,7 @@ static struct bkey_i *bch2_btree_journal_peek(struct btree_trans *trans, {struct btree_path *path =btree_iter_path (trans, iter); - return bch2_journal_keys_peek_upto(trans->c, iter->btree_id, + return bch2_journal_keys_peek_max(trans->c, iter->btree_id, path->level, path->pos, end_pos,
@@ -2274,14 +2274,14 @@ static struct bkey_s_c __bch2_btree_iter_peek(struct btree_iter *iter, struct bp }/** -* bch2_btree_iter_peek_upto() - returns first key greater than or equal to +* bch2_btree_iter_peek_max() - returns first key greater than or equal to * iterator's current position * @iter: iterator to peek from * @end: search limit: returns keys less than or equal to @end * * Returns: key if found, or an error extractable with bkey_err(). */ -struct bkey_s_c bch2_btree_iter_peek_upto (struct btree_iter *iter,struct bpos end) +struct bkey_s_c bch2_btree_iter_peek_max (struct btree_iter *iter,struct bpos end) {struct btree_trans *trans = iter->trans;struct bpos search_key =btree_iter_search_key (iter);
@@ -2681,7 +2681,7 @@ struct bkey_s_c bch2_btree_iter_peek_slot(struct btree_iter *iter)struct btree_iter iter2;bch2_trans_copy_iter (&iter2, iter); - k =bch2_btree_iter_peek_upto (&iter2, end); + k =bch2_btree_iter_peek_max (&iter2, end);if (k.k && !bkey_err (k)) {swap (iter->key_cache_path, iter2.key_cache_path);
@@ -2692,7 +2692,7 @@ struct bkey_s_c bch2_btree_iter_peek_slot(struct btree_iter *iter) }else {struct bpos pos = iter->pos; - k =bch2_btree_iter_peek_upto (iter, end); + k =bch2_btree_iter_peek_max (iter, end);if (unlikely (bkey_err (k)))bch2_btree_iter_set_pos (iter, pos);else
fs/bcachefs/btree_iter.h +18 -18
@@ -401,12 +401,12 @@ struct btree *bch2_btree_iter_peek_node(struct btree_iter *);struct btree *bch2_btree_iter_peek_node_and_restart (struct btree_iter *);struct btree *bch2_btree_iter_next_node (struct btree_iter *); -struct bkey_s_c bch2_btree_iter_peek_upto (struct btree_iter *,struct bpos ); +struct bkey_s_c bch2_btree_iter_peek_max (struct btree_iter *,struct bpos );struct bkey_s_c bch2_btree_iter_next (struct btree_iter *);static inline struct bkey_s_c bch2_btree_iter_peek (struct btree_iter *iter) { -return bch2_btree_iter_peek_upto (iter,SPOS_MAX ); +return bch2_btree_iter_peek_max (iter,SPOS_MAX ); }struct bkey_s_c bch2_btree_iter_peek_prev (struct btree_iter *);
@@ -692,12 +692,12 @@ static inline struct bkey_s_c bch2_btree_iter_peek_type(struct btree_iter *iter,bch2_btree_iter_peek (iter); } -static inline struct bkey_s_c bch2_btree_iter_peek_upto_type (struct btree_iter *iter, +static inline struct bkey_s_c bch2_btree_iter_peek_max_type (struct btree_iter *iter,struct bpos end,unsigned flags) {if (!(flags & BTREE_ITER_slots)) -return bch2_btree_iter_peek_upto (iter, end); +return bch2_btree_iter_peek_max (iter, end);if (bkey_gt (iter->pos, end))return bkey_s_c_null;
@@ -761,7 +761,7 @@ transaction_restart: \ _ret2 ?:trans_was_restarted (_trans, _restart_count); \ }) -#define for_each_btree_key_upto_continue (_trans, _iter, \ +#define for_each_btree_key_max_continue (_trans, _iter, \ _end, _flags, _k, _do) \ ({ \ struct bkey_s_c _k; \
@@ -769,7 +769,7 @@ transaction_restart: \ \ do { \ _ret3 = lockrestart_do(_trans, ({ \ - (_k) = bch2_btree_iter_peek_upto_type(&(_iter), \ + (_k) = bch2_btree_iter_peek_max_type(&(_iter), \ _end, (_flags)); \ if (!(_k).k) \ break; \
@@ -783,9 +783,9 @@ transaction_restart: \ })#define for_each_btree_key_continue (_trans, _iter, _flags, _k, _do) \ - for_each_btree_key_upto_continue(_trans, _iter, SPOS_MAX, _flags, _k, _do) + for_each_btree_key_max_continue(_trans, _iter, SPOS_MAX, _flags, _k, _do) -#define for_each_btree_key_upto (_trans, _iter, _btree_id, \ +#define for_each_btree_key_max (_trans, _iter, _btree_id, \ _start, _end, _flags, _k, _do) \ ({ \ bch2_trans_begin(trans); \
@@ -794,12 +794,12 @@ transaction_restart: \bch2_trans_iter_init ((_trans), &(_iter), (_btree_id), \ (_start), (_flags)); \ \ -for_each_btree_key_upto_continue (_trans, _iter, _end, _flags, _k, _do);\ +for_each_btree_key_max_continue (_trans, _iter, _end, _flags, _k, _do);\ })#define for_each_btree_key (_trans, _iter, _btree_id, \ _start, _flags, _k, _do) \ - for_each_btree_key_upto(_trans, _iter, _btree_id, _start, \ + for_each_btree_key_max(_trans, _iter, _btree_id, _start, \ SPOS_MAX, _flags, _k, _do) #define for_each_btree_key_reverse(_trans, _iter, _btree_id, \
@@ -843,33 +843,33 @@ transaction_restart: \ (_do) ?: bch2_trans_commit(_trans, (_disk_res),\ (_journal_seq), (_commit_flags))) -#define for_each_btree_key_upto_commit (_trans, _iter, _btree_id, \ +#define for_each_btree_key_max_commit (_trans, _iter, _btree_id, \ _start, _end, _iter_flags, _k, \ _disk_res, _journal_seq, _commit_flags,\ _do) \ - for_each_btree_key_upto(_trans, _iter, _btree_id, _start, _end, _iter_flags, _k,\ + for_each_btree_key_max(_trans, _iter, _btree_id, _start, _end, _iter_flags, _k,\ (_do) ?: bch2_trans_commit(_trans, (_disk_res),\ (_journal_seq), (_commit_flags)))struct bkey_s_c bch2_btree_iter_peek_and_restart_outlined (struct btree_iter *); -#define for_each_btree_key_upto_norestart (_trans, _iter, _btree_id, \ +#define for_each_btree_key_max_norestart (_trans, _iter, _btree_id, \ _start, _end, _flags, _k, _ret) \ for (bch2_trans_iter_init((_trans), &(_iter), (_btree_id), \ (_start), (_flags)); \ - (_k) = bch2_btree_iter_peek_upto_type(&(_iter), _end, _flags),\ + (_k) = bch2_btree_iter_peek_max_type(&(_iter), _end, _flags),\ !((_ret) = bkey_err(_k)) && (_k).k; \ bch2_btree_iter_advance(&(_iter))) -#define for_each_btree_key_upto_continue_norestart (_iter, _end, _flags, _k, _ret)\ +#define for_each_btree_key_max_continue_norestart (_iter, _end, _flags, _k, _ret)\ for (; \ - (_k) = bch2_btree_iter_peek_upto_type(&(_iter), _end, _flags), \ + (_k) = bch2_btree_iter_peek_max_type(&(_iter), _end, _flags), \ !((_ret) = bkey_err(_k)) && (_k).k; \ bch2_btree_iter_advance(&(_iter)))#define for_each_btree_key_norestart (_trans, _iter, _btree_id, \ _start, _flags, _k, _ret) \ - for_each_btree_key_upto_norestart(_trans, _iter, _btree_id, _start,\ + for_each_btree_key_max_norestart(_trans, _iter, _btree_id, _start,\ SPOS_MAX, _flags, _k, _ret) #define for_each_btree_key_reverse_norestart(_trans, _iter, _btree_id, \
@@ -881,7 +881,7 @@ struct bkey_s_c bch2_btree_iter_peek_and_restart_outlined(struct btree_iter *); bch2_btree_iter_rewind(&(_iter)))#define for_each_btree_key_continue_norestart (_iter, _flags, _k, _ret) \ - for_each_btree_key_upto_continue_norestart(_iter, SPOS_MAX, _flags, _k, _ret) + for_each_btree_key_max_continue_norestart(_iter, SPOS_MAX, _flags, _k, _ret)/* * This should not be used in a fastpath, without first trying _do in
fs/bcachefs/btree_journal_iter.c +2 -2
@@ -61,7 +61,7 @@ static size_t bch2_journal_key_search(struct journal_keys *keys, }/* Returns first non-overwritten key >= search key: */ -struct bkey_i *bch2_journal_keys_peek_upto (struct bch_fs *c,enum btree_id btree_id, +struct bkey_i *bch2_journal_keys_peek_max (struct bch_fs *c,enum btree_id btree_id,unsigned level,struct bpos pos,struct bpos end_pos,size_t *idx) {
@@ -112,7 +112,7 @@ struct bkey_i *bch2_journal_keys_peek_slot(struct bch_fs *c, enum btree_id btree {size_t idx =0 ; -return bch2_journal_keys_peek_upto (c, btree_id, level, pos, pos, &idx); +return bch2_journal_keys_peek_max (c, btree_id, level, pos, pos, &idx); }static void journal_iter_verify (struct journal_iter *iter)
fs/bcachefs/btree_journal_iter.h +1 -1
@@ -43,7 +43,7 @@ static inline int journal_key_cmp(const struct journal_key *l, const struct jourreturn __journal_key_cmp (l->btree_id, l->level, l->k->k.p, r); } -struct bkey_i *bch2_journal_keys_peek_upto (struct bch_fs *,enum btree_id , +struct bkey_i *bch2_journal_keys_peek_max (struct bch_fs *,enum btree_id ,unsigned ,struct bpos ,struct bpos ,size_t *);struct bkey_i *bch2_journal_keys_peek_slot (struct bch_fs *,enum btree_id ,unsigned ,struct bpos );
fs/bcachefs/btree_update.c +3 -3
@@ -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_upto (&iter,POS (insert->k.p.inode,U64_MAX )); + k =bch2_btree_iter_peek_max (&iter,POS (insert->k.p.inode,U64_MAX ));if ((ret =bkey_err (k))) goto err;if (!k.k)
@@ -323,7 +323,7 @@ static int bch2_trans_update_extent(struct btree_trans *trans, goto out; next:bch2_btree_iter_advance (&iter); - k =bch2_btree_iter_peek_upto (&iter,POS (insert->k.p.inode,U64_MAX )); + k =bch2_btree_iter_peek_max (&iter,POS (insert->k.p.inode,U64_MAX ));if ((ret =bkey_err (k))) goto err;if (!k.k)
@@ -721,7 +721,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_upto (&iter, end)).k) { +while ((k =bch2_btree_iter_peek_max (&iter, end)).k) {struct disk_reservation disk_res =bch2_disk_reservation_init (trans->c,0 );struct bkey_i delete;
fs/bcachefs/dirent.c +2 -2
@@ -500,7 +500,7 @@ int bch2_empty_dir_snapshot(struct btree_trans *trans, u64 dir, u32 subvol, u32struct bkey_s_c k;int ret; -for_each_btree_key_upto_norestart (trans, iter, BTREE_ID_dirents, +for_each_btree_key_max_norestart (trans, iter, BTREE_ID_dirents,SPOS (dir,0 , snapshot),POS (dir,U64_MAX ),0 , k, ret)if (k.k->type == KEY_TYPE_dirent) {
@@ -549,7 +549,7 @@ int bch2_readdir(struct bch_fs *c, subvol_inum inum, struct dir_context *ctx)bch2_bkey_buf_init (&sk); int ret = bch2_trans_run(c, - for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_dirents, + for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_dirents, POS(inum.inum, ctx->pos), POS(inum.inum, U64_MAX), inum.subvol, 0, k, ({
fs/bcachefs/ec.c +1 -1
@@ -2308,7 +2308,7 @@ static int bch2_invalidate_stripe_to_dev(struct btree_trans *trans, struct bkey_int bch2_dev_remove_stripes (struct bch_fs *c,unsigned dev_idx) { return bch2_trans_run(c, - for_each_btree_key_upto_commit(trans, iter, + for_each_btree_key_max_commit(trans, iter, BTREE_ID_alloc, POS(dev_idx, 0), POS(dev_idx, U64_MAX), BTREE_ITER_intent, k, NULL, NULL, 0, ({
fs/bcachefs/extent_update.c +1 -1
@@ -128,7 +128,7 @@ int bch2_extent_atomic_end(struct btree_trans *trans,bch2_trans_copy_iter (©, iter); -for_each_btree_key_upto_continue_norestart (copy, insert->k.p,0 , k, ret) { +for_each_btree_key_max_continue_norestart (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-pagecache.c +1 -1
@@ -199,7 +199,7 @@ int bch2_folio_set(struct bch_fs *c, subvol_inum inum,unsigned folio_idx =0 ; return bch2_trans_run(c, - for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents, + for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents, POS(inum.inum, offset), POS(inum.inum, U64_MAX), inum.subvol, BTREE_ITER_slots, k, ({
fs/bcachefs/fs-io.c +4 -4
@@ -222,7 +222,7 @@ static inline int range_has_data(struct bch_fs *c, u32 subvol, struct bpos end) {return bch2_trans_run (c, - for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents, start, end, + for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents, start, end, subvol,0 , k, ({bkey_extent_is_data (k.k) && !bkey_extent_is_unwritten (k); })));
@@ -800,7 +800,7 @@ static int quota_reserve_range(struct bch_inode_info *inode,u64 sectors = end - start; int ret = bch2_trans_run(c, - for_each_btree_key_in_subvolume_upto(trans, iter, + for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents, POS(inode->v.i_ino, start), POS(inode->v.i_ino, end - 1),
@@ -916,7 +916,7 @@ static loff_t bch2_seek_data(struct file *file, u64 offset)return -ENXIO ; int ret = bch2_trans_run(c, - for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents, + for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents, POS(inode->v.i_ino, offset >> 9), POS(inode->v.i_ino, U64_MAX), inum.subvol, 0, k, ({
@@ -952,7 +952,7 @@ static loff_t bch2_seek_hole(struct file *file, u64 offset)return -ENXIO ; int ret = bch2_trans_run(c, - for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents, + for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents, POS(inode->v.i_ino, offset >> 9), POS(inode->v.i_ino, U64_MAX), inum.subvol, BTREE_ITER_slots, k, ({
fs/bcachefs/fs.c +1 -1
@@ -1296,7 +1296,7 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,bch2_btree_iter_set_snapshot (&iter, snapshot); - k =bch2_btree_iter_peek_upto (&iter, end); + k =bch2_btree_iter_peek_max (&iter, end); ret =bkey_err (k);if (ret)continue ;
fs/bcachefs/fsck.c +4 -4
@@ -73,7 +73,7 @@ static s64 bch2_count_inode_sectors(struct btree_trans *trans, u64 inum, {u64 sectors =0 ; - int ret = for_each_btree_key_upto(trans, iter, BTREE_ID_extents, + int ret = for_each_btree_key_max(trans, iter, BTREE_ID_extents, SPOS(inum, 0, snapshot), POS(inum, U64_MAX), 0, k, ({
@@ -90,7 +90,7 @@ static s64 bch2_count_subdirs(struct btree_trans *trans, u64 inum, {u64 subdirs =0 ; - int ret = for_each_btree_key_upto(trans, iter, BTREE_ID_dirents, + int ret = for_each_btree_key_max(trans, iter, BTREE_ID_dirents, SPOS(inum, 0, snapshot), POS(inum, U64_MAX), 0, k, ({
@@ -1751,7 +1751,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_upto (&iter1,POS (pos1.inode,U64_MAX )); + k1 =bch2_btree_iter_peek_max (&iter1,POS (pos1.inode,U64_MAX )); ret =bkey_err (k1);if (ret) goto err;
@@ -1776,7 +1776,7 @@ static int overlapping_extents_found(struct btree_trans *trans,while (1 ) {bch2_btree_iter_advance (&iter2); - k2 =bch2_btree_iter_peek_upto (&iter2,POS (pos1.inode,U64_MAX )); + k2 =bch2_btree_iter_peek_max (&iter2,POS (pos1.inode,U64_MAX )); ret =bkey_err (k2);if (ret) goto err;
fs/bcachefs/inode.c +3 -3
@@ -618,7 +618,7 @@ bch2_bkey_get_iter_snapshot_parent(struct btree_trans *trans, struct btree_iterstruct bkey_s_c k;int ret =0 ; -for_each_btree_key_upto_norestart (trans, *iter, btree, +for_each_btree_key_max_norestart (trans, *iter, btree,bpos_successor (pos),SPOS (pos.inode, pos.offset,U32_MAX ), flags|BTREE_ITER_all_snapshots, k, ret)
@@ -653,7 +653,7 @@ int __bch2_inode_has_child_snapshots(struct btree_trans *trans, struct bpos pos)struct bkey_s_c k;int ret =0 ; -for_each_btree_key_upto_norestart (trans, iter, +for_each_btree_key_max_norestart (trans, iter, BTREE_ID_inodes,POS (0 , pos.offset),bpos_predecessor (pos), BTREE_ITER_all_snapshots| BTREE_ITER_with_updates, k, ret)
@@ -967,7 +967,7 @@ static int bch2_inode_delete_keys(struct btree_trans *trans,bch2_btree_iter_set_snapshot (&iter, snapshot); - k =bch2_btree_iter_peek_upto (&iter, end); + k =bch2_btree_iter_peek_max (&iter, end); ret =bkey_err (k);if (ret) goto err;
fs/bcachefs/io_misc.c +3 -3
@@ -164,9 +164,9 @@ int bch2_fpunch_at(struct btree_trans *trans, struct btree_iter *iter,bch2_btree_iter_set_snapshot (iter, snapshot);/* -* peek_upto() doesn't have ideal semantics for extents: +* peek_max() doesn't have ideal semantics for extents: */ - k =bch2_btree_iter_peek_upto (iter, end_pos); + k =bch2_btree_iter_peek_max (iter, end_pos);if (!k.k)break ;
@@ -427,7 +427,7 @@ case LOGGED_OP_FINSERT_shift_extents: k = insert ?bch2_btree_iter_peek_prev (&iter) - :bch2_btree_iter_peek_upto (&iter,POS (inum.inum,U64_MAX )); + :bch2_btree_iter_peek_max (&iter,POS (inum.inum,U64_MAX ));if ((ret =bkey_err (k))) goto btree_err;
fs/bcachefs/io_write.c +2 -2
@@ -164,7 +164,7 @@ int bch2_sum_sector_overwrites(struct btree_trans *trans,bch2_trans_copy_iter (&iter, extent_iter); -for_each_btree_key_upto_continue_norestart (iter, +for_each_btree_key_max_continue_norestart (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),
@@ -1165,7 +1165,7 @@ static void bch2_nocow_write_convert_unwritten(struct bch_write_op *op)struct btree_trans *trans =bch2_trans_get (c);for_each_keylist_key (&op->insert_keys, orig) { - int ret = for_each_btree_key_upto_commit(trans, iter, BTREE_ID_extents, + int ret = for_each_btree_key_max_commit(trans, iter, BTREE_ID_extents, bkey_start_pos(&orig->k), orig->k.p, BTREE_ITER_intent, k, NULL, NULL, BCH_TRANS_COMMIT_no_enospc, ({
fs/bcachefs/movinggc.c +1 -1
@@ -167,7 +167,7 @@ static int bch2_copygc_get_buckets(struct moving_context *ctxt,bch2_trans_begin (trans); - ret = for_each_btree_key_upto(trans, iter, BTREE_ID_lru, + ret = for_each_btree_key_max(trans, iter, BTREE_ID_lru, lru_pos(BCH_LRU_FRAGMENTATION_START, 0, 0), lru_pos(BCH_LRU_FRAGMENTATION_START, U64_MAX, LRU_TIME_MAX), 0, k, ({
fs/bcachefs/reflink.c +1 -1
@@ -422,7 +422,7 @@ static struct bkey_s_c get_next_src(struct btree_iter *iter, struct bpos end)struct bkey_s_c k;int ret; -for_each_btree_key_upto_continue_norestart (*iter, end,0 , k, ret) { +for_each_btree_key_max_continue_norestart (*iter, end,0 , k, ret) {if (bkey_extent_is_unwritten (k))continue ;
fs/bcachefs/str_hash.h +3 -3
@@ -160,7 +160,7 @@ bch2_hash_lookup_in_snapshot(struct btree_trans *trans,struct bkey_s_c k;int ret; -for_each_btree_key_upto_norestart (trans, *iter, desc.btree_id, +for_each_btree_key_max_norestart (trans, *iter, desc.btree_id,SPOS (inum.inum, desc.hash_key (info, key), snapshot),POS (inum.inum,U64_MAX ), BTREE_ITER_slots|flags, k, ret) {
@@ -210,7 +210,7 @@ bch2_hash_hole(struct btree_trans *trans,if (ret)return ret; -for_each_btree_key_upto_norestart (trans, *iter, desc.btree_id, +for_each_btree_key_max_norestart (trans, *iter, desc.btree_id,SPOS (inum.inum, desc.hash_key (info, key), snapshot),POS (inum.inum,U64_MAX ), BTREE_ITER_slots|BTREE_ITER_intent, k, ret)
@@ -265,7 +265,7 @@ struct bkey_s_c bch2_hash_set_or_get_in_snapshot(struct btree_trans *trans,bool found = false;int ret; -for_each_btree_key_upto_norestart (trans, *iter, desc.btree_id, +for_each_btree_key_max_norestart (trans, *iter, desc.btree_id,SPOS (insert->k.p.inode, desc.hash_bkey (info,bkey_i_to_s_c (insert)), snapshot),
fs/bcachefs/subvolume.h +6 -6
@@ -34,7 +34,7 @@ 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_upto_type (struct btree_iter *iter,struct bpos end, +bch2_btree_iter_peek_in_subvolume_max_type (struct btree_iter *iter,struct bpos end,u32 subvolid,unsigned flags) {u32 snapshot;
@@ -43,10 +43,10 @@ bch2_btree_iter_peek_in_subvolume_upto_type(struct btree_iter *iter, struct bposreturn bkey_s_c_err (ret);bch2_btree_iter_set_snapshot (iter, snapshot); -return bch2_btree_iter_peek_upto_type (iter, end, flags); +return bch2_btree_iter_peek_max_type (iter, end, flags); } -#define for_each_btree_key_in_subvolume_upto_continue (_trans, _iter, \ +#define for_each_btree_key_in_subvolume_max_continue (_trans, _iter, \ _end, _subvolid, _flags, _k, _do) \ ({ \ struct bkey_s_c _k; \
@@ -54,7 +54,7 @@ bch2_btree_iter_peek_in_subvolume_upto_type(struct btree_iter *iter, struct bpos \ do { \ _ret3 = lockrestart_do(_trans, ({ \ - (_k) = bch2_btree_iter_peek_in_subvolume_upto_type(&(_iter), \ + (_k) = bch2_btree_iter_peek_in_subvolume_max_type(&(_iter), \ _end, _subvolid, (_flags)); \ if (!(_k).k) \ break; \
@@ -67,14 +67,14 @@ bch2_btree_iter_peek_in_subvolume_upto_type(struct btree_iter *iter, struct bpos _ret3; \ }) -#define for_each_btree_key_in_subvolume_upto (_trans, _iter, _btree_id, \ +#define for_each_btree_key_in_subvolume_max (_trans, _iter, _btree_id, \ _start, _end, _subvolid, _flags, _k, _do) \ ({ \ struct btree_iter _iter; \ bch2_trans_iter_init((_trans), &(_iter), (_btree_id), \ (_start), (_flags)); \ \ - for_each_btree_key_in_subvolume_upto_continue(_trans, _iter, \ + for_each_btree_key_in_subvolume_max_continue(_trans, _iter, \ _end, _subvolid, _flags, _k, _do); \ })
fs/bcachefs/tests.c +13 -13
@@ -131,7 +131,7 @@ static int test_iterate(struct bch_fs *c, u64 nr) i =0 ; ret = bch2_trans_run(c, - for_each_btree_key_upto(trans, iter, BTREE_ID_xattrs, + for_each_btree_key_max(trans, iter, BTREE_ID_xattrs, SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 0, k, ({ BUG_ON(k.k->p.offset != i++);
@@ -186,7 +186,7 @@ static int test_iterate_extents(struct bch_fs *c, u64 nr) i =0 ; ret = bch2_trans_run(c, - for_each_btree_key_upto(trans, iter, BTREE_ID_extents, + for_each_btree_key_max(trans, iter, BTREE_ID_extents, SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 0, k, ({ BUG_ON(bkey_start_offset(k.k) != i);
@@ -242,7 +242,7 @@ static int test_iterate_slots(struct bch_fs *c, u64 nr) i =0 ; ret = bch2_trans_run(c, - for_each_btree_key_upto(trans, iter, BTREE_ID_xattrs, + for_each_btree_key_max(trans, iter, BTREE_ID_xattrs, SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 0, k, ({ BUG_ON(k.k->p.offset != i);
@@ -259,7 +259,7 @@ static int test_iterate_slots(struct bch_fs *c, u64 nr) i =0 ; ret = bch2_trans_run(c, - for_each_btree_key_upto(trans, iter, BTREE_ID_xattrs, + for_each_btree_key_max(trans, iter, BTREE_ID_xattrs, SPOS(0, 0, U32_MAX), POS(0, U64_MAX), BTREE_ITER_slots, k, ({ if (i >= nr * 2)
@@ -302,7 +302,7 @@ static int test_iterate_slots_extents(struct bch_fs *c, u64 nr) i =0 ; ret = bch2_trans_run(c, - for_each_btree_key_upto(trans, iter, BTREE_ID_extents, + for_each_btree_key_max(trans, iter, BTREE_ID_extents, SPOS(0, 0, U32_MAX), POS(0, U64_MAX), 0, k, ({ BUG_ON(bkey_start_offset(k.k) != i + 8);
@@ -320,7 +320,7 @@ static int test_iterate_slots_extents(struct bch_fs *c, u64 nr) i =0 ; ret = bch2_trans_run(c, - for_each_btree_key_upto(trans, iter, BTREE_ID_extents, + for_each_btree_key_max(trans, iter, BTREE_ID_extents, SPOS(0, 0, U32_MAX), POS(0, U64_MAX), BTREE_ITER_slots, k, ({ if (i == nr)
@@ -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_upto (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX ))));BUG_ON (k.k); -lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_upto (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&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_upto (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX ))));BUG_ON (k.k); -lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_upto (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&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_upto (&iter,POS (0 ,U64_MAX )))); +lockrestart_do (trans,bkey_err (k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX ))));BUG_ON (k.k->p.snapshot !=U32_MAX );
@@ -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_upto (&iter,POS (0 ,U64_MAX )); + k =bch2_btree_iter_peek_max (&iter,POS (0 ,U64_MAX )); ret =bkey_err (k);if (ret) goto err;
@@ -726,7 +726,7 @@ static int seq_insert(struct bch_fs *c, u64 nr)static int seq_lookup (struct bch_fs *c,u64 nr) {return bch2_trans_run (c, - for_each_btree_key_upto(trans, iter, BTREE_ID_xattrs, + for_each_btree_key_max(trans, iter, BTREE_ID_xattrs,SPOS (0 ,0 ,U32_MAX ),POS (0 ,U64_MAX ),0 , k,0 ));
fs/bcachefs/xattr.c +1 -1
@@ -309,7 +309,7 @@ ssize_t bch2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)u64 offset =0 , inum = inode->ei_inode.bi_inum; int ret = bch2_trans_run(c, - for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_xattrs, + for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_xattrs, POS(inum, offset), POS(inum, U64_MAX), inode->ei_inum.subvol, 0, k, ({
Signature · 1 line
2.45.2
PATCH 6/9 bcachefs: Simplify btree_iter_peek() filter_snapshots
In reply to Kent OverstreetCollapse all the BTREE_ITER_filter_snapshots handling down into a single block; btree iteration is much simpler in the !filter_snapshots case.
--- fs/bcachefs/btree_iter.c | 129 +++++++++++++++++++-------------------- 1 file changed, 62 insertions(+), 67 deletions(-)
fs/bcachefs/btree_iter.c +62 -67
@@ -1837,7 +1837,6 @@ struct bkey_s_c bch2_btree_path_peek_slot(struct btree_path *path, struct bkey *return (struct bkey_s_c ) { u,NULL }; } -void bch2_set_btree_iter_dontneed (struct btree_iter *iter) {struct btree_trans *trans = iter->trans;
@@ -2195,8 +2194,6 @@ static struct bkey_s_c __bch2_btree_iter_peek(struct btree_iter *iter, struct bpbch2_btree_iter_verify (iter);while (1 ) { -struct btree_path_level *l; - iter->path =bch2_btree_path_set_pos (trans, iter->path, search_key, iter->flags & BTREE_ITER_intent,btree_iter_ip_allocated (iter));
@@ -2210,7 +2207,7 @@ static struct bkey_s_c __bch2_btree_iter_peek(struct btree_iter *iter, struct bp }struct btree_path *path =btree_iter_path (trans, iter); - l =path_l (path); +struct btree_path_level *l =path_l (path);if (unlikely (!l->b)) {/* No btree nodes at requested level: */
@@ -2286,10 +2283,11 @@ struct bkey_s_c bch2_btree_iter_peek_max(struct btree_iter *iter, struct bpos enstruct btree_trans *trans = iter->trans;struct bpos search_key =btree_iter_search_key (iter);struct bkey_s_c k; -struct bpos iter_pos; +struct bpos iter_pos = iter->pos;int ret;bch2_trans_verify_not_unlocked (trans); +bch2_btree_iter_verify_entry_exit (iter);EBUG_ON ((iter->flags & BTREE_ITER_filter_snapshots) &&bkey_eq (end,POS_MAX )); ret =trans_maybe_inject_restart (trans, _RET_IP_);
@@ -2304,8 +2302,6 @@ struct bkey_s_c bch2_btree_iter_peek_max(struct btree_iter *iter, struct bpos en iter->update_path =0 ; } -bch2_btree_iter_verify_entry_exit (iter); -while (1 ) { k =__bch2_btree_iter_peek (iter, search_key);if (unlikely (!k.k))
@@ -2313,75 +2309,74 @@ struct bkey_s_c bch2_btree_iter_peek_max(struct btree_iter *iter, struct bpos enif (unlikely (bkey_err (k))) goto out_no_locked; -/* -* We need to check against @end before FILTER_SNAPSHOTS because -* if we get to a different inode that requested we might be -* seeing keys for a different snapshot tree that will all be -* filtered out. -* -* But we can't do the full check here, because bkey_start_pos() -* isn't monotonically increasing before FILTER_SNAPSHOTS, and -* that's what we check against in extents mode: -*/ -if (unlikely (!(iter->flags & BTREE_ITER_is_extents) - ?bkey_gt (k.k->p, end) - : k.k->p.inode > end.inode)) - goto end; +if (iter->flags & BTREE_ITER_filter_snapshots) { +/* +* We need to check against @end before FILTER_SNAPSHOTS because +* if we get to a different inode that requested we might be +* seeing keys for a different snapshot tree that will all be +* filtered out. +* +* But we can't do the full check here, because bkey_start_pos() +* isn't monotonically increasing before FILTER_SNAPSHOTS, and +* that's what we check against in extents mode: +*/ +if (unlikely (!(iter->flags & BTREE_ITER_is_extents) + ?bkey_gt (k.k->p, end) + : k.k->p.inode > end.inode)) + goto end; + +if (iter->update_path && + !bkey_eq (trans->paths[iter->update_path].pos, k.k->p)) { +bch2_path_put_nokeep (trans, iter->update_path, + iter->flags & BTREE_ITER_intent); + iter->update_path =0 ; + } -if (iter->update_path && - !bkey_eq (trans->paths[iter->update_path].pos, k.k->p)) { -bch2_path_put_nokeep (trans, iter->update_path, - iter->flags & BTREE_ITER_intent); - iter->update_path =0 ; - } +if ((iter->flags & BTREE_ITER_intent) && + !(iter->flags & BTREE_ITER_is_extents) && + !iter->update_path) { +struct bpos pos = k.k->p; -if ((iter->flags & BTREE_ITER_filter_snapshots) && - (iter->flags & BTREE_ITER_intent) && - !(iter->flags & BTREE_ITER_is_extents) && - !iter->update_path) { -struct bpos pos = k.k->p; +if (pos.snapshot < iter->snapshot) { + search_key =bpos_successor (k.k->p); +continue ; + } -if (pos.snapshot < iter->snapshot) { - search_key =bpos_successor (k.k->p); -continue ; - } + pos.snapshot = iter->snapshot; - pos.snapshot = iter->snapshot; +/* +* advance, same as on exit for iter->path, but only up +* to snapshot +*/ +__btree_path_get (trans, trans->paths + iter->path, iter->flags & BTREE_ITER_intent); + iter->update_path = iter->path; + + iter->update_path =bch2_btree_path_set_pos (trans, + iter->update_path, pos, + iter->flags & BTREE_ITER_intent, + _THIS_IP_); + ret =bch2_btree_path_traverse (trans, iter->update_path, iter->flags); +if (unlikely (ret)) { + k =bkey_s_c_err (ret); + goto out_no_locked; + } + }/* -* advance, same as on exit for iter->path, but only up -* to snapshot +* We can never have a key in a leaf node at POS_MAX, so +* we don't have to check these successor() calls: */ -__btree_path_get (trans, trans->paths + iter->path, iter->flags & BTREE_ITER_intent); - iter->update_path = iter->path; - - iter->update_path =bch2_btree_path_set_pos (trans, - iter->update_path, pos, - iter->flags & BTREE_ITER_intent, - _THIS_IP_); - ret =bch2_btree_path_traverse (trans, iter->update_path, iter->flags); -if (unlikely (ret)) { - k =bkey_s_c_err (ret); - goto out_no_locked; +if (!bch2_snapshot_is_ancestor (trans->c, + iter->snapshot, + k.k->p.snapshot)) { + search_key =bpos_successor (k.k->p); +continue ; } - } -/* -* We can never have a key in a leaf node at POS_MAX, so -* we don't have to check these successor() calls: -*/ -if ((iter->flags & BTREE_ITER_filter_snapshots) && - !bch2_snapshot_is_ancestor (trans->c, - iter->snapshot, - k.k->p.snapshot)) { - search_key =bpos_successor (k.k->p); -continue ; - } - -if (bkey_whiteout (k.k) && - !(iter->flags & BTREE_ITER_all_snapshots)) { - search_key =bkey_successor (iter, k.k->p); -continue ; +if (bkey_whiteout (k.k)) { + search_key =bkey_successor (iter, k.k->p); +continue ; + } }/*
Signature · 1 line
2.45.2
PATCH 7/9 bcachefs: Kill unnecessary iter_rewind() in bkey_get_empty_slot()
In reply to Kent Overstreet--- fs/bcachefs/btree_update.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
fs/bcachefs/btree_update.c +2 -5
@@ -588,12 +588,9 @@ struct jset_entry *__bch2_trans_jset_entry_alloc(struct btree_trans *trans, unsiint bch2_bkey_get_empty_slot (struct btree_trans *trans,struct btree_iter *iter,enum btree_id btree,struct bpos end) { -struct bkey_s_c k; -int ret =0 ; -bch2_trans_iter_init (trans, iter, btree,POS_MAX , BTREE_ITER_intent); - k =bch2_btree_iter_prev (iter); - ret =bkey_err (k); +struct bkey_s_c k =bch2_btree_iter_peek_prev (iter); +int ret =bkey_err (k);if (ret) goto err;
Signature · 1 line
2.45.2
PATCH 8/9 bcachefs: Implement bch2_btree_iter_prev_min()
In reply to Kent OverstreetA user contributed a filessytem dump, where the dump was actually corrupted (due to being taken while the filesystem was online), but which exposed an interesting bug in fsck - reconstruct_inode().
When itearting in BTREE_ITER_filter_snapshots mode, it's required to give an end position for the iteration and it can't span inode numbers; continuing into the next inode might mean we start seeing keys from a different snapshot tree, that the is_ancestor() checks always filter, thus we're never able to return a key and stop iterating.
Backwards iteration never implemented the end position because nothing else needed it - except for reconstuct_inode().
Additionally, backwards iteration is now able to overlay keys from the journal, which will be useful if we ever decide to start doing journal replay in the background.
--- fs/bcachefs/btree_iter.c | 264 +++++++++++++++++++++---------- fs/bcachefs/btree_iter.h | 8 +- fs/bcachefs/btree_journal_iter.c | 46 ++++++ fs/bcachefs/btree_journal_iter.h | 2 + fs/bcachefs/errcode.h | 1 - fs/bcachefs/fsck.c | 4 +- fs/bcachefs/io_misc.c | 2 +- 7 files changed, 239 insertions(+), 88 deletions(-)
fs/bcachefs/btree_iter.c +181 -83
@@ -270,8 +270,10 @@ static void bch2_btree_iter_verify_entry_exit(struct btree_iter *iter)BUG_ON (!(iter->flags & BTREE_ITER_all_snapshots) && iter->pos.snapshot != iter->snapshot); -BUG_ON (bkey_lt (iter->pos,bkey_start_pos (&iter->k)) || -bkey_gt (iter->pos, iter->k.p)); +BUG_ON (iter->flags & BTREE_ITER_all_snapshots ? !bpos_eq (iter->pos, iter->k.p) : + !(iter->flags & BTREE_ITER_is_extents) ? !bkey_eq (iter->pos, iter->k.p) : + (bkey_lt (iter->pos,bkey_start_pos (&iter->k)) || +bkey_gt (iter->pos, iter->k.p))); }static int bch2_btree_iter_verify_ret (struct btree_iter *iter,struct bkey_s_c k)
@@ -2134,6 +2136,37 @@ struct bkey_s_c btree_trans_peek_journal(struct btree_trans *trans,return k; } +static struct bkey_i *bch2_btree_journal_peek_prev (struct btree_trans *trans, +struct btree_iter *iter, +struct bpos end_pos) +{ +struct btree_path *path =btree_iter_path (trans, iter); + +return bch2_journal_keys_peek_prev_min (trans->c, iter->btree_id, + path->level, + path->pos, + end_pos, + &iter->journal_idx); +} + +static noinline +struct bkey_s_c btree_trans_peek_prev_journal(struct btree_trans *trans, +struct btree_iter *iter, +struct bkey_s_c k) +{ +struct btree_path *path =btree_iter_path (trans, iter); +struct bkey_i *next_journal = +bch2_btree_journal_peek_prev (trans, iter, + k.k ? k.k->p :path_l (path)->b->key.k.p); + +if (next_journal) { + iter->k = next_journal->k; + k =bkey_i_to_s_c (next_journal); + } + +return k; +} +/* * Checks btree key cache for key at iter->pos and returns it if present, or * bkey_s_c_null:
@@ -2446,131 +2479,193 @@ struct bkey_s_c bch2_btree_iter_next(struct btree_iter *iter)return bch2_btree_iter_peek (iter); } +static struct bkey_s_c __bch2_btree_iter_peek_prev (struct btree_iter *iter,struct bpos search_key) +{ +struct btree_trans *trans = iter->trans; +struct bkey_s_c k, k2; + +bch2_btree_iter_verify (iter); + +while (1 ) { + iter->path =bch2_btree_path_set_pos (trans, iter->path, search_key, + iter->flags & BTREE_ITER_intent, +btree_iter_ip_allocated (iter)); + +int ret =bch2_btree_path_traverse (trans, iter->path, iter->flags); +if (unlikely (ret)) { +/* ensure that iter->k is consistent with iter->pos: */ +bch2_btree_iter_set_pos (iter, iter->pos); + k =bkey_s_c_err (ret); +break ; + } + +struct btree_path *path =btree_iter_path (trans, iter); +struct btree_path_level *l =path_l (path); + +if (unlikely (!l->b)) { +/* No btree nodes at requested level: */ +bch2_btree_iter_set_pos (iter,SPOS_MAX ); + k = bkey_s_c_null; +break ; + } + +btree_path_set_should_be_locked (trans, path); + + k =btree_path_level_peek_all (trans->c, l, &iter->k); +if (!k.k ||bpos_gt (k.k->p, search_key)) { + k =btree_path_level_prev (trans, path, l, &iter->k); + +BUG_ON (k.k &&bpos_gt (k.k->p, search_key)); + } + +if (unlikely (iter->flags & BTREE_ITER_with_key_cache) && + k.k && + (k2 =btree_trans_peek_key_cache (iter, k.k->p)).k) { + k = k2; +if (bkey_err (k2)) { +bch2_btree_iter_set_pos (iter, iter->pos); +break ; + } + } + +if (unlikely (iter->flags & BTREE_ITER_with_journal)) + k =btree_trans_peek_prev_journal (trans, iter, k); + +if (unlikely ((iter->flags & BTREE_ITER_with_updates) && + trans->nr_updates)) +bch2_btree_trans_peek_prev_updates (trans, iter, &k); + +if (likely (k.k && !bkey_deleted (k.k))) { +break ; + }else if (k.k) { + search_key =bpos_predecessor (k.k->p); + }else if (likely (!bpos_eq (path->l[0 ].b->data->min_key,POS_MIN ))) { +/* Advance to previous leaf node: */ + search_key =bpos_predecessor (path->l[0 ].b->data->min_key); + }else { +/* Start of btree: */ +bch2_btree_iter_set_pos (iter,POS_MIN ); + k = bkey_s_c_null; +break ; + } + } + +bch2_btree_iter_verify (iter); +return k; +} +/** -* bch2_btree_iter_peek_prev() - returns first key less than or equal to +* bch2_btree_iter_peek_prev_min() - returns first key less than or equal to * iterator's current position * @iter: iterator to peek from +* @end: search limit: returns keys greater than or equal to @end * * Returns: key if found, or an error extractable with bkey_err(). */ -struct bkey_s_c bch2_btree_iter_peek_prev (struct btree_iter *iter) +struct bkey_s_c bch2_btree_iter_peek_prev_min (struct btree_iter *iter,struct bpos end) {struct btree_trans *trans = iter->trans;struct bpos search_key = iter->pos;struct bkey_s_c k; -struct bkey saved_k; -const struct bch_val *saved_v;btree_path_idx_t saved_path =0 ; -int ret;bch2_trans_verify_not_unlocked (trans); -EBUG_ON (btree_iter_path (trans, iter)->cached || -btree_iter_path (trans, iter)->level); - -if (iter->flags & BTREE_ITER_with_journal) -return bkey_s_c_err (-BCH_ERR_btree_iter_with_journal_not_supported); - -bch2_btree_iter_verify (iter);bch2_btree_iter_verify_entry_exit (iter); +EBUG_ON ((iter->flags & BTREE_ITER_filter_snapshots) &&bpos_eq (end,POS_MIN )); - ret =trans_maybe_inject_restart (trans, _RET_IP_); -if (unlikely (ret)) -return bkey_s_c_err (ret); +int ret =trans_maybe_inject_restart (trans, _RET_IP_); +if (unlikely (ret)) { + k =bkey_s_c_err (ret); + goto out_no_locked; + }if (iter->flags & BTREE_ITER_filter_snapshots) search_key.snapshot =U32_MAX ;while (1 ) { - iter->path =bch2_btree_path_set_pos (trans, iter->path, search_key, - iter->flags & BTREE_ITER_intent, -btree_iter_ip_allocated (iter)); - - ret =bch2_btree_path_traverse (trans, iter->path, iter->flags); -if (unlikely (ret)) { -/* ensure that iter->k is consistent with iter->pos: */ -bch2_btree_iter_set_pos (iter, iter->pos); - k =bkey_s_c_err (ret); + k =__bch2_btree_iter_peek_prev (iter, search_key); +if (unlikely (!k.k)) + goto end; +if (unlikely (bkey_err (k))) goto out_no_locked; - } -struct btree_path *path =btree_iter_path (trans, iter); - - k =btree_path_level_peek (trans, path, &path->l[0 ], &iter->k); -if (!k.k || - ((iter->flags & BTREE_ITER_is_extents) - ?bpos_ge (bkey_start_pos (k.k), search_key) - :bpos_gt (k.k->p, search_key))) - k =btree_path_level_prev (trans, path, &path->l[0 ], &iter->k); +if (iter->flags & BTREE_ITER_filter_snapshots) { +struct btree_path *s = saved_path ? trans->paths + saved_path :NULL ; +if (s &&bpos_lt (k.k->p,SPOS (s->pos.inode, s->pos.offset, iter->snapshot))) { +/* +* If we have a saved candidate, and we're past +* the last possible snapshot overwrite, return +* it: +*/ +bch2_path_put_nokeep (trans, iter->path, + iter->flags & BTREE_ITER_intent); + iter->path = saved_path; + saved_path =0 ; + k =bch2_btree_path_peek_slot (btree_iter_path (trans, iter), &iter->k); +break ; + } -if (unlikely ((iter->flags & BTREE_ITER_with_updates) && - trans->nr_updates)) -bch2_btree_trans_peek_prev_updates (trans, iter, &k); +/* +* We need to check against @end before FILTER_SNAPSHOTS because +* if we get to a different inode that requested we might be +* seeing keys for a different snapshot tree that will all be +* filtered out. +*/ +if (unlikely (bkey_lt (k.k->p, end))) + goto end; -if (likely (k.k)) { -if (iter->flags & BTREE_ITER_filter_snapshots) { -if (k.k->p.snapshot == iter->snapshot) - goto got_key; +if (!bch2_snapshot_is_ancestor (trans->c, iter->snapshot, k.k->p.snapshot)) { + search_key =bpos_predecessor (k.k->p); +continue ; + } +if (k.k->p.snapshot != iter->snapshot) {/* -* If we have a saved candidate, and we're no -* longer at the same _key_ (not pos), return -* that candidate +* Have a key visible in iter->snapshot, but +* might have overwrites: - save it and keep +* searching. Unless it's a whiteout - then drop +* our previous saved candidate: */ -if (saved_path && !bkey_eq (k.k->p, saved_k.p)) { -bch2_path_put_nokeep (trans, iter->path, - iter->flags & BTREE_ITER_intent); - iter->path = saved_path; +if (saved_path) { +bch2_path_put_nokeep (trans, saved_path, + iter->flags & BTREE_ITER_intent); saved_path =0 ; - iter->k = saved_k; - k.v = saved_v; - goto got_key; } -if (bch2_snapshot_is_ancestor (trans->c, - iter->snapshot, - k.k->p.snapshot)) { -if (saved_path) -bch2_path_put_nokeep (trans, saved_path, - iter->flags & BTREE_ITER_intent); +if (!bkey_whiteout (k.k)) { saved_path =btree_path_clone (trans, iter->path, iter->flags & BTREE_ITER_intent, _THIS_IP_); - path =btree_iter_path (trans, iter); -trace_btree_path_save_pos (trans, path, trans->paths + saved_path); - saved_k = *k.k; - saved_v = k.v; +trace_btree_path_save_pos (trans, + trans->paths + iter->path, + trans->paths + saved_path); } search_key =bpos_predecessor (k.k->p);continue ; } -got_key: -if (bkey_whiteout (k.k) && - !(iter->flags & BTREE_ITER_all_snapshots)) { + +if (bkey_whiteout (k.k)) { search_key =bkey_predecessor (iter, k.k->p); -if (iter->flags & BTREE_ITER_filter_snapshots) - search_key.snapshot =U32_MAX ; + search_key.snapshot =U32_MAX ;continue ; } - -btree_path_set_should_be_locked (trans, path); -break ; - }else if (likely (!bpos_eq (path->l[0 ].b->data->min_key,POS_MIN ))) { -/* Advance to previous leaf node: */ - search_key =bpos_predecessor (path->l[0 ].b->data->min_key); - }else { -/* Start of btree: */ -bch2_btree_iter_set_pos (iter,POS_MIN ); - k = bkey_s_c_null; - goto out_no_locked; } - } -EBUG_ON (bkey_gt (bkey_start_pos (k.k), iter->pos)); +EBUG_ON (iter->flags & BTREE_ITER_all_snapshots ?bpos_gt (k.k->p, iter->pos) : + iter->flags & BTREE_ITER_is_extents ?bkey_ge (bkey_start_pos (k.k), iter->pos) : +bkey_gt (k.k->p, iter->pos)); + +if (unlikely (iter->flags & BTREE_ITER_all_snapshots ?bpos_lt (k.k->p, end) : + iter->flags & BTREE_ITER_is_extents ?bkey_le (k.k->p, end) : +bkey_lt (k.k->p, end))) + goto end; + +break ; + }/* Extents can straddle iter->pos: */ -if (bkey_lt (k.k->p, iter->pos)) - iter->pos = k.k->p; + iter->pos =bpos_min (iter->pos, k.k->p);;if (iter->flags & BTREE_ITER_filter_snapshots) iter->pos.snapshot = iter->snapshot;
@@ -2580,8 +2675,11 @@ struct bkey_s_c bch2_btree_iter_peek_prev(struct btree_iter *iter)bch2_btree_iter_verify_entry_exit (iter);bch2_btree_iter_verify (iter); -return k; +end: +bch2_btree_iter_set_pos (iter, end); + k = bkey_s_c_null; + goto out_no_locked; }/**
fs/bcachefs/btree_iter.h +7 -1
@@ -409,7 +409,13 @@ static inline struct bkey_s_c bch2_btree_iter_peek(struct btree_iter *iter)return bch2_btree_iter_peek_max (iter,SPOS_MAX ); } -struct bkey_s_c bch2_btree_iter_peek_prev (struct btree_iter *); +struct bkey_s_c bch2_btree_iter_peek_prev_min (struct btree_iter *,struct bpos ); + +static inline struct bkey_s_c bch2_btree_iter_peek_prev (struct btree_iter *iter) +{ +return bch2_btree_iter_peek_prev_min (iter,POS_MIN ); +} +struct bkey_s_c bch2_btree_iter_prev (struct btree_iter *);struct bkey_s_c bch2_btree_iter_peek_slot (struct btree_iter *);
fs/bcachefs/btree_journal_iter.c +46 -0
52 lines not on this page · raw message
fs/bcachefs/btree_journal_iter.h +2 -0
@@ -45,6 +45,8 @@ static inline int journal_key_cmp(const struct journal_key *l, const struct jourstruct bkey_i *bch2_journal_keys_peek_max (struct bch_fs *,enum btree_id ,unsigned ,struct bpos ,struct bpos ,size_t *); +struct bkey_i *bch2_journal_keys_peek_prev_min (struct bch_fs *,enum btree_id , +unsigned ,struct bpos ,struct bpos ,size_t *);struct bkey_i *bch2_journal_keys_peek_slot (struct bch_fs *,enum btree_id ,unsigned ,struct bpos );
fs/bcachefs/errcode.h +0 -1
@@ -192,7 +192,6 @@ x(EINVAL, opt_parse_error) \ x(EINVAL, remove_with_metadata_missing_unimplemented)\ x(EINVAL, remove_would_lose_data) \ - x(EINVAL, btree_iter_with_journal_not_supported) \ x(EROFS, erofs_trans_commit) \ x(EROFS, erofs_no_writes) \x (EROFS , erofs_journal_err) \
fs/bcachefs/fsck.c +2 -2
@@ -618,7 +618,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 (&iter); +struct bkey_s_c k =bch2_btree_iter_peek_prev_min (&iter,POS (inum,0 ));bch2_trans_iter_exit (trans, &iter);int ret =bkey_err (k);if (ret)
@@ -1647,7 +1647,7 @@ static int check_i_sectors_notnested(struct btree_trans *trans, struct inode_walif (i->count != count2) {bch_err_ratelimited (c,"fsck counted i_sectors wrong for inode %llu:%u: got %llu should be %llu" , w->last_pos.inode, i->snapshot, i->count, count2); -return -BCH_ERR_internal_fsck_err; + i->count = count2; } if (fsck_err_on(!(i->inode.bi_flags & BCH_INODE_i_sectors_dirty),
fs/bcachefs/io_misc.c +1 -1
@@ -426,7 +426,7 @@ case LOGGED_OP_FINSERT_shift_extents:bch2_btree_iter_set_pos (&iter,SPOS (inum.inum, pos, snapshot)); k = insert - ?bch2_btree_iter_peek_prev (&iter) + ?bch2_btree_iter_peek_prev_min (&iter,POS (inum.inum,0 )) :bch2_btree_iter_peek_max (&iter,POS (inum.inum,U64_MAX ));if ((ret =bkey_err (k))) goto btree_err;
Signature · 1 line
2.45.2
PATCH 9/9 bcachefs: peek_prev_min(): Search forwards for extents, snapshots
In reply to Kent OverstreetWith extents and snapshots, for slightly different reasons, we may have to search forwards to find a key that compares equal to iter->pos (i.e. a key that peek_prev() should return, as it returns keys <= iter->pos).
peek_slot() does this, and is an easy way to fix this case.
--- fs/bcachefs/btree_iter.c | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-)
fs/bcachefs/btree_iter.c +15 -3
@@ -2564,6 +2564,21 @@ static struct bkey_s_c __bch2_btree_iter_peek_prev(struct btree_iter *iter, stru*/ struct bkey_s_c bch2_btree_iter_peek_prev_min (struct btree_iter *iter,struct bpos end) { +if ((iter->flags & (BTREE_ITER_is_extents|BTREE_ITER_filter_snapshots)) && + !bkey_eq (iter->pos,POS_MAX )) { +/* +* bkey_start_pos(), for extents, is not monotonically +* increasing until after filtering for snapshots: +* +* Thus, for extents we need to search forward until we find a +* real visible extents - easiest to just use peek_slot() (which +* internally uses peek() for extents) +*/ +struct bkey_s_c k =bch2_btree_iter_peek_slot (iter); +if (bkey_err (k) || !bkey_deleted (k.k)) +return k; + } +struct btree_trans *trans = iter->trans;struct bpos search_key = iter->pos;struct bkey_s_c k;
@@ -2579,9 +2594,6 @@ struct bkey_s_c bch2_btree_iter_peek_prev_min(struct btree_iter *iter, struct bp goto out_no_locked; } -if (iter->flags & BTREE_ITER_filter_snapshots) - search_key.snapshot =U32_MAX ; -while (1 ) { k =__bch2_btree_iter_peek_prev (iter, search_key);if (unlikely (!k.k))
Signature · 1 line
2.45.2