[linux-2.6-block.git] / fs / bcachefs / buckets.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Code for manipulating bucket marks for garbage collection.
 *
 * Copyright 2014 Datera, Inc.
 */

#ifndef _BUCKETS_H
#define _BUCKETS_H

#include "buckets_types.h"
#include "extents.h"
#include "sb-members.h"

static inline u64 sector_to_bucket(const struct bch_dev *ca, sector_t s)
{
	return div_u64(s, ca->mi.bucket_size);
}

static inline sector_t bucket_to_sector(const struct bch_dev *ca, size_t b)
{
	return ((sector_t) b) * ca->mi.bucket_size;
}

static inline sector_t bucket_remainder(const struct bch_dev *ca, sector_t s)
{
	u32 remainder;

	div_u64_rem(s, ca->mi.bucket_size, &remainder);
	return remainder;
}

static inline u64 sector_to_bucket_and_offset(const struct bch_dev *ca, sector_t s, u32 *offset)
{
	return div_u64_rem(s, ca->mi.bucket_size, offset);
}

#define for_each_bucket(_b, _buckets)				\
	for (_b = (_buckets)->b + (_buckets)->first_bucket;	\
	     _b < (_buckets)->b + (_buckets)->nbuckets; _b++)

static inline void bucket_unlock(struct bucket *b)
{
	BUILD_BUG_ON(!((union ulong_byte_assert) { .ulong = 1UL << BUCKET_LOCK_BITNR }).byte);

	clear_bit_unlock(BUCKET_LOCK_BITNR, (void *) &b->lock);
	smp_mb__after_atomic();
	wake_up_bit((void *) &b->lock, BUCKET_LOCK_BITNR);
}

static inline void bucket_lock(struct bucket *b)
{
	wait_on_bit_lock((void *) &b->lock, BUCKET_LOCK_BITNR,
			 TASK_UNINTERRUPTIBLE);
}

static inline struct bucket *gc_bucket(struct bch_dev *ca, size_t b)
{
	return bucket_valid(ca, b)
		? genradix_ptr(&ca->buckets_gc, b)
		: NULL;
}

static inline struct bucket_gens *bucket_gens(struct bch_dev *ca)
{
	return rcu_dereference_check(ca->bucket_gens,
				     lockdep_is_held(&ca->fs->state_lock));
}

static inline u8 *bucket_gen(struct bch_dev *ca, size_t b)
{
	struct bucket_gens *gens = bucket_gens(ca);

	if (b - gens->first_bucket >= gens->nbuckets_minus_first)
		return NULL;
	return gens->b + b;
}

static inline int bucket_gen_get_rcu(struct bch_dev *ca, size_t b)
{
	u8 *gen = bucket_gen(ca, b);
	return gen ? *gen : -1;
}

static inline int bucket_gen_get(struct bch_dev *ca, size_t b)
{
	guard(rcu)();
	return bucket_gen_get_rcu(ca, b);
}

static inline size_t PTR_BUCKET_NR(const struct bch_dev *ca,
				   const struct bch_extent_ptr *ptr)
{
	return sector_to_bucket(ca, ptr->offset);
}

static inline struct bpos PTR_BUCKET_POS(const struct bch_dev *ca,
					 const struct bch_extent_ptr *ptr)
{
	return POS(ptr->dev, PTR_BUCKET_NR(ca, ptr));
}

static inline struct bpos PTR_BUCKET_POS_OFFSET(const struct bch_dev *ca,
						const struct bch_extent_ptr *ptr,
						u32 *bucket_offset)
{
	return POS(ptr->dev, sector_to_bucket_and_offset(ca, ptr->offset, bucket_offset));
}

static inline struct bucket *PTR_GC_BUCKET(struct bch_dev *ca,
					   const struct bch_extent_ptr *ptr)
{
	return gc_bucket(ca, PTR_BUCKET_NR(ca, ptr));
}

