[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];
	wait_queue_head_t wait;

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

struct reserve_ticket {
	u64 orig_bytes;
	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)					\
static inline void							\
btrfs_space_info_update_##name(struct btrfs_fs_info *fs_info,		\
			       struct btrfs_space_info *sinfo,		\
			       s64 bytes)				\
{									\
	lockdep_assert_held(&sinfo->lock);				\
	trace_update_##name(fs_info, sinfo, sinfo->name, bytes);	\
	if (bytes < 0 && sinfo->name < -bytes) {			\
		WARN_ON(1);						\
		sinfo->name = 0;					\
		return;							\
	}								\
	sinfo->name += bytes;						\
}

DECLARE_SPACE_INFO_UPDATE(bytes_may_use);
DECLARE_SPACE_INFO_UPDATE(bytes_pinned);

void btrfs_space_info_add_new_bytes(struct btrfs_fs_info *fs_info,
				    struct btrfs_space_info *space_info,
				    u64 num_bytes);
void btrfs_space_info_add_old_bytes(struct btrfs_fs_info *fs_info,
				    struct btrfs_space_info *space_info,
				    u64 num_bytes);
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 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);
int btrfs_can_overcommit(struct btrfs_fs_info *fs_info,
			 struct btrfs_space_info *space_info, u64 bytes,
			 enum btrfs_reserve_flush_enum flush,
			 bool system_chunk);

#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];
66	wait_queue_head_t wait;
67
68	struct kobject kobj;
69	struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
70	};
71
b338b013 JB	72	struct reserve_ticket {
	73	u64 orig_bytes;
	74	u64 bytes;
	75	int error;
	76	struct list_head list;
	77	wait_queue_head_t wait;
	78	};
	79
8719aaae JB	80	static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
	81	{
	82	return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
	83	(space_info->flags & BTRFS_BLOCK_GROUP_DATA));
	84	}
	85
bb96c4e5 JB	86	/*
	87	*
	88	* Declare a helper function to detect underflow of various space info members
	89	*/
	90	#define DECLARE_SPACE_INFO_UPDATE(name) \
	91	static inline void \
	92	btrfs_space_info_update_##name(struct btrfs_fs_info *fs_info, \
	93	struct btrfs_space_info *sinfo, \
	94	s64 bytes) \
	95	{ \
	96	lockdep_assert_held(&sinfo->lock); \
	97	trace_update_##name(fs_info, sinfo, sinfo->name, bytes); \
	98	if (bytes < 0 && sinfo->name < -bytes) { \
	99	WARN_ON(1); \
	100	sinfo->name = 0; \
	101	return; \
	102	} \
	103	sinfo->name += bytes; \
	104	}
	105
	106	DECLARE_SPACE_INFO_UPDATE(bytes_may_use);
	107	DECLARE_SPACE_INFO_UPDATE(bytes_pinned);
	108
d44b72aa JB	109	void btrfs_space_info_add_new_bytes(struct btrfs_fs_info *fs_info,
	110	struct btrfs_space_info *space_info,
	111	u64 num_bytes);
	112	void btrfs_space_info_add_old_bytes(struct btrfs_fs_info *fs_info,
	113	struct btrfs_space_info *space_info,
	114	u64 num_bytes);
280c2908 JB	115	int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
	116	void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags,
	117	u64 total_bytes, u64 bytes_used,
	118	u64 bytes_readonly,
	119	struct btrfs_space_info **space_info);
	120	struct btrfs_space_info btrfs_find_space_info(struct btrfs_fs_info info,
	121	u64 flags);
	122	u64 btrfs_space_info_used(struct btrfs_space_info *s_info,
	123	bool may_use_included);
	124	void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
41783ef2 JB	125	int btrfs_can_overcommit(struct btrfs_fs_info *fs_info,
	126	struct btrfs_space_info *space_info, u64 bytes,
	127	enum btrfs_reserve_flush_enum flush,
	128	bool system_chunk);
d44b72aa	129
8719aaae	130	#endif /* BTRFS_SPACE_INFO_H */