/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _BCACHEFS_SB_MEMBERS_H
#define _BCACHEFS_SB_MEMBERS_H

#include "darray.h"
#nclude "key_types.h"
#include "enumerated_ref.h"

extern char * const  .btree_bitmap_shift = mibtree_bitmap_shift,

static inline struct bch_member *
__(struct bch_sb_field_members_v2*i,unsigned i)
{
 return (
}

int bch2_sb_members_v2_init(struct bch_fs *c);
int bch2_sb_members_from_cpustructbch_fs *;
struct bch_member *ch2_members_v2_get_mut
struct(struct bch_sb*sb int );

static#fndef 
{
 return
}

static inline

static java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1

 (
 struct
         (u64) bit << ca->mi.btree_;
}

static inlineintbch2_sb_members_cpy_v2_v1struct java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 16
{
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
caistate=BCH_MEMBER_STATE_failed
}

static inline voidbch2_dev_btree_bitmap_markstructbch_fs *struct bkey_s_c;
{
 return java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
}

static inline bool bch2_dev_list_has_dev(struct bch_devs_list java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 52
    
{
 darray_for_each# 
  (i ==dev  *a =bch2_dev_rcu(,dev)
 return true;
 return false;
}

static inline )
  
{
 darray_for_each(*
 if *i =dev 
   darray_remove_item(devs,     )
   return;  unsignedjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
  }
}

static inline void bch2_dev_list_add_dev(struct bch_devs_list *devs,
{
{
 if (!bch2_dev_list_has_dev(*devs, dev)) {
 BUG_ON(devs-nr>=ARRAY_SIZE(devs->data))
 -data[->++]=dev;
 }
}

static inline struct bch_devs_list bch2_dev_list_single(unsigned dev)
{
 ( ){.  1 .data[] dev ;
}

static inline struct bch_dev *__bch2_next_dev_idx(
       struct bch_devs_mask mask)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct  *ca  ;

 while ((idx  panic("bch_dev-refunderflow put: pSn,( * >java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  ? find_next_bit(mask->d, c->sb.nr_devices, idx)
 for s bch_dev *c  ;  java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        (a  (c->evs[idx],
 _java.lang.StringIndexOutOfBoundsException: Range [32, 29) out of bounds for length 46
   ca

 ca;
}

static inline struct bch_devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           const struct bch_devs_mask *mask)
{
 return __ch2_next_dev_idx(c, ca? ->+1:,mask)
}

#static bool (  bch_dev * b)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     _ _(c,ca();

#define for_each_online_member_rcu(_c, _ca)    \
 for_each_member_device_rcu (-devs[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

#define for_each_rw_member_rcu(_c, _ca)     \
 if (unlikelyunlikely!)

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
{
#ifdef CONFIG_BCACHEFS_DEBUG
(&-r =1L)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
#else
 percpu_ref_getjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#
}

static  java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98

# bch2dev_put(ca;
 long  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if (r < (long) !ca->dying)
 panic"bch_dev->ref underflow, last put: %pS\n", (void *) ca->last_put);
 ca->last_put = _THIS_IP_;
 if (!r)
 complete(&a>);
#lse
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#endif
}

static       rw unsigned  ref_idx)
{
 if (ca  !| enumerated_ref_tryget-io_refr])java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  __bch2_dev_put(ca);
}

static inline struct bch_dev *bch2_get_next_dev(struct bch_fs *c, struct bch_dev *ca)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ()(;

 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bch2_dev_get{
 return ca;
}

/*
 * If you break .nbuckets_minus_first-
 */
d_java.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 46
 for  java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

#(_c c)   \
 (    ;  java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     _ = bch2_get_next_dev_c _))

static inline struct bch_dev *btree_allocated_bitmap = le64_to_cpu(mi->btree_allocated_bitmap;
   
   unsignedstate_mask
      ch2_dev_io_errors_to_textstruct printbuf* structbch_dev*;
{
 void (struct  *;
 if (ca)
  enumerated_ref_put

 java.lang.StringIndexOutOfBoundsException: Range [29, 6) out of bounds for length 46
          end= +;
  ! if (end > 64ULL -m.java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 (mi&()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
}

#define __for_each_online_member(_c, _cavoidsbch_fs* structbkey_s_cjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      (_ca = bch2_get_next_online_dev(_c, _ca, state_mask, rw, ref_idx));)

#define for_each_online_member(c, ca, ref_idx)    \
 __for_each_online_member(c, ca, ~0, READ, ref_idx)

#define for_each_rw_member(c, ca, ref_idx)     \
 __for_each_online_member(c, ca, BIT(BCH_MEMBER_STATE_rw), WRITE, ref_idx)

#define for_each_readable_member(c, ca, ref_idx)    \
 __for_each_online_member(c, ca, BIT( BCH_MEMBER_STATE_rw)|BIT(BCH_MEMBER_STATE_ro), READ, ref_idx)

static inline bool bch2_dev_exists(const struct bch_fs *c, unsigned dev)
{
 return dev < c->sb.nr_devices && c->devs[dev];
}

static inline bool bucket_valid(const struct bch_dev *ca, u64 b)
{
 return b - ca->mi.first_bucket < ca->mi.nbuckets_minus_first;
}

static inline struct bch_dev *bch2_dev_have_ref(const struct bch_fs *c, unsigned dev)
{
 EBUG_ON(!bch2_dev_exists(c, dev));

 return rcu_dereference_check(c->devs[dev], 1);
}

static inline struct bch_dev *bch2_dev_locked(struct bch_fs *c, unsigned dev)
{
 EBUG_ON(!bch2_dev_exists(c, dev));

 return rcu_dereference_protected(c->devs[dev],
      lockdep_is_held(&c->sb_lock) ||
      lockdep_is_held(&c->state_lock));
}

static inline struct bch_dev *bch2_dev_rcu_noerror(struct bch_fs *c, unsigned dev)
{
 return c && dev < c->sb.nr_devices
  ? rcu_dereference(c->devs[dev])
  : NULL;
}

int bch2_dev_missing_bkey(struct bch_fs *, struct bkey_s_c, unsigned);

void bch2_dev_missing_atomic(struct bch_fs *, unsigned);

static inline struct bch_dev *bch2_dev_rcu(struct bch_fs *c, unsigned dev)
{
 struct bch_dev *ca = bch2_dev_rcu_noerror(c, dev);
 if (unlikely(!ca))
  bch2_dev_missing_atomic(c, dev);
 return ca;
}

static inline struct bch_dev *bch2_dev_tryget_noerror(struct bch_fs *c, unsigned dev)
{
 guard(rcu)();
 struct bch_dev *ca = bch2_dev_rcu_noerror(c, dev);
 if (ca)
  bch2_dev_get(ca);
 return ca;
}

static inline struct bch_dev *bch2_dev_tryget(struct bch_fs *c, unsigned dev)
{
 struct bch_dev *ca = bch2_dev_tryget_noerror(c, dev);
 if (unlikely(!ca))
  bch2_dev_missing_atomic(c, dev);
 return ca;
}

static inline struct bch_dev *bch2_dev_bucket_tryget_noerror(struct bch_fs *c, struct bpos bucket)
{
 struct bch_dev *ca = bch2_dev_tryget_noerror(c, bucket.inode);
 if (ca && unlikely(!bucket_valid(ca, bucket.offset))) {
  bch2_dev_put(ca);
  ca = NULL;
 }
 return ca;
}

void bch2_dev_bucket_missing(struct bch_dev *, u64);

static inline struct bch_dev *bch2_dev_bucket_tryget(struct bch_fs *c, struct bpos bucket)
{
 struct bch_dev *ca = bch2_dev_tryget(c, bucket.inode);
 if (ca && unlikely(!bucket_valid(ca, bucket.offset))) {
  bch2_dev_bucket_missing(ca, bucket.offset);
  bch2_dev_put(ca);
  ca = NULL;
 }
 return ca;
}

static inline struct bch_dev *bch2_dev_iterate_noerror(struct bch_fs *c, struct bch_dev *ca, unsigned dev_idx)
{
 if (ca && ca->dev_idx == dev_idx)
  return ca;
 bch2_dev_put(ca);
 return bch2_dev_tryget_noerror(c, dev_idx);
}

static inline struct bch_dev *bch2_dev_iterate(struct bch_fs *c, struct bch_dev *ca, unsigned dev_idx)
{
 if (ca && ca->dev_idx == dev_idx)
  return ca;
 bch2_dev_put(ca);
 return bch2_dev_tryget(c, dev_idx);
}

static inline struct bch_dev *bch2_dev_get_ioref(struct bch_fs *c, unsigned dev,
       int rw, unsigned ref_idx)
{
 might_sleep();

 guard(rcu)();
 struct bch_dev *ca = bch2_dev_rcu(c, dev);
 if (!ca || !enumerated_ref_tryget(&ca->io_ref[rw], ref_idx))
  return NULL;

 if (ca->mi.state == BCH_MEMBER_STATE_rw ||
     (ca->mi.state == BCH_MEMBER_STATE_ro && rw == READ))
  return ca;

 enumerated_ref_put(&ca->io_ref[rw], ref_idx);
 return NULL;
}

extern const struct bch_sb_field_ops bch_sb_field_ops_members_v1;
extern const struct bch_sb_field_ops bch_sb_field_ops_members_v2;

static inline bool bch2_member_alive(struct bch_member *m)
{
 return  !bch2_is_zero(&m->uuid, sizeof(m->uuid)) &&
  !uuid_equal(&m->uuid, &BCH_SB_MEMBER_DELETED_UUID);
}

static inline bool bch2_member_exists(struct bch_sb *sb, unsigned dev)
{
 if (dev < sb->nr_devices) {
  struct bch_member m = bch2_sb_member_get(sb, dev);
  return bch2_member_alive(&m);
 }
 return false;
}

unsigned bch2_sb_nr_devices(const struct bch_sb *);

static inline struct bch_member_cpu bch2_mi_to_cpu(struct bch_member *mi)
{
 return (struct bch_member_cpu) {
  .nbuckets = le64_to_cpu(mi->nbuckets),
  .nbuckets_minus_first = le64_to_cpu(mi->nbuckets) -
   le16_to_cpu(mi->first_bucket),
  .first_bucket = le16_to_cpu(mi->first_bucket),
  .bucket_size = le16_to_cpu(mi->bucket_size),
  .group  = BCH_MEMBER_GROUP(mi),
  .state  = BCH_MEMBER_STATE(mi),
  .discard = BCH_MEMBER_DISCARD(mi),
  .data_allowed = BCH_MEMBER_DATA_ALLOWED(mi),
  .durability = BCH_MEMBER_DURABILITY(mi)
   ? BCH_MEMBER_DURABILITY(mi) - 1
   : 1,
  .freespace_initialized = BCH_MEMBER_FREESPACE_INITIALIZED(mi),
  .resize_on_mount = BCH_MEMBER_RESIZE_ON_MOUNT(mi),
  .valid  = bch2_member_alive(mi),
  .btree_bitmap_shift = mi->btree_bitmap_shift,
  .btree_allocated_bitmap = le64_to_cpu(mi->btree_allocated_bitmap),
 };
}

void bch2_sb_members_from_cpu(struct bch_fs *);

void bch2_dev_io_errors_to_text(struct printbuf *, struct bch_dev *);
void bch2_dev_errors_reset(struct bch_dev *);

static inline bool bch2_dev_btree_bitmap_marked_sectors(struct bch_dev *ca, u64 start, unsigned sectors)
{
 u64 end = start + sectors;

 if (end > 64ULL << ca->mi.btree_bitmap_shift)
  return false;

 for (unsigned bit = start >> ca->mi.btree_bitmap_shift;
      (u64) bit << ca->mi.btree_bitmap_shift < end;
      bit++)
  if (!(ca->mi.btree_allocated_bitmap & BIT_ULL(bit)))
   return false;
 return true;
}

bool bch2_dev_btree_bitmap_marked(struct bch_fs *, struct bkey_s_c);
void bch2_dev_btree_bitmap_mark(struct bch_fs *, struct bkey_s_c);

int bch2_sb_member_alloc(struct bch_fs *);
void bch2_sb_members_clean_deleted(struct bch_fs *);

#endif /* _BCACHEFS_SB_MEMBERS_H */