static inline enum bch_data_type ptr_data_type(const struct bkey *k,
					       const struct bch_extent_ptr *ptr)
{
	if (bkey_is_btree_ptr(k))
		return BCH_DATA_btree;

	return ptr->cached ? BCH_DATA_cached : BCH_DATA_user;
}

static inline s64 ptr_disk_sectors(s64 sectors, struct extent_ptr_decoded p)
{
	EBUG_ON(sectors < 0);

	return crc_is_compressed(p.crc)
		? DIV_ROUND_UP_ULL(sectors * p.crc.compressed_size,
				   p.crc.uncompressed_size)
		: sectors;
}

static inline int gen_cmp(u8 a, u8 b)
{
	return (s8) (a - b);
}

static inline int gen_after(u8 a, u8 b)
{
	return max(0, gen_cmp(a, b));
}

static inline int dev_ptr_stale_rcu(struct bch_dev *ca, const struct bch_extent_ptr *ptr)
{
	int gen = bucket_gen_get_rcu(ca, PTR_BUCKET_NR(ca, ptr));
	return gen < 0 ? gen : gen_after(gen, ptr->gen);
}

/**
 * dev_ptr_stale() - check if a pointer points into a bucket that has been
 * invalidated.
 */
static inline int dev_ptr_stale(struct bch_dev *ca, const struct bch_extent_ptr *ptr)
{
	guard(rcu)();
	return dev_ptr_stale_rcu(ca, ptr);
}

/* Device usage: */

void bch2_dev_usage_read_fast(struct bch_dev *, struct bch_dev_usage *);
static inline struct bch_dev_usage bch2_dev_usage_read(struct bch_dev *ca)
{
	struct bch_dev_usage ret;

	bch2_dev_usage_read_fast(ca, &ret);
	return ret;
}

void bch2_dev_usage_full_read_fast(struct bch_dev *, struct bch_dev_usage_full *);
static inline struct bch_dev_usage_full bch2_dev_usage_full_read(struct bch_dev *ca)
{
	struct bch_dev_usage_full ret;

	bch2_dev_usage_full_read_fast(ca, &ret);
	return ret;
}

void bch2_dev_usage_to_text(struct printbuf *, struct bch_dev *, struct bch_dev_usage_full *);

static inline u64 bch2_dev_buckets_reserved(struct bch_dev *ca, enum bch_watermark watermark)
{
	s64 reserved = 0;

	switch (watermark) {
	case BCH_WATERMARK_NR:
		BUG();
	case BCH_WATERMARK_stripe:
		reserved += ca->mi.nbuckets >> 6;
		fallthrough;
	case BCH_WATERMARK_normal:
		reserved += ca->mi.nbuckets >> 6;
		fallthrough;
	case BCH_WATERMARK_copygc:
		reserved += ca->nr_btree_reserve;
		fallthrough;
	case BCH_WATERMARK_btree:
		reserved += ca->nr_btree_reserve;
		fallthrough;
	case BCH_WATERMARK_btree_copygc:
	case BCH_WATERMARK_reclaim:
	case BCH_WATERMARK_interior_updates:
		break;
	}

	return reserved;
}

static inline u64 dev_buckets_free(struct bch_dev *ca,
				   struct bch_dev_usage usage,
				   enum bch_watermark watermark)
{
	return max_t(s64, 0,
		     usage.buckets[BCH_DATA_free]-
		     ca->nr_open_buckets -
		     bch2_dev_buckets_reserved(ca, watermark));
}

static inline u64 __dev_buckets_available(struct bch_dev *ca,
					  struct bch_dev_usage usage,
					  enum bch_watermark watermark)
{
	return max_t(s64, 0,
		       usage.buckets[BCH_DATA_free]
		     + usage.buckets[BCH_DATA_cached]
		     + usage.buckets[BCH_DATA_need_gc_gens]
		     + usage.buckets[BCH_DATA_need_discard]
		     - ca->nr_open_buckets
		     - bch2_dev_buckets_reserved(ca, watermark));
}

