[mirror_ubuntu-jammy-kernel.git] / fs / btrfs / space-info.h

/* SPDX-License-Identifier: GPL-2.0 */

#ifndef BTRFS_SPACE_INFO_H
#define BTRFS_SPACE_INFO_H

struct btrfs_space_info {
	spinlock_t lock;

	u64 total_bytes;	/* total bytes in the space,
				   this doesn't take mirrors into account */
	u64 bytes_used;		/* total bytes used,
				   this doesn't take mirrors into account */
	u64 bytes_pinned;	/* total bytes pinned, will be freed when the
				   transaction finishes */
	u64 bytes_reserved;	/* total bytes the allocator has reserved for
				   current allocations */
	u64 bytes_may_use;	/* number of bytes that may be used for
				   delalloc/allocations */
	u64 bytes_readonly;	/* total bytes that are read only */

	u64 max_extent_size;	/* This will hold the maximum extent size of
				   the space info if we had an ENOSPC in the
				   allocator. */

	unsigned int full:1;	/* indicates that we cannot allocate any more
				   chunks for this space */
	unsigned int chunk_alloc:1;	/* set if we are allocating a chunk */

	unsigned int flush:1;		/* set if we are trying to make space */

	unsigned int force_alloc;	/* set if we need to force a chunk
					   alloc for this space */

	u64 disk_used;		/* total bytes used on disk */
	u64 disk_total;		/* total bytes on disk, takes mirrors into
				   account */

	u64 flags;

	/*
	 * bytes_pinned is kept in line with what is actually pinned, as in
	 * we've called update_block_group and dropped the bytes_used counter
	 * and increased the bytes_pinned counter.  However this means that
	 * bytes_pinned does not reflect the bytes that will be pinned once the
	 * delayed refs are flushed, so this counter is inc'ed every time we
	 * call btrfs_free_extent so it is a realtime count of what will be
	 * freed once the transaction is committed.  It will be zeroed every
	 * time the transaction commits.
	 */
	struct percpu_counter total_bytes_pinned;

	struct list_head list;
	/* Protected by the spinlock 'lock'. */
	struct list_head ro_bgs;
	struct list_head priority_tickets;
	struct list_head tickets;
	/*
	 * tickets_id just indicates the next ticket will be handled, so note
	 * it's not stored per ticket.
	 */
	u64 tickets_id;

	struct rw_semaphore groups_sem;
	/* for block groups in our same type */
	struct list_head block_groups[BTRFS_NR_RAID_TYPES];

	struct kobject kobj;
	struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
};

struct reserve_ticket {
	u64 bytes;
	int error;
	struct list_head list;
	wait_queue_head_t wait;
};

static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
{
	return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
		(space_info->flags & BTRFS_BLOCK_GROUP_DATA));
}

/*
 *
 * Declare a helper function to detect underflow of various space info members
 */
#define DECLARE_SPACE_INFO_UPDATE(name, trace_name)			\
static inline void							\
btrfs_space_info_update_##name(struct btrfs_fs_info *fs_info,		\
			       struct btrfs_space_info *sinfo,		\
			       s64 bytes)				\
{									\
	const u64 abs_bytes = (bytes < 0) ? -bytes : bytes;		\
	lockdep_assert_held(&sinfo->lock);				\
	trace_update_##name(fs_info, sinfo, sinfo->name, bytes);	\
	trace_btrfs_space_reservation(fs_info, trace_name,		\
				      sinfo->flags, abs_bytes,		\
				      bytes > 0);			\
	if (bytes < 0 && sinfo->name < -bytes) {			\
		WARN_ON(1);						\
		sinfo->name = 0;					\
		return;							\
	}								\
	sinfo->name += bytes;						\
}

DECLARE_SPACE_INFO_UPDATE(bytes_may_use, "space_info");
DECLARE_SPACE_INFO_UPDATE(bytes_pinned, "pinned");

int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags,
			     u64 total_bytes, u64 bytes_used,
			     u64 bytes_readonly,
			     struct btrfs_space_info **space_info);
