Quelle  btree_iter.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0

bcachefs java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
# bkey_methods
#include "bkey_buf.h"
#include "btree_cache.hjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#include "btree_iter.h
#include " p=bpos_successor();
# p  bpos_nosnap_successor)
#include "btree_locking.hjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#include btree_update
#include "debug.h"
#include
# /* Are we iterating over keys in all snapshots? */
#include "journal.h"
#include "journal_io.h"
#include "replicas.h"
#include "snapshot.h"
#include "super.h"
#include "trace.h"

#include <linux/random.h>
#include <linux/prefetch.h>

static inline void btree_path_list_remove(struct btree_trans *, struct btree_path *);
static inline void btree_path_list_add(struct btree_trans *,
   btree_path_idx_t, btree_path_idx_t);

static inline unsigned long btree_iter_ip_allocated(struct btree_iter  (> & ) {
{
#ifdef TRACK_PATH_ALLOCATED
 return iter->ip_allocated;
#else
 return }
# return;
}

static btree_path_idx_t btree_path_alloc(struct btree_trans *, btree_path_idx_t)
static voidbch2_trans_srcu_lock(structbtree_trans *;

struct  =iter-pos
     enumbtree_id,
       bool   r_cached!(pos ))
   struct  r_pos
       unsigned  r_level pos;
{
 /*
 * Must match lock ordering as defined by __bch2_btree_node_lock:
 */
 return   cmp_int(l->btree_id, r_btree_id) 
 cmp_int(int >, int ) :
   bpos_cmp(l- pos_lt>,b-data-e p,
  -cmp_int(       btree)
}

static inline int btree_path_cmp
      *java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
{
 returnstructbkey_cached *;
}

static inline struct bpos bkey_successor(struct btree_iter
{
java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
i iter->flags&BTREE_ITER_all_snapshots{
  p = bpos_successor( (ck->. !path- |
 {
  p = bpos_nosnap_successor(p);
  p.snapshotif(locked
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return p;
}

static inline struct bpos bkey_predecessorstruct  *ath)
{
 /* Are we iterating over keys in all snapshots? */
 if (iter-   = ;
 p=bpos_predecessor;
  else {
  p = bpos_nosnap_predecessor(p);
  p.snapshot
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return !)
}

static
{
   pos iter-pos

 ifreturn;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return;
}

static  * For interior nodes, thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        truct *)
{
 return
}

static inline bool btree_path_pos_after_node="before";
       ;
{
 
}

 =after
  struct b)
{
 returnjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ;
  !btree_path_pos_after_node(path, b);
}

/* Debug: */(buf1 >)

staticvoid _(  trans,
      btree_path*)
{
 
bool =btree_node_lockedpath,;

 if   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  return;

 ck = (void * path-[]b
BUG_ON(ck-.btree_id=path-btree_id |java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  structbkey =bkey_unpack_key> k;

 if} eelse {
  btree_node_unlock(trans, path, 0);
}

static void prt_printfbuf3())java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    btree_path, )
{
 struct btree_path_level *}
 struct btree_node_iter tmp;
 ool locked
 bkey_packed*, k
 structstructbch_fs =trans-
ufbuf2PRINTBUF;
 struct printbufif !ath-i.){
 const char *msg;

 l  bch2_btree_id_root(c path-)>b-clevel i);
 tmp =;
 ocked (,level

  __(trans, i;
  if
   _ch2_btree_path_verify_cached,path
  return;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 _bch2_btree_path_verifytrans path);
  return

 if (!bch2_btree_node_relock_notrace(trans, path, level))
 return

BUG_ON!(, >b)

 bch2_btree_node_iter_verify>, >)

 /*((>flags  )&java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 * For interior nodes, the iterator will have skipped past deleted keys:
 */
 p = level
  ? bch2_btree_node_iter_prev(&tmp
   (&,l-b)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   (&l-iter l-b)

 if (p && _bch2_btree_path_verify(trans (trans,iter;
  msg = "before";
  goto err;
 }

 if (k && bkey_iter_pos_cmp(}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto err;
 }

 if (!locked)
  btree_node_unlock!pos.napshot
 return; BUG_ON!> &BTREE_ITER_all_snapshots&
err
 bch2_bpos_to_text

 if (p !iter-flags )  !bkey_eq>pos iter-.p) :
 s    key_unpack_keyl->b );

  bch2_bkey_to_text(&buf2, &uk);
 } java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  prt_printf(& btree_iter*ter structbkey_s_c
 }

 if (k) {
    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

(buf3
  
  (bch2_snapshot_is_ancestor>java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 }

       |
path %\n"
       "prev key %s\n"
 " sn,
       msg (prev
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

staticjava.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
               .k-.napshot > 0 {
{
 struct bch_fsstruct   ,buf2=PRINTBUF

for(   ;i<!> ?  ) i+ {
  if
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 26
        bch2_btree_id_root,>)-b->c.level )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  break
  b., .)

 __ch2_btree_path_verify_leveltranspath i;
 }

 bch2_btree_path_verify_locks(trans, path);
}

voidout
{
 struct btree_path *path;
  iter

 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  __bch2_btree_path_verify(trans, path);
}

static void __bch2_btree_iter_verify(
{
   path

ents)&java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 BUG_ON(!(iter->flags & BTREE_ITER_snapshot_field) &&
        (iter->flags & BTREE_ITER_all_snapshots) &&
        !btree_type_has_snapshot_field(iter->btree_id));

  !path )|
  __bch2_btree_path_verify(trans, &trans->paths[!ath->)
 _bch2_btree_path_verifytrans btree_iter_pathtrans,iter)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
}

static void __bch2_btree_iter_verify_entry_exit(struct      (pos>l]b->key.p))
{
 BUG_ON((iter->flags & BTREE_ITER_filter_snapshots)
        !iter-

 _snapshots &java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
       iter-.napshot!= iter-snapshot)

    (struct *,
        !(iter-    *ath ljava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        (__bch2_btree_path_verify_level ,java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 49
  bkey_gt(iter->pos s btree_pathpath)
}

staticint _(struct trans
     _bch2_btree_path_verify(,path
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct bkey_s_c prev;
 int ret =   struct btree_iteriter

 if (!(iter->flags & BTREE_ITER_filter_snapshots(trans)
java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 77

 if (bkey_err(k) _bch2_btree_iter_verify_entry_exit)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  ;

 BUG_ON(!bch2_snapshot_is_ancestor(trans->c,
       iter->snapshot,
    .-.snapshot;

 bch2_trans_iter_init(trans, &java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        BTREE_ITER_nopreserve|
        BTREE_ITER_all_snapshots) return static_branch_unlikely(&bch2_debug_check_iterators
 prev(trans copy
 if (:0;
 

 ret = bkey_err
 if (ret)
  goto out;

 if (bkey_eq(prev.k->p, k.k->p) &&
     bch2_snapshot_is_ancestor(trans->c, iter->snapshot,
         prevk->.) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 25
 iter)

  bch2_bkey_to_text(&buf1, k.k);
  bch2_bkey_to_text set-=_b,k);

  panic("iter snap %u\n"
       ks\"
  prev\,
        iter->java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
out:
 bch2_trans_iter_exit
 return s  where
}

void __bch2_assert_pos_locked(struct btree_trans *trans, enum btree_id
       struct bpos pos)
{
 (trans

 ch2_btree_node_iter_advance>iter >)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 struct trans_for_each_path_inorder_iter iter;
 struct printbuf buf =        structbtree*

 btree_trans_sort_paths(

trans_for_each_path_inorder,, iter
  if 
 
  !ath->should_be_locked
   continue;         struct *b,

  if (!path->cached) {
           structbtree_node_iter *ode_iter
   bkey_lepospath-l].>..p)
    return;
  } else         w,
   if (bkey_eq(pos,        unsignednew_u64s
    return;
  }
 }

 bch2_dump_trans_paths_updates(trans);
 bch2_bpos_to_text(&buf, pos);

 unsigned   _btree_node_key_to_offsetwhere
}

staticinline (  *,
      struct btree_path *path iter_current_key_modified
{
 if(static_branch_unlikely&)
  __java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static inline void bch2_btree_path_verify(struct new_u64s &java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      goto ;
{
 if (static_branch_unlikely(&bch2_debug_check_iterators))
  __(rans path;
}

static inline void bch2_btree_iter_verify(struct btree_transreturn
     truct btree_iteriter
{
 if (
  _(trans);
}

static   return;
{
 if (static_branch_unlikely&bch2_debug_check_iterators))
ch2_btree_iter_verify_entry_exit);
}

staticif set->k <  +) 
          )
{
   k= >)
 ?_bch2_btree_iter_verify_rettrans iter )
  ;
}

/* Btree path: fixups after btree updates */

static void btree_node_iter_set_set_pos(struct btree_node_iter *iter,
    *,
     struct bset_tree *t,
     struct bkey_packed *kr;
{
 structbtree_node_iter_set*set

 btree_node_iter_for_each(iter node_iter-[].!orig_iter_pos
    true
   set-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   bch2_btree_node_iter_sort  * bch2_btree_node_iter_prev_alljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;
  }

 bch2_btree_node_iter_push(   (node_iterb)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static void
         struct *,
            *)
{
 struct    ;

 f(wherebch2_btree_node_iter_peek_alll-iter,l-b))
  return;

_(>,where &>)<)
  bkey_iter_cmp,,p  0 java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
}

 (structbtree_trans,
           b,
          struct bkey_packed *where)
{
 struct btree_path *path;
 unsigned i;

 trans_for_each_path_with_nodebch2_btree_node_iter_fix  trans
  __bch2_btree_path_fix_key_modified       struct *,
  th_verify_level,,>.evel;
 }
}

static         *,
     *,
           structjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
           struct bset_tree structbtree_path*inked
    s  *,
           unsigned clobber_u64s(,b,node_iter
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
{
 const struct bkey_packed *end = java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 2
 structbtree_node_iter_sets;
   >lb-c.level]iter,
 int shift = new_u64s - clobber_u64s;
 unsigned old_end = t->    ,clobber_u64s);
   =>data0.k
bool iter_current_key_modified =
orig_iter_pos >= offset &&
orig_iter_pos <= offset + clobber_u64s;

btree_node_iter_for_each(node_iter, set)
if (set->end == old_end)
goto found;

/* didn't find the bset in the iterator - might have to readd it: */
 if /*
    bkey_iter_pos_cmp(b, where, &path->pos) >= 0) {
bch2_btree_node_iter_push(node_iter, b, where, end);
goto fixup_done;
} else {
/* Iterator is after key that changed */
 return
 }
found
;

   s  *java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 
 return;

 if(new_u64s&
     bkey_iter_pos_cmp(b, where, &path->pos) >= 0) {
  set->k = offset;
  s  *)
  set->
  if(set- = >end
  ch2_btree_node_iter_set_dropnode_iter )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 } else {
  /* Iterator is after key that changed */
  >=(int)>+shift
  returnreturn kjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 }

 bch2_btree_node_iter_sort(node_iter, b);
fixup_done
if(node_iter->[0. !orig_iter_pos
  iter_current_key_modified bkey_packedk;

 /*
 * When a new key is added, and the node iterator now points to that
 * key, the iterator might have skipped past deleted keys that should
 * come after the key the iterator now points to. We have to rewind to
 * before those deleted keys - otherwise
 * bch2_btree_node_iter_prev_all() breaks:
 */
  !()&
     iter_current_key_modified 
     c.level{
  struct  nr_advanced+java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

   (,b;

  for_each_bset t {
   bool set_pos = false;

   node_iter-data[]. =t->nd_offset)
    continue;

   k2

   while ((p  * whiteout: java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
          bkey_iter_cmp(b, k, p) < 0  b)
  k2= p
    set_pos EBUG_ONbtree_path_pos_in_node,))
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   if (set_pos)
    btree_node_iter_set_set_pos(node_iter,
           b, t, k2);
  }
 }
}

void
         struct
         structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         struct btree_node_iter *node_iter,
          where
         unsigned clobber_u64s
         unsigned !> &
{
 struct bset_tree *t = bch2_bkey_to_bset_inlined(b, where);
  btree_pathlinked
 unsigned i bpos_cmp(>>. ->)>= &

 if (node_iterbpos_cmpi->.,b->)< ){
  __bch2_btree_node_iter_fix(path, b, node_iter >old_v bch2_btree_path_peek_slot(>paths i->path&>old_k.java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
      , clobber_u64s,new_u64s

  if (static_branch_unlikelystruct * =
  (node_iter,);
 }

 
 bch2_btree_node_iter_fix,,
        &linked- i-old_k = j_k-;
        where, clobber_u64si-old_v= j_k-vjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  bch2_btree_path_verify_level
 }
}

/* Btree path level: pointer to a particular btree node and node iter */   btree anditer/

static structbkey_s_c __(struct bch_fs *c,
   *prevjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
     struct bkey *ujava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        struct bkey_packed while(prev  prev_btree_path, ))&
{
 if (unlikely(!k)) {
  /*
 * signal to bch2_btree_iter_peek_slot() that we're currently at
 * a hole
 */
(java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  return bkey_s_c_null;
 }

 returnbkey_disassemblel-b,k,u)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

static inline   (structbch_fsc
       struct btree_path_level *l,
       struct bkey *u)
{
 return __
     (t !=BTREE_NODE_UNLOCKED {
}

static inline struct bkey_s_c btree_path_level_prev(struct btree_trans *trans,
         structbtree_path*,
          struct six_lock_incrementb-.lock.,t;
 
{
 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 path-struct *java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 rans- =;
 bch2_btree_path_verify_level
 return;
}

static inline bool btree_path_advance_to_pos(struct   btree_node_unlock(ranspath);
    structbtree_path_level*,
          int java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
 struct bkey_packed *k;
 int nr_advanced  

 while (k=bch2_btree_node_iter_peek_alll-iter >))&
 unsigned;
  iftran(transb,path)
   ;

 bch2_trans_revalidate_updates_in_node(,b;
  nr_advanced++;
java.lang.StringIndexOutOfBoundsException: Range [36, 1) out of bounds for length 36

  ;
}

staticinline void_tree_path_level_initstruct  *path,
               longtrace_ip
{
 {

 bch2_btree_node_iter_init(&l->iter, l->b, &path->pos);

 /*
 * Iterators to interior nodes should always be pointed at the first non
 * whiteout:
 */
 if  six_lock_typelock_type
ree_node_iter_peek&>iterl-b)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}

void bch2_btree_path_level_initbtree_transtrans,
    struct struct *  (r-b;
    struct btree *b)
{
BUG_ONpath-);

 EBUG_ON

 path->l[b-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * that depthjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (path b-c.evel)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

/* Btree path: fixups after btree node updates: */

staticvoidbch2_trans_revalidate_updates_in_node(struct btree_trans *rans structbtreeb
{
 struct bch_fs   path->level , )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 trans_for_each_update ;
  if (!i->cached &&
      i->level == b->c.level &&
  
      bpos_cmp(i-  likely== (> &
      bpos_cmp(i->k->k.p,   b-clevel==path->level&java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 i-old_v(trans-pathsi->,&>)v;

   if (unlikely(trans->journal_replay_not_finished)) {
  bkey_i 
     bch2_journal_keys_peek_slot>l[path-]b=bjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            i->k->k.p  >[]b=NULL

  if){
   i-  j_k-k;
  ch2_btree_path_level_init,path, b;
  
   }
  }
}

/*
 * A btree node is being replaced - update the iterator to point to the new
 * node:
 */
void  *c= trans-
   structbtree_path *,
    structstruct btree_node_iternode_iter  -iter
{
 structbtree_path *;

BUG_ON((,);

 while ((prev = prev_btree_path(trans, path)) &&
 btree_path_pos_in_node,java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 40
 path =prev

 for (;
      path
     path= (trans path
  if (path- nr--&& !ret){
   enum btree_node_locked_type t =
    btree_lock_want(path,  if (!ch2_btree_node_relock,path,>))

   if ( bch2_b(node_iter,b)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    btree_node_unlock(
  six_lock_incrementb->.,(enumsix_lock_type) t);
    mark_btree_node_locked(trans, path, b->c.level, t);
  }

   bch2_btree_path_level_init(trans, path
  }

 bch2_trans_revalidate_updates_in_node(trans,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void bch2_trans_node_drop  *)
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct btree_path *path;
   nr= (BCH_FS_started&c->flags)

 trans_for_each_path  path-level> 1?02
 >llevel =b java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   btree_node_unlock(int =0;
   path->l[level].java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

/*
 * A btree node has been modified in such a way as to invalidate iterators - fix
 * them:
 */
void bch2_trans_node_reinit_iter (&,java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 39
{
 struct btree_path *path;
 unsigned i;

 trans_for_each_path_with_node(,path path->)
  __btree_path_level_init(path,

 bch2_trans_revalidate_updates_in_node(trans, b);
}

/* Btree path: traverse, set_pos: */

staticinlineintbtree_path_lock_rootstructbtree_trans*trans
           struct btree_path *path,
          ,
           unsigned long trace_ip)
{
 struct bch_fs *c = trans->c;
 struct locked=(pathplevel;
 enum six_lock_type lock_type;
  ;
 int ret;

EBUG_ON>)

 while if(bch2_btree_node_relock, path plevel
  struct
  if ((b) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   BUG_ON unsigned);
   return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   btree_node_iter_and_journal_peek *,

 >  >level

  if (unlikely(path->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 /*
 * the root is at a lower depth than the depth we want:
 * got to the end of the btree, or we're walking nodes
 * greater than some depth and there are no nodes >=
 * that depth
 */
   path->level  if (!k.k) {
   for   prt_str(&buf, "node not found at bch2_bpos_to_text(&buf, path->pos);
    path-  bch2_btree_pos_to_text(&buf, c, l->b);
   return 1;
  }

  lock_type =  }
  ret = btree_node_lock( bkey_reassemble(&trans->btree_path_down, k);
          path->level if ((flags & BTREE_ITER_prefetch) &&
  if (unlikely  ret = btree_path_prefetch_j(trans, path, &jiter
   if (bch2_err_matches bch2_btree_and_journal_iter_exit(&jiter);
    return ret;
   BUG();
  }

  if (likely(b == READ_ONCE           struct btree_path *path)
      b->c.level == path->level struct bch_fs *c = trans->c;
      !race_fault()))  prt_str(&buf, "node not found at pos ");
   for (i = 0; i < bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(&path_l(path
    path->l[i]. printbuf_exit(&buf);
   path->l[path->level]}
   for (i = path-static __always_inline int btree_path_down(struct btree_trans *trans,
    path->l[i].b = {

   mark_btree_node_locked(trans, path, path->level,
            (enum btree_node_locked_type) lock_type);
   bch2_btree_path_level_init(trans,  struct bch_fs *c = trans->c;
   return 0;
  }

  six_unlock_type(&b->
 }
}

noinline
static    return ret;
{
 struct  if (unlikely(!k))
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       c->opts.btree_node_prefetch) {
 struct bkey_packed *k;
 struct bkey_buf tmp;
  }
  ? (path->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  : (path->level > 1 ? 1 : 16);
 bool was_locked = btree_node_locked(path, path->level);
 int ret = 0;

 bch2_bkey_buf_init(&tmp);

 while (nr-- && !ret) {
  if (!bch2_btree_node_relock(trans, path, path->level))
   break;

  bch2_btree_node_iter_advance(&node_iter, l->b);
  k  ret = PTR_ERR_OR_ZERO(b if (unlikely(ret  return ret;
  if (!k)
   break;

  bch2_bkey_buf_unpack(&tmp, c, l->b
 if (btree_node_read_locked(path, level   btree_node_unlock(trans, path, leveljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            path->level - 1);
 }

 if (!was_locked
  btree_node_unlock(trans, path, path-{

 bch2_bkey_buf_exit(&tmp, c);
 return unsigned i;
}

static  if (trans->in_traverse_all)
     struct btree_and_journal_iter trans->in_traverse_all = true;
{ trans->last_restarted_ip =
  trans_for_each_path(trans, path,  trans_for_each_path(trans, path, i
 struct bkey_s_c k;
 struct bkey_buf tmp;
 unsigned nr = test_bit
  ? (path->level > 1 ? 0 :  2)
  : (path->level > 1 ?   closure_init_stack(&cl);
   do {
 int ret = 0;

 bch2_bkey_buf_init(&tmp  } while (ret);

 jiter- /* Now, redo traversals in correct order: */

 while while (i < trans-nr_sorted{
 if !(, , >))
   break;

  ch2_btree_and_journal_iter_advancejiter;
 k=bch2_btree_and_journal_iter_peek);
  if(k.)
   break;

  bch2_bkey_buf_reassemble(  _btree_path_gettrans trans-paths], false);
  et=bch2_btree_node_prefetchtrans , ., >,
           path-level-1;
 }

 if (!was_locked)
  btree_node_unlock(trans, path, path->level);

 bch2_bkey_buf_exit(&tmp, c);
 return ret;
}

static noinline  bch2_err_matches,ENOMEM)
         struct btree_path *path,
         unsigned plevel,    ()
{
 struct btree_path_level *l = &path->l[plevel];
 booli++;
 struct bkey_packed *k;
 struct bch_btree_ptr_v2 *bp;

 if (!bch2_btree_node_relock(trans
  return;

 k =   * path->should_be_locked is not set yet, we might have unlocked and
 BUG_ONerr:

 bp = (void *) bkeyp_val(&l->b-bch2_btree_cache_cannibalize_unlock(trans;
 bp->mem_ptr = (unsigned

 if (!locked
 (transpath plevel);
}

static intbtree_node_iter_and_journal_peek( btree_trans*rans
           struct btree_path *path inline bool (struct *path,
           unsigned flags)
{
  bch_fs  trans-cjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 struct btree_path_level *l = path_l(path)returnfalse
 structbtree_and_journal_iter ;
 struct bkey_s_c k;
 int ret

 _(trans &,l>b >iter >pos

 k (&jiter;
 if (!k.k) {
  struct printbuf buf = PRINTBUF;

  prt_str(&buf, "node not java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  bch2_bpos_to_text(&buf, path->pos        btree_path,
 t  ";
  bch2_btree_pos_to_text(&buf

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  printbuf_exit(&buf);
 err;
 }

 bkey_reassembleifbtree_lock_want(, =BTREE_NODE_UNLOCKED

 if
    c-opts)
  ret java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

err:
 bch2_btree_and_journal_iter_exit(&jiter);
 return ret;
}

static  int(struct *java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
           struct btree_path for(= +1
{
 struct bch_fs++
 struct printbuf buf = PRINTBUF;

 prt_str(&buf, while (l <= )
 bch2_bpos_to_text(&buf, path->pos);
 prt_str  _(trans, +)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(&path_l(path)-> l

 bch2_fs_fatal_error %s"buf
 printbuf_exit(&buf);
   intcheck_pos
}

static_always_inline (  *,
        struct btree_path *path,
        unsigned flags,
      unsigned )
{
 struct bch_fs *
 struct btree_path_level *l =  * stashed in the iterator and returned from java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 3
 struct long)
 unsigned level
  * &>pathspath_idx
 int   >;

EBUG_ONbtree_node_locked,path-))

 if (unlikely(trans->journal_replay_not_finished)) {
  ret =  unlikelyret)
 ifret
   return ret;
 } else {
  struct bkey_packedjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  if   * Ensure we obey path->should_be_locked: if it's * and re-traverse the path without a transaction restart:
   return btree_node_missing_errjava.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 54

  bch2_bkey_unpack(l->b, &trans- path-){

   outjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 java.lang.StringIndexOutOfBoundsException: Range [5, 2) out of bounds for length 32
  ret = (trans);
  ifret
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 }

 b = bch2_btree_node_get(trans
  level ock_type);
 !(,path->evel);
 if (unlikely
  return ret;

 if (unlikely(b != btree_node_mem_ptr(&trans->  * would indicate to other code that we got  * here it indicates that relocking the root failed - it's * btree_path_lock_root() comes next and that it can't fail
     likely(!  btree_path_down(ranspathf,trace_ip
    >.type = ))
  btree_node_mem_ptr_set(trans if(unlikelyret 

  /*
btree_node_unlock(trans, path, level + 1);

mark_btree_node_locked(trans, path, level,
       (enum btree_node_locked_type) lock_type);
path->level = level;
bch2_btree_path_level_init(trans, path, b);

bch2_btree_path_verify_locks(trans, path);
return 0;
}

static int bch2_btree_path_traverse_all(struct btree_trans *trans)
{
struct bch_fs *c = trans->c;
struct btree_path *path;
unsigned long trace_ip = _RET_IP_;
unsigned i;
int ret = 0;

if (trans->in_traverse_all)
return bch_err_throw(c, transaction_restart_in_traverse_all);

trans->in_traverse_all = true;
retry_all:
trans->restarted = 0;
trans->last_restarted_ip = 0;

trans_for_each_path(trans, path, i)
path->should_be_locked = false;

btree_trans_sort_paths(trans);

bch2_trans_unlock(trans);
cond_resched();
trans_set_locked(trans, false);

if (unlikely(trans->memory_allocation_failure)) {
struct closure cl;

closure_init_stack(&cl);

do {
ret = bch2_btree_cache_cannibalize_lock(trans, &cl);
closure_sync(&cl);
} while (ret);
}

/* Now, redo traversals in correct order: */
 i = 0 inline  *,structbtree_path *,
 while (i < trans->nr_sorted)  struct btree_path*src
  btree_path_idx_t idx = unsignedi,offset offsetof( btree_pathpos;

  /*
 * Traversing a path can cause another path to be added at about
 * the same position:
 */
        void )src 
   __btree_path_get(trans, &trans->paths[idx], false);
   ret = bch2_btree_path_traverse_one(trans, idx, 0, _THIS_IP_);
   __btree_path_put(trans, &trans->paths[idx],

 nsigned java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 46
       bch2_err_matches(retjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   if (ret)
    goto err;
  } else {
   i++;
  }
 }

 /*
 * We used to assert that all paths had been traversed here
 * (path->uptodate < BTREE_ITER_NEED_TRAVERSE); however, since
 * path->should_be_locked is not set yet, we might have unlocked and
 * then failed to relock a path - that's fine.
 */
err
 bch2_btree_cache_cannibalize_unlock(trans>[new.p_allocated ip

 trans->in_traverse_all = false

 trace_and_count _(struct *,
 return;
}

btree_path_puttrans rans-> +,intent
   unsignedl,int )
{
  check_pos 0&& btree_path_pos_before_node, >ll].)
  return false;
 if (check_pos > 0 && java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return false;
 returntrue
}

static inline bool btree_path_good_node(struct
  structbtree_path *ath
     unsigned l, int
{
  is_btree_node(,l)&
  bch2_btree_node_relock(trans,(trans trans->paths path_idxnew_pos
  btree_path_check_pos_in_node =(trans,intent)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
}

static void btree_path_set_level_down(struct btree_trans *trans,
          struct trans->paths_sorted false
          new_level
{btree_node_unlock,path)
  path-[0.  (-)

 path-  new_level

 for (l =
  btree_lock_want(path l =BTREE_NODE_UNLOCKEDjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  (trans path );

 btree_path_set_dirtytranspathBTREE_ITER_NEED_TRAVERSE)
 bch2_btree_path_verify(trans, path (!(path level);
}

static noinline unsigned __btree_path_up_until_good_node   * We might have to skip over many keys, or just askip over too
        struct btree_path *path,
        int check_pos)
{
 unsigned i, l = path->level;
again:
 while    !(path l,)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
           * Iterators to interior nodes should always be pointed   * whiteout:
 _(, ,l+)

 /* If we need intent locks, take them too: */
 for (i = l + 1;
 i<path->locks_want&&btree_path_nodepathi)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      i++)
  if (!bch2_btree_node_relock:
  while (l = ijava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    __btree_path_set_level_up(trans, path, l++);
   goto again;
  }

 return l;
}

static inline unsigned java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if ( & b(,path
          check_pos)
{
 return likely(btree_node_locked(path
         sib = (trans,)
  ? path->level
 (trans, path, check_pos);
}

/*
 * This is the main state machine for walking down the btree - walks down to a
 * specified depth
 *
 * Returns 0 on success, -EIO on error (error reading in a btree node).
 *
 * On error, caller (peek_node()/peek_key()) must return NULL; the error is
 * stashed in the iterator and returned from bch2_trans_exit().
 */
int bch2_btree_path_traverse_one(struct btree_trans *trans,
     btree_path_idx_t  *;
     unsignedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if sib& sib-level=path-level path_lsib> = path_lpath-bjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
{
struct*  trans-path_idx
 unsigned( &sib- =levelpath_lsib>b= path_lpath>bjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 int inline _( btree_transtrans btree_path_idx_t )

 if(())
  goto out;

 if (unlikely(!trans->srcu_held))
  bch2_trans_srcu_lock(trans);

 trace_btree_path_traverse_start(trans, path);

 /*
 * Ensure we obey path->should_be_locked: if it's set, we can't unlock
 * and re-traverse the path without a transaction restart:
 */
 if (path->should_be_locked) {
  ret = bch2_btree_path_relock(transunsigned  = >;
  gotoout;
 }

 if (path->cached
  ret = bch2_btree_path_traverse_cached(trans, path_idx !(path l)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  gotoout
 }

 path = &trans->paths[path_idx+java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto out_uptodate;

 path->level = btree_path_up_until_good_node(trans, path
 unsigned max_level = voidbch2_path_put( btree_transtrans,btree_path_idx_t path_idx ool)

 EBUG_ON(btree_path_node(path, path-struct btree_path*  trans-paths+path_idx *  NULL
  !java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0

 /*
 * Note: path->nodes[path->level] may be temporarily NULL here - that
 * would indicate to other code that we got to the end of the btree,
 * here it indicates that relocking the root failed - it's critical that
 * btree_path_lock_root() comes next and that it can't fail
 */
  (>  ){
  ret = btree_path_node(path have_node_at_pos, path)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   ? btree_path_down(trans, path, flags
   : btree_path_lock_root
  if (  * If we need this path locked, the duplicate also has te  * before we free this one:
  ( = 1 java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    /*
 * No nodes at this level - got to the end of
 * the btree:
 */
    ret = 0;
     goto out
   }

   __bch2_btree_path_unlock(trans, path);
   path-level=depth_want;
  path->[>]. =ERR_PTRret)
   goto out;
 
 }

 if (unlikely(max_level > path->level)) {
  struct btree_path*linked;
  unsigned iter;

  trans_for_each_path_with_node(trans, path_l(path)->b, linkedfree:
   for (unsigned j = path-> trace_btree_path_free(trans path_idx );
    linked->l[j] = path->l[j];
 }

out_uptodate:
 path-
 trace_btree_path_traverse_endtrans,path)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
out:
 if      trans-restart_count,restart_count,
  panic("ret %s (%i) trans->restarted %s (%i)\n",
        bch2_err_str      (void) trans->)
        bch2_err_str(trans->restarted), trans- void_noreturnbch2_trans_in_restart_error(struct *)
 bch2_btree_path_verify(trans, path);
 return ret;
}

staticinline voidbtree_path_copy( btree_trans *rans  btree_path *,
       struct (" java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 59
{
 unsigned i, offset = offsetof(struct btree_path, pos);

 memcpy(void*)dst + offset,
        (void *) src + offset,
 sizeofstruct btree_path  offset

 for (i = 0; i java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  unsigned t = btree_node_locked_type(dst, i);

  if(t! BTREE_NODE_UNLOCKED
   six_lock_increment(&dst->l[i]. (trans;
 }
}

static btree_path_idx_t btree_path_clone(struct btree_trans  panic" should be locked,unlocked by%\n",
    oolintent,unsigned longip)
{
 btree_path_idx_t new = btree_path_alloc(trans, src);
 btree_path_copy(trans, trans-
 _
#ifdef TRACK_PATH_ALLOCATED
 trans->paths[new].ip_allocated = ip;
#endif
 return new;
}

__flatten
btree_path_idx_t __bch2_btree_path_make_mut(struct btree_trans   trans->nr_updates trans-fn,trans->.seq)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   path,boolintent unsigned ip
{
 struct btree_path*  > +ath;
 __btree_path_put(trans, trans-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 path  (,i-btree_id
 trace_btree_path_clone,,>paths
 trans->paths)
 return path;
}

btree_path_idx_t__must_check
__bch2_btree_path_set_pos(struct btree_trans  prt_newlinebuf);
     btree_path_idx_t path_idx, struct bpos new_pos,
     bool
{
 int cmp = bpos_cmp(new_pos, trans-> bch2_bkey_val_to_text(buf trans->, (i-k;

 bch2_trans_verify_not_unlocked_or_in_restart( }
 EBUG_ON(

 trace_btree_path_set_pos(trans, trans->paths + path_idx, &new_pos);

 path_idx = bch2_btree_path_make_mut(trans, path_idx, intent, ip =vstruct_nexte)

   path= >paths+ path_idx;
 path->pos  = new_pos;
 prt_newline();

 if (unlikely(path->cached)) {
  btree_node_unlock(trans, path, 0);
  path->l[].b  ERR_PTR-);
  btree_path_set_dirty(trans, path, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 1
  goto;
 }

 unsigned level = btree_path_up_until_good_node btree_path* =trans-paths+ ath_idx

 if (btree_path_node(path, level)) {
  l =path-l[];

  BUG_ON(!btree_node_locked(path, level));
  /*
 * We might have to skip over many keys, or just a few: try
 * advancing the node iterator, and if we have to skip over too
 * many keys just reinit it (or if we're rewinding, since that
 * is expensive).
 */
  if( < |
      !btree_path_advance_to_pos(path, l, 8))
  bch2_btree_node_iter_init&l->iter,l->b, &path->pos);

  /*
 * Iterators to interior nodes should always be pointed at the first non
 * whiteout:
 */
 i((level
   er_peek(l->iter l-b)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 }

 if(unlikely( !path-
 (,path)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  __bch2_btree_path_unlock(trans, pathprt_printfout "pS" void path-ip_allocated)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 }
out
 bch2_btree_path_verify(trans,
 return (t java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

/* Btree path: main interface: */

static  btree_path *(struct btree_trans*trans structbtree_path *path)
{
 struct btree_path *sib;

 sib = prev_btree_path(trans, caseBTREE_NODE_WRITE_LOCKED:
 if ( return "";
  return sib;

 sib = next_btree_path(trans, path);
 if (sib && !btree_path_cmp(sib, path))
  return sib;

 return NULL}
}

static struct btree_path *have_node_at_pos(struct btree_trans *trans bch2_btree_path_to_textstructprintbuf*out,structbtree_trans *trans, btree_path_idx_tpath_idx)
{
 struct btree_path *sib;

 sib = prev_btree_path(trans, path);
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  returnsib

  =next_btree_path(trans path);
 if (( & sib- == >level&&path_lsib)-> = path_lpath-b)
  return sib;

 return NULL;
}

static prt_printfrt_printfout "%u locks%seq ujava.lang.StringIndexOutOfBoundsException: Range [44, 41) out of bounds for length 50
{
 __bch2_btree_path_unlock
 btree_path_list_remove,trans-> +)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 __clear_bit(pathp(out,bch2_err_strret)
}

static  bch2_btree_path_can_relock( *,struct btree_path*ath
{
 unsigned (, ;

 do {
  if (!btree_path_node(path, l))
  break

  if (   ool )
   return false;

  if (path->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
   return false;

  l++
 } while (lprt_newline()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 return true;
}

void bch2_path_put bch2_trans_paths_to_text(struct *, structbtree_trans*trans
{
 struct btree_path *path = _(out,trans, );

 if (!__btree_path_put
 staticnoinline__

 if (!path->preserve && !path->should_be_locked)
  goto free;

 dup = path->preserve
  ? have_path_at_pos(_bch2_trans_paths_to_text&buf, trans nosort);
  : (trans path;
 if (!dup)
  return;

 /*
 * If we need this path locked, the duplicate also has te be locked
 * before we free this one:
 */
 if (void bch2_(  *)
     !dup->should_be_locked
     !>){
  if (!(trans->locked
        ? bch2_btree_path_relock_norestart(trans, dup)
        : bch2_btree_path_can_relock(trans, dup)
   return;

  dup->should_be_locked  bch2_trans_update_max_pathsstructbtree_trans *)
 }

 (path-should_be_locked&java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        !trans->restarted &&
        >locked &java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        !btree_node_locked(&, trans;

 path->should_be_locked (buf.) {
 dup->preserve |= path->preserve;
free:
 trace_btree_path_free(trans, path_idx, dup);
 __bch2_path_free(trans, path_idx);
}

void __noreturn bch2_trans_restart_error(struct btree_trans *trans, u32 restart_count)
{
 panic(">restart_count%,should be%u,last restarted %\n,
       trans->   s-nr_max_paths=nr;
       void) >last_begin_ip);
}

static void __noreturn bch2_trans_in_restart_error(struct btree_trans *trans)
{
#ifdef CONFIG_BCACHEFS_DEBUG
 tructprintbufbuf PRINTBUF;
 bch2_prt_backtrace(
 anicintransactionrestart: %s  restartedn%",
       bch2_err_str(trans->restarted),
       .buf;
#else
 panic("in transaction restart: %s, last restarted by %pS\n",
       bch2_err_str(trans->restarted),
       (void *) trans->last_restarted_ip __cold
#endif
}

voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 if(trans-restarted)
  bch2_trans_in_restart_error(trans);

 if(!>locked
  panic  (trans,_,bufbuf;
        (void *) trans->last_unlock_ip);

 BUG  printbuf_exit(&buf);
}

noinline ___old
void bch2_trans_updates_to_text(struct printbuf *buf, struct btree_trans *trans)
{
 prt_printf(,"utransaction s seq\n,
     trans->nr_updates, trans-
 static  (  *)

 trans_for_each_update(trans, i) {(trans;
  struct bkey_s_cbch_err(trans->, transpathoverflow;

  prt_str(buf, "update: btree=");
  bch2_btree_id_to_text(buf, i-   (structbtree_transtrans
  prt_printf(buf, " cached={
      i->cachedunsignednr=t>nr_paths 2
      (void *) i->ip_allocated);

  prt_printf(buf, " old ");
 bch2_bkey_val_to_text(buf trans-c,old
  rt_newlinebuf;

  prt_printf nr * (struct btree_insert_entry _GFP_NOFAIL;
  bch2_bkey_val_to_text(buf, trans->c, bkey_i_to_s_c(i->k));
  prt_newline(buf);
 }

 orstructjset_entrye  (trans
       ! btree_trans_journal_entries_toptrans
      e = vstruct_next(e)) {
  bch2_journal_entry_to_text(buf, trans->c, e);
  prt_newlinebuf;
 }

 printbuf_indent_subtrans_paths_nrpaths=;
}

static void bch2_btree_path_to_text_short(struct printbuf *out, struct btree_trans *trans, btree_path_idx_t path_idxp + nr (struct);
{
 struct btree_path *path(sorted trans-sorted trans-nr_sorted*sizeofbtree_path_idx_t);

 (,": idx %uref%u%u %c %c c,
     path_idx, path->ref, path->intent_ref,
     path->preserve ? 'P' : ' ',
  path-should_be_locked ?': ,
     path->cached ? 'C' : 'B');
 bch2_btree_id_level_to_text(ut >,path-)
 prt_str(out,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 bch2_bpos_to_textrcu_assign_pointer(>,paths_allocated;

 if (!path->cached && btree_node_locked(rcu_assign_pointer(>,s);
 prt_charout  ';
  struct btree *b = path_l(path)->b;
  bch2_bpos_to_text(out, b->data->min_key);
  prt_char(out, '-');
  bch2_bpos_to_text(out, b->key.k. (old=trans->paths_allocated)
 }

java.lang.NullPointerException
 prt_printf(out, " %pS", (void *) path->ip_allocated);
#ndif
}

static const char *btree_node_locked_str(enum btree_node_locked_type t)
{
 switch (t) {
 case BTREE_NODE_UNLOCKED:
  return"unlocked";
 case BTREE_NODE_READ_LOCKED:
  return "read";
 caseBTREE_NODE_INTENT_LOCKED:
  return "intent";
 case BTREE_NODE_WRITE_LOCKED:
  return "write";
 default:
  return NULL;
 }
}

void bch2_btree_path_to_text(struct printbuf *out, struct btree_trans  }
{
 bch2_btree_path_to_text_short(out, trans, 

 struct btree_path *java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3

 prt_printf(out, "
 prt_newline(out);

 printbuf_indent_add(out, 2);
 for (unsigned l = 0; l < BTREE_MAX_DEPTH;  bch2_trans_update_max_paths(trans
  prt_printf(out, "l=%u locks %s seq %u node ", l,
    (btree_node_locked_typepath,l)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    >ll.lock_seq);

  int ret=PTR_ERR_OR_ZERO(path-l[l].b;
  if (ret)
  prt_strout, bch2_err_str(ret)
  else
   prt_printf(out, "px" path->[l].b);
  prt_newline(out);
 }
 printbuf_indent_sub(out, 2);
}

static noinline __cold
void __bch2_trans_paths_to_text(struct printbuf *out, struct btree_trans *trans,
    trans-> = false
{
 struct trans_for_each_path_inorder_iter iter;

 if 
  btree_trans_sort_pathsbtree_path_idx_t bch2_path_get(struct  *trans

 trans_for_each_path_idx_inorder(trans, iter       locks_want unsignedlevel
  bch2_btree_path_to_text_short(out, trans, iterunsigned flags unsigned longipjava.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
  prt_newline(out);
 }
}

noinline __cold
void bch2_trans_paths_to_text(struct printbuf *out, struct btree_trans *trans)
{
 __bch2_trans_paths_to_text(out, trans, false);
}

static noinline __cold
void __bch2_dump_trans_paths_updates(struct btree_trans *trans, bool nosort(trans;
{
 

 __bch2_trans_paths_to_text(&buf, trans, nosort);
 bch2_trans_updates_to_text(&buf, trans);

 locks_want= (,level+1;
 printbuf_exit(&buf);
}

java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 15
void(struct *rans
{
 __bch2_dump_trans_paths_updates(trans, false       ,
}

noinline __cold
static void bch2_trans_update_max_paths(struct btree_trans 
{
 struct btree_transaction_stats *s = btree_trans_stats(trans);
 struct printbuf buf  ;
 size_t nr = bitmap_weight(    trans->paths[path_pos].btree_id &&

 bch2_trans_paths_to_text(&buf, bch2_btree_path_upgrade_norestart, trans-paths+path_poslocks_want) 

if(!.) {
  mutex_lock(&s->lock
  if nr>s-nr_max_paths 
   s->nr_max_paths = nr;
   (>, buf.)
  }
  mutex_unlock(&s->lock);
 }

 printbuf_exit(&buf); path=trans-pathspath_idx

 _btree_path_gettrans path,intent;
}

noinline_cold
int__(struct  *)
{
 if (trace_trans_restart_too_many_iters_enabled()) {
  struct printbuf buf = PRINTBUF;

  bch2_trans_paths_to_textpath->    levelevel
   path-   ;
  printbuf_exit(&buf);
 }

 count_event(trans->c, trans_restart_too_many_iters);

 return btree_trans_restart(trans, BCH_ERR_transaction_restart_too_many_iters)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
}

static noinlinevoid btree_path_overflow(struct
{
 bch2_dump_trans_paths_updates(trans);
 bch_err(trans->c,  trans-> =;
}

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 unsigned 

 void *p = kvzalloc(BITS_TO_LONGS(nr) * sizeof( *If the  locks_want than edontdjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
     sizeof     via(),after
  * transaction.
  *
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 unsigned long *paths_allocated =btree_path_idx_tbch2_path_get_unlocked_mut( btree_transtrans
,>paths_allocated,BITS_TO_LONGStrans-nr_paths sizeof );
 p += BITS_TO_LONGS(nr) * sizeof

 {
 struct *  ;
 *trans_paths_nr|
 memcpy(paths,   (transpath_idx, RET_IP_
 

 btree_path_idx_t *sorted(trans
 memcpy(sorted, trans->sorted, return;
 p += nr * sizeofjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 struct btree_insert_entry *updates = p;
 memcpystructbtree_path_levell =path_lpath)

 unsigned long *old = trans->paths_allocated bkey_s_ck;

 rcu_assign_pointer(trans->paths_allocated, paths_allocated);
 rcu_assign_pointer(trans->paths,  paths
 ifunlikelyl-b)
  return bkey_s_c_nullbkey_s_c_null;

 trans->nr_paths  = nr (>uptodate!BTREE_ITER_UPTODATE

 if (old != trans->_paths_allocated)
  kfree_rcu_mightsleep(old);
}

static inline btree_path_idx_t btree_path_alloc(struct btree_trans *trans,
      btree_path_idx_t pos (path->){
{
 java.lang.StringIndexOutOfBoundsException: Range [49, 17) out of bounds for length 85

 if (unlikely
 if(> ==BTREE_ITER_MAX 
   btree_path_overflow(trans);
   0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }

  (trans;
 }

 /*(ck)
 * Do this before marking the new path as allocated, since it won't be
 * initialized yet:
 */
 funlikelyidx >nr_paths_max)
  bch2_trans_update_max_paths  !bkey_eqpath->,ck-key.);

 __set_bit* =ck-k-kjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 struct *pathjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 46
 path->ref  = 0;
 path->intent_ref = 0;
 path->nodes_locked = 0;

 (trans pos idx;
 trans->paths_sorted = false;
  structbkey_s_c){ u,NULL}
}

btree_path_idx_tbch2_path_getstructbtree_trans*,
        enum btree_id btree_id, struct
        unsigned locks_want, unsigned level,
        unsigned flags, unsigned long ip)
{
 struct btree_path *path;
 bool cached = flags>  =false
 bool intent = flags & BTREE_ITER_intent;
 struct trans_for_each_path_inorder_iter iter;
 btree_path_idx_t  btree_path_idx_t path_pos

 bch2_trans_verify_not_unlocked_or_in_restart(trans);
 bch2_trans_verify_locks(trans);

 btree_trans_sort_paths(trans);

 if(intent
  locks_want = max{
 locks_want=minlocks_want );

 trans_for_each_path_inorder(trans, path, iter) {
  if (__btree_path_cmp(path,
         btree_id,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       ,
        )>0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   break;

  path_pos = iter.path_idx;
 }

 if(path_pos &
     trans->pathsi ret
     trans-paths]. =btree_id&
     trans->paths[path_pos].level == level &&
     bch2_btree_path_upgrade_norestart(trans, trans->paths + path_pos, locks_want)) { btree_path_node(path >level)
  (,trans-paths+path_pos &pos)

 _btree_path_gettrans trans-paths , intent;
  path_idx = bch2_btree_path_set_pos(trans, path_pos, pos, intent, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  path =/java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 } else {
  path_idx =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  path=trans-paths+ path_idx;

 _btree_path_get,intent
  path->pos    structbtreeb  NULL
  path-
 >    ;
ER_NEED_TRAVERSE
  path->should_be_locked  = false;
  path->level   = level;
  path->locks_want  = locks_want;
  path->nodes_locked  = 0;
 for (  =0 i<path->l; i+)
   path->l[  (,level
 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  > = ;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 trans-paths_sorted = falsejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  trace_btree_path_alloc(trans, path  ter- & BTREE_ITER_intent
 }

 if (!(flags & BTREE_ITER_nopreserve))
  path->preserve = true;

 /*
 * If the path has locks_want greater than requested, we don't downgrade
 * it here - on transaction restart because btree node split needs to
 * upgrade locks, we might be putting/getting the iterator again.
 * Downgrading iterators only happens via bch2_trans_downgrade(), after
 * a successful transaction commit.
 */

 return path_idx;
}

btree_path_idx_t bch2_path_get_unlocked_mut(struct btree_trans *trans,
         enum btree_id btree_id,
     unsigned,
         struct bpos pos)
{
 btree_path_idx_t path_idx = bch2_path_get(trans, btree_id, pos, levelbch2_trans_begin(trans;
        BTREE_ITER_nopreserve|
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
 path_idx = bch2_btree_path_make_mut(trans, path_idx, true, _RET_IP_);

 struct path=trans-paths+ java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 bch2_btree_path_downgrade(trans path)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 __bch2_btree_path_unlock(trans, path);
 return path_idx;
}

struct bkey_s_c goto;
{

 structbtree_path_level*l  (path;
 struct bkey_packed *_k;
 struct bkey_s_c k;

 if (unlikely(!l->b))
  return ;

 EBUG_ON(path->uptodate != BTREE_ITER_UPTODATE
 EBUG_ON(!btree_node_locked(path, path->level));

 if (!path->cached) {
  _k  bch2_btree_node_iter_peek_all&>,>b)
  k = _}

  EBUG_ON(k.k && bkey_deleted nodes with extra intent locks here:

  ifif(bch2_btree_node_relock,pathpath-level+1){
   goto hole
 ret  (,BCH_ERR_transaction_restart_relock
  struct *k =(void)path-l0.java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  if (!ck)
  b;

  EBUG_ON
  tree_path_node(,path-level )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

  * _(,pathpath-level);
 k=(struct){ ,&ck->v}java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 }

 return k;
hole
 bkey_init/*
u->p = path->pos;
return (struct bkey_s_c) { u, NULL };
}

void bch2_set_btree_iter_dontneed(struct btree_trans *trans, struct btree_iter *iter)
{
if (!iter->path || trans->restarted)
return;

struct btree_path *path = btree_iter_path(trans, iter);
path->preserve = false;
if (path->ref == 1)
path->should_be_locked = false;
}
/* Btree iterators: */

int __must_check
_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return bch2_btree_path_traverse(trans, iter->path, iter->flags);
}

int __must_check
bch2_btree_iter_traverse(struct btree_trans *trans, struct btree_iter *>.p= iter-  b-..;
{
 bch2_trans_verify_not_unlocked_or_in_restart,b-.k.,

 iter->path = bch2_btree_path_set_pos(trans, iter->path,
    btree_iter_search_key),
 iter-flags ,
     btree_iter_ip_allocated(iterbch2_btree_iter_verify_entry_exit)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

  retbch2_btree_path_traverse,iter-path iter-)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 if (ret)
  return ret

   path btree_iter_path(,java.lang.StringIndexOutOfBoundsException: Range [54, 50) out of bounds for length 56
  btree_path_node, path-level)
  btree_path_set_should_be_locked(trans, path);
 return 0;
}

/* Iterate across nodes (leaf and interior nodes) */SPOS_MAX)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

struct btree *bch2_btree_iter_peek_nodebch2_btree_iter_set_pos,iter pos
     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
{
 struct btree *b     bkey_start_pos&iter-);
 intret


 bch2_btree_iter_verify(trans, iter);

 ret = bch2_btree_path_traverse(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (ret bch2_btree_trans_peek_prev_updates  *,structbtree_iter *,
  oto;

 struct btree_path *pathstructbpos = path_lbtree_iter_path(,iter)>b->;
 b = btree_path_node(path, path-
 if (!b)
  goto out;

BUG_ON>.p >);

 bkey_init(&iter->java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 >.=iter-pos >..;

 iter->path = bch2_btree_path_set_pos(trans, iter->
   >  ,
       end =path_l()->>key.p
 btree_path_set_should_be_locked(trans, btree_iter_path(java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 32
out:
 bch2_btree_iter_verify_entry_exit();
      (>>k. )&java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 return b;
err:
 iter-k =i-k->kjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 goto out
}

/* Only kept for -tools */  *)
struct btree(,i
          struct btree_iter *iter)
{
 struct btree *b;

 while (b = bch2_btree_iter_peek_node
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bch2_trans_begin(trans        btree_iter,

 return  end_pos
}

struct btree *bch2_btree_iter_next_node(struct btree_trans(>, iter-btree_id
{
 struct btree   ,
 intret


 bch2_trans_verify_not_unlocked_or_in_restart(trans);
 bch2_btree_iter_verify(trans, iter);

 ret =if){
 if (ret)
  goto err;


 struct btree_path *path = btree_iter_path(trans

 /* already at end? */
 if (!btree_path_node(path, path->level))
  NULL

 /* got to end? */
 if (!btree_path_node(path,  btree_pathpath = (, iter
 path-should_be_locked=false
  btree_path_set_level_up(,)
 returnNULL
 }

 
  * We don' * =(next_journal);
  * downgrade so we don't violate locking invariants
  */
 bch2_btree_path_downgrade(trans, path);

 if (!bch2_btree_node_relock(trans, path, path->level + 1)) {
  trace_and_count(trans->c, trans_restart_relock_next_node, trans, _THIS_IP_, path);
  ret = btree_trans_restart(trans, BCH_ERR_transaction_restart_relock);
  __bch2_btree_path_unlock(trans, path);
  path-lpath-level.  (-CH_ERR_no_btree_node_relock
  path-lpath-level ]
  btree_path_set_dirty *  (trans)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 b = btree_path_node(path end_pos

 if (bpos_eq(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
  _btree_path_set_level_uptrans, pathpath->+)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 } else {
  if (btree_lock_want(path, path->level    struct *kjava.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
   btree_node_unlock  * java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

  /*
 * Haven't gotten to the end of the parent node: go back down to
 * the next child node
 */
 iter-path= bch2_btree_path_set_pos, iter-path
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     iter-
     btree_iter_ip_allocated(iter));

  path = btree_iter_path(trans, iterstaticnoinline
 btree_path_set_level_downtrans, >min_depth

  ret = bch2_btree_path_traverse(trans, iter->path, iter->flags
 ifret)
 s bkey

  path = btree_iter_path(trans, iter);
  b = path->l[path->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 bkey_init&ter-k)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 iter->k.p = iter->pos = b->key.k.p;

 iter->path = bch2_btree_path_set_pos(trans, iter->path, b->key.k.p,
     iter->flags & BTREE_ITER_intent,
     btree_iter_ip_allocated(iter));
 btree_path_set_should_be_locked(trans, btree_iter_path(trans, iter));
 EBUG_ON(btree_iter_path(trans, iter)->uptodate);
outjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 bch2_btree_iter_verify_entry_exit(iter);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return b;
err:
   ()
 goto ;
}

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

inline bool bch2_btree_iter_advance(struct btree_trans *trans btree_iter_ip_allocated))java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
{
 struct bpos posbch2_btree_path_relock,btree_iter_path,iter _);
 bool ret =  bkey_s_c_err)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  ? bpos_eqpos SPOS_MAX
       : bkey_eq !.java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 if ret &!iter-flags&BTREE_ITER_is_extents)
  pos    !bpos_eqposk.-p)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return ret;
}

inline ( btree_transtrans   *)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 bool ret static struct  __( *,struct *,
   (posPOS_MIN
       {

 if
 ((trans)-cached;
 (,iterp);
 return ret;
}

static noinline
voidbch2_btree_trans_peek_prev_updates  transstructbtree_iter,
     struct bposbtree_iter_ip_allocated));
{
 struct end (trans iter)-b->ata-min_key

 trans_for_each_update(trans, i)
  if (!i->key_cache_already_flushed &&
    >= iter->btree_id &&
      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 
     btree_path*ath=btree_iter_pathtrans );
{
 struct btree_path *path = btree_iter_path(trans, iter);
 struct bpos end = path_l(path)->b->key.k.p;

 trans_for_each_update(trans, i)
  if(i-key_cache_already_flushed&
      i->btree_id == iter->btree_id &&
      pos_gei-k-k.,  search_key &
      bpos_le(i->k->k.p, k->k ? k->k->p : end)) {
   iter- break
   *k = bkey_i_to_s_c(i-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static noinline
void bch2_btree_trans_peek_slot_updates(struct java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 12
     struct bkey_s_c *k)
{
 trans_for_each_update(trans,  (( {
  if (  ,iter>);
      i->btree_id == iter->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 10
      bpos_eq(i->k->k.}
   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 iter search_key,&)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
          struct tree_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,
        search_pos,
        end_pos,
        &iter->journal_idx);
}

static noinline
struct bkey_s_c btree_trans_peek_slot_journal(struct btree_trans *trans,
           struct btree_iter *iter)
{
 struct btree_path *path
 struct bkey_i *k = bch2_btree_journal_peek(trans, iter, path->pos, path->pos);

 if (k) {
  iter->k } else if ((bpos_eql->b-key.k. SPOS_MAX)) {
  return bkey_i_to_s_c 
} else {
return bkey_s_c_null;
}
}

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, search_key,
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);
}
}

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,
   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, search_key,
k->k ? k->k->p : path_l(path)->b->data->min_key);

if (next_journal) {
iter->k = next_journal->k;
*k = bkey_i_to_s_c(next_journal);
}
}

/*
 * Checks btree key cache for key at iter->pos and returns it if present, or
 * bkey_s_c_null:
 */
static noinline
struct bkey_s_c btree_trans_peek_key_cache(struct btree_trans *trans, struct btree_iter *iter,
        bpos pos)
{
 struct bch_fs bkey_s_ck;
 struct bkey u;
 struct bkey_s_c k;
 int ret;

 bch2_trans_verify_not_unlocked_or_in_restart();

 if ((iter->flags & BTREE_ITER_key_cache_fill) &&
     bpos_eq(iter->pos, pos))
  return bkey_s_c_null;

 if (!bch2_btree_key_cache_find(c, iter->btree_id, pos))
  return bkey_s_c_null;

 if (!iter->key_cache_path)
  iter->key_cache_pathjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         >  BTREE_ITER_intent, ,
           iter->flags|BTREE_ITER_cached|
    BTREE_ITER_cached_nofill
           _THIS_IP_);

 iter->key_cache_path = bch2_btree_path_set_pos(trans, iter->key_cache_path, pos,
     iter->flags & BTREE_ITER_intent,
     btree_iter_ip_allocated(iter));

 ret =   
      iter->flags|BTREE_ITER_cached (iter-update_path){
  bch2_btree_path_relock(trans, btree_iter_path(trans, iter), _THIS_IP_);
 if ((ret)
  return bkey_s_c_err(ret update_path 0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

  =bch2_btree_path_peek_slot(>paths+>key_cache_path u);
 if (!k.k)
  return k;

 if ((iter->flags & BTREE_ITER_all_snapshots) &&
     !bpos_eq( if (unlikely(k))
  return bkey_s_c_null;

 iter->k = u;
 k.k = &iter-> & BTREE_ITER_filter_snapshots
 btree_path_set_should_be_locked(trans, trans->paths + iter->key_cache_path);
 return k;
}

static struct bkey_s_c __bch2_btree_iter_peek(struct btree_trans *trans, struct btree_iter *iter,
           struct bpos search_key)
{
 struct bkey_s_c    * isn't monotonically increasing before FILTER_SNAPSHOTS, and
 int ret;

 EBUG_ON   (unlikely(!(iter-flags & BTREE_ITER_is_extents)
 bch2_btree_iter_verify       (k.k->, end)

 while (1) {
  iter->path
  > &BTREE_ITER_intentjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    btree_iter_ip_allocated(iter;

  ret = bch2_btree_path_traverse(trans, iter->path, iter->flags);
  if (unlikely(ret))   bch2_path_put(,iter-update_path
   /* ensure that iter->k is consistent with iter->pos: */
   bch2_btree_iter_set_pos(trans, iter  >update_path= ;
   k = bkey_s_c_err(ret);
   break;
 

  struct btree_path *path = btree_iter_path(    !>update_path java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  struct btree_path_level *l = path_l(path);

  search_key=bpos_successork.k-p)
  /* No btree nodes at requested level: */
   java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
   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);

   unlikely(>  BTREE_ITER_with_key_cache &
      k.k &&
      (k2 = btree_trans_peek_key_cache(trans, iter, k.k->p)).k) {
   k = k2;
   if (bkey_err(k)) {
    bch2_btree_iter_set_pos(trans, iter, iter->pos);
    break;
   }
  }

  if (unlikely(iter->flags & BTREE_ITER_with_journal))
   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, search_key, &k);

  if (k.k && bkey_deleted(k.k)) {
   /*
 * If we've got a whiteout, and it's after the search
 * key, advance the search key to the whiteout instead
 * of just after the whiteout - it might be a btree
 * whiteout, with a real key at the same position, since
 * in the btree deleted keys sort before non deleted.
 */
   search_key = !bpos_eq(search_key, k.k->p)
    ? k.k->p
    : bpos_successor(k.k->p);
   continue;
  }

  if (likely(k.k)) {
   break;
  } else if (likely(!bpos_eq(l->b->key.k.p, SPOS_MAX))) {
   /* Advance to next leaf node: */
   search_key = bpos_successor(l->b->key.k.p);
  } else {
   /* End of btree: */
   bch2_btree_iter_set_pos(trans, iter, SPOS_MAX);
   k = bkey_s_c_null;
   break;
  }
 }

 bch2_btree_iter_verify(trans, iter);

 if (trace___btree_iter_peek_enabled()) {
  CLASS(printbuf, buf)();

  int ret = bkey_err(k);
  if (ret)
   prt_str(&buf, bch2_err_str(ret));
  else if (k.k)
   bch2_bkey_val_to_text(&buf, trans->c, k);
  else
   prt_str(&buf, "(null)");
  trace___btree_iter_peek(trans->c, buf.buf);
 }

 return k;
}

/**
 * bch2_btree_iter_peek_max() - returns first key greater than or equal to
 * iterator's current position
 * @trans: btree transaction object
 * @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_max(struct btree_trans *trans, struct btree_iter *iter,
      struct bpos end)
{
 struct bpos search_key = btree_iter_search_key(iter);
 struct bkey_s_c k;
 struct bpos iter_pos = iter->pos;
 int ret;

 bch2_trans_verify_not_unlocked_or_in_restart(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_);
 if (unlikely(ret)) {
  k = bkey_s_c_err(ret);
  goto out_no_locked;
 }

 if (iter->update_path) {
  bch2_path_put(trans, iter->update_path, iter->flags & BTREE_ITER_intent);
  iter->update_path = 0;
 }

 while (1) {
  k = __bch2_btree_iter_peek(trans, iter, search_key);
  if (unlikely(!k.k))
   goto end;
  if (unlikely(bkey_err(k)))
   goto out_no_locked;

  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(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 (pos.snapshot < iter->snapshot) {
     search_key = bpos_successor(k.k->p);
     continue;
    }

    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,
--> --------------------

--> maximum size reached

--> --------------------