static inline u64 dev_buckets_available(struct bch_dev *ca,
					enum bch_watermark watermark)
{
	return __dev_buckets_available(ca, bch2_dev_usage_read(ca), watermark);
}

/* Filesystem usage: */

struct bch_fs_usage_short
bch2_fs_usage_read_short(struct bch_fs *);

int bch2_bucket_ref_update(struct btree_trans *, struct bch_dev *,
			   struct bkey_s_c, const struct bch_extent_ptr *,
			   s64, enum bch_data_type, u8, u8, u32 *);

int bch2_check_fix_ptrs(struct btree_trans *,
			enum btree_id, unsigned, struct bkey_s_c,
			enum btree_iter_update_trigger_flags);

int bch2_trigger_extent(struct btree_trans *, enum btree_id, unsigned,
			struct bkey_s_c, struct bkey_s,
			enum btree_iter_update_trigger_flags);
int bch2_trigger_reservation(struct btree_trans *, enum btree_id, unsigned,
			  struct bkey_s_c, struct bkey_s,
			  enum btree_iter_update_trigger_flags);

#define trigger_run_overwrite_then_insert(_fn, _trans, _btree_id, _level, _old, _new, _flags)\
({												\
	int ret = 0;										\
												\
	if (_old.k->type)									\
		ret = _fn(_trans, _btree_id, _level, _old, _flags & ~BTREE_TRIGGER_insert);	\
	if (!ret && _new.k->type)								\
		ret = _fn(_trans, _btree_id, _level, _new.s_c, _flags & ~BTREE_TRIGGER_overwrite);\
	ret;											\
})

void bch2_trans_account_disk_usage_change(struct btree_trans *);

int bch2_trans_mark_metadata_bucket(struct btree_trans *, struct bch_dev *, u64,
				    enum bch_data_type, unsigned,
				    enum btree_iter_update_trigger_flags);
int bch2_trans_mark_dev_sb(struct bch_fs *, struct bch_dev *,
				    enum btree_iter_update_trigger_flags);
int bch2_trans_mark_dev_sbs_flags(struct bch_fs *,
				    enum btree_iter_update_trigger_flags);
int bch2_trans_mark_dev_sbs(struct bch_fs *);

bool bch2_is_superblock_bucket(struct bch_dev *, u64);

static inline const char *bch2_data_type_str(enum bch_data_type type)
{
	return type < BCH_DATA_NR
		? __bch2_data_types[type]
		: "(invalid data type)";
}

/* disk reservations: */

static inline void bch2_disk_reservation_put(struct bch_fs *c,
					     struct disk_reservation *res)
{
	if (res->sectors) {
		this_cpu_sub(*c->online_reserved, res->sectors);
		res->sectors = 0;
	}
}

enum bch_reservation_flags {
	BCH_DISK_RESERVATION_NOFAIL	= 1 << 0,
	BCH_DISK_RESERVATION_PARTIAL	= 1 << 1,
};

int __bch2_disk_reservation_add(struct bch_fs *, struct disk_reservation *,
				u64, enum bch_reservation_flags);

static inline int bch2_disk_reservation_add(struct bch_fs *c, struct disk_reservation *res,
					    u64 sectors, enum bch_reservation_flags flags)
{
#ifdef __KERNEL__
	u64 old, new;

	old = this_cpu_read(c->pcpu->sectors_available);
	do {
		if (sectors > old)
			return __bch2_disk_reservation_add(c, res, sectors, flags);

		new = old - sectors;
	} while (!this_cpu_try_cmpxchg(c->pcpu->sectors_available, &old, new));

	this_cpu_add(*c->online_reserved, sectors);
	res->sectors			+= sectors;
	return 0;
#else
	return __bch2_disk_reservation_add(c, res, sectors, flags);
#endif
}

static inline struct disk_reservation
bch2_disk_reservation_init(struct bch_fs *c, unsigned nr_replicas)
{
	return (struct disk_reservation) {
		.sectors	= 0,
#if 0
		/* not used yet: */
		.gen		= c->capacity_gen,
#endif
		.nr_replicas	= nr_replicas,
	};
}

