subpage.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2
  3#ifndef BTRFS_SUBPAGE_H
  4#define BTRFS_SUBPAGE_H
  5
  6#include <linux/spinlock.h>
  7#include <linux/atomic.h>
  8#include <linux/sizes.h>
  9#include "btrfs_inode.h"
 10
 11struct address_space;
 12struct folio;
 13
 14/*
 15 * Extra info for subpage bitmap.
 16 *
 17 * For subpage we pack all uptodate/dirty/writeback/ordered bitmaps into
 18 * one larger bitmap.
 19 *
 20 * This structure records how they are organized in the bitmap:
 21 *
 22 * /- uptodate          /- dirty        /- ordered
 23 * |			|		|
 24 * v			v		v
 25 * |u|u|u|u|........|u|u|d|d|.......|d|d|o|o|.......|o|o|
 26 * |< sectors_per_page >|
 27 *
 28 * Unlike regular macro-like enums, here we do not go upper-case names, as
 29 * these names will be utilized in various macros to define function names.
 30 */
 31enum {
 32	btrfs_bitmap_nr_uptodate = 0,
 33	btrfs_bitmap_nr_dirty,
 34
 35	/*
 36	 * This can be changed to atomic eventually.  But this change will rely
 37	 * on the async delalloc range rework for locked bitmap.  As async
 38	 * delalloc can unlock its range and mark blocks writeback at random
 39	 * timing.
 40	 */
 41	btrfs_bitmap_nr_writeback,
 42
 43	/*
 44	 * The ordered and checked flags are for COW fixup, already marked
 45	 * deprecated, and will be removed eventually.
 46	 */
 47	btrfs_bitmap_nr_ordered,
 48	btrfs_bitmap_nr_checked,
 49
 50	/*
 51	 * The locked bit is for async delalloc range (compression), currently
 52	 * async extent is queued with the range locked, until the compression
 53	 * is done.
 54	 * So an async extent can unlock the range at any random timing.
 55	 *
 56	 * This will need a rework on the async extent lifespan (mark writeback
 57	 * and do compression) before deprecating this flag.
 58	 */
 59	btrfs_bitmap_nr_locked,
 60	btrfs_bitmap_nr_max
 61};
 62
 63/*
 64 * Structure to trace status of each sector inside a page, attached to
 65 * page::private for both data and metadata inodes.
 66 */
 67struct btrfs_folio_state {
 68	/* Common members for both data and metadata pages */
 69	spinlock_t lock;
 70	union {
 71		/*
 72		 * Structures only used by metadata
 73		 *
 74		 * @eb_refs should only be operated under private_lock, as it
 75		 * manages whether the btrfs_folio_state can be detached.
 76		 */
 77		atomic_t eb_refs;
 78
 79		/*
 80		 * Structures only used by data,
 81		 *
 82		 * How many sectors inside the page is locked.
 83		 */
 84		atomic_t nr_locked;
 85	};
 86	unsigned long bitmaps[];
 87};
 88
 89enum btrfs_folio_type {
 90	BTRFS_SUBPAGE_METADATA,
 91	BTRFS_SUBPAGE_DATA,
 92};
 93
 94/*
 95 * Subpage support for metadata is more complex, as we can have dummy extent
 96 * buffers, where folios have no mapping to determine the owning inode.
 97 *
 98 * Thankfully we only need to check if node size is smaller than page size.
 99 * Even with larger folio support, we will only allocate a folio as large as
100 * node size.
101 * Thus if nodesize < PAGE_SIZE, we know metadata needs need to subpage routine.
102 */
103static inline bool btrfs_meta_is_subpage(const struct btrfs_fs_info *fs_info)
104{
105	return fs_info->nodesize < PAGE_SIZE;
106}
107static inline bool btrfs_is_subpage(const struct btrfs_fs_info *fs_info,
108				    struct folio *folio)
109{
110	if (folio->mapping && folio->mapping->host)
111		ASSERT(is_data_inode(BTRFS_I(folio->mapping->host)));
112	return fs_info->sectorsize < folio_size(folio);
113}
114
115int btrfs_attach_folio_state(const struct btrfs_fs_info *fs_info,
116			     struct folio *folio, enum btrfs_folio_type type);
117void btrfs_detach_folio_state(const struct btrfs_fs_info *fs_info, struct folio *folio,
118			      enum btrfs_folio_type type);
119
120/* Allocate additional data where page represents more than one sector */
121struct btrfs_folio_state *btrfs_alloc_folio_state(const struct btrfs_fs_info *fs_info,
122						  size_t fsize, enum btrfs_folio_type type);
123static inline void btrfs_free_folio_state(struct btrfs_folio_state *bfs)
124{
125	kfree(bfs);
126}
127
128void btrfs_folio_inc_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio);
129void btrfs_folio_dec_eb_refs(const struct btrfs_fs_info *fs_info, struct folio *folio);
130
131void btrfs_folio_end_lock(const struct btrfs_fs_info *fs_info,
132			  struct folio *folio, u64 start, u32 len);
133void btrfs_folio_set_lock(const struct btrfs_fs_info *fs_info,
134			  struct folio *folio, u64 start, u32 len);
135void btrfs_folio_end_lock_bitmap(const struct btrfs_fs_info *fs_info,
136				 struct folio *folio, unsigned long bitmap);
137/*
138 * Template for subpage related operations.
139 *
140 * btrfs_subpage_*() are for call sites where the folio has subpage attached and
141 * the range is ensured to be inside the folio's single page.
142 *
143 * btrfs_folio_*() are for call sites where the page can either be subpage
144 * specific or regular folios. The function will handle both cases.
145 * But the range still needs to be inside one single page.
146 *
147 * btrfs_folio_clamp_*() are similar to btrfs_folio_*(), except the range doesn't
148 * need to be inside the page. Those functions will truncate the range
149 * automatically.
150 *
151 * Both btrfs_folio_*() and btrfs_folio_clamp_*() are for data folios.
152 *
153 * For metadata, one should use btrfs_meta_folio_*() helpers instead, and there
154 * is no clamp version for metadata helpers, as we either go subpage
155 * (nodesize < PAGE_SIZE) or go regular folio helpers (nodesize >= PAGE_SIZE,
156 * and our folio is never larger than nodesize).
157 */
158#define DECLARE_BTRFS_SUBPAGE_OPS(name)					\
159void btrfs_subpage_set_##name(const struct btrfs_fs_info *fs_info,	\
160		struct folio *folio, u64 start, u32 len);			\
161void btrfs_subpage_clear_##name(const struct btrfs_fs_info *fs_info,	\
162		struct folio *folio, u64 start, u32 len);			\
163bool btrfs_subpage_test_##name(const struct btrfs_fs_info *fs_info,	\
164		struct folio *folio, u64 start, u32 len);			\
165void btrfs_folio_set_##name(const struct btrfs_fs_info *fs_info,	\
166		struct folio *folio, u64 start, u32 len);			\
167void btrfs_folio_clear_##name(const struct btrfs_fs_info *fs_info,	\
168		struct folio *folio, u64 start, u32 len);			\
169bool btrfs_folio_test_##name(const struct btrfs_fs_info *fs_info,	\
170		struct folio *folio, u64 start, u32 len);			\
171void btrfs_folio_clamp_set_##name(const struct btrfs_fs_info *fs_info,	\
172		struct folio *folio, u64 start, u32 len);			\
173void btrfs_folio_clamp_clear_##name(const struct btrfs_fs_info *fs_info,	\
174		struct folio *folio, u64 start, u32 len);			\
175bool btrfs_folio_clamp_test_##name(const struct btrfs_fs_info *fs_info,	\
176		struct folio *folio, u64 start, u32 len);		\
177void btrfs_meta_folio_set_##name(struct folio *folio, const struct extent_buffer *eb); \
178void btrfs_meta_folio_clear_##name(struct folio *folio, const struct extent_buffer *eb); \
179bool btrfs_meta_folio_test_##name(struct folio *folio, const struct extent_buffer *eb);
180
181DECLARE_BTRFS_SUBPAGE_OPS(uptodate);
182DECLARE_BTRFS_SUBPAGE_OPS(dirty);
183DECLARE_BTRFS_SUBPAGE_OPS(writeback);
184DECLARE_BTRFS_SUBPAGE_OPS(ordered);
185DECLARE_BTRFS_SUBPAGE_OPS(checked);
186
187/*
188 * Helper for error cleanup, where a folio will have its dirty flag cleared,
189 * with writeback started and finished.
190 */
191static inline void btrfs_folio_clamp_finish_io(struct btrfs_fs_info *fs_info,
192					       struct folio *locked_folio,
193					       u64 start, u32 len)
194{
195	btrfs_folio_clamp_clear_dirty(fs_info, locked_folio, start, len);
196	btrfs_folio_clamp_set_writeback(fs_info, locked_folio, start, len);
197	btrfs_folio_clamp_clear_writeback(fs_info, locked_folio, start, len);
198}
199
200bool btrfs_subpage_clear_and_test_dirty(const struct btrfs_fs_info *fs_info,
201					struct folio *folio, u64 start, u32 len);
202
203void btrfs_folio_assert_not_dirty(const struct btrfs_fs_info *fs_info,
204				  struct folio *folio, u64 start, u32 len);
205bool btrfs_meta_folio_clear_and_test_dirty(struct folio *folio, const struct extent_buffer *eb);
206void btrfs_get_subpage_dirty_bitmap(struct btrfs_fs_info *fs_info,
207				    struct folio *folio,
208				    unsigned long *ret_bitmap);
209void __cold btrfs_subpage_dump_bitmap(const struct btrfs_fs_info *fs_info,
210				      struct folio *folio, u64 start, u32 len);
211
212#endif