static noinline
 void bch2_btree_trans_peek_prev_updates(struct btree_trans *trans, struct btree_iter *iter,
-                                       struct bkey_s_c *k)
+                                       struct bpos search_key, struct bkey_s_c *k)
 {
        struct bpos end = path_l(btree_iter_path(trans, iter))->b->data->min_key;
 
        trans_for_each_update(trans, i)
                if (!i->key_cache_already_flushed &&
                    i->btree_id == iter->btree_id &&
-                   bpos_le(i->k->k.p, iter->pos) &&
+                   bpos_le(i->k->k.p, search_key) &&
                    bpos_ge(i->k->k.p, k->k ? k->k->p : end)) {
                        iter->k = i->k->k;
                        *k = bkey_i_to_s_c(i->k);
 
 static noinline
 void bch2_btree_trans_peek_updates(struct btree_trans *trans, struct btree_iter *iter,
+                                  struct bpos search_key,
                                   struct bkey_s_c *k)
 {
        struct btree_path *path = btree_iter_path(trans, iter);
        trans_for_each_update(trans, i)
                if (!i->key_cache_already_flushed &&
                    i->btree_id == iter->btree_id &&
-                   bpos_ge(i->k->k.p, path->pos) &&
+                   bpos_ge(i->k->k.p, search_key) &&
                    bpos_le(i->k->k.p, k->k ? k->k->p : end)) {
                        iter->k = i->k->k;
                        *k = bkey_i_to_s_c(i->k);
 
 static struct bkey_i *bch2_btree_journal_peek(struct btree_trans *trans,
                                              struct btree_iter *iter,
+                                             struct bpos search_pos,
                                              struct bpos end_pos)
 {
        struct btree_path *path = btree_iter_path(trans, iter);
 
        return bch2_journal_keys_peek_max(trans->c, iter->btree_id,
                                           path->level,
-                                          path->pos,
+                                          search_pos,
                                           end_pos,
                                           &iter->journal_idx);
 }
                                              struct btree_iter *iter)
 {
        struct btree_path *path = btree_iter_path(trans, iter);
-       struct bkey_i *k = bch2_btree_journal_peek(trans, iter, path->pos);
+       struct bkey_i *k = bch2_btree_journal_peek(trans, iter, path->pos, path->pos);
 
        if (k) {
                iter->k = k->k;
 static noinline
 void btree_trans_peek_journal(struct btree_trans *trans,
                              struct btree_iter *iter,
+                             struct bpos search_key,
                              struct bkey_s_c *k)
 {
        struct btree_path *path = btree_iter_path(trans, iter);
        struct bkey_i *next_journal =
-               bch2_btree_journal_peek(trans, iter,
+               bch2_btree_journal_peek(trans, iter, search_key,
                                k->k ? k->k->p : path_l(path)->b->key.k.p);
        if (next_journal) {
                iter->k = next_journal->k;
 
 static struct bkey_i *bch2_btree_journal_peek_prev(struct btree_trans *trans,
                                              struct btree_iter *iter,
+                                             struct bpos search_key,
                                              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,
+                                          search_key,
                                           end_pos,
                                           &iter->journal_idx);
 }
 static noinline
 void btree_trans_peek_prev_journal(struct btree_trans *trans,
                                   struct btree_iter *iter,
+                                  struct bpos search_key,
                                   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,
+               bch2_btree_journal_peek_prev(trans, iter, search_key,
                                k->k ? k->k->p : path_l(path)->b->key.k.p);
 
        if (next_journal) {
                }
 
                if (unlikely(iter->flags & BTREE_ITER_with_journal))
-                       btree_trans_peek_journal(trans, iter, &k);
+                       btree_trans_peek_journal(trans, iter, search_key, &k);
 
                if (unlikely((iter->flags & BTREE_ITER_with_updates) &&
                             trans->nr_updates))
-                       bch2_btree_trans_peek_updates(trans, iter, &k);
+                       bch2_btree_trans_peek_updates(trans, iter, search_key, &k);
 
                if (k.k && bkey_deleted(k.k)) {
                        /*
                }
 
                if (unlikely(iter->flags & BTREE_ITER_with_journal))
-                       btree_trans_peek_prev_journal(trans, iter, &k);
+                       btree_trans_peek_prev_journal(trans, iter, search_key, &k);
 
                if (unlikely((iter->flags & BTREE_ITER_with_updates) &&
                             trans->nr_updates))
-                       bch2_btree_trans_peek_prev_updates(trans, iter, &k);
+                       bch2_btree_trans_peek_prev_updates(trans, iter, search_key, &k);
 
                if (likely(k.k && !bkey_deleted(k.k))) {
                        break;