static inline int bch2_disk_reservation_get(struct bch_fs *c,
					    struct disk_reservation *res,
					    u64 sectors, unsigned nr_replicas,
					    int flags)
{
	*res = bch2_disk_reservation_init(c, nr_replicas);

	return bch2_disk_reservation_add(c, res, sectors * nr_replicas, flags);
}

#define RESERVE_FACTOR	6

static inline u64 avail_factor(u64 r)
{
	return div_u64(r << RESERVE_FACTOR, (1 << RESERVE_FACTOR) + 1);
}

void bch2_buckets_nouse_free(struct bch_fs *);
int bch2_buckets_nouse_alloc(struct bch_fs *);

int bch2_dev_buckets_resize(struct bch_fs *, struct bch_dev *, u64);
void bch2_dev_buckets_free(struct bch_dev *);
int bch2_dev_buckets_alloc(struct bch_fs *, struct bch_dev *);

#endif /* _BUCKETS_H */
Commit	Line	Data
1c6fdbd8 KO	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Code for manipulating bucket marks for garbage collection.
	4	*
	5	* Copyright 2014 Datera, Inc.
	6	*/
	7
	8	#ifndef _BUCKETS_H
	9	#define _BUCKETS_H
	10
	11	#include "buckets_types.h"
f0ac7df2	12	#include "extents.h"
fb8e5b4c KO	13	#include "sb-members.h"
fb8e5b4c KO	14
d155272b	15	static inline u64 sector_to_bucket(const struct bch_dev *ca, sector_t s)
fb8e5b4c KO	16	{
	17	return div_u64(s, ca->mi.bucket_size);
	18	}
	19
	20	static inline sector_t bucket_to_sector(const struct bch_dev *ca, size_t b)
	21	{
	22	return ((sector_t) b) * ca->mi.bucket_size;
	23	}
	24
	25	static inline sector_t bucket_remainder(const struct bch_dev *ca, sector_t s)
	26	{
	27	u32 remainder;
	28
	29	div_u64_rem(s, ca->mi.bucket_size, &remainder);
	30	return remainder;
	31	}
	32
d155272b	33	static inline u64 sector_to_bucket_and_offset(const struct bch_dev ca, sector_t s, u32 offset)
fb8e5b4c KO	34	{
	35	return div_u64_rem(s, ca->mi.bucket_size, offset);
	36	}
1c6fdbd8 KO	37
	38	#define for_each_bucket(_b, _buckets) \
	39	for (_b = (_buckets)->b + (_buckets)->first_bucket; \
	40	_b < (_buckets)->b + (_buckets)->nbuckets; _b++)
	41
66d90823 KO	42	static inline void bucket_unlock(struct bucket *b)
66d90823 KO	43	{
8c2d82a6	44	BUILD_BUG_ON(!((union ulong_byte_assert) { .ulong = 1UL << BUCKET_LOCK_BITNR }).byte);
73bbeaa2 KO	45
73bbeaa2 KO	46	clear_bit_unlock(BUCKET_LOCK_BITNR, (void *) &b->lock);
7a69fa65	47	smp_mb__after_atomic();
73bbeaa2	48	wake_up_bit((void *) &b->lock, BUCKET_LOCK_BITNR);
66d90823 KO	49	}
	50
	51	static inline void bucket_lock(struct bucket *b)
	52	{
73bbeaa2 KO	53	wait_on_bit_lock((void *) &b->lock, BUCKET_LOCK_BITNR,
73bbeaa2 KO	54	TASK_UNINTERRUPTIBLE);
66d90823	55	}
1c6fdbd8	56
5735608c	57	static inline struct bucket gc_bucket(struct bch_dev ca, size_t b)
1c6fdbd8	58	{
49f2d182 KO	59	return bucket_valid(ca, b)
	60	? genradix_ptr(&ca->buckets_gc, b)
	61	: NULL;
1c6fdbd8 KO	62	}
1c6fdbd8 KO	63
a7860877 KO	64	static inline struct bucket_gens bucket_gens(struct bch_dev ca)
	65	{
	66	return rcu_dereference_check(ca->bucket_gens,
49f2d182	67	lockdep_is_held(&ca->fs->state_lock));
a7860877 KO	68	}
	69
	70	static inline u8 bucket_gen(struct bch_dev ca, size_t b)
	71	{
	72	struct bucket_gens *gens = bucket_gens(ca);
	73
9c4acd19 KO	74	if (b - gens->first_bucket >= gens->nbuckets_minus_first)
9c4acd19 KO	75	return NULL;
a7860877 KO	76	return gens->b + b;
	77	}
	78
