1 files changed, 133 insertions, 0 deletions
diff --git a/fs/btrfs/space-info.h b/fs/btrfs/space-info.h
new file mode 100644
index 000000000000..c2b54b8e1a14
--- /dev/null
+++ b/fs/btrfs/space-info.h
@@ -0,0 +1,133 @@
+/* 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);
+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);
+#endif /* BTRFS_SPACE_INFO_H */

diff --git a/fs/btrfs/space-info.h b/fs/btrfs/space-info.h new file mode 100644 index 000000000000..c2b54b8e1a14 --- /dev/null +++ b/fs/btrfs/space-info.h
@@ -0,0 +1,133 @@
	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
	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
	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
	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
	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);
	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);
	125	void btrfs_dump_space_info(struct btrfs_fs_info *fs_info,
	126	struct btrfs_space_info *info, u64 bytes,
	127	int dump_block_groups);
	128	int btrfs_reserve_metadata_bytes(struct btrfs_root *root,
	129	struct btrfs_block_rsv *block_rsv,
	130	u64 orig_bytes,
	131	enum btrfs_reserve_flush_enum flush);
	132
	133	#endif /* BTRFS_SPACE_INFO_H */