struct btrfs_space_info *btrfs_find_space_info(struct btrfs_fs_info *info,
					       u64 flags);
u64 __pure btrfs_space_info_used(struct btrfs_space_info *s_info,
			  bool may_use_included);
void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
void btrfs_dump_space_info(struct btrfs_fs_info *fs_info,
			   struct btrfs_space_info *info, u64 bytes,
			   int dump_block_groups);
int btrfs_reserve_metadata_bytes(struct btrfs_root *root,
				 struct btrfs_block_rsv *block_rsv,
				 u64 orig_bytes,
				 enum btrfs_reserve_flush_enum flush);
void btrfs_try_granting_tickets(struct btrfs_fs_info *fs_info,
				struct btrfs_space_info *space_info);
int btrfs_can_overcommit(struct btrfs_fs_info *fs_info,
			 struct btrfs_space_info *space_info, u64 bytes,
			 enum btrfs_reserve_flush_enum flush);

static inline void btrfs_space_info_free_bytes_may_use(
				struct btrfs_fs_info *fs_info,
				struct btrfs_space_info *space_info,
				u64 num_bytes)
{
	spin_lock(&space_info->lock);
	btrfs_space_info_update_bytes_may_use(fs_info, space_info, -num_bytes);
	btrfs_try_granting_tickets(fs_info, space_info);
	spin_unlock(&space_info->lock);
}

#endif /* BTRFS_SPACE_INFO_H */
Commit	Line	Data
8719aaae JB	1	/* SPDX-License-Identifier: GPL-2.0 */
	2
	3	#ifndef BTRFS_SPACE_INFO_H
	4	#define BTRFS_SPACE_INFO_H
	5
	6	struct btrfs_space_info {
	7	spinlock_t lock;
	8
	9	u64 total_bytes; /* total bytes in the space,
	10	this doesn't take mirrors into account */
	11	u64 bytes_used; /* total bytes used,
	12	this doesn't take mirrors into account */
	13	u64 bytes_pinned; /* total bytes pinned, will be freed when the
	14	transaction finishes */
	15	u64 bytes_reserved; /* total bytes the allocator has reserved for
	16	current allocations */
	17	u64 bytes_may_use; /* number of bytes that may be used for
	18	delalloc/allocations */
	19	u64 bytes_readonly; /* total bytes that are read only */
	20
	21	u64 max_extent_size; /* This will hold the maximum extent size of
	22	the space info if we had an ENOSPC in the
	23	allocator. */
	24
	25	unsigned int full:1; /* indicates that we cannot allocate any more
	26	chunks for this space */
	27	unsigned int chunk_alloc:1; /* set if we are allocating a chunk */
	28
	29	unsigned int flush:1; /* set if we are trying to make space */
	30
	31	unsigned int force_alloc; /* set if we need to force a chunk
	32	alloc for this space */
	33
	34	u64 disk_used; /* total bytes used on disk */
	35	u64 disk_total; /* total bytes on disk, takes mirrors into
	36	account */
	37
	38	u64 flags;
	39
	40	/*
	41	* bytes_pinned is kept in line with what is actually pinned, as in
	42	* we've called update_block_group and dropped the bytes_used counter
	43	* and increased the bytes_pinned counter. However this means that
	44	* bytes_pinned does not reflect the bytes that will be pinned once the
	45	* delayed refs are flushed, so this counter is inc'ed every time we
	46	* call btrfs_free_extent so it is a realtime count of what will be
	47	* freed once the transaction is committed. It will be zeroed every
	48	* time the transaction commits.
	49	*/
	50	struct percpu_counter total_bytes_pinned;
	51
	52	struct list_head list;
	53	/* Protected by the spinlock 'lock'. */
	54	struct list_head ro_bgs;
	55	struct list_head priority_tickets;
	56	struct list_head tickets;
	57	/*
	58	* tickets_id just indicates the next ticket will be handled, so note
	59	* it's not stored per ticket.
	60	*/
	61	u64 tickets_id;
	62
	63	struct rw_semaphore groups_sem;
	64	/* for block groups in our same type */
65	struct list_head block_groups[BTRFS_NR_RAID_TYPES];
8719aaae JB	66
	67	struct kobject kobj;
	68	struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
	69	};
	70