fd00045f KO	79	static inline int bucket_gen_get_rcu(struct bch_dev *ca, size_t b)
	80	{
	81	u8 *gen = bucket_gen(ca, b);
	82	return gen ? *gen : -1;
	83	}
	84
	85	static inline int bucket_gen_get(struct bch_dev *ca, size_t b)
6f692b16	86	{
18dad454 KO	87	guard(rcu)();
18dad454 KO	88	return bucket_gen_get_rcu(ca, b);
6f692b16 KO	89	}
6f692b16 KO	90
1c6fdbd8 KO	91	static inline size_t PTR_BUCKET_NR(const struct bch_dev *ca,
	92	const struct bch_extent_ptr *ptr)
	93	{
	94	return sector_to_bucket(ca, ptr->offset);
	95	}
	96
1f2f92ec KO	97	static inline struct bpos PTR_BUCKET_POS(const struct bch_dev *ca,
1f2f92ec KO	98	const struct bch_extent_ptr *ptr)
3d48a7f8	99	{
3d48a7f8 KO	100	return POS(ptr->dev, PTR_BUCKET_NR(ca, ptr));
	101	}
	102
1f2f92ec	103	static inline struct bpos PTR_BUCKET_POS_OFFSET(const struct bch_dev *ca,
a8c752bb KO	104	const struct bch_extent_ptr *ptr,
	105	u32 *bucket_offset)
	106	{
a8c752bb KO	107	return POS(ptr->dev, sector_to_bucket_and_offset(ca, ptr->offset, bucket_offset));
	108	}
	109
47ac34ec KO	110	static inline struct bucket PTR_GC_BUCKET(struct bch_dev ca,
47ac34ec KO	111	const struct bch_extent_ptr *ptr)
1c6fdbd8	112	{
47ac34ec	113	return gc_bucket(ca, PTR_BUCKET_NR(ca, ptr));
1c6fdbd8 KO	114	}
1c6fdbd8 KO	115
06ab329c KO	116	static inline enum bch_data_type ptr_data_type(const struct bkey *k,
	117	const struct bch_extent_ptr *ptr)
	118	{
f0ac7df2	119	if (bkey_is_btree_ptr(k))
89fd25be	120	return BCH_DATA_btree;
06ab329c	121
89fd25be	122	return ptr->cached ? BCH_DATA_cached : BCH_DATA_user;
06ab329c KO	123	}
06ab329c KO	124
a8c752bb KO	125	static inline s64 ptr_disk_sectors(s64 sectors, struct extent_ptr_decoded p)
	126	{
	127	EBUG_ON(sectors < 0);
	128
	129	return crc_is_compressed(p.crc)
	130	? DIV_ROUND_UP_ULL(sectors * p.crc.compressed_size,
	131	p.crc.uncompressed_size)
	132	: sectors;
	133	}
	134
