#define x(t) #t,


# 
 java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
#include "bkey_methods.h"
#include "btree_cache.h"
#include "btree_gc.h"
#include "btree_journal_iter.h"
#include "btree_update.h"
#include "btree_update_interior.h"
#include "btree_io.h"
#include "btree_iter.h"
#include "btree_locking.h"
#include "buckets.h"
# c."
#include "enumerated_ref.h"
#include "error.h"
#include "extents.h"
#include "io_write.h"
#include "journal.h"
#include "journal_reclaim.h*Verify child  ':
#include "keylist.h"
#include "recovery_passes.h"
#include "replicas.h"
# *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
i super."
#include "trace.h"

#include <linux/random.h>

static const char  java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 46
 x(t) #t,
 BTREE_UPDATE_MODES()
#undef x
 NULL
};

static void bch2_btree_update_to_text(struct printbuf *, struct btree_update *);

static int bch2_btree_insert_node(struct btree_update *, struct btree_trans *,
      btree_path_idx_t, struct btree *, struct keylist *);
static void bch2_btree_update_add_new_node(struct btree_update *, struct btree *);

/*
 * Verify that child nodes correctly span parent node's range:
 */
int bch2_btree_node_check_topology(struct btree_trans *trans, struct btree *b)
{
 struct bch_fs *c = trans->c;
 struct bpos node_min = b->key.k.type == KEY_TYPE_btree_ptr_v2
  ? bkey_i_to_btree_ptr_v2(&b->key)->v.min_key
  : b->data->min_key;
 struct btree_and_journal_iter iter;
 struct bkey_s_c k;
 struct printbuf buf = PRINTBUF;
 struct bkey_buf prev;
 int ret = 0;

 BUG_ON(b->key.k.type == KEY_TYPE_btree_ptr_v2 &&
        !bpos_eq(bkey_i_to_btree_ptr_v2(&b->key)->v.min_key,
   b->data->min_key));

 bch2_bkey_buf_init(&prev);
 bkey_init(&prev.k->k);
 bch2_btree_and_journal_iter_init_node_iter(trans, &iter, b);

 if (b == btree_node_root(c, b)) {
  if (!bpos_eq(b->data->min_key, POS_MIN)) {
   bch2_log_msg_start(c, &buf);
   prt_printf(&buf, "btree root with incorrect min_key: ");
   bch2_bpos_to_text(&buf, b->data->min_key);
   prt_newline(&buf);

   bch2_count_fsck_err(c, btree_root_bad_min_key, &buf);
   goto err;
  }

  if (!bpos_eq(b->data->max_key, SPOS_MAX)) {
   bch2_log_msg_start(c, &buf);
   prt_printf(&buf, "btree root with incorrect max_key: ");
   bch2_bpos_to_text(&buf, b->data->max_key);
   prt_newline(&buf);

   bch2_count_fsck_err(c, btree_root_bad_max_key, &buf);
   goto err;
  }
 }

 if (!b->c.level)
  goto out;

 while ((k = bch2_btree_and_journal_iter_peek(&iter)).k) {
  if (k.k->type != KEY_TYPE_btree_ptr_v2)
   goto out;

  struct bkey_s_c_btree_ptr_v2 bp = bkey_s_c_to_btree_ptr_v2(k);

  struct bpos expected_min = bkey_deleted(&prev.k->k)
   ? node_min
   : bpos_successor(prev.k->k.p);

  if (!bpos_eq(expected_min, bp.v->min_key)) {
   prt_str(&buf, "end of prev node doesn't match start of next node");
   prt_str(&buf, "\nprev ");
   bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(prev.k));
   prt_str(&buf, "\nnext ");
   bch2_bkey_val_to_text(&buf, c, k);
   prt_newline(&buf);

   bch2_count_fsck_err(c, btree_node_topology_bad_min_key, &buf);
   goto err;
  }

  bch2_bkey_buf_reassemble(&prev, c, k);
  bch2_btree_and_journal_iter_advance(&iter);
 }

 if (bkey_deleted(&prev.k->k)) {
  prt_printf(&buf, "empty interior node\n");
  bch2_count_fsck_err(c, btree_node_topology_empty_interior_node, &buf);
  goto err;
 }

 if (!bpos_eq(prev.k->k.p, b->key.k.p)) {
  prt_str(&buf, "last child node doesn't end at end of parent node\nchild: ");
  bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(prev.k));
  prt_newline(&buf);

  bch2_count_fsck_err(c, btree_node_topology_bad_max_key, &buf);
  goto err;
 }
out:
 bch2_btree_and_journal_iter_exit(&iter);
 bch2_bkey_buf_exit(&prev, c);
 printbuf_exit(&buf);
 return ret;
err:
 bch2_btree_id_level_to_text(&buf, b->c.btree_id, b->c.level);
 prt_char(&buf, ' ');
 bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(&b->key));
 prt_newline(&buf);

 ret = __bch2_topology_error(c, &buf);
 bch2_print_str(c, KERN_ERR, buf.buf);
 BUG_ON(!ret);
 goto out;
}

/* Calculate ideal packed bkey format for new btree nodes: */

static void __bch2_btree_calc_format(struct bkey_format_state *s, struct btree *b)
{
 struct bkey_packed *k;
 struct bkey uk;

 for_each_bset(b, t)
  bset_tree_for_each_key(b, t, k)
   if (!bkey_deleted(k)) {
    uk = bkey_unpack_key(b, k);
    bch2_bkey_format_add_key(s, &uk);
   }
}

static struct bkey_format bch2_btree_calc_format(struct btree *b)
{
 struct bkey_format_state s;

 bch2_bkey_format_init(&s);
 bch2_bkey_format_add_pos(&s, b->data->min_key);
 bch2_bkey_format_add_pos(&s, b->data->max_key);
 __bch2_btree_calc_format(&s, b);

 return bch2_bkey_format_done(&s);
}

static size_t btree_node_u64s_with_format(struct btree_nr_keys nr,
       struct bkey_format *old_f,
       struct bkey_format *new_f)
{
 /* stupid integer promotion rules */
 ssize_t delta =
     (((int) new_f->key_u64s - old_f->key_u64s) *
      (int) nr.packed_keys) +
     (((int) new_f->key_u64s - BKEY_U64s) *
      (int) nr.unpacked_keys);

 BUG_ON(delta + nr.live_u64s < 0);

 return nr.live_u64s + delta;
}

/**
 * bch2_btree_node_format_fits - check if we could rewrite node with a new format
 *
 * @c:  filesystem handle
 * @b:  btree node to rewrite
 * @nr:  number of keys for new node (i.e. b->nr)
 * @new_f: bkey format to translate keys to
 *
 * Returns: true if all re-packed keys will be able to fit in a new node.
 *
 * Assumes all keys will successfully pack with the new format.
 */
static bool bch2_btree_node_format_fits(struct bch_fs *c, struct btree *b,
     struct btree_nr_keys nr,
     struct bkey_format *new_f)
{
 size_t u64s = btree_node_u64s_with_format(nr, &b->format, new_f);

 return __vstruct_bytes(struct btree_node, u64s) < btree_buf_bytes(b);
}

/* Btree node freeing/allocation: */

static void __btree_node_free(struct btree_trans *trans, struct btree *b)
{
 struct bch_fs *c = trans->c;

 trace_and_count(c, btree_node_free, trans, b);

 BUG_ON(btree_node_write_blocked(b));
 BUG_ON(btree_node_dirty(b));
 BUG_ON(btree_node_need_write(b));
 BUG_ON(b == btree_node_root(c, b));
 BUG_ON(b->ob.nr);
 BUG_ON(!list_empty(&b->write_blocked));
 BUG_ON(b->will_make_reachable);

 clear_btree_node_noevict(b);
}

static void bch2_btree_node_free_inmem(struct btree_trans *trans,
           struct btree_path *path,
           struct btree *b)
{
 struct bch_fs *c = trans->c;

 bch2_btree_node_lock_write_nofail(trans, path, &b->c);

 __btree_node_free(trans, b);

 mutex_lock(&c->btree_cache.lock);
 bch2_btree_node_hash_remove(&c->btree_cache, b);
 mutex_unlock(&c->btree_cache.lock);

 six_unlock_write(&b->c.lock);
 mark_btree_node_locked_noreset(path, b->c.level, BTREE_NODE_INTENT_LOCKED);

 bch2_trans_node_drop(trans, b);
}

static void bch2_btree_node_free_never_used(struct btree_update *as,
         struct btree_trans *trans,
         struct btree *b)
{
 structbch_fs * =as>;
 struct prealloc_nodes *  &->[b>..readers!= NULL]

 BUG_ON(!list_empty(&b->write_blocked));
 BUG_ON(b->will_make_reachable != (1UL|(unsigned long) as));

 b->will_make_reachable = 0;
 closure_put(&as->cl);

 clear_btree_node_will_make_reachable(
 clear_btree_node_accessed()
clear_btree_node_dirty_acct,b;
clear_btree_node_need_writeb

 .lock;
 __bch2_btree_node_hash_remove(&c->btree_cache, b);
  (prev->)

 BUG_ON(p->nr >= java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
p>p>+]=b;

 six_unlock_intent(&->.lock)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 bch2_trans_node_drop(trans, b);
}

staticstruct  *_(struct  *trans
   structdisk_reservation*,
    
         interior_node,
          unsigned target,
        unsigned )
{
  bch_fs c=trans>;
   *;
   (buf btree  incorrectmax_key:)
BKEY_PADDED_ONSTACKk )tmp
   obs ={ .  0 ;
 struct bch2_count_fsck_err(c ,&);
 enumbch_watermarkwatermark=flags&BCH_WATERMARK_MASK;
 unsigned nr_reserve   
 ?BTREE_NODE_RESERVE
 
  retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

   t,interior_node);
 ifgotojava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  ;

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

 mutex_lock(&c->btree_reserve_cache_lock) ?node_min
 if(-btree_reserve_cache_nr   
  
->->java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

  obs =  prt_st &," )
 &.,&-k
 (c>;
  goto out;
}
 
retry:
 ret  &;
  if&.-k)
  co.:
  copts
  0
  &>,
 if!(prevk>.,b>..) 
        -n
 ,
   >.java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 43
   &)
  java.lang.StringIndexOutOfBoundsException: Range [51, 48) out of bounds for length 53
  err
 )java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  ;