b338b013	71	struct reserve_ticket {
b338b013 JB	72	u64 bytes;
	73	int error;
	74	struct list_head list;
	75	wait_queue_head_t wait;
	76	};
	77
8719aaae JB	78	static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
	79	{
	80	return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
	81	(space_info->flags & BTRFS_BLOCK_GROUP_DATA));
	82	}
	83
bb96c4e5 JB	84	/*
	85	*
	86	* Declare a helper function to detect underflow of various space info members
	87	*/
f3e75e38	88	#define DECLARE_SPACE_INFO_UPDATE(name, trace_name) \
bb96c4e5 JB	89	static inline void \
	90	btrfs_space_info_update_##name(struct btrfs_fs_info *fs_info, \
	91	struct btrfs_space_info *sinfo, \
	92	s64 bytes) \
	93	{ \
f3e75e38	94	const u64 abs_bytes = (bytes < 0) ? -bytes : bytes; \
bb96c4e5 JB	95	lockdep_assert_held(&sinfo->lock); \
bb96c4e5 JB	96	trace_update_##name(fs_info, sinfo, sinfo->name, bytes); \
f3e75e38 JB	97	trace_btrfs_space_reservation(fs_info, trace_name, \
	98	sinfo->flags, abs_bytes, \
	99	bytes > 0); \
bb96c4e5 JB	100	if (bytes < 0 && sinfo->name < -bytes) { \
	101	WARN_ON(1); \
	102	sinfo->name = 0; \
	103	return; \
	104	} \
	105	sinfo->name += bytes; \
	106	}
	107
f3e75e38 JB	108	DECLARE_SPACE_INFO_UPDATE(bytes_may_use, "space_info");
f3e75e38 JB	109	DECLARE_SPACE_INFO_UPDATE(bytes_pinned, "pinned");
bb96c4e5	110
280c2908 JB	111	int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
	112	void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags,
	113	u64 total_bytes, u64 bytes_used,
	114	u64 bytes_readonly,
	115	struct btrfs_space_info **space_info);
	116	struct btrfs_space_info btrfs_find_space_info(struct btrfs_fs_info info,
	117	u64 flags);
e1f60a65	118	u64 __pure btrfs_space_info_used(struct btrfs_space_info *s_info,
280c2908 JB	119	bool may_use_included);
280c2908 JB	120	void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
5da6afeb JB	121	void btrfs_dump_space_info(struct btrfs_fs_info *fs_info,
	122	struct btrfs_space_info *info, u64 bytes,
	123	int dump_block_groups);
0d9764f6 JB	124	int btrfs_reserve_metadata_bytes(struct btrfs_root *root,
	125	struct btrfs_block_rsv *block_rsv,
	126	u64 orig_bytes,
	127	enum btrfs_reserve_flush_enum flush);
18fa2284 JB	128	void btrfs_try_granting_tickets(struct btrfs_fs_info *fs_info,
18fa2284 JB	129	struct btrfs_space_info *space_info);
a30a3d20 JB	130	int btrfs_can_overcommit(struct btrfs_fs_info *fs_info,
	131	struct btrfs_space_info *space_info, u64 bytes,
	132	enum btrfs_reserve_flush_enum flush);
18fa2284	133
d05e4649	134	static inline void btrfs_space_info_free_bytes_may_use(
18fa2284 JB	135	struct btrfs_fs_info *fs_info,
	136	struct btrfs_space_info *space_info,
	137	u64 num_bytes)
	138	{
	139	spin_lock(&space_info->lock);
	140	btrfs_space_info_update_bytes_may_use(fs_info, space_info, -num_bytes);
	141	btrfs_try_granting_tickets(fs_info, space_info);
	142	spin_unlock(&space_info->lock);
	143	}
d44b72aa	144
8719aaae	145	#endif /* BTRFS_SPACE_INFO_H */