1c6fdbd8 KO	135	static inline int gen_cmp(u8 a, u8 b)
	136	{
	137	return (s8) (a - b);
	138	}
	139
	140	static inline int gen_after(u8 a, u8 b)
	141	{
ff4cb203	142	return max(0, gen_cmp(a, b));
1c6fdbd8 KO	143	}
1c6fdbd8 KO	144
9432e90d	145	static inline int dev_ptr_stale_rcu(struct bch_dev ca, const struct bch_extent_ptr ptr)
3858aa42	146	{
fd00045f KO	147	int gen = bucket_gen_get_rcu(ca, PTR_BUCKET_NR(ca, ptr));
fd00045f KO	148	return gen < 0 ? gen : gen_after(gen, ptr->gen);
3858aa42 KO	149	}
3858aa42 KO	150
1c6fdbd8	151	/**
3858aa42	152	* dev_ptr_stale() - check if a pointer points into a bucket that has been
1c6fdbd8 KO	153	* invalidated.
1c6fdbd8 KO	154	*/
9432e90d	155	static inline int dev_ptr_stale(struct bch_dev ca, const struct bch_extent_ptr ptr)
1c6fdbd8	156	{
18dad454 KO	157	guard(rcu)();
18dad454 KO	158	return dev_ptr_stale_rcu(ca, ptr);
1c6fdbd8 KO	159	}
1c6fdbd8 KO	160
1c6fdbd8 KO	161	/* Device usage: */
1c6fdbd8 KO	162
ed80c569 KO	163	void bch2_dev_usage_read_fast(struct bch_dev , struct bch_dev_usage );
	164	static inline struct bch_dev_usage bch2_dev_usage_read(struct bch_dev *ca)
	165	{
	166	struct bch_dev_usage ret;
	167
	168	bch2_dev_usage_read_fast(ca, &ret);
	169	return ret;
	170	}
	171
955ba7b5 KO	172	void bch2_dev_usage_full_read_fast(struct bch_dev , struct bch_dev_usage_full );
	173	static inline struct bch_dev_usage_full bch2_dev_usage_full_read(struct bch_dev *ca)
	174	{
	175	struct bch_dev_usage_full ret;
	176
	177	bch2_dev_usage_full_read_fast(ca, &ret);
	178	return ret;
	179	}
	180
	181	void bch2_dev_usage_to_text(struct printbuf , struct bch_dev , struct bch_dev_usage_full *);
1c6fdbd8	182
e53a961c	183	static inline u64 bch2_dev_buckets_reserved(struct bch_dev *ca, enum bch_watermark watermark)
f25d8215	184	{
f25d8215 KO	185	s64 reserved = 0;
f25d8215 KO	186
e53a961c KO	187	switch (watermark) {
e53a961c KO	188	case BCH_WATERMARK_NR:
3764647b	189	BUG();
e53a961c	190	case BCH_WATERMARK_stripe:
e84face6 KO	191	reserved += ca->mi.nbuckets >> 6;
e84face6 KO	192	fallthrough;
e53a961c	193	case BCH_WATERMARK_normal:
f25d8215 KO	194	reserved += ca->mi.nbuckets >> 6;
f25d8215 KO	195	fallthrough;
e53a961c	196	case BCH_WATERMARK_copygc:
f25d8215 KO	197	reserved += ca->nr_btree_reserve;
f25d8215 KO	198	fallthrough;
e53a961c	199	case BCH_WATERMARK_btree:
f25d8215 KO	200	reserved += ca->nr_btree_reserve;
f25d8215 KO	201	fallthrough;
e53a961c	202	case BCH_WATERMARK_btree_copygc:
494036d8	203	case BCH_WATERMARK_reclaim:
e2a316b3	204	case BCH_WATERMARK_interior_updates:
f25d8215	205	break;
f25d8215	206	}
1c6fdbd8	207
822835ff KO	208	return reserved;
822835ff KO	209	}
1c6fdbd8	210
30f0349d KO	211	static inline u64 dev_buckets_free(struct bch_dev *ca,
30f0349d KO	212	struct bch_dev_usage usage,
e53a961c	213	enum bch_watermark watermark)
30f0349d KO	214	{
30f0349d KO	215	return max_t(s64, 0,
955ba7b5	216	usage.buckets[BCH_DATA_free]-
30f0349d	217	ca->nr_open_buckets -
e53a961c	218	bch2_dev_buckets_reserved(ca, watermark));
30f0349d KO	219	}
30f0349d KO	220
822835ff KO	221	static inline u64 __dev_buckets_available(struct bch_dev *ca,
822835ff KO	222	struct bch_dev_usage usage,
e53a961c	223	enum bch_watermark watermark)
822835ff	224	{
f25d8215	225	return max_t(s64, 0,
955ba7b5 KO	226	usage.buckets[BCH_DATA_free]
	227	+ usage.buckets[BCH_DATA_cached]
	228	+ usage.buckets[BCH_DATA_need_gc_gens]
	229	+ usage.buckets[BCH_DATA_need_discard]
58aaa083	230	- ca->nr_open_buckets
e53a961c	231	- bch2_dev_buckets_reserved(ca, watermark));
1c6fdbd8 KO	232	}
1c6fdbd8 KO	233
f25d8215	234	static inline u64 dev_buckets_available(struct bch_dev *ca,
e53a961c	235	enum bch_watermark watermark)
1c6fdbd8	236	{
e53a961c	237	return __dev_buckets_available(ca, bch2_dev_usage_read(ca), watermark);
1c6fdbd8 KO	238	}
	239
	240	/* Filesystem usage: */
	241