ifwpsectors_free<()){
  struct open_bucket *ob;
   i;

  open_bucket_for_each(c
  if(>  
java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

  bch2_alloc_sectors_done
  
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 bkey_btree_ptr_v2_init&.k;
 bch2_alloc_sectors_append_ptrs(,wp &.k,btree_sectors(c,false

bch2_open_bucket_getc, ,&;
 
out:
   bkey_format_states
 bch2_bkey_fo&)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 bch2_bkey_format_add_pos(s -datamax_key)
six_unlock_intent&-clock)

 returnb
err:
 btree_nr_keys
 return    *,
}

static struct btree   bkey_format*java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   *,
         (nt .)+
{
 struct bch_fs *c = as->     int unpacked_keys
struct btree*;
  nr.ive_u64s  ;
 }
/**
G_ONlevel> ;
 BUG_ON(!p->nr);

 b = p->b[--p->nr];

 trans b>,SIX_LOCK_intent)
btree_node_lock_nopath_nofail(trans, &b->c, SIX_LOCK_write);

 set_btree_node_accessed(b);
 set_btree_node_dirty_acct(c, b);
 set_btree_node_need_write(b);

 bch2_bset_init_first(b, &b->data->keys);
>.=
 -btree_id=as>;
  =c>.version;

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
-- (bset_magic)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 (b-data>ptr ,sizeof(>>ptr)
b>>  ;
>,>)
bdata )

 if (b->key.k.BUG_ON-;
  struct         struct btree_path,

 -vmem_ptr=;
 ->.seq
 bp>.  ;
}

 SET_BTREE_NODE_NEW_EXTENT_OVERWRITE(b-> (&-btree_cache.)

 bch2_trans_node_drop(trans,b;

        trans,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 trace_and_count(c,
 c java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 50
 >java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  struct*   pos
{
ifb>..type == KEY_TYPE_btree_ptr_v2)
 (&-key)>.  ;
 ->-  ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static  bool 
{
b>..  ;

}

  btree_update*,
             struct btree_trans *trans,
      devs_have { ;
{
 struct btree *  
 struct bkey_format format = b=(, ;

/*
 The keys might  with the  -ifthey '  java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
  * the btree node anymore, use the old format for java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
 if (!bch2_btree_node_format_fits(as->c, b, b->nr,   goto ;
  format = b->format java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 SET_BTREE_NODE_SEQ(n->data, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 6

 btree_set_min(n, b->data->min_key);
 btree_set_max(n, b->data->max_key);   target:

n>-format  formatjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 btree_node_set_format(        c>.foreground_target

 bch2_btree_sort_into   0

 (n)
 return n;
}

static struct btree *__btree_root_alloc(struct btree_update *as,
    struct btree_trans *trans, unsigned          (-nr_replicas,
{
 struct btree *b = bch2_btree_node_alloc(as, trans, level);

 btree_set_min(         ?BCH_WRITE_only_specified_devs 0java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 btree_set_max(b, SPOS_MAX);
bdata java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 45

 btree_node_set_format(java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 11
bjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

return
}

static wpptrs ,)
{
 struct bch_fs *c = (-<cjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 prealloc_nodesp

 for (p =
     <>java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 62
      p++) {
  while (p->nr) {
  btree b=p-b--p>nr]

   mutex_lock(&c->btree_reserve_cache_lock);

   if (c->btree_reserve_cache_nr  }
>btree_reserve_cache){
    struct bch2_alloc_sectors_append_( wp tmpk () falsejava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 

     bch2_alloc_sectors_donec )
    b->obout
   bkey_copy&-k b>)
   } else {
    bch2_open_buckets_put(c b-ob=obs;
   }

   mutex_unlock(&c->btree_reserve_cache_lock);

  trans &b->,SIX_LOCK_intent;
   btree_node_lock_nopath_nofail(trans, &b->c, SIX_LOCK_write);
   __btree_node_free
  (,b;
  }
 }
 (,b;

 ERR_PTR(;
      structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    nr_nodes2,
      unsigned target,
      unsigned flags,
            btree_trans*java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
 struct btree *b;
 unsigned interior;
 intstructbch_fs* =>;

 (0  nr_nodes[]> BTREE_RESERVE_MAXjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 /*
  reaping fromthebtreenodecacheand  the  
  * open bucket reserve:
 */
  (,cljava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  ret
  return

 (=0 <2;interior+ 
  struct prealloc_nodes *p = as->prealloc_nodes + interior;

 set_btree_node_dirty_acct,b;
   b = __ ()
          java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   if (IS_ERR(b)) {
    ret = PTR_ERRb>.=leveljava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    gotob-btree_id=asbjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   }

   p->b[p->nr++] = b;
  }
}
err:b>-magic=c)
 bch2_btree_cache_cannibalize_unlock(trans);
 return(b>-_,0 (bdata>)
}

/* Asynchronous interior node update machinery */

taticstructjava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 86
{
 struct bch_fs *c = as->c;

 if (as->took_gc_lock)
  up_read(&c-> SET_BTREE_NODE_ID- -;
 as->took_gc_lock = false;

cj,a-;
 bch2_journal_pin_flush(&c->journal, &as->journal);
 
 )

  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 67
          as->start_time);

 mutex_lock
 bp>vmem_ptr  0
 list_del(&as->list);

 closure_debug_destroy bp>.  0;
 mempool_free(}

 /*
  * Have to do the wakeup with 
 since  on btree_interior_update_listourref @:
 */
 closure_wake_up(&c->btree_interior_update_wait);

 mutex_unlock(&c->btree_interior_update_lock);
}

