bch2_btree_path_verify(trans, path);

}

{

BUG_ON(!!(iter->flags & BTREE_ITER_cached) != btree_iter_path(trans, iter)->cached);

BUG_ON((iter->flags & BTREE_ITER_is_extents) &&

bkey_gt(iter->pos, iter->k.p)));

}

{

struct btree_iter copy;

struct bkey_s_c prev;

int ret = 0;

bch2_trans_iter_init(trans, &copy, iter->btree_id, iter->pos,

BTREE_ITER_nopreserve|

BTREE_ITER_all_snapshots);

if (!prev.k)

goto out;

struct btree_path *path, unsigned l) {}

static inline void bch2_btree_path_verify(struct btree_trans *trans,

struct btree_path *path) {}

static inline void bch2_btree_iter_verify_entry_exit(struct btree_iter *iter) {}

#endif

bch2_btree_node_iter_peek_all(&l->iter, l->b));

}

static inline struct bkey_s_c btree_path_level_prev(struct btree_trans *trans,

struct btree_path *path,

struct btree_path_level *l,

for (struct jset_entry *e = trans->journal_entries;

e != btree_trans_journal_entries_top(trans);

bch2_journal_entry_to_text(buf, trans->c, e);

printbuf_indent_sub(buf, 2);

}

static void bch2_btree_path_to_text_short(struct printbuf *out, struct btree_trans *trans, btree_path_idx_t path_idx)

{

struct btree_path *path = trans->paths + path_idx;

return (struct bkey_s_c) { u, NULL };

}

{

if (!iter->path || trans->restarted)

return;

/* Btree iterators: */

int __must_check

{

}

int __must_check

{

bch2_trans_verify_not_unlocked_or_in_restart(trans);

iter->path = bch2_btree_path_set_pos(trans, iter->path,

iter->flags & BTREE_ITER_intent,

btree_iter_ip_allocated(iter));

if (ret)

return ret;

/* Iterate across nodes (leaf and interior nodes) */

{

struct btree *b = NULL;

int ret;

EBUG_ON(trans->paths[iter->path].cached);

ret = bch2_btree_path_traverse(trans, iter->path, iter->flags);

if (ret)

btree_path_set_should_be_locked(trans, btree_iter_path(trans, iter));

out:

bch2_btree_iter_verify_entry_exit(iter);

return b;

err:

}

/* Only kept for -tools */

{

struct btree *b;

bch2_err_matches(PTR_ERR_OR_ZERO(b), BCH_ERR_transaction_restart))

return b;

}

{

struct btree *b = NULL;

int ret;

EBUG_ON(trans->paths[iter->path].cached);

bch2_trans_verify_not_unlocked_or_in_restart(trans);

ret = bch2_btree_path_traverse(trans, iter->path, iter->flags);

if (ret)

EBUG_ON(btree_iter_path(trans, iter)->uptodate);

out:

bch2_btree_iter_verify_entry_exit(iter);

return b;

err:

/* Iterate across keys (in leaf nodes only) */

{

struct bpos pos = iter->k.p;

bool ret = !(iter->flags & BTREE_ITER_all_snapshots

if (ret && !(iter->flags & BTREE_ITER_is_extents))

pos = bkey_successor(iter, pos);

return ret;

}

{

struct bpos pos = bkey_start_pos(&iter->k);

bool ret = !(iter->flags & BTREE_ITER_all_snapshots

if (ret && !(iter->flags & BTREE_ITER_is_extents))

pos = bkey_predecessor(iter, pos);

return ret;

}

* bkey_s_c_null:

*/

static noinline

{

struct bch_fs *c = trans->c;

struct bkey u;

struct bkey_s_c k;

return k;

}

{

struct bkey_s_c k, k2;

int ret;

EBUG_ON(btree_iter_path(trans, iter)->cached);

while (1) {

iter->path = bch2_btree_path_set_pos(trans, iter->path, search_key,

ret = bch2_btree_path_traverse(trans, iter->path, iter->flags);

if (unlikely(ret)) {

/* ensure that iter->k is consistent with iter->pos: */

k = bkey_s_c_err(ret);

break;

}

if (unlikely(!l->b)) {

/* No btree nodes at requested level: */

k = bkey_s_c_null;

break;

}

if (unlikely(iter->flags & BTREE_ITER_with_key_cache) &&

k.k &&

k = k2;

if (bkey_err(k)) {

break;

}

}

search_key = bpos_successor(l->b->key.k.p);

} else {

/* End of btree: */

k = bkey_s_c_null;

break;

}

}

return k;

}

/**

* 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 bpos search_key = btree_iter_search_key(iter);

struct bkey_s_c k;

struct bpos iter_pos = iter->pos;

}

while (1) {

if (unlikely(!k.k))

goto end;

if (unlikely(bkey_err(k)))

if (!(iter->flags & BTREE_ITER_all_snapshots))

iter->pos.snapshot = iter->snapshot;

if (unlikely(ret)) {

k = bkey_s_c_err(ret);

}

return k;

end:

k = bkey_s_c_null;

goto out_no_locked;

}

/**

* bch2_btree_iter_next() - returns first key greater than iterator's current

* position

* @iter: iterator to peek from

*

* Returns: key if found, or an error extractable with bkey_err().

*/

{

return bkey_s_c_null;

}

{

struct bkey_s_c k, k2;

while (1) {

iter->path = bch2_btree_path_set_pos(trans, iter->path, search_key,

int ret = bch2_btree_path_traverse(trans, iter->path, iter->flags);

if (unlikely(ret)) {

/* ensure that iter->k is consistent with iter->pos: */

k = bkey_s_c_err(ret);

break;

}

if (unlikely(!l->b)) {

/* No btree nodes at requested level: */

k = bkey_s_c_null;

break;

}

if (unlikely(iter->flags & BTREE_ITER_with_key_cache) &&

k.k &&

k = k2;

if (bkey_err(k2)) {

break;

}

}

search_key = bpos_predecessor(path->l[0].b->data->min_key);

} else {

/* Start of btree: */

k = bkey_s_c_null;

break;

}

}

return k;

}

/**

* 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().

*/

{

if ((iter->flags & (BTREE_ITER_is_extents|BTREE_ITER_filter_snapshots)) &&

!bkey_eq(iter->pos, POS_MAX)) {

* real visible extents - easiest to just use peek_slot() (which

* internally uses peek() for extents)

*/

if (bkey_err(k))

return k;

return k;

}

struct bpos search_key = iter->pos;

struct bkey_s_c k;

btree_path_idx_t saved_path = 0;

}

while (1) {

if (unlikely(!k.k))

goto end;

if (unlikely(bkey_err(k)))

bch2_path_put_nokeep(trans, saved_path, iter->flags & BTREE_ITER_intent);

bch2_btree_iter_verify_entry_exit(iter);

return k;

end:

k = bkey_s_c_null;

goto out_no_locked;

}

/**

* bch2_btree_iter_prev() - returns first key less than iterator's current

* position

* @iter: iterator to peek from

*

* Returns: key if found, or an error extractable with bkey_err().

*/

{

return bkey_s_c_null;

}

{

struct bpos search_key;

struct bkey_s_c k;

int ret;

bch2_trans_verify_not_unlocked_or_in_restart(trans);

bch2_btree_iter_verify_entry_exit(iter);

EBUG_ON(btree_iter_path(trans, iter)->level && (iter->flags & BTREE_ITER_with_key_cache));

if (iter->pos.inode == KEY_INODE_MAX)

return bkey_s_c_null;

}

search_key = btree_iter_search_key(iter);

goto out;

if (unlikely(iter->flags & BTREE_ITER_with_key_cache) &&

if (!bkey_err(k))

iter->k = *k.k;

/* We're not returning a key from iter->path: */

if (iter->flags & BTREE_ITER_intent) {

struct btree_iter iter2;

if (k.k && !bkey_err(k)) {

swap(iter->key_cache_path, iter2.key_cache_path);

} else {

struct bpos pos = iter->pos;

if (unlikely(bkey_err(k)))

else

iter->pos = pos;

}

btree_path_set_should_be_locked(trans, btree_iter_path(trans, iter));

out_no_locked:

bch2_btree_iter_verify_entry_exit(iter);

if (unlikely(ret))

return bkey_s_c_err(ret);

return k;

}

{

return bkey_s_c_null;

}

{

return bkey_s_c_null;

}

/* Obsolete, but still used by rust wrapper in -tools */

{

struct bkey_s_c k;

bch2_err_matches(bkey_err(k), BCH_ERR_transaction_restart)))

return k;

}

iter->path = 0;

iter->update_path = 0;

iter->key_cache_path = 0;

}

void bch2_trans_iter_init_outlined(struct btree_trans *trans,

BUG_ON(iter->min_depth != depth);

}

{

*dst = *src;

#ifdef TRACK_PATH_ALLOCATED

dst->ip_allocated = _RET_IP_;