5663a415 KO	242	struct bch_fs_usage_short
5663a415 KO	243	bch2_fs_usage_read_short(struct bch_fs *);
b092dadd	244
07d7c4da KO	245	int bch2_bucket_ref_update(struct btree_trans , struct bch_dev ,
07d7c4da KO	246	struct bkey_s_c, const struct bch_extent_ptr *,
70e3e039	247	s64, enum bch_data_type, u8, u8, u32 *);
f4f78779	248
f40d13f9 KO	249	int bch2_check_fix_ptrs(struct btree_trans *,
	250	enum btree_id, unsigned, struct bkey_s_c,
	251	enum btree_iter_update_trigger_flags);
	252
4f9ec59f	253	int bch2_trigger_extent(struct btree_trans *, enum btree_id, unsigned,
5dd8c60e KO	254	struct bkey_s_c, struct bkey_s,
5dd8c60e KO	255	enum btree_iter_update_trigger_flags);
6cacd0c4	256	int bch2_trigger_reservation(struct btree_trans *, enum btree_id, unsigned,
5dd8c60e KO	257	struct bkey_s_c, struct bkey_s,
5dd8c60e KO	258	enum btree_iter_update_trigger_flags);
880e2275	259
282e7c37	260	#define trigger_run_overwrite_then_insert(_fn, _trans, _btree_id, _level, _old, _new, _flags)\
523f33ef KO	261	({ \
	262	int ret = 0; \
	263	\
	264	if (_old.k->type) \
5dd8c60e	265	ret = _fn(_trans, _btree_id, _level, _old, _flags & ~BTREE_TRIGGER_insert); \
523f33ef	266	if (!ret && _new.k->type) \
5dd8c60e	267	ret = _fn(_trans, _btree_id, _level, _new.s_c, _flags & ~BTREE_TRIGGER_overwrite);\
523f33ef KO	268	ret; \
	269	})
	270
5b14ce35 KO	271	void bch2_trans_account_disk_usage_change(struct btree_trans *);
5b14ce35 KO	272
c281db0f	273	int bch2_trans_mark_metadata_bucket(struct btree_trans , struct bch_dev , u64,
5dd8c60e KO	274	enum bch_data_type, unsigned,
	275	enum btree_iter_update_trigger_flags);
	276	int bch2_trans_mark_dev_sb(struct bch_fs , struct bch_dev ,
	277	enum btree_iter_update_trigger_flags);
	278	int bch2_trans_mark_dev_sbs_flags(struct bch_fs *,
	279	enum btree_iter_update_trigger_flags);