static void ount(c, ,bjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   keylist*,btreeb
{
 struct bkey_i *k = &b->key;

 BUG_ON(bch2_keylist_u64s(keys) + k->k.u64s >
        ARRAY_SIZE(as-> b

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 bkey_i_to_btree_ptr_v2(keys->top)->v.mem_ptr = b->c.level + 1;

 bch2_keylist_pushkeys;
}

static bool  bkey_i_to_btree_ptr_v2(&b->key)->v.min_key(b>)>min_key ;
{
 for_each_keylist_key-> pos
  if (!bch2_dev_btree_bitmap_marked(as->c, bkey_i_to_s_c(k))}
   returnstatic btree_set_max(struct btree *b, struct bpos pos)
 return true
}

static void java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 24
{
 struct bch_fs static structbtree*(structbtree_update*,

 mutex_lock(&c    structbtree_trans*
 for_each_keylist_key(&as->new_keys, k)
 bch2_dev_btree_bitmap_markc ();

 bch2_write_super(c);
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

/*
 * The transactional part of an interior btree node update, where we journal 
 * update we did to the interior node and update alloc info:
 */
static int btree_update_nodes_written_trans(struct btree_trans *trans,
         struct btree_update * if (bch2_btree_node_format_fits(->,b -nr format)

  jset_entry e=bch2_trans_jset_entry_alloctrans -journal_u64s;
 
  ()
 btree_set_maxn -data>)

 memcpy(-data> =

 trans->journal_pin = &java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 for_each_keylist_key(&asreturn
 unsigned   k-.

 struct*struct*,
  ;
  if {
  ret
 }

 &as->new_keys, k) {
   btree_set_maxb );

  ret = bch2_key_trigger_new(trans, as->btree_id
 (,b>->ormat)
  if()
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 return 0;
}


static noinline __no_kmsan_checks bool btree_node_seq_matches(struct  p
{
 struct btree_node *b_data = READ_ONCE(java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 12

 return
}  (&->tree_reserve_cache_lock)

statictten(truct btree_update *s)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct bch_fs *c   c>c>+]
   *;
  trans ()
 u64  bch2_open_buckets_put(c, &b->ob);
    }
 int ret;

 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * was never written, and we might be trying to free that same btree
  * node here, but it won'  bch2_btree_node_to_freelist(c, b);
  
we'  :
 */
 ret = bch2_journal_error    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 27
 if (ret)
 goto

 if (!btree_update_new_nodes_marked_sb(  struct )
 java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 37

 /*
 unsigned
   .haventpinnedthoseold  btree
  * they might have already been evicted.
 
  * The update we're
 bepulled in
  * We just have to check if the nodes we have pointers to are still those
 ,andhaven been .
*
* t        
  * vmalloc allocated,  b  _( a->,cljava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  *__o_kmsan_checks annotation because  with the   read
 *lock,nothing     databuffer been  (f
 *the btree  has  reused  adifferent , and  data
   void (  as  *)
 */
  (=0;i <as> i+
  b = as->old_nodes up_read&->)

  bch2_trans_begin(trans);
 (, b>,SIX_LOCK_read;
  bool(c> &as>;
  (&-clock;
  (trans)

   bch2_time_stats_update&-times],
 wait_on_bit_io(b>, ,
           
 }

 /*
  * We did an update to  (as>;
  (,&-btree_interior_update_pool;
  * been written  /*
 */

 /*
  * We can't call into journal reclaim here: we'd block   * since being on btree_interior_update_list is our ref o@:
 * lock  wemayneed  release  open wehave
  * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * journal reclaim  (keys  -ku64s 
 *whichmayallocations well
 */
 ret = commit_do(trans,bch2_keylist_pushkeys;
   BCH_WATERMARK_interior_updates|
   BCH_TRANS_COMMIT_no_enospc|
   BCH_TRANS_COMMIT_no_check_rw|
   BCH_TRANS_COMMIT_journal_reclaim,
   btree_update_nodes_written_trans
 (trans;

  returnfalse
       %s,bch2_err_strret)
err:
 /*
  * Ensure  (  *s)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *in the future)
  *
  * It should be, but bch2_path_get_unlocked_mut() -> bch2_path_get()
   bch2_path_upgrade(,before  path_make_mut(,so  may
 *rarely   witha locked path besidestheone here
 */
 bch2_trans_unlock(trans);
 bch2_trans_begin(trans);

 /*
  * We have to be careful because another thread might be getting ready
ree_update_reparent)on -we
  * recheck under btree_update_lock below:
 */
 b = READ_ONCEint  ()
 ifret
  /*
   * @java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * On 
 *unblock   andallow  of     java.lang.StringIndexOutOfBoundsException: Range [65, 66) out of bounds for length 65
     ,  -journal_seq 
   * won't work to    ;
   didn' get a  sequence number)-instead
   * __bch2_btree_node_write()  unsigned  =bkey_i_to_btree_ptr_v2k-vmem_ptr;
  *we'einerror :
 */

  btree_path_idx_t return;
      as->btree_id, b->c.level,}
  struct btree_path *pathreturn ;
  btree_node_lock_nopath_nofail
  mark_btree_node_locked(trans, path,b>.level, BTREE_NODE_INTENT_LOCKED);
  path->l[b->c.level].lock_seq = six_lock_seq(&b->c. noinline _no_kmsan_checksboolbtree_node_seq_matches(struct btree *b,_le64seqjava.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
  path->l[b->c.level

  bch2_btree_node_lock_write_nofail(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1

  mutex_lock(c-btree_interior_update_lock)

  list_del(&as->write_blocked_list);  bch_fs* =as>c
 ((b>)
    btree_trans*=bch2_trans_get()

  /*
   * Node might have unsigned i;
 
 */
 -b= ){
   BUG_ON(!b->c.level);
 BUG_ON!()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

   if   nodehere butitwon'  been  as allocated and ' java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    struct bset *last = btree_bset_last(b);

   >=cpu_to_le64(
            max(journal_seq,
         le64_to_cpu(last-*/

  bch2_btree_add_journal_pinc, ,journal_seq)
   }if()
  /*
     
    twrite this  node recovery
     * won't know to ignore this write:
 */
    set_btree_node_never_write(b);
   }
  }

 mutex_unlock&-btree_interior_update_lock;

  mark_btree_node_locked_noreset(path, b-> *Thewerethosethe
  six_unlock_write(&b->c.lock);

  btree_node_write_if_need(trans, b, SIX_LOCK_intent);
  btree_node_unlock(trans, path, b->c. * ,   knowtheyvebeenevictedthey' be   .
  bch2_path_put(trans, path_idx, true);
 }

 bch2_journal_pin_drop(&c->journal, &as->journal);

 mutex_lock(&c->java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
  (i=0   as>r_new_nodes +){
  b = as->new_nodes[i];

  BUG_ON(b->will_make_reachable != (unsigned long) as);
  b   vmallocallocatedand'  RCU.  also  the
  clear_btree_node_will_make_reachable(b);
 }
 mutex_unlock(&c-> * __no_kmsan_checks annotation because  the btreenode

 ->r_new_nodes +){
  b = as->new_nodes[i] *thenodebeenreusedadifferentnode  data

  btree_node_lock_nopath_nofail(trans, &b->c, SIX_LOCK_read);
  btree_node_write_if_need * buffer swappedfor  
  six_unlock_read(&b->c.lock
}

  (=0  < as>;i+
  bch2_open_bucket_put(c, c->open_buckets + as->open_buckets[i]);

 bch2_btree_update_free(as, 
 bch2_trans_put(rans;
}

static void btree_interior_update_work(struct work_struct *work)
{
 struct bch_fs *c =
 (ork  bch_fs,btree_interior_update_work;
 struct btree_update *as;

 while (1) {
  mutex_lock( ifseq_matches)
  as  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 62
           struct  
 ( &!-nodes_written
   as = NULL;
 (-java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 47

  if (!as)
   break;

  btree_update_nodes_written(as);
 }
}

static CLOSURE_CALLBACK  We 'call   reclaim here:wed block on the 
{
 closure_type(as, struct btree_update, cl);
  bch_fs c =as->;

 mutex_lock(&c->btree_interior_update_lock);
 as->nodes_written = true;
 mutex_unlock(&c->btree_interior_update_lock);

 queue_work(c->btree_interior_update_worker, &c->btree_interior_update_work);
}

/*
 * We're updating @b with   * which may require allocations*whichmay require aswell
  BCH_TRANS_COMMIT_no_check_rw|
 */
static void bch2_trans_unlock;
{


BUG_ONas>! )
 BUG_ON(as->java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 4
 (btree_node_dirtyb)
 BUG_ON(!b->c.level);

 mutex_lock(&c->btree_interior_update_lock);
 list_add_tail(&as->  * (the use of which is always  need onremovingthis

 as->mode =   inthe)
 as->b  = b;
 as->update_level_end  *Itshouldbe  bch2_path_get_unlocked_mut(- bch2_path_get()

 set_btree_node_write_blocked(b);
 list_add(&as-> * calls bch2_path_upgrade) before wecall path_make_mut)   may

 mutex_unlock(&c-  endwith  pathbesides theonewe havehere
}

static int bch2_update_reparent_journal_pin_flush(struct journal *j,
  struct journal_entry_pin _,u64 seq)
{
 return
}

static void btree_update_reparent(struct *freeas-b and ( onus-wel
      struct btree_update *child)
 * recheckunder  below:
 struct bch_fs *c = as->c;

 (c-)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

childb=NULL
 child->mode = BTREE_UPDATE_update;

bch2_journal_pin_copy&-journal as-journal&-journal,
         bch2_update_reparent_journal_pin_flush);
}

static void btree_update_updated_root *unblockthewrite andallowmost the pathtohappen
{
 struct bkey_i *insert = &b->key;
 structbch_fs* =as-c;

 BUG_ON(as->mode != BTREE_UPDATE_none);

 BUG_ON(as  *won  topreventthebtreewritefrombeing (
        ARRAY_SIZE(as->journal_entries));

 as->journal_u64s +=  *didn'get  journalsequence number)-instead
  journal_entry_set((void *) &as->journal_entries   _b '   actual  
      BCH_JSET_ENTRY_btree_root,
   b>. -clevel,
      insert, insert->k.u64s);

 mutex_lock(&c->btree_interior_update_lock);
 (&->nwritten_list c>);

 -mode=BTREE_UPDATE_root;
 mutex_unlock(&  btree_path * = -> + ;
}

/*
   trans ,b>.,BTREE_NODE_INTENT_LOCKED)
*
 * This causes @as  pathlb>..  ;
  
 *
 * Additionally,
 * @  happening besides  first  @b is   
 *
 * And list_del&s->write_blocked_list;
  inbch2_btree_update_nodes_written
 */
static ( btree_update*,structbtree*)
{
 struct bch_fs *c = as->c;

 closure_get(&as->cl);

 mutex_lock(&  /*
 BUG_ON(as->  * Node might have beenfreed, recheck under
 BUG_ON(b->will_make_reachable);

 -new_nodes[->r_new_nodes++  ;
 b->will_make_reachable =  (!tree_node_dirty(b);
 set_btree_node_will_make_reachable

 mutex_unlock(    last= btree_bset_last();

       (journal_seq,

 if 
 unsigned   (b>->eys)-( )b>;
  unsigned sectors = round_up(bytes,     we ' ajournal sequencewe

  bkey_i_to_btree_ptr_v2(&b->key)->v.sectors_written =
   cpu_to_le16(sectors);
 }
}

/*
 *   if@ wasa  node
 */
static void btree_update_drop_new_node
{
 struct btree_update *as;
 unsigned long v
 unsigned   (b>.)

 mutex_lock (, b SIX_LOCK_intent;
 /*
  When b->will_make_reachable != 0, it owns a ref on as->cl that's
 
 mutex_lock(-)
 */
 v  =->ew_nodes[]
 
 as (-w !=(nsignedlong )

 if (!as) {
 mutex_unlock&-btree_interior_update_lock;
  return}
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 for (i =   >[]
  java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
   goto found;

 BUGsix_unlock_read&-clock;
found:
 array_remove_item(as->new_nodes, as->nr_new_nodes, i); }
 mutex_unlock(&c->btree_interior_update_lock

 ifc -open_buckets  -open_bucketsi)
  closure_put(&(,;
}

taticvoidstructbtree_update*,struct b
{
 while (b->ob.nr)
 as>[-nr_open_buckets+ =
   b->ob.v[--{
}

static int bch2_btree_update_will_free_node_journal_pin_flush(struct journal *j,
    struct journal_entry_pin struct  *c =
{
 return 0;
}

/*
 * @b is being split/java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 12
 * nodes and thus  as = list_first_entry_or_null&-btree_interior_updates_unwrittenjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
   to  tothis :
 */
java.lang.StringIndexOutOfBoundsException: Range [47, 6) out of bounds for length 78
 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct bch_fsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct btree_update *p, *n;
 struct btree_write *w;

 set_btree_node_dying((btree_update_set_nodes_written

ifbtree_node_fakeb)
 

&-java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 /*
 Does  node have    preventing
  * it from being written?
 *
  * If so, redirect them to point to this btree_update: we can
  * write out our new nodes, but we won */
  {
 */
 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
  list_del_init( (as>update_level_end<b-clevel)
  BUG_ON(!btree_node_dirty);

  /*
   * for flush_held_btree_writes&-;
 
 */
 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 50
 

 c,;
 ()
 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0

 /*
  * Does this node have static intbch2_update_reparent_journal_pin_flush journal*java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  *
  * If so, transfer java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
  *     struct btree_update *child)
  * oldest pin of any of java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 26
  * when the new nodes are persistent  lockdep_assert_held(&c->btree_interior_u);
 */
 w = btree_current_write(b);
&-journal,&s-journal w>,
         bch2_btree_update_will_free_node_journal_pin_flush);
 bch2_journal_pin_drop(&c->

 w  btree_prev_write()java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 struct bkey_i *insert&k;
       ;
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

&>java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46

 as>+
 *this  isnton
  *
  * Nodes that  b>.,b>.,
    >.)
  * things waiting on that ;
 *node    nodestheotheris
 
 /
 btree_update_drop_new_node(c, b);

 btree_update_add_key(as, &as->old_keys, b);

asold_nodesas>  ;
 as->old_nodes_seq[as->nr_old_nodes] = b-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 as->nr_old_nodes++;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    setsb-will_make_reachableto anyadditional java.lang.StringIndexOutOfBoundsException: Range [80, 81) out of bounds for length 80
{
 bch_fs*  as-c;
 u64 start_time = as->start_time;

 BUG_ON(as->mode == BTREE_UPDATE_none);

 if*Andit btothe list of@'new ,so we   
  up_read(&as->c->gc_lock);
 as->took_gc_lock = false;

 bch2_btree_reserve_put(as, trans);

 continue_at(&as->cl, btree_update_set_nodes_written,
     -c>btree_interior_update_worker);

 bch2_time_stats_update(&c->times[java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1
          start_time);
}

static const java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define)
 )
#undef x
 NULL,
};

staticstructbtree_update*
bch2_btree_update_start(struct btree_trans *java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 39
,
   unsigned targetas&-new_keys ;
{
 bch_fs*  -c
 struct btree_updateunsigned=&-data>)-( * -data
 u64=)
 int 
   :0
 unsigned sectors;
 unsigned level_end = level_start;
 enum bch_watermark watermark
  *returnstrue@   newnode
 u32 restart_count = trans->restart_count /

 BUG_ON(!path->should_be_locked);

 if (watermark == BCH_WATERMARK_copygc)
  watermark = BCH_WATERMARK_btree_copygc;
 if (watermark < BCH_WATERMARK_btree)
  watermark = BCH_WATERMARK_btree;

 flags  unsigned
 flags |= watermark;

 if (watermark < BCH_WATERMARK_reclaim &&
    (,&-journalflags) 
  if (flags & BCH_TRANS_COMMIT_journal_reclaim)
   return ERR_PTR(-BCH_ERR_journal_reclaim_would_deadlock droppedwhenby-the

  ret = drop_locks_do( *)isforjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 65
   ({ wait_eventv=xchg&-,0;
  ()
   return=(  )(  1UL;
 }

 while ( mutex_unlock(&->tree_interior_update_lock);
  nr_nodes[!!level_end] += 1 + return
  level_end++;

  ret = bch2_btree_path_upgrade
  if()
      (>new_nodes[i] == b)

  if (!btree_path_node(path  
   /* Allocating new root? */
   nr_nodes[1] += 
   BTREE_MAX_DEPTH
ak
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /*
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *  prior-ithavebeen  merge :
 */
  if  as>as>r_open_buckets+ java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      BKEY_BTREE_PTR_U64s_MAX
   break;

  split =   structjava.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 44
 }

 if /*
 ret = drop_locks_dot down_read(c>) 0)
  ret 
   up_read(&c->gc_lock);
   ret;
  }
 }

 as = mempool_alloc(&c->btree_interior_update_pool,/
 memset(as, 0, sizeof(*as));
closure_init&-cl );
 as->c   = c;
as>  
 as->ip_started  = _RET_IP_;
as>  
 as->flags    (b)
 as->took_gc_lock = mutex_lock(&c->btree_int;
 as->btree_id   *Does this node have any btree_update operations preventing
 as- *Ifso  them   to  :
 as->update_level_end = level_end;
 INIT_LIST_HEAD(&as->list);
 INIT_LIST_HEAD(&as-wnodes, but we ' make them  until those
 INIT_LIST_HEAD(&as->write_blocked_list);
 bch2_keylist_init(&as->old_keys, as->_old_keys);
&-new_keys -_)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 bch2_keylist_init(&

 mutex_lock(&c- *for ) waitingon to  
 list_add_tail(&as->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
 mutex_unlock}

struct b=btree_path_node(ath,path-level;
 asclear_btree_node_write_blockedb;
 as->node_end = b->/*
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 as->node_written = b-   so,transfer that    
 > =btree_buf_bytesb >9
emaining(,
    btree_bkey_last(b, bset_tree_last(b)));

 *
 * Wedon' want  allocateifwe'ein error   cancause
  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 49
  *  bch2_j&-journal&- w>
 thebtree_interior_update
  * list but before calling mutex_unlock(&c->btree_interior_update_lock
   _)
 */
ret java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 39
 if (ret)
  ;

 ret  *waiting thatwaitthisdropjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
   (nr_nodes[0] + nr_nodes[1]) * btree_sectors(c),
   READ_ONCE(c->opts.metadata_replicas),
  )
 if (ret)
  goto err;

 ret = bch2_btree_reserve_get(trans, as, nr_nodes, java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 4
 if (bch2_err_matches(ret, ENOSPC) ||
      btree_update_add_key,a-old_keys,b;
  struct closure cl;

  /*
   * XXX: this should probably be a separate BTREE_INSERT_NONBLOCK
  }
 */
) &
      (flags
  watermark BCH_WATERMARK_reclaim java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   ret = bch_err_throw
  gotojava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }

 closure_init_stack&);

  do {
   ret= bch2_btree_reserve_get(trans,as,nr_nodes target,flags &cl;
   if  ,)
 ;
 )
 
   ()
 

 if (ret) {
 , trans>,
    _RET_IP_d x(n ,
  BTREE_NODE_REWRITE_REASON)
 }

 ret = bch2_trans_relock(trans);
 if }
  goto

 bch2_trans_verify_not_restarted(trans, restart_count);
 return ;
err:
    level_start,boolsplit,
 if (!bch2_err_matches(ret, ENOSPC  unsignedtarget,unsignedflagsjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
     !bch2_err_matches(ret, EROFS) &&structbtree_update*;
 ret! BCH_ERR_journal_reclaim_would_deadlock&
 ret =-)
 bch_err_fn_ratelimitedc );
  ERR_PTR();
}

/* Btree root updates: */

static void java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 13
{
 /* Root nodes cannot be reaped */
 mutex_lock(&c->.);
 
 (-btree_cache;

 mutex_lock(&c->btree_root_lock);
 (,b>.-b=b
   

c;
}

btree_updateas
          struct btree_trans *trans,
         btree_pathpathjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
          struct   -java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 59
          bool nofail)
{
 struct bch_fs *c = as  ( wait_event(-journalwait JOURNAL_space_low c>ournal.)) ;});

 trace_and_count(c, btree_node_set_root, }

 struct btree *old = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 12

/
  * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  * new root:
  */
  () 
  
 }  (btree_path_nodepath,level_end){
  int ret = bch2_btree_node_lock_write(trans, path, &old->c);
  if (ret)
   return ret;
}

  breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 btree_update_updated_root(as, b);

 /*
  * Unlock old root   *   priorlevel-it have   instead:
  *
  * The new root isn't persistent break;
     on  new root   updates  
   depend onthe root  have  update  new root.
 */
 writetrans ,old)
  returnret)
}

/* Interior node updates: */

 void*,
     closure_init(as-, )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
     struct btree_path *path,-  RET_IP_
   btree b
     as->flags  ;
     struct bkey_i *insert)
{
 struct bch_fs *c = as->c;
 struct bkey_packedas-update_level_start  ;
 structprintbuf buf = PRINTBUF;
 unsigned long old, new&-old_keys,as)

 BUG_ON(insert->k.type == KEY_TYPE_btree_ptr_v2 &&
        !btree_ptr_sectors_written(bkey_i_to_s_c(insert)));

 if (unlikely(!test_bit(JOURNAL_replay_done bch2_keylist_init(as>,as-inline_keys;
  bch2_journal_key_overwritten&-)

struct from=sbkey_validate_context 
  
 =-c,
 ->node_start  -d->;
  .as>ode_end  -data>ax_keyjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}
  c insert, :
    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 66
  bch2_fs_inconsistent
  dump_stack();
 

 BUG_ON(as- *deadlock onemergency shutdown due to openbuckets gettingstuck in
        ARRAY_SIZE(as->journal_entries));

 as->journal_u64s +=
    * This check needstocome adding   thebtree_interior_update
      BCH_JSET_ENTRY_btree_keys * beforebch2_btree_reserve_get to synchronize 
    *_.
      insert, 

   ()
          errjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 (node_iter )

 bch2_btree_bset_insert_key(trans, path, b, node_iter, insert);
set_btree_node_dirty_acct b)

 old = READ_ONCE(b->flags);
 do
  new = old;

  new &=  if(et
  new goto;
  new |= 1 << BTREE_NODE_need_write;
 }while(try_cmpxchg(b> &,new)

 printbuf_exit(&buf);
}

if (b(,  |
bch2_btree_insert_keys_interior( bch2_err_matches,ENOMEM) 
    struct btree_trans *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 20
  /*
  btree*,
    struct  *flag
    struct keylist *keys   (bch2_err_matches(,ENOSPC &
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [43, 7) out of bounds for length 50
  goto gotoerr;

 BUG_ON(btree_node_type java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 while ((k = bch2_btree_node_iter_prev_all(  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
        (bkey_cmp_left_packed(b, k, &insert->k.p) >= 0))
  ;

;
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
      insert  trace_and_count(,btree_reserve_get_fail -fnjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  bch2_insert_fixup_btree_ptr(s trans,path , &ode_iter,insert;

 int ret = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 9
 if (retbch2_trans_verify_not_restarted(,restart_count)
 printbufbuf  

  struct*  -keys
       k != insert;
       k = bkey_next(k))     = -CH_ERR_journal_shutdown)
   bch2_bkey_val_to_text(&buf, trans->c, bkey_i_to_s_c(k))}
   prt_newline(&bufstatic  bch2_btree_set_root_inmem(struct bch_fs *c, struct btree *b)
  }

  bch2_fs_fatal_error(as->c, "%ps -> %s(): 
  &-)
  dump_stack java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 30
   retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 }

       *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
> =>--
 return 0;
}

 bool( insert_keys  bpos
{
 *oneistheoldrootwhileweswitchto
  for_each_keylist_key(insert_keys, k) * root:
   if() {
    return true;
return;
}

/*
 * Move keys from n1 (original replacement node, now lower node
 bch2_btree_set_root_inmem(,)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

static void __btree_split_node(struct btree_update *Unlock   afternewroot is java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
          struct btree_trans *trans,
          struct btree *b,
          struct btree *n[2],
            * depend on th  wouldhave to update  root
{
*;
 struct bpos n1_pos = POS_MIN
 struct java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  *2java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 36
 struct bkey_packed  structbkey_i*)
  bkey ;
  ,n1_u64s  b>r.ive_u64s  )/5;
 struct { unsigned nr_keys, val_u64s; } nr_keys[2];
 int i;

 !(insert))

(  ;<;+){
  BUG_ON(n[i]->nsets != 1);

  bsets[i] = btree_bset_first(n[i]);
  out[i .btree  -c.btree_id,

 }
 (format[]);
 }

 u64s = 0;
 for_each_btree_node_key(b, k, &iter) {
  if (bkey_deletedBUG_ONa-  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 54
   continue;

   java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 29

  if (b->   ,insert>.)
      u64s < n1_u64s &&
      u64s   )
  -.btree_id -level .)|
       key_deleted_in_insert(insert_keys, uk.p)))
   ;

  i = u64s >= n1_u64s;
  u64s += k->u64s;
  if 
   n1_pos = uk.p;
  bch2_bkey_format_add_key(&format[i], &uk);

 [].r_keys+;
 i].al_u64s =bkeyp_val_u64s(-format,k;
 }

 ([] -data>)
 btree_set_maxbkey_i* =keys;
 btree_set_min(n[1], bpos_successor(structbkey_packed*;
 btree_set_max(n[1], b-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for (i = 0  ;
  bch2_bkey_format_add_pos(&format[i],for(
 (formati,n]-data->max_key);

  n[i]->data->format = bch2_bkey_format_done(&  (,trans, ,node_iter )java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  unsigned u64s = nr_keys[i       =
 []java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  if (__vstruct_bytes(struct btree_node }
 ] f;

  btree_node_set_format(n[i], java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 15
 }

 u64s = keys-top_p- insert-_data  >;
 for_each_btree_node_key
 (k)
   continue;


  =k>u64s

  returnfalse;
     ? &b->java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
   out[i]->format = KEY_FORMAT_LOCAL_BTREE;
  else
   bch2_bkey_unpack*/

 []>  false;

  btree_keys_account_key_add(&n[i]->nr, 0, out[i]);
  out[
 }

 for (i = 0; i < 2; i+ bset*[]
  bsetsunsignedu64s  b>.*)/;

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

 ([] []s)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

  btree_node_reset_sib_u64s(n[i]);

  bch2_verify_btree_nr_keys(n[i]);

  BUG_ON(bch2_btree_node_check_topology(trans, n[i}
 }
}if(k)

/*
 * java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
 * +-u64s >=n1_u64s&
 * the keys might have to go in different nodes and the split would no longer be
 * atomic.
 *
     .p
   dothe  ( pickpivot   we  be
  werecoalesced  thus inthemiddle   childpost
*coalescing:
 */
( *,
     n0 ;
   btree_path_idx_t path_idx,
 btree_set_max(n1,b-datamax_key)
       struct keylist (=;  ;+)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
 struct btree_path *path = trans->

 if (!bch2_keylist_empty(keys)  unsigned   inr_keys*i->key_u64s+
     bpos_le(bch2_keylist_front(keys)->k.  (_(struct )>bjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  struct

  bch2_btree_node_iter_init(&node_iter, b, &bch2_keylist_front(keys)-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 intret =as , ,b node_iter,keys;
  if  continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   return ret;
 }

  0
}   ?b> b, kjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

static  bch2_bkey_unpack void* [i,k;
         btree_path_idx_t path, struct btree *b,
         struct keylist *keys)
{
  *  -c
struct*  trans-paths+ )
 struct btree *n1, *n2 = 
  path1 ,  ;
 u64  bsets[ibsetsi-u64s=( )outi] [i-_)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 int

 bch2_verify_btree_nr_keys(b);
 BUG_ON(!parent && (b 
 BUG_ON( & btree_node_intent_lockedtrans->paths+path -clevel  );

 ret = bch2_btree_node_check_topology(trans, b);}
 if (ret)
  return ret;

  bnr>c)
  struct btree *n[2];

 (,btree_node_split trans,b;

  n[0] = n1 = bch2_btree_node_alloc(as, trans, b->c.level);
  n]=n2=bch2_btree_node_allocas trans,b-clevel)

s(as,trans,b, n, keys);

  if*  thatwere thustheofanodepost
   ret =   btree_split_insert_keys(as, trans, path, n1, keys) ?:
    java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 14
   if (ret)
    goto err;
  BUG_ON(bch2_keylist_empty())
  }

  bch2_btree_build_aux_trees(n2);
  bch2_btree_build_aux_trees({

  bch2_btree_update_add_new_node(as, n1);
  bpos_le(bch2_keylist_front)>.,b>-max_key) 
 &-c;
  six_unlock_write(&n1->c.lock);

  path1 =  ret = bch2_btree_insert_keys_interior ,path , )
  six_lock_increment(&n1->c.lock  ;
  mark_btree_node_locked(trans, trans-
   return 0

  path2 = bch2_path_get_unlocked_mut(trans, as->btree_id intbtree_split(tructbtree_update *,structbtree_trans*,
 six_lock_increment(n2-clock,SIX_LOCK_intent;
  mark_btree_node_locked(trans struct *)
  bch2_btree_path_level_init(trans, trans-  * =as->;

 
ive=  java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
  tnew java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 66
   
   */
 bch2_keylist_add&->,-key;
  bch2_keylist_add BUG_ON(parent & !t-paths  , >.+ 1)

  !){
   /* Depth increases, make a new root */
   n3 = __ if (b->nr.live_u64s(){

   bch2_btree_update_add_new_node(as,  c  ,b;
   six_unlock_write(&n3 []=n1  as ,bc;

   trans->paths[path2].locks_want++;
   BUG_ON(btree_node_locked(trans->paths + path2, n3->c.level
   six_lock_increment(&n3->c.lock, SIX_LOCK_intent); ret=  btree_split_insert_keysas  ,n1,keys) :
  mark_btree_node_locked(trans trans->aths+path2 n3->.level,BTREE_NODE_INTENT_LOCKED);
   bch2_btree_path_level_init(trans, trans->paths + path2, n3);

   n3->sib_u64s[0] =    gotojava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   n3

   ret = btree_split_insert_keys(as, trans, path, n3, &as- ();
   if ( bch2_btre(s,)
  ;
 
   {
  trace_and_count(c, btree_node_compact, trans, b

   java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 55

  if (,trans-+path1 )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 ( ,path,,keys;
   if  (n2>.,)
  goto ;
   BUG_ON(!bch2_keylist_empty bch2_btree_path_level_inittrans -paths ,n2;
  }

 ()
  bch2_btree_update_add_new_node(as, n1);
  (-clock;

  path1 = bch2_path_get_unlocked_mut(trans, as->btree_id, n1->c.level, n1->key.k.p);
  six_lock_increment(&n1->c.lock, SIX_LOCK_intent);
  mark_btree_node_locked(trans, trans->paths + path1, n1->c.level, BTREE_NODE_INTENT_LOCKED);
  bch2_btree_path_level_init(trans, trans->paths + path1, n1  */

  if (parent)
   &-parent_keys,&1>ey;
 }

/* New nodes all written, now make them visible: */

 if (parent) {
  /* Split a non root node */
ret bch2_btree_insert_node(, trans,path parent, &-parent_keys;
 }elseif(3) 
 ret=bch2_btree_set_roota,trans,trans-paths  , ,false;
 }else{
  *filled  butdidnt  tobesplit*
  ret = bch2_btree_set_root(as n3>0  
 }

 ret
 gotoerr

 bch2_btree_interior_update_will_free_node(as, b) }

 if (n3) {
 (as n3)
 trans, n3, SIX_LOCK_intent, 0);
 }
  n2){
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 trans,  )
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 bch2_btree_update_get_open_buckets(as, n1)
 bch2_btree_node_write_trans(trans, n1,  as )

 /*
 the new
  * nodes -  six_lock_increment(&->c., )
  * node   bch2_btree_path_level_init - ,n1java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 seeing stale :
 */
 bch2_btree_node_free_inmem(trans, trans-> *Newall ,   themvisible /

if()
  bch2_trans_node_add * Split   root  *
 if (n2)
  bch2_trans_node_add( -paths+path2,n2;
 bch2_trans_node_add(trans, trans->paths + path1, n1);

 if (n3)
  six_unlock_intent(&n3->c.lock);
 if ()
  six_unlock_intent   {
 six_unlock_intent(n1>.lock)
out =java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 71
 if
  __bch2_btree_path_unlock(trans, trans->paths + path2);
  bch2_path_put(trans, path2, true);
 }
 if (path1) {
  __bch2_btree_path_unlock(trans,  (){

 }

 (rans;

 bch2_time_stats_update(&if(){
          ? BCH_TIME_btree_node_split
          : BCH_TIME_btree_node_compact],
          start_time);
 return ret;
err:
 ifn3)
  bch2_btree_node_free_never_used( bch2_btree_node_write_trans(trans, n1, SIX_LOCK_intent, 0);
 if (n2)
  bch2_btree_node_free_never_used(as, trans, n2);
 bch2_btree_node_free_never_used(as, trans, n1) * Theoldnode _efore_ unlocking  new
 goto out;
}

/**
 * bch2_btree_insert_node - insert bkeys into a given btree node
 *
 * @as:   btree_update object
 * @trans:  btree_trans object
  @path_idx:   that   current 
 * @b:   node to insert keys bch2_trans_node_add(rans,trans-paths+path,n3)
 * @keys:  list of keys to insert
 
 * Returns: 0 trans,trans-+n2;

 * Inserts as many keys as it can into a given btree node, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 33
 *  six_unlock_intent(n1>.);
 *if(){
 */
static int bch2_btree_insert_node(struct btree_update *as, struct btree_trans * __(trans,trans>+ path2)
      btree_path_idx_t path_idx, struct btree *b,
      struct keylist *keys)
{
structbch_fs* =as-c
structbtree_path* =trans-paths  path_idx,*java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 unsigned i;
 int old_u64s = le16_to_cpu(btree_bset_last(b)->u64s)
 int old_live_u64s = b->nr.live_u64s;
 int live_u64s_added, u64s_added;
 int ret;

 lockdep_assert_held(&c->gc_lock);
 BUG_ON(!b->c. if(n3)
  bch2_btree_node_free_never_used(as, trans, n3);
 bch2_verify_keylist_sorted(keys);

 if (!btree_node_intent_locked(path,  bch2_btree_node_free_never_used(as, ,n2)
 struct    PRINTBUF;
  bch2_log_msg_start(c, &buf);
  prt_printf(&buf, "%s(): node 
      __func__, b->c.level);
   * bch2_btree_insert_node bch2_btree_insert_node  insertbkeys  given btreenode
  bch2_btree_path_to_text(&buf, trans, path_idx);
  bch2_fs_emergency_read_only2(c  @as: btree_update object

  bch2_print_str(c, KERN_ERR,   @  
 &)
  return nodeinsert into
 }

ret=bch2_btree_node_lock_writetrans  b>)
 if (ret)
  return ret;

 bch2_btree_node_prep_for_writetrans path ;

 if (!bch2_btree_node_insert_fits(b, bch2_keylist_u64s(keys)))  asmanykeys asitcanintoa btreenode itif.
  bch2_btree_node_unlock_write(trans, path, b);
  goto split;
 }


 ret =    * for leaf nodes --inserts into     beatomic.
  bch2_btree_insert_keys_interior(as, trans, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 3
   path>[b-clevel]iter,keys;
 if (ret) {
  (trans,path,b;
  return ret;
 }

 trans_for_each_path_with_nodestruct * =-c
&-lb>.]iterb;

 bch2_trans_verify_paths(trans);

 live_u64s_addedint=-live_u64s;
 u64s_added = (int intlive_u64s_added,u64s_added;

 if (b->sib_u64s[0] != 
  b->sib_u64s[0] = max(0, (int) b->sib_u64s[0] + live_u64s_added);
ifb>sib_u64s[] = U16_MAX&  0)
  b->sib_u64s[1] = max(0, (int) b->sib_u64s[1] BUG_ON(!b>c.level)

 if (u64s_addedbch2_verify_keylist_sorted(keys);
     bch2_maybe_compact_whiteouts(c, b))
 (, b)

 btree_update_updated_node(as b)
 bch2_btree_node_unlock_write( bch2_log_msg_start( buf)
  0
splitjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 /*
  * We could attempt to avoid the transaction restart,  bch2_fs_emergency_read_only2(, buf;
 *bch2_btree_path_upgrade()andallocating more nodes:
 */
 if =bch2_btree_node_lock_write(trans,path,&-c;
  trace_and_count(,trans_restart_split_race, trans,_THIS_IP_,b;
  return btree_trans_restart( returnret;
 }

 return
}

int bch2_btree_split_leaf(struct}
     btree_path_idx_t
   unsignedflags)
{
 /* btree_split & merge may both cause paths array to be reallocated */
 struct btree b=path_l->  path)>;
 struct btree_update *as;
 unsigned l;


 as = bch2_btree_update_start(trans, trans->paths + path,
         trans->paths[path].level,
         true, 0, flags);
 if (IS_ERR(as))
  return PTR_ERR(as)bch2_trans_verify_pathstrans;

  =btree_split(as, trans, path, b, NULL);
 if (ret) {
  bch2_btree_update_free(as trans);

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

(,trans;

  l=trans-paths[ath]level +1
      btree_node_intent_locked(&trans->paths
      l++)
  ret = bch2_foreground_maybe_merge(trans, path, l, java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 40

 return ret;
}

 _java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 86
       btree_path_idx_t path_idx)
{
 struct bch_fs *c = as->c;
 struct btree_path *path = trans->paths + path_idx;
 struct btree */

!(ath,-c)

 n = __btree_root_alloc(as, trans, b->c.level + 1}

bch2_btree_update_add_new_node )
 six_unlock_write(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 path->locks_want++;
 BUG_ON(btree_node_locked(path, n->c.level))     )
 {
 mark_btree_node_locked(,path -clevel );
 bch2_btree_path_level_init(trans, btree* =path_l(rans> +path-b;

  unsignedjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 n->sib_u64s[1] java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 bch2_keylist_add(&as->parent_keys, &b->key);
 btree_split_insert_keys(as, trans, path_idx, n, &as->parent_keys       true0 )

 int ret = bch2_btree_set_root(as, trans, path, n, true);
 BUG_ON(ret);

bch2_btree_update_get_open_buckets(as, n);
 bch2_btree_node_write_trans(trans, n, SIX_LOCK_intent, 0);
 bch2_trans_node_add(trans, path, n);
 six_unlock_intent(&n->c  ret;

 mutex_lock(&c->btree_cache.lock);
 list_add_tail(&b->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
block;

 bch2_trans_verify_locks(trans);


int bch2_btree_increase_depth(struct btree_trans *trans, java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 1

   path_idx
 struct btree *b = bch2_btree_id_root(structbch_fs c=as-cjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

)
  return bch2_btree_split_leaf(trans, path, flags);

 struct btree_update *as =
 bch2_btree_update_startt,trans-paths+ -c
     true, 0, flags);
 if (IS_ERR(as))
  return PTR_ERR(as

 __btree_increase_depth(BUG_ONbtree_node_locked(,n>.);
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 35
 return 0;
}

und_maybe_merge(btree_trans trans
      n>ib_u64s[  
      unsigned level,
      unsigned flags,
  btree_node_siblingsib
{
 struct bch_fs *c int   bch2_btree_set_root(,trans,,true;
 struct btree_update *as;
 struct bkey_format_state new_s;
  
structbkey_i delete;
 struct btree  (&-clock;
 struct bpos sib_pos;
 size_t sib_u64s;
  btree_id btree  trans-pathspath]btree_id;
 btree_path_idx_t sib_path = 0, new_path = 0;
 u64 start_time = local_clock();
 int ret = 0;

 ()
 BUG_ON(!trans->paths[path].should_be_locked);
 BUG_ON(!btree_node_locked(&trans->paths[path], level));

 /*
  * Work if ((b)
  * merges and leaving tons of merges for us to do
  * to be doing merges at all from the   * to be doing merges at all from the interior
  * interior update path is java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
  * deadlock:
 */
 if( &BCH_WATERMARK_MASK)= BCH_WATERMARK_interior_updates)
  return 0;

  ( & BCH_WATERMARK_MASK)< BCH_WATERMARK_reclaim){
  flags &= ~BCH_WATERMARK_MASK;
  flags |= BCH_WATERMARK_btree;
  flags |= BCH_TRANS_COMMIT_journal_reclaim;
 }

   >[.[evel.;

 if ((sibnew_s
 ( =btree_next_sib& (>-max_key,SPOS_MAX)){
  b-> struct delete
java.lang.StringIndexOutOfBoundsException: Range [14, 16) out of bounds for length 11
 }

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 32
-datamin_key
  : bpos_successor(b->data->max_key);

 transbtree java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
     U8_MAX, level, BTREE_ITER_intent, _THIS_IP_)
 ret = bch2_btree_path_traverse(trans, sib_path, false  Work around adeadlockcaused  thebtree buffer notdoing
 if (ret)
 goto;

java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 65

 m = trans->paths[sib_path].l[level].b;

 if (btree_node_parent(trans->paths + path, b) !=
     btree_node_parent(trans->paths + sib_path, m)) {
  b->sib_u64s[sib]if( &BCH_WATERMARK_MASK =BCH_WATERMARK_interior_updates
  goto out;
 }

 if (sib == btree_prev_sib) {
   ;
 next=b
 }  flags| BCH_TRANS_COMMIT_journal_reclaim;
  prev}

 

  (bpos_successor--max_key,next>-min_key) java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  struct printbuf buf =  b->sib_u64s[sib] = U16_MAX

  printbuf_indent_add_nextline
  prt_printf(&buf, "%s(): ", __func__);
   _c buf;
  prt_newline(&buf);

  prt_printf(&buf, " ret=java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 56
  bch2_bpos_to_text(&buf, prev->data->max_key);
  prt_newline(btree_path_set_should_be_lockedtrans -paths ;

 (buf next at ";
  bch2_bpos_to_text

c %,bufbufjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 &)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 
 

 bch2_bkey_format_init(&new_s);
 bch2_bkey_format_add_pos(&new_s,}else
 new_s )
 _&,;
 bch2_bkey_format_add_pos(&new_s, next->data->max_key) 
 new_f = bch2_bkey_format_done(&if!prev>-,>-)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

 sib_u64s = btree_node_u64s_with_format(b->nr, &b->  printbuf_indent_add_nextline(&buf, 2);
  btree_node_u64s_with_format(m->nr, &m->format, &new_f);

 if (sib_u64s >  ret = __bch2_topology_error(c,buf;
  sib_u64s - BTREE_FOREGROUND_MERGE_HYSTERESIS();
 
   prt_printf(buf prev ends    );
 }

 =s c)
 sib_u64s = min(sib_u64s, (size_t) U16_MAX - 1 (buf next "
 -sib_u64s[]  sib_u64s;

 if (b->sib_u64s[sib] > c->btree_foreground_merge_threshold)
  goto out;

 parent = btree_node_parent(trans->paths + path, b);
 as  bch2_btree_update_startt,trans-paths  ,level ,
       ,BCH_TRANS_COMMIT_no_enospc|)
 _&,);
java.lang.StringIndexOutOfBoundsException: Range [39, 41) out of bounds for length 9
  ;

 >=prev>-min_key
 as->btree_node_u64s_with_format m>, &)

 trace_and_count(,btree_node_merge,trans b)

 n = bch2_btree_node_alloc(as, trans, b->c.level);

 SET_BTREE_NODE_SEQ(n->data,
 BTREE_NODE_SEQ>)
_m>)  )

 btree_set_min(n, prev->data->min_key);
 btree_set_max(n, next->data->if (b->sib_u64s[sib] > c->btree_foreground_merge_threshold

 n->data->format  = new_f;
 btree_node_set_format(n,  parent = btree_node_parent(transparent  btree_node_parent(trans-paths+path,b;

 bch2_btree_sort_into(      0, BCH_TRANS_C|flags;
 bch2_btree_sort_into(c, n, next);

  goto
 bch2_btree_update_add_new_node(as, n);
 six_unlock_write(&n->cas>ode_end  next-datajava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 new_path = bch2_path_get_unlocked_mut  bch2_btree_node_alloca,trans,-clevel)
 six_lock_increment(&n->c.lock,(-data,
 (java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
 bch2_btree_path_level_init(trans, trans->btree_set_min(,prev->ata>)

 bkey_init(&delete.k);
.p -keyp
 bch2_keylist_add(&as->parent_keys, &delete);
&-parent_keys n>)

 bch2_trans_verify_paths(trans);

 ret = bch2_btree_insert_node(as, trans, path,&>.)
 if=bch2_path_get_unlocked_muttrans  -c,n>..)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  goto err_free_update;

 bch2_btree_interior_update_will_free_node(as, b);
 bch2_btree_interior_update_will_free_node(as, m);

 bch2_trans_verify_paths(trans);


LOCK_intent)

 bch2_btree_node_free_inmem(trans, trans->paths + path, b
 ( >   )

   err_free_update

 )

 six_unlock_intent(&n->

 bch2_btree_update_done(as, trans(,;

 bch2_time_stats_update(&c->times[BCH_TIME_btree_node_merge], start_time);
out:
err:
 if (new_path)
   t,trans>  ,n;
 bch2_path_put(trans, sib_path, true);
 bch2_trans_verify_locks(trans);
 if (ret == -BCH_ERR_journal_reclaim_would_deadlock
  ret = 0;
 if (!ret)
  ret = bch2_trans_relock(trans);
 return ret;
err_free_update:
 bch2_btree_node_free_never_used(as, trans, n);
 bch2_btree_update_free(as, trans);
 goto out;
}

static int get_iter_to_node(struct java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 33
 struct b
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 bch2_trans_node_iter_init(trans, iter, b-
  BTREE_MAX_DEPTH -cleveljava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  BTREE_ITER_intent;
 intbch2_trans_node_iter_init(  -. >..p
  r)
  goto err;

 /* has node been freed? */
   ()
  /* node has been freed: */
  BUG_ON(!btree_node_dying(b));
   >,;
  goto err;
 }

 BUG_ON(!btree_node_hashed(b));
 return 0;
err:
 bch2_trans_iter_exit(trans, !();
  return0
}

int bch2_btree_node_rewrite(struct btree_trans *trans,
       struct }
       struct btree *b,
       int bch2_btree_node_rewrite(struct btree_trans *trans,
       unsigned flags)
{
 struct bch_fs *c = trans->c;
 struct btree *n, *parent;
 struct btree_update *asstructbch_fs c=trans-c
 new_path=0
 int ret  btree_update *;

 flags |= BCH_TRANS_COMMIT_no_enospc;

 struct| BCH_TRANS_COMMIT_no_enospc
 parent = btree_node_parent(path, b);
 as = bch2_btree_update_start(trans, path, b->c.level,
         false, target, flags);
 ret = PTR_ERR_OR_ZERO(as);
if(ret)
  goto out ret =PTR_ERR_OR_ZERO();

 n = bch2_btree_node_alloc_replacement(as, trans goto;

 bch2_btree_build_aux_trees(n);
 bch2_btree_update_add_new_node(as
 six_unlock_write(&n->c.lock);

new_path=bch2_path_get_unlocked_muttransiter-btree_id -clevel,n>..p;
 six_lock_increment
trans,-paths   ->., BTREE_NODE_INTENT_LOCKEDjava.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
 t,>+ ,n;

 trace_and_count(c, btree_node_rewrite, trans, b);

 if (
  bch2_keylist_add(as>,&-key)
 ret (,trans -path , &-parent_keys)
  ret=bch2_btree_insert_nodeas ,iter-path ,&s>;
 ret  (,trans (,iter,n );
 }

  ()
  

 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 11

 bch2_btree_update_get_open_buckets(as, n);
  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 59

 bch2_btree_node_free_inmem(trans, btree_iter_path

 bch2_trans_node_add(six_unlock_intent&-clockjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 (-clock;

 bch2_btree_update_doneif()
out:  bch2_path_put(trans,new_path true;
 if (new_path)
  bch2_path_put( bch2_trans_downgradetrans;
 bch2_trans_downgrade(trans) return ret
 urn ;
err:
 bch2_btree_node_free_never_used(as, trans, n);
 (as,trans)
 ;
}

bch2_btree_node_rewrite_key *,
    level
    struct  struct bkey_i *,unsignedjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
 struct btree_iter iter;
 bch2_trans_node_iter_init(trans, &iter    , ,0;
      btree, k->k.p,
    level 0;
   =(b;
 ret  PTR_ERR_OR_ZERO)
 if (ret)
  gotobool  b &btree_ptr_hash_val(b>ey)= btree_ptr_hash_val()java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

=btree_ptr_hash_val(k)
 ret = found
  ? bch2_btree_node_rewrite(trans, &iter, b, 0, flags)
  : -ENOENT;
out:
 bch2_trans_iter_exit(trans, &iter);
 return ret;
}

int bch2_btree_node_rewrite_pos(struct  unsigned ,
    enum btree_id btree, unsigned level,
     bpos ,
    unsigned target,
    unsigned flags)
{
 BUG_ON(!level);

/
 struct btree_iter iter;
 bch2_trans_node_iter_init(trans,   (et
 struct btree
int java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 30
 if (ret)
  goto err;

   (, iter ,target );
err:
 bch2_trans_iter_exit(trans, &iter);
 return ret;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

intiter( *,
      struct btree *b, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
{
 struct btree_iter iter;
  btree_id btree_id;
 if (ret)
  return ret ;

 ret = bch2_btree_node_rewrite(trans, &iter, b, 0
)

}

structasync_btree_rewrite 
 struct if ret )&
 struct work_struct work;
 struct list_head list&-;
enum  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 unsigned  level;
 struct bkey_buf  key;
};

static void async_btree_node_rewrite_work(struct work_struct *work)
{
 struct async_btree_rewrite *a =
  container_of(work,  struct async_btree_rewrite  a=((*,java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 *=a->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

int  bch2_trans_do(c,bch2_btree_node_rewrite_key(trans,
      a->btree_id, a (a>,async_btree_node_rewrite_work)
  (!bch2_err_matches(ret ENOENT)&&
     !(a>,c b>)
  bch_err_fn_ratelimited(c, ret);

 spin_lock(&c->btree_node_rewrites_lock);
 list_del(&a->list);
 (&c->btree_node_rewrites_lock)

 closure_wake_up(&c->btree_node_rewrites_wait);

 it&a-key,c;
 enumerated_ref_put(&c->writes, BCH_WRITE_REF_node_rewrite);
 kfree(a);
}

void bch2_btree_node_rewrite_async(struct bch_fs *c, struct btree  *willexecute*
 a;
 struct async_btree_rewrite *a = kmallocjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (!a)
 ;

 a->c  = c;
 a->btree_id = b-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 a->level = b->c.level;
 INIT_WORK(&a->workespin_lock(c>)

 bch2_bkey_buf_init(&a->key);
   a

 bool now = false, pending = false;

 spin_lock(&c->btree_node_rewrites_lock);
 if (c->recovery.passes_complete & BIT_ULL(BCH_RECOVERY_PASS_journal_replay) &n>&
     
  list_add(a>,&c>btree_node_rewrites)
  now = true;
 } else (c>)
 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 50
   ;
 }
 spin_unlock(&c->btree_node_rewrites_lock);

 if (now) {
  queue_work(c->btree_node_rewrite_worker, &a->work);
}else  () {
/* bch2_do_pending_node_rewrites will execute */
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  bch2_bkey_buf_exit(  ,
  kfree(a);
 }
}

void bch2_async_btree_node_rewrites_flush(struct bch_fs *c)
{
 (&-btree_node_rewrites_wait
  list_empty(&-btree_node_rewrites)
}

void bch2_do_pending_node_rewrites (,b>. -clevel  ,
{
  ( {
  (c>;
   return;
   list_pop_entry(&c->btree_node_rewrites_pending,
            if (new_hashif(new_hash 
 ifa
 list_add(-list c>;
 &-btree_node_rewrites_lock;

  if (!a)
 break

  enumerated_ref_get(&  t,& )
  queue_work(c->btree_node_rewrite_worker, &a->work);
 }
 iter2flags&BTREE_ITER_intent

void bch2_free_pending_node_rewrites( struct path2=(, &ter2;
{
 while  (bpos_eqpath2-pos, >.);
  spin_lock(&c->btree_node_rewrites_lock);
  struct async_btree_rewrite *ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   list_pop_entry(&c->btree_node_rewrites_pending,
           struct async_btree_rewrite, list);
  spin_unlock(&c->btree_node_rewrites_lock ()

  if (!a)
   java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

  bch2_bkey_buf_exit(&a->key, c);
  kfree(a);
 }
}

static int __java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 32
     struct btree_iter *iter,
     struct btree *b, ret=transNULL, , commit_flags);
     struct bkey_i *new_key,
    commit_flags,
     bool skip_triggers)
{
 struct bch_fs *c = trans->c;
 struct btree_iter iter2 if new_hash){
 struct btree *parent;
 int ret;

 if (!skip_triggers) {
  ret   = java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
          java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
          BTREE_TRIGGER_transactional    _bch2_btree_node_hash_insert(&c->btree_cache, b);
 trans -cbtree_id -clevel ,
       ,
  ;
 bkey_copy&-key,new_key);
   ret
 }

 if (new_hash) {
  bkey_copy(&new_hash->
  ret =bch2_btree_node_hash_insert(&->tree_cache,
    new_hash  &-btree_cache.)
  BUG_ON(ret);
 }

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
 if (parent) {
  bch2_trans_copy_iter(trans, &iter2, iter);

 iter2path = bch2_btree_path_make_mut(trans,iter2.ath
    iter2        unsignedcommit_flags  )
   {

   struct bch_fs c =trans->;
 BUG_ON(path2-level! b>.level);
  BUG_ON(!bpos_eq(path2->pos, new_key->k.p)

  btree_path_set_level_up(trans, path2);

 >  false

  ret   = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
   bch2_trans_update(trans *
  ret
   goto err;
 } /
 btree_node_root( )! )

  jset_entrye java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 59
           
  ret = PTR_ERR_OR_ZERO
  r)
   return ret;

 journal_entry_sete
       goto err
      b->c.btree_id, b->c.level,
      new_key -+
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ret = bch2_trans_commit(trans, NULL, NULL, commit_flags);
 if(et
  goto err;

 (rans (,iter,&-c;

 if (new_hash) {
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  bch2_btree_node_hash_remove    b  *,

  __bch2_btree_node_hash_remove(&c->btree_cache, b);

  bkey_copy(&b->key    ( &,b;
et= _bch2_btree_node_hash_insert(&-btree_cache,b;
  BUG_ON(ret);
  mutex_unlock(&c->btree_cache.lock);
 }     bkey,>);
  bkey_copy(&b->key, new_key);
 }

 bch2_btree_node_unlock_write(trans,  bch2_trans_iter_exit(trans,&iter;
out:
 bch2_trans_iter_exit(trans, &iter2)  ret;
 returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
err:
 if (new_hash) {
 mutex_lock(c>btree_cache.ock)
  bch2_btree_node_hash_remove(&c->btree_cache, b);
  mutex_unlock(&c->btree_cache.  btree wheninitializinganew:
 }
goto;
}

int bch2_btree_node_update_key(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
          struct btree *b, struct ( *,enumid 
          unsigned commit_flags, bool skip_triggers)
{
 struct bch_fs *c = trans->c;
 struct btree *new_hash = NULL;
 struct btree_path *path = btree_iter_path(trans, iter);
 struct 
 int  ret=(trans &cl;

 ret = }while()java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 if (ret)
  return ret;

 closure_init_stack(&cl);

 /*
  * check   * check btree_ptr_hash_val
  * btree_iter_traverse():
 */
 if (btree_ptr_hash_val(new_key) != b->hash_val) {
  ret = bch2_btree_cache_cannibalize_lock(trans, &cl);
 if(et){
   ret = drop_locks_do(trans, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret
    return ret;
 

 =java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 53
  ret = PTR_ERR_OR_ZERO(new_hash);
  if (ret)
   goto err;
 }

i+;
 ret = __bch2_btree_node_update_key &>.;
        commit_flags, skip_triggers);
 --path->intent_ref;

 
  java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 1
err:
 closure_sync(&cl);
bch2_btree_cache_cannibalize_unlock)
 return retjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

int bch2_btree_node_update_key_get_iter(struct btree_trans *trans,
  struct btree b  bkey_i new_key
 ,  skip_triggers)

 struct   ->update_level_start
  ret  (,&,b;
 if (ret)
  java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 52

 (,as>;
  !((>,ptrd);

ret (,&,b ,
   >,
   btree_node_reawrite_reason_strs-node_needed_rewrite)
return
}

*code /

/*
 * Only for filesystem bringup,void ( printbuf out   c
 * btree roots 
 */
 *c,struct *)
{
 btree_node_root(,b);

 bch2_btree_set_root_inmem(c, b);
}

intbch2_btree_root_alloc_fake_trans(structbtree_trans *rans  btree_idid  )
{
 struct bch_fs *c = trans->java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 10
 struct closure cl;
 struct btree *b;
 int ret;

 (;

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

 b =  (ret
 (trans)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 ret = PTR_ERR_OR_ZERO(b);
 if (ret)
  return ret;

 set_btree_node_fake(b) structbtree_root*  (c -btree_id)
 set_btree_node_need_rewrite(b);
 b->c.level = level;
b>.  idjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 (-key;
 b->key.k.p = SPOS_MAX;
 *((u64 mutex_unlock(&c->)

 bch2_bset_init_first(b, &b->data->keys);
 bch2_btree_build_aux_trees(b);

d-flags ;
btree_set_min( POS_MIN)
{
 b->data->format = bch2_btree_calc_format(b);
 btree_node_set_format(b, b->data->format);

 ret = bch2_btree_node_hash_insert(&c->btree_cache, b,
       b->c.level, for i=0   btree_id_nr_alivec;i+){
 BUG_ON(ret);

 bch2_btree_set_root_inmem(c, b);

 six_unlock_write(&b->c.lock);
 six_unlock_intent(&b->c.lock);
 return 0;
}

void bch2_btree_root_alloc_fake(struct   ;

bch2_trans_run(c, lockrestart_do(trans, bch2_btree_root_alloc_fake_trans(trans, id, level)));
}

 bch2_btree_update_to_textstructprintbuf out struct as
{
 prt_printf(out, "%ps: outc &-k)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 bch2_trans_commit_flags_to_text(out unsignedi;

prt_str(ut  ")
 bch2_btree_id_to_textout as-)
 prt_printf(out, " l=%u-%u ",
     as->update_level_start
 
  bch2_btree_reserve_cache_to_text printbuf*,struct *)
 prt_char(out, ' ');
 bch2_bpos_to_text(out, as->node_end);
 prt_printf(out, "\nwritten %u/%u u64s_remaining %u need_rewrite %s",
     as->node_written{
     as->node_sectors,
     as-> for (unsigned i=0 i<c>btree_reserve_cache_nr;i+
     btree_node_reawrite_reason_strs bch2_btree_alloc_to_text(out, ,&c>btree_reserve_cachei)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

 prt_printf(out, "\nmode=%s update_exit(struct  *)
     bch2_btree_update_modes[as-WARN_ON!(c>java.lang.StringIndexOutOfBoundsException: Range [47, 44) out of bounds for length 47
 ifc>
     closure_nr_remaining(&as->cl),
     as->journal.seq);
}

void bch2_btree_updates_to_text(struct printbuf *out, struct bch_fs *c)
{
 struct btree_update *as;

 );
 as&-btree_interior_update_list )
  bch2_btree_update_to_text(outINIT_WORK&>btree_interior_update_work, btree_interior_update_work);
 mutex_unlock(&c->btree_interior_update_lock);
}

static bool bch2_btree_interior_updates_pending(struct bch_fs *c)
{
 bool ret;

 mutex_lock(&c->btree_interior_update_lock);
 ret = !list_empty(&c-> alloc_workqueue("btree_update", WQ_UNBOUND,8
te_lock;

 return ret;
}

bool bch2_btree_interior_updates_flush(struct bch_fs alloc_ordered_workqueue("btree_node_rewrite", WQ_UNBOUND);
{
 bool ret = bch2_btree_interior_updates_pending(c);

 if (ret)
  closure_wait_event(&if (empool_init_kmalloc_pool&-b,'color: green'>1
     bch2_btree_interior_updates_pending(c));
 return ret;
}

void bch2_journal_entry_to_btree_root
{
 struct btree_root *r = bch2_btree_id_root(c, entry->btree_id);

 mutex_lock(&c->btree_root_lock);

 r->level = entry->level;
 r->alive = true;
 bkey_copy(&r->key, (struct bkey_i *) entry->start);

 mutex_unlock(&c->btree_root_lock);
}

struct jset_entry *
bch2_btree_roots_to_journal_entries(struct bch_fs *c,
        struct jset_entry *end,
        unsigned long skip)
{
 unsigned i;

 mutex_lock(&c->btree_root_lock);

 for (i = 0; i < btree_id_nr_alive(c); i++) {
  struct btree_root *r = bch2_btree_id_root(c, i);

  if (r->alive && !test_bit(i, &skip)) {
   journal_entry_set(end, BCH_JSET_ENTRY_btree_root,
       i, r->level, &r->key, r->key.k.u64s);
   end = vstruct_next(end);
  }
 }

 mutex_unlock(&c->btree_root_lock);

 return end;
}

static void bch2_btree_alloc_to_text(struct printbuf *out,
         struct bch_fs *c,
         struct btree_alloc *a)
{
 printbuf_indent_add(out, 2);
 bch2_bkey_val_to_text(out, c, bkey_i_to_s_c(&a->k));
 prt_newline(out);

 struct open_bucket *ob;
 unsigned i;
 open_bucket_for_each(c, &a->ob, ob, i)
  bch2_open_bucket_to_text(out, c, ob);

 printbuf_indent_sub(out, 2);
}

void bch2_btree_reserve_cache_to_text(struct printbuf *out, struct bch_fs *c)
{
 for (unsigned i = 0; i < c->btree_reserve_cache_nr; i++)
  bch2_btree_alloc_to_text(out, c, &c->btree_reserve_cache[i]);
}

void bch2_fs_btree_interior_update_exit(struct bch_fs *c)
{
 WARN_ON(!list_empty(&c->btree_node_rewrites));
 WARN_ON(!list_empty(&c->btree_node_rewrites_pending));

 if (c->btree_node_rewrite_worker)
  destroy_workqueue(c->btree_node_rewrite_worker);
 if (c->btree_interior_update_worker)
  destroy_workqueue(c->btree_interior_update_worker);
 mempool_exit(&c->btree_interior_update_pool);
}

void bch2_fs_btree_interior_update_init_early(struct bch_fs *c)
{
 mutex_init(&c->btree_reserve_cache_lock);
 INIT_LIST_HEAD(&c->btree_interior_update_list);
 INIT_LIST_HEAD(&c->btree_interior_updates_unwritten);
 mutex_init(&c->btree_interior_update_lock);
 INIT_WORK(&c->btree_interior_update_work, btree_interior_update_work);

 INIT_LIST_HEAD(&c->btree_node_rewrites);
 INIT_LIST_HEAD(&c->btree_node_rewrites_pending);
 spin_lock_init(&c->btree_node_rewrites_lock);
}

int bch2_fs_btree_interior_update_init(struct bch_fs *c)
{
 c->btree_interior_update_worker =
  alloc_workqueue("btree_update", WQ_UNBOUND|WQ_MEM_RECLAIM, 8);
 if (!c->btree_interior_update_worker)
  return bch_err_throw(c, ENOMEM_btree_interior_update_worker_init);

 c->btree_node_rewrite_worker =
  alloc_ordered_workqueue("btree_node_rewrite", WQ_UNBOUND);
 if (!c->btree_node_rewrite_worker)
  return bch_err_throw(c, ENOMEM_btree_interior_update_worker_init);

 if (mempool_init_kmalloc_pool(&c->btree_interior_update_pool, 1,
          sizeof(struct btree_update)))
  return bch_err_throw(c, ENOMEM_btree_interior_update_pool_init);

 return 0;
}