bbe682c7	280	int bch2_trans_mark_dev_sbs(struct bch_fs *);
bfcf840d	281
828552ca	282	bool bch2_is_superblock_bucket(struct bch_dev *, u64);
fb8e5b4c	283
e58f963c KO	284	static inline const char *bch2_data_type_str(enum bch_data_type type)
	285	{
	286	return type < BCH_DATA_NR
	287	? __bch2_data_types[type]
	288	: "(invalid data type)";
	289	}
	290
5663a415	291	/* disk reservations: */
1c6fdbd8	292
1c6fdbd8 KO	293	static inline void bch2_disk_reservation_put(struct bch_fs *c,
	294	struct disk_reservation *res)
	295	{
7e94eeff KO	296	if (res->sectors) {
	297	this_cpu_sub(*c->online_reserved, res->sectors);
	298	res->sectors = 0;
	299	}
1c6fdbd8 KO	300	}
1c6fdbd8 KO	301
335d318e KO	302	enum bch_reservation_flags {
	303	BCH_DISK_RESERVATION_NOFAIL = 1 << 0,
	304	BCH_DISK_RESERVATION_PARTIAL = 1 << 1,
	305	};
1c6fdbd8	306
335d318e KO	307	int __bch2_disk_reservation_add(struct bch_fs , struct disk_reservation ,
335d318e KO	308	u64, enum bch_reservation_flags);
7e94eeff KO	309
7e94eeff KO	310	static inline int bch2_disk_reservation_add(struct bch_fs c, struct disk_reservation res,
335d318e	311	u64 sectors, enum bch_reservation_flags flags)
7e94eeff	312	{
b2d1d56b	313	#ifdef __KERNEL__
7e94eeff KO	314	u64 old, new;
7e94eeff KO	315
68573b93	316	old = this_cpu_read(c->pcpu->sectors_available);
7e94eeff	317	do {
7e94eeff KO	318	if (sectors > old)
	319	return __bch2_disk_reservation_add(c, res, sectors, flags);
	320
	321	new = old - sectors;
68573b93	322	} while (!this_cpu_try_cmpxchg(c->pcpu->sectors_available, &old, new));
7e94eeff KO	323
	324	this_cpu_add(*c->online_reserved, sectors);
	325	res->sectors += sectors;
	326	return 0;
b2d1d56b KO	327	#else
	328	return __bch2_disk_reservation_add(c, res, sectors, flags);
	329	#endif
7e94eeff	330	}
1c6fdbd8 KO	331
	332	static inline struct disk_reservation
	333	bch2_disk_reservation_init(struct bch_fs *c, unsigned nr_replicas)
	334	{
	335	return (struct disk_reservation) {
	336	.sectors = 0,
	337	#if 0
	338	/* not used yet: */
	339	.gen = c->capacity_gen,
	340	#endif
	341	.nr_replicas = nr_replicas,
	342	};
	343	}
	344
	345	static inline int bch2_disk_reservation_get(struct bch_fs *c,
	346	struct disk_reservation *res,
cd9f3dfe	347	u64 sectors, unsigned nr_replicas,
1c6fdbd8 KO	348	int flags)
	349	{
	350	*res = bch2_disk_reservation_init(c, nr_replicas);
	351
	352	return bch2_disk_reservation_add(c, res, sectors * nr_replicas, flags);
	353	}
	354
ed343411 DR	355	#define RESERVE_FACTOR 6
	356
	357	static inline u64 avail_factor(u64 r)
	358	{
	359	return div_u64(r << RESERVE_FACTOR, (1 << RESERVE_FACTOR) + 1);
	360	}
	361
ffcbec60 KO	362	void bch2_buckets_nouse_free(struct bch_fs *);
	363	int bch2_buckets_nouse_alloc(struct bch_fs *);
	364
1c6fdbd8 KO	365	int bch2_dev_buckets_resize(struct bch_fs , struct bch_dev , u64);
	366	void bch2_dev_buckets_free(struct bch_dev *);
	367	int bch2_dev_buckets_alloc(struct bch_fs , struct bch_dev );
	368
	369	#endif /* _BUCKETS_H */