Skip to contentSkip to conversation

btrfs: add read-only support for subpage sector size

PATCH Superseded Qu Wenruo 5 participants 34 messages Jan 6, 2021 – Jan 13, 2021 Btrfs file system

v3 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Qu Wenruo

author
#0 lore raw

v3 cover btrfs: add read-only support for subpage sector size

Patches can be fetched from github:
https://github.com/adam900710/linux/tree/subpage
Currently the branch also contains partial RW data support (still some out-of-sync subpage data page status).

Great thanks to David for his effort reviewing and merging the preparation patches into misc-next.
Now all previously submitted preparation patches are already in misc-next.

=== What works ===

Just from the patchset:
- Data read
Both regular and compressed data, with csum check.

- Metadata read

This means, with these patchset, 64K page systems can at least mount btrfs with 4K sector size.

In the subpage branch
- Metadata read write and balance
Not yet full tested due to data write still has bugs need to be solved.
But considering that metadata operations from previous iteration is mostly untouched, metadata read write should be pretty stable.

- Baisc data balance
This is new.

- Data read write
Only uncompressed data writes. Fsstress can survive.
But still very rare data csum error, which only happens in bookend data extents (part of the data extent which is not referred by any file). This looks like something related to reflink/invalidate page and cow fixup.
Still invetigating.

=== Needs feedback ===
The following design needs extra comments:

- u16 bitmap
As David mentioned, using u16 as bit map is not the fastest way. That's also why current bitmap code requires unsigned long (u32) as minimal unit.
But using bitmap directly would double the memory usage. Thus the best way is to pack two u16 bitmap into one u32 bitmap, but that still needs extra investigation to find better practice.

Anyway the skeleton should be pretty simple to expand.

- Separate handling for subpage metadata
Currently the metadata read and (later write path) handles subpage metadata differently. Mostly due to the page locking must be skipped for subpage metadata.
I tried several times to use as many common code as possible, but every time I ended up reverting back to current code.

Thankfully, for data handling we will use the same common code.

- Incompatible subpage strcuture against iomap_page
In btrfs we need extra bits than iomap_page.
This is due to we need sector perfect write for data balance. E.g. if only one 4K sector is dirty in a 64K page, we should only write that dirty 4K back to disk, not the full 64K page.

As data balance requires the new data extents to have exactly the same size as the original ones.
This means, unless iomap_page get extra bits like what we're doing in btrfs for dirty, we can't merge the btrfs_subpage with iomap_page.

=== Patchset structure ===
Patch 01~03: Existing preparation patches.
Mostly readability related patches found during RW development
Patch 04~05: New preparation patches.
Mostly related to __process_pages_contig().
Patch 06~10: Subpage handling for extent buffer allocation and
freeing
Patch 11~22: Subpage handling for extent buffer read path

=== Changelog ===
v1:
- Separate the main implementation from previous huge patchset Huge patchset doesn't make much sense.

- Use bitmap implementation
Now page::private will be a pointer to btrfs_subpage structure, which contains bitmaps for various page status.

v2:
- Use page::private as btrfs_subpage for extra info
This replace old extent io tree based solution, which reduces latency and don't require memory allocation for its operations.

- Cherry-pick new preparation patches from RW development Those new preparation patches improves the readability by their own.

v3:
- Make dummy extent buffer to follow the same subpage accessors Fsstress exposed several ASSERT() for dummy extent buffers. It turns out we need to make dummy extent buffer to own the same btrfs_subpage structure to make eb accessors to work properly

- Two new small __process_pages_contig() related preparation patches One to make __process_pages_contig() to enhance the error handling path for locked_page, one to merge one macro.

- Extent buffers refs count update
Except try_release_extent_buffer(), all other eb uses will try to increase the ref count of the eb.
For try_release_extent_buffer(), the eb refs check will happen inside the rcu critical section to avoid eb being freed.

- Comment updates
Addressing the comments from the mail list.

Qu Wenruo (22):
btrfs: extent_io: rename @offset parameter to @disk_bytenr for
submit_extent_page()
btrfs: extent_io: refactor __extent_writepage_io() to improve
readability
btrfs: file: update comment for btrfs_dirty_pages()
btrfs: extent_io: update locked page dirty/writeback/error bits in
__process_pages_contig()
btrfs: extent_io: merge PAGE_CLEAR_DIRTY and PAGE_SET_WRITEBACK into
PAGE_START_WRITEBACK
btrfs: extent_io: introduce a helper to grab an existing extent buffer
from a page
btrfs: extent_io: introduce the skeleton of btrfs_subpage structure
btrfs: extent_io: make attach_extent_buffer_page() to handle subpage
case
btrfs: extent_io: make grab_extent_buffer_from_page() to handle
subpage case
btrfs: extent_io: support subpage for extent buffer page release
btrfs: extent_io: attach private to dummy extent buffer pages
btrfs: subpage: introduce helper for subpage uptodate status
btrfs: subpage: introduce helper for subpage error status
btrfs: extent_io: make set/clear_extent_buffer_uptodate() to support
subpage size
btrfs: extent_io: make btrfs_clone_extent_buffer() to be subpage
compatible
btrfs: extent_io: implement try_release_extent_buffer() for subpage
metadata support
btrfs: extent_io: introduce read_extent_buffer_subpage()
btrfs: extent_io: make endio_readpage_update_page_status() to handle
subpage case
btrfs: disk-io: introduce subpage metadata validation check
btrfs: introduce btrfs_subpage for data inodes
btrfs: integrate page status update for read path into
begin/end_page_read()
btrfs: allow RO mount of 4K sector size fs on 64K page system

 fs/btrfs/Makefile           |   3 +-
 fs/btrfs/compression.c      |  10 +-
 fs/btrfs/disk-io.c          |  82 +++++-
 fs/btrfs/extent_io.c        | 534 ++++++++++++++++++++++++++++--------
 fs/btrfs/extent_io.h        |  15 +-
 fs/btrfs/file.c             |  35 +--
 fs/btrfs/free-space-cache.c |  15 +-
 fs/btrfs/inode.c            |  40 ++-
 fs/btrfs/ioctl.c            |   5 +-
 fs/btrfs/reflink.c          |   5 +-
 fs/btrfs/relocation.c       |  12 +-
 fs/btrfs/subpage.c          |  39 +++
 fs/btrfs/subpage.h          | 256 +++++++++++++++++
 fs/btrfs/super.c            |   7 +
 14 files changed, 876 insertions(+), 182 deletions(-)
 create mode 100644 fs/btrfs/subpage.c
 create mode 100644 fs/btrfs/subpage.h
Signature · 1 line
2.29.2
author
#1 lore raw

PATCH v3 1/22 btrfs: extent_io: rename @offset parameter to @disk_bytenr for submit_extent_page()

The parameter @offset can't be more confusing.
In fact that parameter is the disk bytenr for metadata/data.

Rename it to @disk_bytenr and update the comment to reduce confusion.

Since we're here, also rename all @offset passed into submit_extent_page() to @disk_bytenr.

---
 fs/btrfs/extent_io.c | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)
fs/btrfs/extent_io.c +15 -15
index c9cee458e001..99e04fc731a3 100644
@@ -3062,10 +3062,10 @@ struct bio *btrfs_bio_clone_partial(struct bio *orig, int offset, int size)
  * @opf:	bio REQ_OP_* and REQ_* flags as one value
  * @wbc:	optional writeback control for io accounting
  * @page:	page to add to the bio
+ * @disk_bytenr:the logical bytenr where the write will be
+ * @size:	portion of page that we want to write
  * @pg_offset:	offset of the new bio or to check whether we are adding
  *              a contiguous page to the previous one
- * @size:	portion of page that we want to write
- * @offset:	starting offset in the page
  * @bio_ret:	must be valid pointer, newly allocated bio will be stored there
  * @end_io_func:     end_io callback for new bio
  * @mirror_num:	     desired mirror to read/write
@@ -3074,7 +3074,7 @@ struct bio *btrfs_bio_clone_partial(struct bio *orig, int offset, int size)
  */
 static int submit_extent_page(unsigned int opf,
 			      struct writeback_control *wbc,
-			      struct page *page, u64 offset,
+			      struct page *page, u64 disk_bytenr,
 			      size_t size, unsigned long pg_offset,
 			      struct bio **bio_ret,
 			      bio_end_io_t end_io_func,
@@ -3086,7 +3086,7 @@ static int submit_extent_page(unsigned int opf,
 	int ret = 0;
 	struct bio *bio;
 	size_t io_size = min_t(size_t, size, PAGE_SIZE);
-	sector_t sector = offset >> 9;
+	sector_t sector = disk_bytenr >> 9;
 	struct extent_io_tree *tree = &BTRFS_I(page->mapping->host)->io_tree;
 
 	ASSERT(bio_ret);
@@ -3120,7 +3120,7 @@ static int submit_extent_page(unsigned int opf,
 		}
 	}
 
-	bio = btrfs_bio_alloc(offset);
+	bio = btrfs_bio_alloc(disk_bytenr);
 	bio_add_page(bio, page, io_size, pg_offset);
 	bio->bi_end_io = end_io_func;
 	bio->bi_private = tree;
@@ -3242,7 +3242,7 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 	}
 	while (cur <= end) {
 		bool force_bio_submit = false;
-		u64 offset;
+		u64 disk_bytenr;
 
 		if (cur >= last_byte) {
 			char *userpage;
@@ -3280,9 +3280,9 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 		cur_end = min(extent_map_end(em) - 1, end);
 		iosize = ALIGN(iosize, blocksize);
 		if (this_bio_flag & EXTENT_BIO_COMPRESSED)
-			offset = em->block_start;
+			disk_bytenr = em->block_start;
 		else
-			offset = em->block_start + extent_offset;
+			disk_bytenr = em->block_start + extent_offset;
 		block_start = em->block_start;
 		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
 			block_start = EXTENT_MAP_HOLE;
@@ -3371,7 +3371,7 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 		}
 
 		ret = submit_extent_page(REQ_OP_READ | read_flags, NULL,
-					 page, offset, iosize,
+					 page, disk_bytenr, iosize,
 					 pg_offset, bio,
 					 end_bio_extent_readpage, 0,
 					 *bio_flags,
@@ -3548,8 +3548,8 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 	blocksize = inode->vfs_inode.i_sb->s_blocksize;
 
 	while (cur <= end) {
+		u64 disk_bytenr;
 		u64 em_end;
-		u64 offset;
 
 		if (cur >= i_size) {
 			btrfs_writepage_endio_finish_ordered(page, cur,
@@ -3569,7 +3569,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 		BUG_ON(end < cur);
 		iosize = min(em_end - cur, end - cur + 1);
 		iosize = ALIGN(iosize, blocksize);
-		offset = em->block_start + extent_offset;
+		disk_bytenr = em->block_start + extent_offset;
 		block_start = em->block_start;
 		compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
 		free_extent_map(em);
@@ -3599,7 +3599,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 		}
 
 		ret = submit_extent_page(REQ_OP_WRITE | write_flags, wbc,
-					 page, offset, iosize, pg_offset,
+					 page, disk_bytenr, iosize, pg_offset,
 					 &epd->bio,
 					 end_bio_extent_writepage,
 					 0, 0, 0, false);
@@ -3923,7 +3923,7 @@ static noinline_for_stack int write_one_eb(struct extent_buffer *eb,
 			struct writeback_control *wbc,
 			struct extent_page_data *epd)
 {
-	u64 offset = eb->start;
+	u64 disk_bytenr = eb->start;
 	u32 nritems;
 	int i, num_pages;
 	unsigned long start, end;
@@ -3956,7 +3956,7 @@ static noinline_for_stack int write_one_eb(struct extent_buffer *eb,
 		clear_page_dirty_for_io(p);
 		set_page_writeback(p);
 		ret = submit_extent_page(REQ_OP_WRITE | write_flags, wbc,
-					 p, offset, PAGE_SIZE, 0,
+					 p, disk_bytenr, PAGE_SIZE, 0,
 					 &epd->bio,
 					 end_bio_extent_buffer_writepage,
 					 0, 0, 0, false);
@@ -3969,7 +3969,7 @@ static noinline_for_stack int write_one_eb(struct extent_buffer *eb,
 			ret = -EIO;
 			break;
 		}
-		offset += PAGE_SIZE;
+		disk_bytenr += PAGE_SIZE;
 		update_nr_written(wbc, 1);
 		unlock_page(p);
 	}
Signature · 1 line
2.29.2
author
#2 lore raw

PATCH v3 2/22 btrfs: extent_io: refactor __extent_writepage_io() to improve readability

In reply to Qu Wenruo

The refactor involves the following modifications:
- iosize alignment
In fact we don't really need to manually do alignment at all. All extent maps should already be aligned, thus basic ASSERT() check would be enough.

- redundant variables
We have extra variable like blocksize/pg_offset/end. They are all unnecessary.

@blocksize can be replaced by sectorsize size directly, and it's only used to verify the em start/size is aligned.

@pg_offset can be easily calculated using @cur and page_offset(page).

@end is just assigned from @page_end and never modified, use "start +
PAGE_SIZE - 1" directly and remove @page_end.

- remove some BUG_ON()s
The BUG_ON()s are for extent map, which we have tree-checker to check on-disk extent data item and runtime check.
ASSERT() should be enough.

---
 fs/btrfs/extent_io.c | 38 +++++++++++++++++---------------------
 1 file changed, 17 insertions(+), 21 deletions(-)
fs/btrfs/extent_io.c +17 -21
index 99e04fc731a3..6f156ce501a1 100644
@@ -3513,23 +3513,20 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 				 unsigned long nr_written,
 				 int *nr_ret)
 {
+	struct btrfs_fs_info *fs_info = inode->root->fs_info;
 	struct extent_io_tree *tree = &inode->io_tree;
 	u64 start = page_offset(page);
-	u64 page_end = start + PAGE_SIZE - 1;
-	u64 end;
+	u64 end = start + PAGE_SIZE - 1;
 	u64 cur = start;
 	u64 extent_offset;
 	u64 block_start;
-	u64 iosize;
 	struct extent_map *em;
-	size_t pg_offset = 0;
-	size_t blocksize;
 	int ret = 0;
 	int nr = 0;
 	const unsigned int write_flags = wbc_to_write_flags(wbc);
 	bool compressed;
 
-	ret = btrfs_writepage_cow_fixup(page, start, page_end);
+	ret = btrfs_writepage_cow_fixup(page, start, end);
 	if (ret) {
 		/* Fixup worker will requeue */
 		redirty_page_for_writepage(wbc, page);
@@ -3544,16 +3541,13 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 	 */
 	update_nr_written(wbc, nr_written + 1);
 
-	end = page_end;
-	blocksize = inode->vfs_inode.i_sb->s_blocksize;
-
 	while (cur <= end) {
 		u64 disk_bytenr;
 		u64 em_end;
+		u32 iosize;
 
 		if (cur >= i_size) {
-			btrfs_writepage_endio_finish_ordered(page, cur,
-							     page_end, 1);
+			btrfs_writepage_endio_finish_ordered(page, cur, end, 1);
 			break;
 		}
 		em = btrfs_get_extent(inode, NULL, 0, cur, end - cur + 1);
@@ -3565,16 +3559,20 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 
 		extent_offset = cur - em->start;
 		em_end = extent_map_end(em);
-		BUG_ON(em_end <= cur);
-		BUG_ON(end < cur);
-		iosize = min(em_end - cur, end - cur + 1);
-		iosize = ALIGN(iosize, blocksize);
-		disk_bytenr = em->block_start + extent_offset;
+		ASSERT(cur <= em_end);
+		ASSERT(cur < end);
+		ASSERT(IS_ALIGNED(em->start, fs_info->sectorsize));
+		ASSERT(IS_ALIGNED(em->len, fs_info->sectorsize));
 		block_start = em->block_start;
 		compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
+		disk_bytenr = em->block_start + extent_offset;
+
+		/* Note that em_end from extent_map_end() is exclusive */
+		iosize = min(em_end, end + 1) - cur;
 		free_extent_map(em);
 		em = NULL;
 
+
 		/*
 		 * compressed and inline extents are written through other
 		 * paths in the FS
@@ -3587,7 +3585,6 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 				btrfs_writepage_endio_finish_ordered(page, cur,
 							cur + iosize - 1, 1);
 			cur += iosize;
-			pg_offset += iosize;
 			continue;
 		}
 
@@ -3599,8 +3596,8 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 		}
 
 		ret = submit_extent_page(REQ_OP_WRITE | write_flags, wbc,
-					 page, disk_bytenr, iosize, pg_offset,
-					 &epd->bio,
+					 page, disk_bytenr, iosize,
+					 cur - page_offset(page), &epd->bio,
 					 end_bio_extent_writepage,
 					 0, 0, 0, false);
 		if (ret) {
@@ -3609,8 +3606,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 				end_page_writeback(page);
 		}
 
-		cur = cur + iosize;
-		pg_offset += iosize;
+		cur += iosize;
 		nr++;
 	}
 	*nr_ret = nr;
Signature · 1 line
2.29.2
author
#3 lore raw

PATCH v3 3/22 btrfs: file: update comment for btrfs_dirty_pages()

In reply to Qu Wenruo

The original comment is from the initial merge, which has several problems:
- No holes check any more
- No inline decision is made

Update the out-of-date comment with more correct one.

---
 fs/btrfs/file.c | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)
fs/btrfs/file.c +5 -6
index e65223e3510d..1602975ddb88 100644
@@ -453,12 +453,11 @@ static void btrfs_drop_pages(struct page **pages, size_t num_pages)
 }
 
 /*
- * after copy_from_user, pages need to be dirtied and we need to make
- * sure holes are created between the current EOF and the start of
- * any next extents (if required).
- *
- * this also makes the decision about creating an inline extent vs
- * doing real data extents, marking pages dirty and delalloc as required.
+ * After btrfs_copy_from_user(), update the following things for delalloc:
+ * - Mark newly dirtied pages as DELALLOC in the io tree.
+ *   Used to advise which range is to be written back.
+ * - Marks modified pages as Uptodate/Dirty and not needing cowfixup
+ * - Update inode size for past EOF write.
  */
 int btrfs_dirty_pages(struct btrfs_inode *inode, struct page **pages,
 		      size_t num_pages, loff_t pos, size_t write_bytes,
Signature · 1 line
2.29.2
author
#4 lore raw

PATCH v3 4/22 btrfs: extent_io: update locked page dirty/writeback/error bits in __process_pages_contig()

In reply to Qu Wenruo

When __process_pages_contig() get called for extent_clear_unlock_delalloc(), if we hit the locked page, only Private2 bit is updated, but dirty/writeback/error bits are all skiped.

There are several call sites call extent_clear_unlock_delalloc() with @locked_page and PAGE_CLEAR_DIRTY/PAGE_SET_WRITEBACK/PAGE_END_WRITEBACK

- cow_file_range()
- run_delalloc_nocow()
- cow_file_range_async()
All for their error handling branches.

For those call sites, since we skip the locked page for dirty/error/writeback bit update, the locked page will still have its dirty bit remaining.

Thankfully, since all those call sites can only be hit with various serious errors, it's pretty hard to hit and shouldn't affect regular btrfs operations.

But still, we shouldn't leave the locked_page with its dirty/error/writeback bits untouched.

Fix this by only skipping lock/unlock page operations for locked_page.

---
 fs/btrfs/extent_io.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)
fs/btrfs/extent_io.c +5 -5
index 6f156ce501a1..098c68583ebb 100644
@@ -1970,11 +1970,6 @@ static int __process_pages_contig(struct address_space *mapping,
 			if (page_ops & PAGE_SET_PRIVATE2)
 				SetPagePrivate2(pages[i]);
 
-			if (locked_page && pages[i] == locked_page) {
-				put_page(pages[i]);
-				pages_processed++;
-				continue;
-			}
 			if (page_ops & PAGE_CLEAR_DIRTY)
 				clear_page_dirty_for_io(pages[i]);
 			if (page_ops & PAGE_SET_WRITEBACK)
@@ -1983,6 +1978,11 @@ static int __process_pages_contig(struct address_space *mapping,
 				SetPageError(pages[i]);
 			if (page_ops & PAGE_END_WRITEBACK)
 				end_page_writeback(pages[i]);
+			if (locked_page && pages[i] == locked_page) {
+				put_page(pages[i]);
+				pages_processed++;
+				continue;
+			}
 			if (page_ops & PAGE_UNLOCK)
 				unlock_page(pages[i]);
 			if (page_ops & PAGE_LOCK) {
Signature · 1 line
2.29.2
author
#5 lore raw

PATCH v3 5/22 btrfs: extent_io: merge PAGE_CLEAR_DIRTY and PAGE_SET_WRITEBACK into PAGE_START_WRITEBACK

In reply to Qu Wenruo

PAGE_CLEAR_DIRTY and PAGE_SET_WRITEBACK are two macros used in __process_pages_contig(), to inform the function to clear page dirty and then set page writeback.

However page write back and dirty are two conflict status (at least for sector size == PAGE_SIZE case), this means those two macros are always called together.

This means we can merge PAGE_CLEAR_DIRTY and PAGE_SET_WRITEBACK, into one macro, PAGE_START_WRITEBACK.

---
 fs/btrfs/extent_io.c |  4 ++--
 fs/btrfs/extent_io.h | 12 ++++++------
 fs/btrfs/inode.c     | 28 ++++++++++------------------
 3 files changed, 18 insertions(+), 26 deletions(-)
fs/btrfs/extent_io.c +2 -2
index 098c68583ebb..a2a9c2148e91 100644
@@ -1970,10 +1970,10 @@ static int __process_pages_contig(struct address_space *mapping,
 			if (page_ops & PAGE_SET_PRIVATE2)
 				SetPagePrivate2(pages[i]);
 
-			if (page_ops & PAGE_CLEAR_DIRTY)
+			if (page_ops & PAGE_START_WRITEBACK) {
 				clear_page_dirty_for_io(pages[i]);
-			if (page_ops & PAGE_SET_WRITEBACK)
 				set_page_writeback(pages[i]);
+			}
 			if (page_ops & PAGE_SET_ERROR)
 				SetPageError(pages[i]);
 			if (page_ops & PAGE_END_WRITEBACK)
fs/btrfs/extent_io.h +6 -6
index 19221095c635..bedf761a0300 100644
@@ -35,12 +35,12 @@ enum {
 
 /* these are flags for __process_pages_contig */
 #define PAGE_UNLOCK		(1 << 0)
-#define PAGE_CLEAR_DIRTY	(1 << 1)
-#define PAGE_SET_WRITEBACK	(1 << 2)
-#define PAGE_END_WRITEBACK	(1 << 3)
-#define PAGE_SET_PRIVATE2	(1 << 4)
-#define PAGE_SET_ERROR		(1 << 5)
-#define PAGE_LOCK		(1 << 6)
+/* This one will clera page dirty and then set paeg writeback */
+#define PAGE_START_WRITEBACK	(1 << 1)
+#define PAGE_END_WRITEBACK	(1 << 2)
+#define PAGE_SET_PRIVATE2	(1 << 3)
+#define PAGE_SET_ERROR		(1 << 4)
+#define PAGE_LOCK		(1 << 5)
 
 /*
  * page->private values.  Every page that is controlled by the extent
fs/btrfs/inode.c +10 -18
index 9c2800fa80c6..ecc1f1f60b48 100644
@@ -692,8 +692,7 @@ static noinline int compress_file_range(struct async_chunk *async_chunk)
 						     NULL,
 						     clear_flags,
 						     PAGE_UNLOCK |
-						     PAGE_CLEAR_DIRTY |
-						     PAGE_SET_WRITEBACK |
+						     PAGE_START_WRITEBACK |
 						     page_error_op |
 						     PAGE_END_WRITEBACK);
 
@@ -934,8 +933,7 @@ static noinline void submit_compressed_extents(struct async_chunk *async_chunk)
 				async_extent->start +
 				async_extent->ram_size - 1,
 				NULL, EXTENT_LOCKED | EXTENT_DELALLOC,
-				PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
-				PAGE_SET_WRITEBACK);
+				PAGE_UNLOCK | PAGE_START_WRITEBACK);
 		if (btrfs_submit_compressed_write(inode, async_extent->start,
 				    async_extent->ram_size,
 				    ins.objectid,
@@ -971,9 +969,8 @@ static noinline void submit_compressed_extents(struct async_chunk *async_chunk)
 				     NULL, EXTENT_LOCKED | EXTENT_DELALLOC |
 				     EXTENT_DELALLOC_NEW |
 				     EXTENT_DEFRAG | EXTENT_DO_ACCOUNTING,
-				     PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
-				     PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK |
-				     PAGE_SET_ERROR);
+				     PAGE_UNLOCK | PAGE_START_WRITEBACK |
+				     PAGE_END_WRITEBACK | PAGE_SET_ERROR);
 	free_async_extent_pages(async_extent);
 	kfree(async_extent);
 	goto again;
@@ -1071,8 +1068,7 @@ static noinline int cow_file_range(struct btrfs_inode *inode,
 				     EXTENT_LOCKED | EXTENT_DELALLOC |
 				     EXTENT_DELALLOC_NEW | EXTENT_DEFRAG |
 				     EXTENT_DO_ACCOUNTING, PAGE_UNLOCK |
-				     PAGE_CLEAR_DIRTY | PAGE_SET_WRITEBACK |
-				     PAGE_END_WRITEBACK);
+				     PAGE_START_WRITEBACK | PAGE_END_WRITEBACK);
 			*nr_written = *nr_written +
 			     (end - start + PAGE_SIZE) / PAGE_SIZE;
 			*page_started = 1;
@@ -1194,8 +1190,7 @@ static noinline int cow_file_range(struct btrfs_inode *inode,
 out_unlock:
 	clear_bits = EXTENT_LOCKED | EXTENT_DELALLOC | EXTENT_DELALLOC_NEW |
 		EXTENT_DEFRAG | EXTENT_CLEAR_META_RESV;
-	page_ops = PAGE_UNLOCK | PAGE_CLEAR_DIRTY | PAGE_SET_WRITEBACK |
-		PAGE_END_WRITEBACK;
+	page_ops = PAGE_UNLOCK | PAGE_START_WRITEBACK | PAGE_END_WRITEBACK;
 	/*
 	 * If we reserved an extent for our delalloc range (or a subrange) and
 	 * failed to create the respective ordered extent, then it means that
@@ -1320,9 +1315,8 @@ static int cow_file_range_async(struct btrfs_inode *inode,
 		unsigned clear_bits = EXTENT_LOCKED | EXTENT_DELALLOC |
 			EXTENT_DELALLOC_NEW | EXTENT_DEFRAG |
 			EXTENT_DO_ACCOUNTING;
-		unsigned long page_ops = PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
-			PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK |
-			PAGE_SET_ERROR;
+		unsigned long page_ops = PAGE_UNLOCK | PAGE_START_WRITEBACK |
+			PAGE_END_WRITEBACK | PAGE_SET_ERROR;
 
 		extent_clear_unlock_delalloc(inode, start, end, locked_page,
 					     clear_bits, page_ops);
@@ -1519,8 +1513,7 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,
 					     EXTENT_LOCKED | EXTENT_DELALLOC |
 					     EXTENT_DO_ACCOUNTING |
 					     EXTENT_DEFRAG, PAGE_UNLOCK |
-					     PAGE_CLEAR_DIRTY |
-					     PAGE_SET_WRITEBACK |
+					     PAGE_START_WRITEBACK |
 					     PAGE_END_WRITEBACK);
 		return -ENOMEM;
 	}
@@ -1842,8 +1835,7 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,
 					     locked_page, EXTENT_LOCKED |
 					     EXTENT_DELALLOC | EXTENT_DEFRAG |
 					     EXTENT_DO_ACCOUNTING, PAGE_UNLOCK |
-					     PAGE_CLEAR_DIRTY |
-					     PAGE_SET_WRITEBACK |
+					     PAGE_START_WRITEBACK |
 					     PAGE_END_WRITEBACK);
 	btrfs_free_path(path);
 	return ret;
Signature · 1 line
2.29.2
author
#6 lore raw

PATCH v3 6/22 btrfs: extent_io: introduce a helper to grab an existing extent buffer from a page

In reply to Qu Wenruo

This patch will extract the code to grab an extent buffer from a page into a helper, grab_extent_buffer_from_page().

This reduces one indent level, and provides the work place for later expansion for subapge support.

---
 fs/btrfs/extent_io.c | 51 +++++++++++++++++++++++++++-----------------
 1 file changed, 31 insertions(+), 20 deletions(-)
fs/btrfs/extent_io.c +31 -20
index a2a9c2148e91..d60f1837f8fb 100644
@@ -5248,6 +5248,30 @@ struct extent_buffer *alloc_test_extent_buffer(struct btrfs_fs_info *fs_info,
 }
 #endif
 
+static struct extent_buffer *grab_extent_buffer(struct page *page)
+{
+	struct extent_buffer *exists;
+
+	/* Page not yet attached to an extent buffer */
+	if (!PagePrivate(page))
+		return NULL;
+
+	/*
+	 * We could have already allocated an eb for this page
+	 * and attached one so lets see if we can get a ref on
+	 * the existing eb, and if we can we know it's good and
+	 * we can just return that one, else we know we can just
+	 * overwrite page->private.
+	 */
+	exists = (struct extent_buffer *)page->private;
+	if (atomic_inc_not_zero(&exists->refs))
+		return exists;
+
+	WARN_ON(PageDirty(page));
+	detach_page_private(page);
+	return NULL;
+}
+
 struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
 					  u64 start, u64 owner_root, int level)
 {
@@ -5293,26 +5317,13 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
 		}
 
 		spin_lock(&mapping->private_lock);
-		if (PagePrivate(p)) {
-			/*
-			 * We could have already allocated an eb for this page
-			 * and attached one so lets see if we can get a ref on
-			 * the existing eb, and if we can we know it's good and
-			 * we can just return that one, else we know we can just
-			 * overwrite page->private.
-			 */
-			exists = (struct extent_buffer *)p->private;
-			if (atomic_inc_not_zero(&exists->refs)) {
-				spin_unlock(&mapping->private_lock);
-				unlock_page(p);
-				put_page(p);
-				mark_extent_buffer_accessed(exists, p);
-				goto free_eb;
-			}
-			exists = NULL;
-
-			WARN_ON(PageDirty(p));
-			detach_page_private(p);
+		exists = grab_extent_buffer(p);
+		if (exists) {
+			spin_unlock(&mapping->private_lock);
+			unlock_page(p);
+			put_page(p);
+			mark_extent_buffer_accessed(exists, p);
+			goto free_eb;
 		}
 		attach_extent_buffer_page(eb, p);
 		spin_unlock(&mapping->private_lock);
Signature · 1 line
2.29.2
#7 lore raw

Re: [PATCH v3 06/22] btrfs: extent_io: introduce a helper to grab an existing extent buffer from a page

Quoted 5 lines · Qu Wenruo
fs/btrfs/extent_io.c +5 -0
+static struct extent_buffer *grab_extent_buffer(struct page *page)
+{
+	struct extent_buffer *exists;
+
+	/* Page not yet attached to an extent buffer */

fs/btrfs/extent_io.c struct extent_buffer *alloc_test_extent_buffer(struct btrfs_fs_info *fs_info, · line 5265

Quoted 10 lines
fs/btrfs/extent_io.c +10 -0
+	if (!PagePrivate(page))
+		return NULL;
+
+	/*
+	 * We could have already allocated an eb for this page
+	 * and attached one so lets see if we can get a ref on
+	 * the existing eb, and if we can we know it's good and
+	 * we can just return that one, else we know we can just
+	 * overwrite page->private.
+	 */

Please reformat comments that get moved to full 80 columns line. Fixed.

author
#8 lore raw

PATCH v3 7/22 btrfs: extent_io: introduce the skeleton of btrfs_subpage structure

In reply to Qu Wenruo

For btrfs subpage support, we need a structure to record extra info for the status of each sectors of a page.

This patch will introduce the skeleton structure for future btrfs subpage support.
All subpage related code would go to subpage.[ch] to avoid populating the existing code base.

---
 fs/btrfs/Makefile  |  3 ++-
 fs/btrfs/subpage.c | 39 +++++++++++++++++++++++++++++++++++++++
 fs/btrfs/subpage.h | 31 +++++++++++++++++++++++++++++++
 3 files changed, 72 insertions(+), 1 deletion(-)
 create mode 100644 fs/btrfs/subpage.c
 create mode 100644 fs/btrfs/subpage.h
fs/btrfs/Makefile +2 -1
index 9f1b1a88e317..942562e11456 100644
@@ -11,7 +11,8 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
 	   compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \
 	   reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \
 	   uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o \
-	   block-rsv.o delalloc-space.o block-group.o discard.o reflink.o
+	   block-rsv.o delalloc-space.o block-group.o discard.o reflink.o \
+	   subpage.o
 
 btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o
 btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o
fs/btrfs/subpage.c new file +39 -0
new file mode 100644
index 000000000000..c6ab32db3995
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include "subpage.h"
+
+int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page)
+{
+	struct btrfs_subpage *subpage;
+
+	/*
+	 * We have cases like a dummy extent buffer page, which is not
+	 * mappped and doesn't need to be locked.
+	 */
+	if (page->mapping)
+		ASSERT(PageLocked(page));
+	/* Either not subpage, or the page already has private attached */
+	if (fs_info->sectorsize == PAGE_SIZE || PagePrivate(page))
+		return 0;
+
+	subpage = kzalloc(sizeof(*subpage), GFP_NOFS);
+	if (!subpage)
+		return -ENOMEM;
+
+	spin_lock_init(&subpage->lock);
+	attach_page_private(page, subpage);
+	return 0;
+}
+
+void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page)
+{
+	struct btrfs_subpage *subpage;
+
+	/* Either not subpage, or already detached */
+	if (fs_info->sectorsize == PAGE_SIZE || !PagePrivate(page))
+		return;
+
+	subpage = (struct btrfs_subpage *)detach_page_private(page);
+	ASSERT(subpage);
+	kfree(subpage);
+}
fs/btrfs/subpage.h new file +31 -0
new file mode 100644
index 000000000000..96f3b226913e
@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef BTRFS_SUBPAGE_H
+#define BTRFS_SUBPAGE_H
+
+#include <linux/spinlock.h>
+#include "ctree.h"
+
+/*
+ * Since the maximum page size btrfs is going to support is 64K while the
+ * minimum sectorsize is 4K, this means a u16 bitmap is enough.
+ *
+ * The regular bitmap requires 32 bits as minimal bitmap size, so we can't use
+ * existing bitmap_* helpers here.
+ */
+#define BTRFS_SUBPAGE_BITMAP_SIZE	16
+
+/*
+ * Structure to trace status of each sector inside a page.
+ *
+ * Will be attached to page::private for both data and metadata inodes.
+ */
+struct btrfs_subpage {
+	/* Common members for both data and metadata pages */
+	spinlock_t lock;
+};
+
+int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page);
+void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page);
+
+#endif /* BTRFS_SUBPAGE_H */
Signature · 1 line
2.29.2
author
#9 lore raw

PATCH v3 8/22 btrfs: extent_io: make attach_extent_buffer_page() to handle subpage case

In reply to Qu Wenruo

For subpage case, we need to allocate new memory for each metadata page.

So we need to:
- Allow attach_extent_buffer_page() to return int
To indicate allocation failure

- Prealloc page->private for alloc_extent_buffer()
We don't want to call memory allocation with spinlock hold, so do preallocation before we acquire the spin lock.

- Handle subpage and regular case differently in attach_extent_buffer_page()
For regular case, just do the usual thing.
For subpage case, allocate new memory and update the tree_block bitmap.

The bitmap update will be handled by new subpage specific helper, btrfs_subpage_set_tree_block().

---
 fs/btrfs/extent_io.c | 74 ++++++++++++++++++++++++++++++++++----------
 fs/btrfs/subpage.h   | 50 ++++++++++++++++++++++++++++++
 2 files changed, 108 insertions(+), 16 deletions(-)
fs/btrfs/extent_io.c +58 -16
index d60f1837f8fb..2eeff925450f 100644
@@ -24,6 +24,7 @@
 #include "rcu-string.h"
 #include "backref.h"
 #include "disk-io.h"
+#include "subpage.h"
 
 static struct kmem_cache *extent_state_cache;
 static struct kmem_cache *extent_buffer_cache;
@@ -3140,22 +3141,41 @@ static int submit_extent_page(unsigned int opf,
 	return ret;
 }
 
-static void attach_extent_buffer_page(struct extent_buffer *eb,
+static int attach_extent_buffer_page(struct extent_buffer *eb,
 				      struct page *page)
 {
-	/*
-	 * If the page is mapped to btree inode, we should hold the private
-	 * lock to prevent race.
-	 * For cloned or dummy extent buffers, their pages are not mapped and
-	 * will not race with any other ebs.
-	 */
-	if (page->mapping)
-		lockdep_assert_held(&page->mapping->private_lock);
+	struct btrfs_fs_info *fs_info = eb->fs_info;
+	int ret;
 
-	if (!PagePrivate(page))
-		attach_page_private(page, eb);
-	else
-		WARN_ON(page->private != (unsigned long)eb);
+	if (fs_info->sectorsize == PAGE_SIZE) {
+		/*
+		 * If the page is mapped to btree inode, we should hold the
+		 * private lock to prevent race.
+		 * For cloned or dummy extent buffers, their pages are not
+		 * mapped and will not race with any other ebs.
+		 */
+		if (page->mapping)
+			lockdep_assert_held(&page->mapping->private_lock);
+
+		if (!PagePrivate(page))
+			attach_page_private(page, eb);
+		else
+			WARN_ON(page->private != (unsigned long)eb);
+		return 0;
+	}
+
+	/* Already mapped, just update the existing range */
+	if (PagePrivate(page))
+		goto update_bitmap;
+
+	/* Do new allocation to attach subpage */
+	ret = btrfs_attach_subpage(fs_info, page);
+	if (ret < 0)
+		return ret;
+
+update_bitmap:
+	btrfs_subpage_set_tree_block(fs_info, page, eb->start, eb->len);
+	return 0;
 }
 
 void set_page_extent_mapped(struct page *page)
@@ -5063,21 +5083,29 @@ struct extent_buffer *btrfs_clone_extent_buffer(const struct extent_buffer *src)
 	if (new == NULL)
 		return NULL;
 
+	set_bit(EXTENT_BUFFER_UPTODATE, &new->bflags);
+	set_bit(EXTENT_BUFFER_UNMAPPED, &new->bflags);
+
 	for (i = 0; i < num_pages; i++) {
+		int ret;
+
 		p = alloc_page(GFP_NOFS);
 		if (!p) {
 			btrfs_release_extent_buffer(new);
 			return NULL;
 		}
-		attach_extent_buffer_page(new, p);
+		ret = attach_extent_buffer_page(new, p);
+		if (ret < 0) {
+			put_page(p);
+			btrfs_release_extent_buffer(new);
+			return NULL;
+		}
 		WARN_ON(PageDirty(p));
 		SetPageUptodate(p);
 		new->pages[i] = p;
 		copy_page(page_address(p), page_address(src->pages[i]));
 	}
 
-	set_bit(EXTENT_BUFFER_UPTODATE, &new->bflags);
-	set_bit(EXTENT_BUFFER_UNMAPPED, &new->bflags);
 
 	return new;
 }
@@ -5316,6 +5344,18 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
 			goto free_eb;
 		}
 
+		/*
+		 * Preallocate page->private for subpage case, so that
+		 * we won't allocate memory with private_lock hold.
+		 */
+		ret = btrfs_attach_subpage(fs_info, p);
+		if (ret < 0) {
+			unlock_page(p);
+			put_page(p);
+			exists = ERR_PTR(-ENOMEM);
+			goto free_eb;
+		}
+
 		spin_lock(&mapping->private_lock);
 		exists = grab_extent_buffer(p);
 		if (exists) {
@@ -5325,8 +5365,10 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
 			mark_extent_buffer_accessed(exists, p);
 			goto free_eb;
 		}
+		/* Should not fail, as we have attached the subpage already */
 		attach_extent_buffer_page(eb, p);
 		spin_unlock(&mapping->private_lock);
+
 		WARN_ON(PageDirty(p));
 		eb->pages[i] = p;
 		if (!PageUptodate(p))
fs/btrfs/subpage.h +50 -0

59 lines not on this page · raw message

Signature · 1 line
2.29.2
author
#10 lore raw

Re: [PATCH v3 08/22] btrfs: extent_io: make attach_extent_buffer_page() to handle subpage case

Quoted 126 lines · Qu Wenruo

For subpage case, we need to allocate new memory for each metadata page.

So we need to:
- Allow attach_extent_buffer_page() to return int
To indicate allocation failure

- Prealloc page->private for alloc_extent_buffer()
We don't want to call memory allocation with spinlock hold, so do preallocation before we acquire the spin lock.

- Handle subpage and regular case differently in attach_extent_buffer_page()
For regular case, just do the usual thing.
For subpage case, allocate new memory and update the tree_block bitmap.

The bitmap update will be handled by new subpage specific helper, btrfs_subpage_set_tree_block().

---
  fs/btrfs/extent_io.c | 74 ++++++++++++++++++++++++++++++++++----------
  fs/btrfs/subpage.h   | 50 ++++++++++++++++++++++++++++++
  2 files changed, 108 insertions(+), 16 deletions(-)
fs/btrfs/extent_io.c +44 -16
index d60f1837f8fb..2eeff925450f 100644
@@ -24,6 +24,7 @@
  #include "rcu-string.h"
  #include "backref.h"
  #include "disk-io.h"
+#include "subpage.h"
 
  static struct kmem_cache *extent_state_cache;
  static struct kmem_cache *extent_buffer_cache;
@@ -3140,22 +3141,41 @@ static int submit_extent_page(unsigned int opf,
  	return ret;
  }
 
-static void attach_extent_buffer_page(struct extent_buffer *eb,
+static int attach_extent_buffer_page(struct extent_buffer *eb,
  				      struct page *page)
  {
-	/*
-	 * If the page is mapped to btree inode, we should hold the private
-	 * lock to prevent race.
-	 * For cloned or dummy extent buffers, their pages are not mapped and
-	 * will not race with any other ebs.
-	 */
-	if (page->mapping)
-		lockdep_assert_held(&page->mapping->private_lock);
+	struct btrfs_fs_info *fs_info = eb->fs_info;
+	int ret;
 
-	if (!PagePrivate(page))
-		attach_page_private(page, eb);
-	else
-		WARN_ON(page->private != (unsigned long)eb);
+	if (fs_info->sectorsize == PAGE_SIZE) {
+		/*
+		 * If the page is mapped to btree inode, we should hold the
+		 * private lock to prevent race.
+		 * For cloned or dummy extent buffers, their pages are not
+		 * mapped and will not race with any other ebs.
+		 */
+		if (page->mapping)
+			lockdep_assert_held(&page->mapping->private_lock);
+
+		if (!PagePrivate(page))
+			attach_page_private(page, eb);
+		else
+			WARN_ON(page->private != (unsigned long)eb);
+		return 0;
+	}
+
+	/* Already mapped, just update the existing range */
+	if (PagePrivate(page))
+		goto update_bitmap;
+
+	/* Do new allocation to attach subpage */
+	ret = btrfs_attach_subpage(fs_info, page);
+	if (ret < 0)
+		return ret;
+
+update_bitmap:
+	btrfs_subpage_set_tree_block(fs_info, page, eb->start, eb->len);
+	return 0;
  }
 
  void set_page_extent_mapped(struct page *page)
@@ -5063,21 +5083,29 @@ struct extent_buffer *btrfs_clone_extent_buffer(const struct extent_buffer *src)
  	if (new == NULL)
  		return NULL;
 
+	set_bit(EXTENT_BUFFER_UPTODATE, &new->bflags);
+	set_bit(EXTENT_BUFFER_UNMAPPED, &new->bflags);
+
  	for (i = 0; i < num_pages; i++) {
+		int ret;
+
  		p = alloc_page(GFP_NOFS);
  		if (!p) {
  			btrfs_release_extent_buffer(new);
  			return NULL;
  		}
-		attach_extent_buffer_page(new, p);
+		ret = attach_extent_buffer_page(new, p);
+		if (ret < 0) {
+			put_page(p);
+			btrfs_release_extent_buffer(new);
+			return NULL;
+		}
  		WARN_ON(PageDirty(p));
  		SetPageUptodate(p);
  		new->pages[i] = p;
  		copy_page(page_address(p), page_address(src->pages[i]));
  	}
 
-	set_bit(EXTENT_BUFFER_UPTODATE, &new->bflags);
-	set_bit(EXTENT_BUFFER_UNMAPPED, &new->bflags);
 
  	return new;
  }

fs/btrfs/extent_io.c struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info, · line 5351

Quoted 8 lines
fs/btrfs/extent_io.c +5 -0
@@ -5316,6 +5344,18 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
  			goto free_eb;
  		}
 
+		/*
+		 * Preallocate page->private for subpage case, so that
+		 * we won't allocate memory with private_lock hold.
+		 */
+		ret = btrfs_attach_subpage(fs_info, p);

Although we try to preallocate the subpage structure here, it's not reliable.

I have hit a case just minutes before, where we still try to allocate memory inside that private_lock spinlock, and causes sleep inside atomic warning.

The problem is, we can have a race where the page has one existing eb, and it's being freed.

At this point, we still have page::private.

But before we acquire that private_lock, the eb get freed and since it's the only eb of that page (our eb hasn't yet being added to the page), it detach page private.

Quoted 11 lines
fs/btrfs/extent_io.c +7 -0
+		if (ret < 0) {
+			unlock_page(p);
+			put_page(p);
+			exists = ERR_PTR(-ENOMEM);
+			goto free_eb;
+		}
+
  		spin_lock(&mapping->private_lock);
  		exists = grab_extent_buffer(p);
  		if (exists) {

fs/btrfs/extent_io.c struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info, · line 5369

Quoted 5 lines
fs/btrfs/extent_io.c +1 -0
@@ -5325,8 +5365,10 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
  			mark_extent_buffer_accessed(exists, p);
  			goto free_eb;
  		}
+		/* Should not fail, as we have attached the subpage already */
  		attach_extent_buffer_page(eb, p);

So here we can not rely on any result before we acquire private_lock.

Thus I guess we have to pre-allocate the memory manually and pass the pointer in.

Why I didn't hit the bug before sending the patches...

Thanks,
Qu

Quoted 70 lines
fs/btrfs/extent_io.c +1 -0
  		spin_unlock(&mapping->private_lock);
+
  		WARN_ON(PageDirty(p));
  		eb->pages[i] = p;
  		if (!PageUptodate(p))
fs/btrfs/subpage.h +50 -0
index 96f3b226913e..e49d4a7329e1 100644
@@ -23,9 +23,59 @@
  struct btrfs_subpage {
  	/* Common members for both data and metadata pages */
  	spinlock_t lock;
+	union {
+		/* Structures only used by metadata */
+		struct {
+			u16 tree_block_bitmap;
+		};
+		/* structures only used by data */
+	};
  };
 
  int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page);
  void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page);
 
+/*
+ * Convert the [start, start + len) range into a u16 bitmap
+ *
+ * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0.
+ */
+static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info *fs_info,
+			struct page *page, u64 start, u32 len)
+{
+	int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits;
+	int nbits = len >> fs_info->sectorsize_bits;
+
+	/* Basic checks */
+	ASSERT(PagePrivate(page) && page->private);
+	ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
+	       IS_ALIGNED(len, fs_info->sectorsize));
+
+	/*
+	 * The range check only works for mapped page, we can
+	 * still have unampped page like dummy extent buffer pages.
+	 */
+	if (page->mapping)
+		ASSERT(page_offset(page) <= start &&
+			start + len <= page_offset(page) + PAGE_SIZE);
+	/*
+	 * Here nbits can be 16, thus can go beyond u16 range. Here we make the
+	 * first left shift to be calculated in unsigned long (u32), then
+	 * truncate the result to u16.
+	 */
+	return (u16)(((1UL << nbits) - 1) << bit_start);
+}
+
+static inline void btrfs_subpage_set_tree_block(struct btrfs_fs_info *fs_info,
+			struct page *page, u64 start, u32 len)
+{
+	struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
+	unsigned long flags;
+	u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len);
+
+	spin_lock_irqsave(&subpage->lock, flags);
+	subpage->tree_block_bitmap |= tmp;
+	spin_unlock_irqrestore(&subpage->lock, flags);
+}
+
  #endif /* BTRFS_SUBPAGE_H */
author
#11 lore raw

Re: [PATCH v3 08/22] btrfs: extent_io: make attach_extent_buffer_page() to handle subpage case

In reply to Qu Wenruo
Quoted 160 lines · Qu Wenruo

For subpage case, we need to allocate new memory for each metadata page.

So we need to:
- Allow attach_extent_buffer_page() to return int
To indicate allocation failure

- Prealloc page->private for alloc_extent_buffer()
We don't want to call memory allocation with spinlock hold, so do preallocation before we acquire the spin lock.

- Handle subpage and regular case differently in attach_extent_buffer_page()
For regular case, just do the usual thing.
For subpage case, allocate new memory and update the tree_block bitmap.

The bitmap update will be handled by new subpage specific helper, btrfs_subpage_set_tree_block().

---
  fs/btrfs/extent_io.c | 74 ++++++++++++++++++++++++++++++++++----------
  fs/btrfs/subpage.h   | 50 ++++++++++++++++++++++++++++++
  2 files changed, 108 insertions(+), 16 deletions(-)
fs/btrfs/extent_io.c +58 -16
index d60f1837f8fb..2eeff925450f 100644
@@ -24,6 +24,7 @@
  #include "rcu-string.h"
  #include "backref.h"
  #include "disk-io.h"
+#include "subpage.h"
 
  static struct kmem_cache *extent_state_cache;
  static struct kmem_cache *extent_buffer_cache;
@@ -3140,22 +3141,41 @@ static int submit_extent_page(unsigned int opf,
  	return ret;
  }
 
-static void attach_extent_buffer_page(struct extent_buffer *eb,
+static int attach_extent_buffer_page(struct extent_buffer *eb,
  				      struct page *page)
  {
-	/*
-	 * If the page is mapped to btree inode, we should hold the private
-	 * lock to prevent race.
-	 * For cloned or dummy extent buffers, their pages are not mapped and
-	 * will not race with any other ebs.
-	 */
-	if (page->mapping)
-		lockdep_assert_held(&page->mapping->private_lock);
+	struct btrfs_fs_info *fs_info = eb->fs_info;
+	int ret;
 
-	if (!PagePrivate(page))
-		attach_page_private(page, eb);
-	else
-		WARN_ON(page->private != (unsigned long)eb);
+	if (fs_info->sectorsize == PAGE_SIZE) {
+		/*
+		 * If the page is mapped to btree inode, we should hold the
+		 * private lock to prevent race.
+		 * For cloned or dummy extent buffers, their pages are not
+		 * mapped and will not race with any other ebs.
+		 */
+		if (page->mapping)
+			lockdep_assert_held(&page->mapping->private_lock);
+
+		if (!PagePrivate(page))
+			attach_page_private(page, eb);
+		else
+			WARN_ON(page->private != (unsigned long)eb);
+		return 0;
+	}
+
+	/* Already mapped, just update the existing range */
+	if (PagePrivate(page))
+		goto update_bitmap;
+
+	/* Do new allocation to attach subpage */
+	ret = btrfs_attach_subpage(fs_info, page);
+	if (ret < 0)
+		return ret;
+
+update_bitmap:
+	btrfs_subpage_set_tree_block(fs_info, page, eb->start, eb->len);
+	return 0;
  }
 
  void set_page_extent_mapped(struct page *page)
@@ -5063,21 +5083,29 @@ struct extent_buffer *btrfs_clone_extent_buffer(const struct extent_buffer *src)
  	if (new == NULL)
  		return NULL;
 
+	set_bit(EXTENT_BUFFER_UPTODATE, &new->bflags);
+	set_bit(EXTENT_BUFFER_UNMAPPED, &new->bflags);
+
  	for (i = 0; i < num_pages; i++) {
+		int ret;
+
  		p = alloc_page(GFP_NOFS);
  		if (!p) {
  			btrfs_release_extent_buffer(new);
  			return NULL;
  		}
-		attach_extent_buffer_page(new, p);
+		ret = attach_extent_buffer_page(new, p);
+		if (ret < 0) {
+			put_page(p);
+			btrfs_release_extent_buffer(new);
+			return NULL;
+		}
  		WARN_ON(PageDirty(p));
  		SetPageUptodate(p);
  		new->pages[i] = p;
  		copy_page(page_address(p), page_address(src->pages[i]));
  	}
 
-	set_bit(EXTENT_BUFFER_UPTODATE, &new->bflags);
-	set_bit(EXTENT_BUFFER_UNMAPPED, &new->bflags);
 
  	return new;
  }
@@ -5316,6 +5344,18 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
  			goto free_eb;
  		}
 
+		/*
+		 * Preallocate page->private for subpage case, so that
+		 * we won't allocate memory with private_lock hold.
+		 */
+		ret = btrfs_attach_subpage(fs_info, p);
+		if (ret < 0) {
+			unlock_page(p);
+			put_page(p);
+			exists = ERR_PTR(-ENOMEM);
+			goto free_eb;
+		}
+
  		spin_lock(&mapping->private_lock);
  		exists = grab_extent_buffer(p);
  		if (exists) {
@@ -5325,8 +5365,10 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
  			mark_extent_buffer_accessed(exists, p);
  			goto free_eb;
  		}
+		/* Should not fail, as we have attached the subpage already */
  		attach_extent_buffer_page(eb, p);
  		spin_unlock(&mapping->private_lock);
+
  		WARN_ON(PageDirty(p));
  		eb->pages[i] = p;
  		if (!PageUptodate(p))
fs/btrfs/subpage.h +0 -0
index 96f3b226913e..e49d4a7329e1 100644

fs/btrfs/subpage.h line 30

Quoted 8 lines
fs/btrfs/subpage.h +5 -0
@@ -23,9 +23,59 @@
  struct btrfs_subpage {
  	/* Common members for both data and metadata pages */
  	spinlock_t lock;
+	union {
+		/* Structures only used by metadata */
+		struct {
+			u16 tree_block_bitmap;
+		};

After more investigation, the idea of using subpage structure to record tree blocks bitmap may not be a good idea.

The main problem is the synchronization for the bit and extent buffer, which have different lock schemas. I'll try to use radix tree only to do the check, other than relying on some extra bit.

Thanks,
Qu

Quoted 52 lines
fs/btrfs/subpage.h +45 -0
+		/* structures only used by data */
+	};
  };
 
  int btrfs_attach_subpage(struct btrfs_fs_info *fs_info, struct page *page);
  void btrfs_detach_subpage(struct btrfs_fs_info *fs_info, struct page *page);
 
+/*
+ * Convert the [start, start + len) range into a u16 bitmap
+ *
+ * E.g. if start == page_offset() + 16K, len = 16K, we get 0x00f0.
+ */
+static inline u16 btrfs_subpage_calc_bitmap(struct btrfs_fs_info *fs_info,
+			struct page *page, u64 start, u32 len)
+{
+	int bit_start = offset_in_page(start) >> fs_info->sectorsize_bits;
+	int nbits = len >> fs_info->sectorsize_bits;
+
+	/* Basic checks */
+	ASSERT(PagePrivate(page) && page->private);
+	ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
+	       IS_ALIGNED(len, fs_info->sectorsize));
+
+	/*
+	 * The range check only works for mapped page, we can
+	 * still have unampped page like dummy extent buffer pages.
+	 */
+	if (page->mapping)
+		ASSERT(page_offset(page) <= start &&
+			start + len <= page_offset(page) + PAGE_SIZE);
+	/*
+	 * Here nbits can be 16, thus can go beyond u16 range. Here we make the
+	 * first left shift to be calculated in unsigned long (u32), then
+	 * truncate the result to u16.
+	 */
+	return (u16)(((1UL << nbits) - 1) << bit_start);
+}
+
+static inline void btrfs_subpage_set_tree_block(struct btrfs_fs_info *fs_info,
+			struct page *page, u64 start, u32 len)
+{
+	struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
+	unsigned long flags;
+	u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len);
+
+	spin_lock_irqsave(&subpage->lock, flags);
+	subpage->tree_block_bitmap |= tmp;
+	spin_unlock_irqrestore(&subpage->lock, flags);
+}
+
  #endif /* BTRFS_SUBPAGE_H */
author
#12 lore raw

PATCH v3 9/22 btrfs: extent_io: make grab_extent_buffer_from_page() to handle subpage case

In reply to Qu Wenruo

For subpage case, grab_extent_buffer() can't really get an extent buffer just from btrfs_subpage.

Although we have btrfs_subpage::tree_block_bitmap, which can be used to grab the bytenr of an existing extent buffer, and can then go radix tree search to grab that existing eb.

However we are still doing radix tree insert check in alloc_extent_buffer(), thus we don't really need to do the extra hassle, just let alloc_extent_buffer() to handle existing eb in radix tree.

So for grab_extent_buffer(), just always return NULL for subpage case.

---
 fs/btrfs/extent_io.c | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)
fs/btrfs/extent_io.c +11 -2
index 2eeff925450f..9b6b8f6b6da3 100644
@@ -5276,10 +5276,19 @@ struct extent_buffer *alloc_test_extent_buffer(struct btrfs_fs_info *fs_info,
 }
 #endif
 
-static struct extent_buffer *grab_extent_buffer(struct page *page)
+static struct extent_buffer *grab_extent_buffer(
+		struct btrfs_fs_info *fs_info, struct page *page)
 {
 	struct extent_buffer *exists;
 
+	/*
+	 * For subpage case, we completely rely on radix tree to ensure we
+	 * don't try to insert two eb for the same bytenr.
+	 * So here we alwasy return NULL and just continue.
+	 */
+	if (fs_info->sectorsize < PAGE_SIZE)
+		return NULL;
+
 	/* Page not yet attached to an extent buffer */
 	if (!PagePrivate(page))
 		return NULL;
@@ -5357,7 +5366,7 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
 		}
 
 		spin_lock(&mapping->private_lock);
-		exists = grab_extent_buffer(p);
+		exists = grab_extent_buffer(fs_info, p);
 		if (exists) {
 			spin_unlock(&mapping->private_lock);
 			unlock_page(p);
Signature · 1 line
2.29.2
author
#13 lore raw

PATCH v3 10/22 btrfs: extent_io: support subpage for extent buffer page release

In reply to Qu Wenruo

In btrfs_release_extent_buffer_pages(), we need to add extra handling for subpage.

To do so, introduce a new helper, detach_extent_buffer_page(), to do different handling for regular and subpage cases.

For subpage case, the new trick is to clear the range of current extent buffer, and detach page private if and only if we're the last tree block of the page.
This part is handled by the subpage helper, btrfs_subpage_clear_and_test_tree_block().

---
 fs/btrfs/extent_io.c | 57 +++++++++++++++++++++++++++++++-------------
 fs/btrfs/subpage.h   | 24 +++++++++++++++++++
 2 files changed, 64 insertions(+), 17 deletions(-)
fs/btrfs/extent_io.c +40 -17
index 9b6b8f6b6da3..3158461ebf4c 100644
@@ -4991,25 +4991,13 @@ int extent_buffer_under_io(const struct extent_buffer *eb)
 		test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
 }
 
-/*
- * Release all pages attached to the extent buffer.
- */
-static void btrfs_release_extent_buffer_pages(struct extent_buffer *eb)
+static void detach_extent_buffer_page(struct extent_buffer *eb,
+				      struct page *page)
 {
-	int i;
-	int num_pages;
-	int mapped = !test_bit(EXTENT_BUFFER_UNMAPPED, &eb->bflags);
-
-	BUG_ON(extent_buffer_under_io(eb));
-
-	num_pages = num_extent_pages(eb);
-	for (i = 0; i < num_pages; i++) {
-		struct page *page = eb->pages[i];
+	struct btrfs_fs_info *fs_info = eb->fs_info;
+	bool last = false;
 
-		if (!page)
-			continue;
-		if (mapped)
-			spin_lock(&page->mapping->private_lock);
+	if (fs_info->sectorsize == PAGE_SIZE) {
 		/*
 		 * We do this since we'll remove the pages after we've
 		 * removed the eb from the radix tree, so we could race
@@ -5028,6 +5016,41 @@ static void btrfs_release_extent_buffer_pages(struct extent_buffer *eb)
 			 */
 			detach_page_private(page);
 		}
+		return;
+	}
+
+	ASSERT(PagePrivate(page));
+	/*
+	 * For subpage case, clear the range in tree_block_bitmap,
+	 * and if we're the last one, detach private completely.
+	 */
+	last = btrfs_subpage_clear_and_test_tree_block(fs_info, page,
+					eb->start, eb->len);
+	if (last)
+		btrfs_detach_subpage(fs_info, page);
+}
+
+/*
+ * Release all pages attached to the extent buffer.
+ */
+static void btrfs_release_extent_buffer_pages(struct extent_buffer *eb)
+{
+	int i;
+	int num_pages;
+	int mapped = !test_bit(EXTENT_BUFFER_UNMAPPED, &eb->bflags);
+
+	ASSERT(!extent_buffer_under_io(eb));
+
+	num_pages = num_extent_pages(eb);
+	for (i = 0; i < num_pages; i++) {
+		struct page *page = eb->pages[i];
+
+		if (!page)
+			continue;
+		if (mapped)
+			spin_lock(&page->mapping->private_lock);
+
+		detach_extent_buffer_page(eb, page);
 
 		if (mapped)
 			spin_unlock(&page->mapping->private_lock);
fs/btrfs/subpage.h +24 -0
index e49d4a7329e1..c1556b3b68f3 100644
@@ -78,4 +78,28 @@ static inline void btrfs_subpage_set_tree_block(struct btrfs_fs_info *fs_info,
 	spin_unlock_irqrestore(&subpage->lock, flags);
 }
 
+/*
+ * Clear the bits in tree_block_bitmap and return if we're the last bit set
+ * int tree_block_bitmap.
+ *
+ * Return true if we're the last bits in the tree_block_bitmap.
+ * Return false otherwise.
+ */
+static inline bool btrfs_subpage_clear_and_test_tree_block(
+			struct btrfs_fs_info *fs_info, struct page *page,
+			u64 start, u32 len)
+{
+	struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
+	u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len);
+	unsigned long flags;
+	bool last = false;
+
+	spin_lock_irqsave(&subpage->lock, flags);
+	subpage->tree_block_bitmap &= ~tmp;
+	if (subpage->tree_block_bitmap == 0)
+		last = true;
+	spin_unlock_irqrestore(&subpage->lock, flags);
+	return last;
+}
+
 #endif /* BTRFS_SUBPAGE_H */
Signature · 1 line
2.29.2
author
#14 lore raw

PATCH v3 11/22 btrfs: extent_io: attach private to dummy extent buffer pages

In reply to Qu Wenruo

Even for regular btrfs, there are locations where we allocate dummy extent buffers for temporary usage.

Like tree_mod_log_rewind() and get_old_root().

Those dummy extent buffers will be handled by the same eb accessors, and if they don't have page::private subpage eb accessors can fail.

To address such problems, make __alloc_dummy_extent_buffer() to attach page private for dummy extent buffers too.

---
 fs/btrfs/extent_io.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)
fs/btrfs/extent_io.c +8 -1
index 3158461ebf4c..3bd4b99897d6 100644
@@ -5146,9 +5146,14 @@ struct extent_buffer *__alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info,
 
 	num_pages = num_extent_pages(eb);
 	for (i = 0; i < num_pages; i++) {
+		int ret;
+
 		eb->pages[i] = alloc_page(GFP_NOFS);
 		if (!eb->pages[i])
 			goto err;
+		ret = attach_extent_buffer_page(eb, eb->pages[i]);
+		if (ret < 0)
+			goto err;
 	}
 	set_extent_buffer_uptodate(eb);
 	btrfs_set_header_nritems(eb, 0);
@@ -5156,8 +5161,10 @@ struct extent_buffer *__alloc_dummy_extent_buffer(struct btrfs_fs_info *fs_info,
 
 	return eb;
 err:
-	for (; i > 0; i--)
+	for (; i > 0; i--) {
+		detach_extent_buffer_page(eb, eb->pages[i - 1]);
 		__free_page(eb->pages[i - 1]);
+	}
 	__free_extent_buffer(eb);
 	return NULL;
 }
Signature · 1 line
2.29.2
author
#15 lore raw

PATCH v3 12/22 btrfs: subpage: introduce helper for subpage uptodate status

In reply to Qu Wenruo

This patch introduce the following functions to handle btrfs subpage uptodate status:
- btrfs_subpage_set_uptodate()
- btrfs_subpage_clear_uptodate()
- btrfs_subpage_test_uptodate()
Those helpers can only be called when the range is ensured to be inside the page.

- btrfs_page_set_uptodate()
- btrfs_page_clear_uptodate()
- btrfs_page_test_uptodate()
Those helpers can handle both regular sector size and subpage without problem.
Although caller should still ensure that the range is inside the page.

---
 fs/btrfs/subpage.h | 84 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)
fs/btrfs/subpage.h +84 -0
index c1556b3b68f3..2b2d25cc6cba 100644
@@ -23,6 +23,7 @@
 struct btrfs_subpage {
 	/* Common members for both data and metadata pages */
 	spinlock_t lock;
+	u16 uptodate_bitmap;
 	union {
 		/* Structures only used by metadata */
 		struct {
@@ -102,4 +103,87 @@ static inline bool btrfs_subpage_clear_and_test_tree_block(
 	return last;
 }
 
+static inline void btrfs_subpage_set_uptodate(struct btrfs_fs_info *fs_info,
+			struct page *page, u64 start, u32 len)
+{
+	struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
+	u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len);
+	unsigned long flags;
+
+	spin_lock_irqsave(&subpage->lock, flags);
+	subpage->uptodate_bitmap |= tmp;
+	if (subpage->uptodate_bitmap == U16_MAX)
+		SetPageUptodate(page);
+	spin_unlock_irqrestore(&subpage->lock, flags);
+}
+
+static inline void btrfs_subpage_clear_uptodate(struct btrfs_fs_info *fs_info,
+			struct page *page, u64 start, u32 len)
+{
+	struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
+	u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len);
+	unsigned long flags;
+
+	spin_lock_irqsave(&subpage->lock, flags);
+	subpage->uptodate_bitmap &= ~tmp;
+	ClearPageUptodate(page);
+	spin_unlock_irqrestore(&subpage->lock, flags);
+}
+
+/*
+ * Unlike set/clear which is dependent on each page status, for test all bits
+ * are tested in the same way.
+ */
+#define DECLARE_BTRFS_SUBPAGE_TEST_OP(name)				\
+static inline bool btrfs_subpage_test_##name(struct btrfs_fs_info *fs_info, \
+			struct page *page, u64 start, u32 len)		\
+{									\
+	struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private; \
+	u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len); \
+	unsigned long flags;						\
+	bool ret;							\
+									\
+	spin_lock_irqsave(&subpage->lock, flags);			\
+	ret = ((subpage->name##_bitmap & tmp) == tmp);			\
+	spin_unlock_irqrestore(&subpage->lock, flags);			\
+	return ret;							\
+}
+DECLARE_BTRFS_SUBPAGE_TEST_OP(uptodate);
+
+/*
+ * Note that, in selftest, especially extent-io-tests, we can have empty
+ * fs_info passed in.
+ * Thankfully in selftest, we only test sectorsize == PAGE_SIZE cases so far,
+ * thus we can fall back to regular sectorsize branch.
+ */
+#define DECLARE_BTRFS_PAGE_OPS(name, set_page_func, clear_page_func,	\
+			       test_page_func)				\
+static inline void btrfs_page_set_##name(struct btrfs_fs_info *fs_info,	\
+			struct page *page, u64 start, u32 len)		\
+{									\
+	if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) {	\
+		set_page_func(page);					\
+		return;							\
+	}								\
+	btrfs_subpage_set_##name(fs_info, page, start, len);		\
+}									\
+static inline void btrfs_page_clear_##name(struct btrfs_fs_info *fs_info, \
+			struct page *page, u64 start, u32 len)		\
+{									\
+	if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE) {	\
+		clear_page_func(page);					\
+		return;							\
+	}								\
+	btrfs_subpage_clear_##name(fs_info, page, start, len);		\
+}									\
+static inline bool btrfs_page_test_##name(struct btrfs_fs_info *fs_info, \
+			struct page *page, u64 start, u32 len)		\
+{									\
+	if (unlikely(!fs_info) || fs_info->sectorsize == PAGE_SIZE)	\
+		return test_page_func(page);				\
+	return btrfs_subpage_test_##name(fs_info, page, start, len);	\
+}
+DECLARE_BTRFS_PAGE_OPS(uptodate, SetPageUptodate, ClearPageUptodate,
+			PageUptodate);
+
 #endif /* BTRFS_SUBPAGE_H */
Signature · 1 line
2.29.2
author
#16 lore raw

PATCH v3 13/22 btrfs: subpage: introduce helper for subpage error status

In reply to Qu Wenruo

This patch introduce the following functions to handle btrfs subpage error status:
- btrfs_subpage_set_error()
- btrfs_subpage_clear_error()
- btrfs_subpage_test_error()
Those helpers can only be called when the range is ensured to be inside the page.

- btrfs_page_set_error()
- btrfs_page_clear_error()
- btrfs_page_test_error()
Those helpers can handle both regular sector size and subpage without problem.

---
 fs/btrfs/subpage.h | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
fs/btrfs/subpage.h +32 -0
index 2b2d25cc6cba..25f6d0cd1a1e 100644
@@ -24,6 +24,7 @@ struct btrfs_subpage {
 	/* Common members for both data and metadata pages */
 	spinlock_t lock;
 	u16 uptodate_bitmap;
+	u16 error_bitmap;
 	union {
 		/* Structures only used by metadata */
 		struct {
@@ -130,6 +131,35 @@ static inline void btrfs_subpage_clear_uptodate(struct btrfs_fs_info *fs_info,
 	spin_unlock_irqrestore(&subpage->lock, flags);
 }
 
+static inline void btrfs_subpage_set_error(struct btrfs_fs_info *fs_info,
+					   struct page *page, u64 start,
+					   u32 len)
+{
+	struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
+	u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len);
+	unsigned long flags;
+
+	spin_lock_irqsave(&subpage->lock, flags);
+	subpage->error_bitmap |= tmp;
+	SetPageError(page);
+	spin_unlock_irqrestore(&subpage->lock, flags);
+}
+
+static inline void btrfs_subpage_clear_error(struct btrfs_fs_info *fs_info,
+					   struct page *page, u64 start,
+					   u32 len)
+{
+	struct btrfs_subpage *subpage = (struct btrfs_subpage *)page->private;
+	u16 tmp = btrfs_subpage_calc_bitmap(fs_info, page, start, len);
+	unsigned long flags;
+
+	spin_lock_irqsave(&subpage->lock, flags);
+	subpage->error_bitmap &= ~tmp;
+	if (subpage->error_bitmap == 0)
+		ClearPageError(page);
+	spin_unlock_irqrestore(&subpage->lock, flags);
+}
+
 /*
  * Unlike set/clear which is dependent on each page status, for test all bits
  * are tested in the same way.
@@ -149,6 +179,7 @@ static inline bool btrfs_subpage_test_##name(struct btrfs_fs_info *fs_info, \
 	return ret;							\
 }
 DECLARE_BTRFS_SUBPAGE_TEST_OP(uptodate);
+DECLARE_BTRFS_SUBPAGE_TEST_OP(error);
 
 /*
  * Note that, in selftest, especially extent-io-tests, we can have empty
@@ -185,5 +216,6 @@ static inline bool btrfs_page_test_##name(struct btrfs_fs_info *fs_info, \
 }
 DECLARE_BTRFS_PAGE_OPS(uptodate, SetPageUptodate, ClearPageUptodate,
 			PageUptodate);
+DECLARE_BTRFS_PAGE_OPS(error, SetPageError, ClearPageError, PageError);
 
 #endif /* BTRFS_SUBPAGE_H */
Signature · 1 line
2.29.2
author
#17 lore raw

PATCH v3 14/22 btrfs: extent_io: make set/clear_extent_buffer_uptodate() to support subpage size

In reply to Qu Wenruo

For those functions, to support subpage size they just need to call btrfs_page_set/clear_uptodate() wrappers.

---
 fs/btrfs/extent_io.c | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)
fs/btrfs/extent_io.c +7 -4
index 3bd4b99897d6..66e70b263343 100644
@@ -5613,30 +5613,33 @@ bool set_extent_buffer_dirty(struct extent_buffer *eb)
 
 void clear_extent_buffer_uptodate(struct extent_buffer *eb)
 {
-	int i;
+	struct btrfs_fs_info *fs_info = eb->fs_info;
 	struct page *page;
 	int num_pages;
+	int i;
 
 	clear_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
 	num_pages = num_extent_pages(eb);
 	for (i = 0; i < num_pages; i++) {
 		page = eb->pages[i];
 		if (page)
-			ClearPageUptodate(page);
+			btrfs_page_clear_uptodate(fs_info, page,
+						  eb->start, eb->len);
 	}
 }
 
 void set_extent_buffer_uptodate(struct extent_buffer *eb)
 {
-	int i;
+	struct btrfs_fs_info *fs_info = eb->fs_info;
 	struct page *page;
 	int num_pages;
+	int i;
 
 	set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
 	num_pages = num_extent_pages(eb);
 	for (i = 0; i < num_pages; i++) {
 		page = eb->pages[i];
-		SetPageUptodate(page);
+		btrfs_page_set_uptodate(fs_info, page, eb->start, eb->len);
 	}
 }
 
Signature · 1 line
2.29.2
author
#18 lore raw

PATCH v3 15/22 btrfs: extent_io: make btrfs_clone_extent_buffer() to be subpage compatible

In reply to Qu Wenruo

For btrfs_clone_extent_buffer(), it's mostly the same code of __alloc_dummy_extent_buffer(), except it has extra page copy.

So to make it subpage compatible, we only need to:
- Call set_extent_buffer_uptodate() instead of SetPageUptodate() This will set correct uptodate bit for subpage and regular sector size cases.

Since we're calling set_extent_buffer_uptodate() which will also set EXTENT_BUFFER_UPTODATE bit, we don't need to manually set that bit either.

---
 fs/btrfs/extent_io.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)
fs/btrfs/extent_io.c +1 -3
index 66e70b263343..194cb8b63216 100644
@@ -5106,7 +5106,6 @@ struct extent_buffer *btrfs_clone_extent_buffer(const struct extent_buffer *src)
 	if (new == NULL)
 		return NULL;
 
-	set_bit(EXTENT_BUFFER_UPTODATE, &new->bflags);
 	set_bit(EXTENT_BUFFER_UNMAPPED, &new->bflags);
 
 	for (i = 0; i < num_pages; i++) {
@@ -5124,11 +5123,10 @@ struct extent_buffer *btrfs_clone_extent_buffer(const struct extent_buffer *src)
 			return NULL;
 		}
 		WARN_ON(PageDirty(p));
-		SetPageUptodate(p);
 		new->pages[i] = p;
 		copy_page(page_address(p), page_address(src->pages[i]));
 	}
-
+	set_extent_buffer_uptodate(new);
 
 	return new;
 }
Signature · 1 line
2.29.2
author
#19 lore raw

PATCH v3 16/22 btrfs: extent_io: implement try_release_extent_buffer() for subpage metadata support

In reply to Qu Wenruo

Unlike the original try_release_extent_buffer, try_release_subpage_extent_buffer() will iterate through btrfs_subpage::tree_block_bitmap, and try to release each extent buffer.

---
 fs/btrfs/extent_io.c | 76 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)
fs/btrfs/extent_io.c +76 -0
index 194cb8b63216..792264f5c3c2 100644
@@ -6258,10 +6258,86 @@ void memmove_extent_buffer(const struct extent_buffer *dst,
 	}
 }
 
+static int try_release_subpage_extent_buffer(struct page *page)
+{
+	struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb);
+	u64 page_start = page_offset(page);
+	int bitmap_size = BTRFS_SUBPAGE_BITMAP_SIZE;
+	int bit_start = 0;
+	int ret;
+
+	while (bit_start < bitmap_size) {
+		struct btrfs_subpage *subpage;
+		struct extent_buffer *eb;
+		unsigned long flags;
+		u16 tmp = 1 << bit_start;
+		u64 start;
+
+		/*
+		 * Make sure the page still has private, as previous iteration
+		 * can detach page private.
+		 */
+		spin_lock(&page->mapping->private_lock);
+		if (!PagePrivate(page)) {
+			spin_unlock(&page->mapping->private_lock);
+			break;
+		}
+
+		subpage = (struct btrfs_subpage *)page->private;
+
+		spin_lock_irqsave(&subpage->lock, flags);
+		spin_unlock(&page->mapping->private_lock);
+
+		if (!(tmp & subpage->tree_block_bitmap))  {
+			spin_unlock_irqrestore(&subpage->lock, flags);
+			bit_start++;
+			continue;
+		}
+
+		start = bit_start * fs_info->sectorsize + page_start;
+		bit_start += fs_info->nodesize >> fs_info->sectorsize_bits;
+		/*
+		 * Here we can't call find_extent_buffer() which will increase
+		 * eb->refs.
+		 */
+		rcu_read_lock();
+		eb = radix_tree_lookup(&fs_info->buffer_radix,
+				start >> fs_info->sectorsize_bits);
+		ASSERT(eb);
+		spin_lock(&eb->refs_lock);
+		if (atomic_read(&eb->refs) != 1 || extent_buffer_under_io(eb) ||
+		    !test_and_clear_bit(EXTENT_BUFFER_TREE_REF, &eb->bflags)) {
+			spin_unlock(&eb->refs_lock);
+			rcu_read_unlock();
+			continue;
+		}
+		rcu_read_unlock();
+		spin_unlock_irqrestore(&subpage->lock, flags);
+		/*
+		 * Here we don't care the return value, we will always check
+		 * the page private at the end.
+		 * And release_extent_buffer() will release the refs_lock.
+		 */
+		release_extent_buffer(eb);
+	}
+	/* Finally to check if we have cleared page private */
+	spin_lock(&page->mapping->private_lock);
+	if (!PagePrivate(page))
+		ret = 1;
+	else
+		ret = 0;
+	spin_unlock(&page->mapping->private_lock);
+	return ret;
+
+}
+
 int try_release_extent_buffer(struct page *page)
 {
 	struct extent_buffer *eb;
 
+	if (btrfs_sb(page->mapping->host->i_sb)->sectorsize < PAGE_SIZE)
+		return try_release_subpage_extent_buffer(page);
+
 	/*
 	 * We need to make sure nobody is attaching this page to an eb right
 	 * now.
Signature · 1 line
2.29.2
author
#20 lore raw

Re: [PATCH v3 16/22] btrfs: extent_io: implement try_release_extent_buffer() for subpage metadata support

Quoted 53 lines · Qu Wenruo

Unlike the original try_release_extent_buffer, try_release_subpage_extent_buffer() will iterate through btrfs_subpage::tree_block_bitmap, and try to release each extent buffer.

---
  fs/btrfs/extent_io.c | 76 ++++++++++++++++++++++++++++++++++++++++++++
  1 file changed, 76 insertions(+)
fs/btrfs/extent_io.c +36 -0
index 194cb8b63216..792264f5c3c2 100644
@@ -6258,10 +6258,86 @@ void memmove_extent_buffer(const struct extent_buffer *dst,
  	}
  }
 
+static int try_release_subpage_extent_buffer(struct page *page)
+{
+	struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb);
+	u64 page_start = page_offset(page);
+	int bitmap_size = BTRFS_SUBPAGE_BITMAP_SIZE;
+	int bit_start = 0;
+	int ret;
+
+	while (bit_start < bitmap_size) {
+		struct btrfs_subpage *subpage;
+		struct extent_buffer *eb;
+		unsigned long flags;
+		u16 tmp = 1 << bit_start;
+		u64 start;
+
+		/*
+		 * Make sure the page still has private, as previous iteration
+		 * can detach page private.
+		 */
+		spin_lock(&page->mapping->private_lock);
+		if (!PagePrivate(page)) {
+			spin_unlock(&page->mapping->private_lock);
+			break;
+		}
+
+		subpage = (struct btrfs_subpage *)page->private;
+
+		spin_lock_irqsave(&subpage->lock, flags);
+		spin_unlock(&page->mapping->private_lock);
+
+		if (!(tmp & subpage->tree_block_bitmap))  {
+			spin_unlock_irqrestore(&subpage->lock, flags);
+			bit_start++;
+			continue;
+		}
+

fs/btrfs/extent_io.c void memmove_extent_buffer(const struct extent_buffer *dst, · line 6306

Quoted 10 lines
fs/btrfs/extent_io.c +10 -0
+		start = bit_start * fs_info->sectorsize + page_start;
+		bit_start += fs_info->nodesize >> fs_info->sectorsize_bits;
+		/*
+		 * Here we can't call find_extent_buffer() which will increase
+		 * eb->refs.
+		 */
+		rcu_read_lock();
+		eb = radix_tree_lookup(&fs_info->buffer_radix,
+				start >> fs_info->sectorsize_bits);
+		ASSERT(eb);

Another ASSERT() hit here. Surprised that I have never hit such case before.

Since in releasse_extent_buffer(), radix tree is removed first, then subpage tree_block_bitmap update, we could have cases where subpage tree_block_bitmap is set but no eb in radix tree.

In that case, we can safely go next bit and re-check.

The function return value is only bounded to if the page has private bit or not, so here we can safely continue.

Nik is right on this, we need better eb refs handling refactor, I'll investigate more time to make the eb refs handling better.

Thanks,
Qu

Quoted 38 lines
fs/btrfs/extent_io.c +30 -0
+		spin_lock(&eb->refs_lock);
+		if (atomic_read(&eb->refs) != 1 || extent_buffer_under_io(eb) ||
+		    !test_and_clear_bit(EXTENT_BUFFER_TREE_REF, &eb->bflags)) {
+			spin_unlock(&eb->refs_lock);
+			rcu_read_unlock();
+			continue;
+		}
+		rcu_read_unlock();
+		spin_unlock_irqrestore(&subpage->lock, flags);
+		/*
+		 * Here we don't care the return value, we will always check
+		 * the page private at the end.
+		 * And release_extent_buffer() will release the refs_lock.
+		 */
+		release_extent_buffer(eb);
+	}
+	/* Finally to check if we have cleared page private */
+	spin_lock(&page->mapping->private_lock);
+	if (!PagePrivate(page))
+		ret = 1;
+	else
+		ret = 0;
+	spin_unlock(&page->mapping->private_lock);
+	return ret;
+
+}
+
  int try_release_extent_buffer(struct page *page)
  {
  	struct extent_buffer *eb;
 
+	if (btrfs_sb(page->mapping->host->i_sb)->sectorsize < PAGE_SIZE)
+		return try_release_subpage_extent_buffer(page);
+
  	/*
  	 * We need to make sure nobody is attaching this page to an eb right
  	 * now.
author
#21 lore raw

Re: [PATCH v3 16/22] btrfs: extent_io: implement try_release_extent_buffer() for subpage metadata support

Quoted 69 lines · Qu Wenruo
Quoted 53 lines · Qu Wenruo

Unlike the original try_release_extent_buffer, try_release_subpage_extent_buffer() will iterate through btrfs_subpage::tree_block_bitmap, and try to release each extent buffer.

---
  fs/btrfs/extent_io.c | 76 ++++++++++++++++++++++++++++++++++++++++++++

  1 file changed, 76 insertions(+)
fs/btrfs/extent_io.c +36 -0
index 194cb8b63216..792264f5c3c2 100644
@@ -6258,10 +6258,86 @@ void memmove_extent_buffer(const struct 
 extent_buffer *dst,
       }
   }
+static int try_release_subpage_extent_buffer(struct page *page)
+{
+    struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb);
+    u64 page_start = page_offset(page);
+    int bitmap_size = BTRFS_SUBPAGE_BITMAP_SIZE;
+    int bit_start = 0;
+    int ret;
+
+    while (bit_start < bitmap_size) {
+        struct btrfs_subpage *subpage;
+        struct extent_buffer *eb;
+        unsigned long flags;
+        u16 tmp = 1 << bit_start;
+        u64 start;
+
+        /*
+         * Make sure the page still has private, as previous iteration
+         * can detach page private.
+         */
+        spin_lock(&page->mapping->private_lock);
+        if (!PagePrivate(page)) {
+            spin_unlock(&page->mapping->private_lock);
+            break;
+        }
+
+        subpage = (struct btrfs_subpage *)page->private;
+
+        spin_lock_irqsave(&subpage->lock, flags);
+        spin_unlock(&page->mapping->private_lock);
+
+        if (!(tmp & subpage->tree_block_bitmap))  {
+            spin_unlock_irqrestore(&subpage->lock, flags);
+            bit_start++;
+            continue;
+        }
+

fs/btrfs/extent_io.c void memmove_extent_buffer(const struct · line 6306

Quoted 10 lines
fs/btrfs/extent_io.c +10 -0
+        start = bit_start * fs_info->sectorsize + page_start;
+        bit_start += fs_info->nodesize >> fs_info->sectorsize_bits;
+        /*
+         * Here we can't call find_extent_buffer() which will increase
+         * eb->refs.
+         */
+        rcu_read_lock();
+        eb = radix_tree_lookup(&fs_info->buffer_radix,
+                start >> fs_info->sectorsize_bits);
+        ASSERT(eb);

Another ASSERT() hit here. Surprised that I have never hit such case before.

Quoted 7 lines

Since in releasse_extent_buffer(), radix tree is removed first, then subpage tree_block_bitmap update, we could have cases where subpage tree_block_bitmap is set but no eb in radix tree.

In that case, we can safely go next bit and re-check.

The function return value is only bounded to if the page has private bit or not, so here we can safely continue.

Nik is right on this, we need better eb refs handling refactor, I'll investigate more time to make the eb refs handling better.

The root problem here is, we have too many things to be synchronized for extent buffer.

We have eb::refs, eb::bflags (IN_TREE), buffer_radix, and the new subpage::tree_block_bitmap, they all need to be in sync with each other.

I'm wondering if we could find a good and clear enough way to handle extent buffers.

IMHO, we need to sacrifice some metadata performance (which is already poor enough), or there is really no better way to solve the mess...

Thanks,
Qu

Quoted 41 lines

Thanks,
Qu

Quoted 37 lines
fs/btrfs/extent_io.c +30 -0
+        spin_lock(&eb->refs_lock);
+        if (atomic_read(&eb->refs) != 1 || extent_buffer_under_io(eb) ||
+            !test_and_clear_bit(EXTENT_BUFFER_TREE_REF, &eb->bflags)) {
+            spin_unlock(&eb->refs_lock);
+            rcu_read_unlock();
+            continue;
+        }
+        rcu_read_unlock();
+        spin_unlock_irqrestore(&subpage->lock, flags);
+        /*
+         * Here we don't care the return value, we will always check
+         * the page private at the end.
+         * And release_extent_buffer() will release the refs_lock.
+         */
+        release_extent_buffer(eb);
+    }
+    /* Finally to check if we have cleared page private */
+    spin_lock(&page->mapping->private_lock);
+    if (!PagePrivate(page))
+        ret = 1;
+    else
+        ret = 0;
+    spin_unlock(&page->mapping->private_lock);
+    return ret;
+
+}
+
   int try_release_extent_buffer(struct page *page)
   {
       struct extent_buffer *eb;
+    if (btrfs_sb(page->mapping->host->i_sb)->sectorsize < PAGE_SIZE)
+        return try_release_subpage_extent_buffer(page);
+
       /*
        * We need to make sure nobody is attaching this page to an eb right
        * now.
 
author
#22 lore raw

PATCH v3 17/22 btrfs: extent_io: introduce read_extent_buffer_subpage()

In reply to Qu Wenruo

Introduce a new helper, read_extent_buffer_subpage(), to do the subpage extent buffer read.

The difference between regular and subpage routines are:
- No page locking
Here we completely rely on extent locking.
Page locking can reduce the concurrency greatly, as if we lock one page to read one extent buffer, all the other extent buffers in the same page will have to wait.

- Extent uptodate condition
Despite the existing PageUptodate() and EXTENT_BUFFER_UPTODATE check, We also need to check btrfs_subpage::uptodate_bitmap.

- No page loop
Just one page, no need to loop, this greately simplified the subpage routine.

This patch only implemented the bio submit part, no endio support yet.

---
 fs/btrfs/disk-io.c   |  1 +
 fs/btrfs/extent_io.c | 70 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 71 insertions(+)
fs/btrfs/disk-io.c +1 -0
index 5473bed6a7e8..7440663e8d13 100644
@@ -602,6 +602,7 @@ int btrfs_validate_metadata_buffer(struct btrfs_io_bio *io_bio,
 	ASSERT(page->private);
 	eb = (struct extent_buffer *)page->private;
 
+
 	/*
 	 * The pending IO might have been the only thing that kept this buffer
 	 * in memory.  Make sure we have a ref for all this other checks
fs/btrfs/extent_io.c +70 -0

82 lines not on this page · raw message

Signature · 1 line
2.29.2
author
#23 lore raw

PATCH v3 18/22 btrfs: extent_io: make endio_readpage_update_page_status() to handle subpage case

In reply to Qu Wenruo

To handle subpage status update, add the following new tricks:
- Use btrfs_page_*() helpers to update page status Now we can handle both cases well.

- No page unlock for subpage metadata
Since subpage metadata doesn't utilize page locking at all, skip it. For subpage data locking, it's handled in later commits.

---
 fs/btrfs/extent_io.c | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)
fs/btrfs/extent_io.c +15 -6
index b828314bf43a..2902484ab9f9 100644
@@ -2839,15 +2839,24 @@ static void endio_readpage_release_extent(struct processed_extent *processed,
 	processed->uptodate = uptodate;
 }
 
-static void endio_readpage_update_page_status(struct page *page, bool uptodate)
+static void endio_readpage_update_page_status(struct page *page, bool uptodate,
+					      u64 start, u32 len)
 {
+	struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb);
+
+	ASSERT(page_offset(page) <= start &&
+		start + len <= page_offset(page) + PAGE_SIZE);
+
 	if (uptodate) {
-		SetPageUptodate(page);
+		btrfs_page_set_uptodate(fs_info, page, start, len);
 	} else {
-		ClearPageUptodate(page);
-		SetPageError(page);
+		btrfs_page_clear_uptodate(fs_info, page, start, len);
+		btrfs_page_set_error(fs_info, page, start, len);
 	}
-	unlock_page(page);
+
+	if (fs_info->sectorsize == PAGE_SIZE)
+		unlock_page(page);
+	/* Subpage locking will be handled in later patches */
 }
 
 /*
@@ -2984,7 +2993,7 @@ static void end_bio_extent_readpage(struct bio *bio)
 		bio_offset += len;
 
 		/* Update page status and unlock */
-		endio_readpage_update_page_status(page, uptodate);
+		endio_readpage_update_page_status(page, uptodate, start, len);
 		endio_readpage_release_extent(&processed, BTRFS_I(inode),
 					      start, end, uptodate);
 	}
Signature · 1 line
2.29.2
author
#24 lore raw

PATCH v3 19/22 btrfs: disk-io: introduce subpage metadata validation check

In reply to Qu Wenruo

For subpage metadata validation check, there are some difference:

- Read must finish in one bvec
Since we're just reading one subpage range in one page, it should never be split into two bios nor two bvecs.

- How to grab the existing eb
Instead of grabbing eb using page->private, we have to go search radix tree as we don't have any direct pointer at hand.

---
 fs/btrfs/disk-io.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
fs/btrfs/disk-io.c +57 -0
index 7440663e8d13..73733250d12c 100644
@@ -591,6 +591,59 @@ static int validate_extent_buffer(struct extent_buffer *eb)
 	return ret;
 }
 
+static int validate_subpage_buffer(struct page *page, u64 start, u64 end,
+				   int mirror)
+{
+	struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb);
+	struct extent_buffer *eb;
+	int reads_done;
+	int ret = 0;
+
+	/*
+	 * We don't allow bio merge for subpage metadata read, so we should
+	 * only get one eb for each endio hook.
+	 */
+	ASSERT(end == start + fs_info->nodesize - 1);
+	ASSERT(PagePrivate(page));
+
+	eb = find_extent_buffer(fs_info, start);
+	/*
+	 * When we are reading one tree block, eb must have been
+	 * inserted into the radix tree. If not something is wrong.
+	 */
+	ASSERT(eb);
+
+	reads_done = atomic_dec_and_test(&eb->io_pages);
+	/* Subpage read must finish in page read */
+	ASSERT(reads_done);
+
+	eb->read_mirror = mirror;
+	if (test_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags)) {
+		ret = -EIO;
+		goto err;
+	}
+	ret = validate_extent_buffer(eb);
+	if (ret < 0)
+		goto err;
+
+	if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
+		btree_readahead_hook(eb, ret);
+
+	set_extent_buffer_uptodate(eb);
+
+	free_extent_buffer(eb);
+	return ret;
+err:
+	/*
+	 * end_bio_extent_readpage decrements io_pages in case of error,
+	 * make sure it has something to decrement.
+	 */
+	atomic_inc(&eb->io_pages);
+	clear_extent_buffer_uptodate(eb);
+	free_extent_buffer(eb);
+	return ret;
+}
+
 int btrfs_validate_metadata_buffer(struct btrfs_io_bio *io_bio,
 				   struct page *page, u64 start, u64 end,
 				   int mirror)
@@ -600,6 +653,10 @@ int btrfs_validate_metadata_buffer(struct btrfs_io_bio *io_bio,
 	int reads_done;
 
 	ASSERT(page->private);
+
+	if (btrfs_sb(page->mapping->host->i_sb)->sectorsize < PAGE_SIZE)
+		return validate_subpage_buffer(page, start, end, mirror);
+
 	eb = (struct extent_buffer *)page->private;
 
 
Signature · 1 line
2.29.2
author
#25 lore raw

PATCH v3 20/22 btrfs: introduce btrfs_subpage for data inodes

In reply to Qu Wenruo

To support subpage sector size, data also need extra info to make sure which sectors in a page are uptodate/dirty/...

This patch will make pages for data inodes to get btrfs_subpage structure attached, and detached when the page is freed.

This patch also slightly changes the timing when
set_page_extent_mapped() to make sure:

- We have page->mapping set
page->mapping->host is used to grab btrfs_fs_info, thus we can only call this function after page is mapped to an inode.

One call site attaches pages to inode manually, thus we have to modify the timing of set_page_extent_mapped() a little.

- As soon as possible, before other operations
Since memory allocation can fail, we have to do extra error handling. Calling set_page_extent_mapped() as soon as possible can simply the error handling for several call sites.

The idea is pretty much the same as iomap_page, but with more bitmaps for btrfs specific cases.

Currently the plan is to switch iomap if iomap can provide sector aligned write back (only write back dirty sectors, but not the full page, data balance require this feature).

So we will stick to btrfs specific bitmap for now.

---
 fs/btrfs/compression.c      | 10 ++++++--
 fs/btrfs/extent_io.c        | 46 +++++++++++++++++++++++++++++++++----
 fs/btrfs/extent_io.h        |  3 ++-
 fs/btrfs/file.c             | 24 ++++++++-----------
 fs/btrfs/free-space-cache.c | 15 +++++++++---
 fs/btrfs/inode.c            | 12 ++++++----
 fs/btrfs/ioctl.c            |  5 +++-
 fs/btrfs/reflink.c          |  5 +++-
 fs/btrfs/relocation.c       | 12 ++++++++--
 9 files changed, 99 insertions(+), 33 deletions(-)
fs/btrfs/compression.c +8 -2
index 5ae3fa0386b7..6d203acfdeb3 100644
@@ -542,13 +542,19 @@ static noinline int add_ra_bio_pages(struct inode *inode,
 			goto next;
 		}
 
-		end = last_offset + PAGE_SIZE - 1;
 		/*
 		 * at this point, we have a locked page in the page cache
 		 * for these bytes in the file.  But, we have to make
 		 * sure they map to this compressed extent on disk.
 		 */
-		set_page_extent_mapped(page);
+		ret = set_page_extent_mapped(page);
+		if (ret < 0) {
+			unlock_page(page);
+			put_page(page);
+			break;
+		}
+
+		end = last_offset + PAGE_SIZE - 1;
 		lock_extent(tree, last_offset, end);
 		read_lock(&em_tree->lock);
 		em = lookup_extent_mapping(em_tree, last_offset,
fs/btrfs/extent_io.c +42 -4

66 lines not on this page · raw message

fs/btrfs/extent_io.h +2 -1
index bedf761a0300..357a3380cd42 100644
@@ -178,7 +178,8 @@ int btree_write_cache_pages(struct address_space *mapping,
 void extent_readahead(struct readahead_control *rac);
 int extent_fiemap(struct btrfs_inode *inode, struct fiemap_extent_info *fieinfo,
 		  u64 start, u64 len);
-void set_page_extent_mapped(struct page *page);
+int __must_check set_page_extent_mapped(struct page *page);
+void clear_page_extent_mapped(struct page *page);
 
 struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info,
 					  u64 start, u64 owner_root, int level);
fs/btrfs/file.c +9 -15
index 1602975ddb88..a6f627f92c64 100644
@@ -1369,6 +1369,12 @@ static noinline int prepare_pages(struct inode *inode, struct page **pages,
 			goto fail;
 		}
 
+		err = set_page_extent_mapped(pages[i]);
+		if (err < 0) {
+			faili = i;
+			goto fail;
+		}
+
 		if (i == 0)
 			err = prepare_uptodate_page(inode, pages[i], pos,
 						    force_uptodate);
@@ -1453,23 +1459,11 @@ lock_and_cleanup_extent_if_need(struct btrfs_inode *inode, struct page **pages,
 	}
 
 	/*
-	 * It's possible the pages are dirty right now, but we don't want
-	 * to clean them yet because copy_from_user may catch a page fault
-	 * and we might have to fall back to one page at a time.  If that
-	 * happens, we'll unlock these pages and we'd have a window where
-	 * reclaim could sneak in and drop the once-dirty page on the floor
-	 * without writing it.
-	 *
-	 * We have the pages locked and the extent range locked, so there's
-	 * no way someone can start IO on any dirty pages in this range.
-	 *
-	 * We'll call btrfs_dirty_pages() later on, and that will flip around
-	 * delalloc bits and dirty the pages as required.
+	 * We should be called after prepare_pages() which should have
+	 * locked all pages in the range.
 	 */
-	for (i = 0; i < num_pages; i++) {
-		set_page_extent_mapped(pages[i]);
+	for (i = 0; i < num_pages; i++)
 		WARN_ON(!PageLocked(pages[i]));
-	}
 
 	return ret;
 }
fs/btrfs/free-space-cache.c +12 -3
index fd6ddd6b8165..379bef967e1d 100644
@@ -431,11 +431,22 @@ static int io_ctl_prepare_pages(struct btrfs_io_ctl *io_ctl, bool uptodate)
 	int i;
 
 	for (i = 0; i < io_ctl->num_pages; i++) {
+		int ret;
+
 		page = find_or_create_page(inode->i_mapping, i, mask);
 		if (!page) {
 			io_ctl_drop_pages(io_ctl);
 			return -ENOMEM;
 		}
+
+		ret = set_page_extent_mapped(page);
+		if (ret < 0) {
+			unlock_page(page);
+			put_page(page);
+			io_ctl_drop_pages(io_ctl);
+			return -ENOMEM;
+		}
+
 		io_ctl->pages[i] = page;
 		if (uptodate && !PageUptodate(page)) {
 			btrfs_readpage(NULL, page);
@@ -455,10 +466,8 @@ static int io_ctl_prepare_pages(struct btrfs_io_ctl *io_ctl, bool uptodate)
 		}
 	}
 
-	for (i = 0; i < io_ctl->num_pages; i++) {
+	for (i = 0; i < io_ctl->num_pages; i++)
 		clear_page_dirty_for_io(io_ctl->pages[i]);
-		set_page_extent_mapped(io_ctl->pages[i]);
-	}
 
 	return 0;
 }
fs/btrfs/inode.c +8 -4
index ecc1f1f60b48..0cf3a0b7e98c 100644
@@ -4712,6 +4712,9 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len,
 		ret = -ENOMEM;
 		goto out;
 	}
+	ret = set_page_extent_mapped(page);
+	if (ret < 0)
+		goto out_unlock;
 
 	if (!PageUptodate(page)) {
 		ret = btrfs_readpage(NULL, page);
@@ -4729,7 +4732,6 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len,
 	wait_on_page_writeback(page);
 
 	lock_extent_bits(io_tree, block_start, block_end, &cached_state);
-	set_page_extent_mapped(page);
 
 	ordered = btrfs_lookup_ordered_extent(inode, block_start);
 	if (ordered) {
@@ -8109,7 +8111,7 @@ static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
 {
 	int ret = try_release_extent_mapping(page, gfp_flags);
 	if (ret == 1)
-		detach_page_private(page);
+		clear_page_extent_mapped(page);
 	return ret;
 }
 
@@ -8268,7 +8270,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,
 	}
 
 	ClearPageChecked(page);
-	detach_page_private(page);
+	clear_page_extent_mapped(page);
 }
 
 /*
@@ -8347,7 +8349,9 @@ vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
 	wait_on_page_writeback(page);
 
 	lock_extent_bits(io_tree, page_start, page_end, &cached_state);
-	set_page_extent_mapped(page);
+	ret = set_page_extent_mapped(page);
+	if (ret < 0)
+		goto out_unlock;
 
 	/*
 	 * we can't set the delalloc bits if there are pending ordered
fs/btrfs/ioctl.c +4 -1
index 5b9b0a390f0e..5a93530bca46 100644
@@ -1314,6 +1314,10 @@ static int cluster_pages_for_defrag(struct inode *inode,
 		if (!page)
 			break;
 
+		ret = set_page_extent_mapped(page);
+		if (ret < 0)
+			break;
+
 		page_start = page_offset(page);
 		page_end = page_start + PAGE_SIZE - 1;
 		while (1) {
@@ -1435,7 +1439,6 @@ static int cluster_pages_for_defrag(struct inode *inode,
 	for (i = 0; i < i_done; i++) {
 		clear_page_dirty_for_io(pages[i]);
 		ClearPageChecked(pages[i]);
-		set_page_extent_mapped(pages[i]);
 		set_page_dirty(pages[i]);
 		unlock_page(pages[i]);
 		put_page(pages[i]);
fs/btrfs/reflink.c +4 -1
index b03e7891394e..b24396cf2f99 100644
@@ -81,7 +81,10 @@ static int copy_inline_to_page(struct btrfs_inode *inode,
 		goto out_unlock;
 	}
 
-	set_page_extent_mapped(page);
+	ret = set_page_extent_mapped(page);
+	if (ret < 0)
+		goto out_unlock;
+
 	clear_extent_bit(&inode->io_tree, file_offset, range_end,
 			 EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
 			 0, 0, NULL);
fs/btrfs/relocation.c +10 -2
index 8e51b39cbfbb..d917fdef0cbf 100644
@@ -2679,6 +2679,16 @@ static int relocate_file_extent_cluster(struct inode *inode,
 				goto out;
 			}
 		}
+		ret = set_page_extent_mapped(page);
+		if (ret < 0) {
+			btrfs_delalloc_release_metadata(BTRFS_I(inode),
+						PAGE_SIZE, true);
+			btrfs_delalloc_release_extents(BTRFS_I(inode),
+						PAGE_SIZE);
+			unlock_page(page);
+			put_page(page);
+			goto out;
+		}
 
 		if (PageReadahead(page)) {
 			page_cache_async_readahead(inode->i_mapping,
@@ -2706,8 +2716,6 @@ static int relocate_file_extent_cluster(struct inode *inode,
 
 		lock_extent(&BTRFS_I(inode)->io_tree, page_start, page_end);
 
-		set_page_extent_mapped(page);
-
 		if (nr < cluster->nr &&
 		    page_start + offset == cluster->boundary[nr]) {
 			set_extent_bits(&BTRFS_I(inode)->io_tree,
Signature · 1 line
2.29.2
#26 lore raw

Re: [PATCH v3 20/22] btrfs: introduce btrfs_subpage for data inodes

Thank you for the patch! Perhaps something to improve:

Hi Qu,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on kdave/for-next]
[also build test WARNING on v5.11-rc2 next-20210104]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847
base:   https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next
config: m68k-randconfig-s032-20210106 (attached as .config)
compiler: m68k-linux-gcc (GCC) 9.3.0

reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# apt-get install sparse
# sparse version: v0.6.3-208-g46a52ca4-dirty
# https://github.com/0day-ci/linux/commit/2c54bbf363f66a7c4d489fa0b7967ce5fc960afb
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847 git checkout 2c54bbf363f66a7c4d489fa0b7967ce5fc960afb
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=m68k

If you fix the issue, kindly add following tag as appropriate

"sparse warnings: (new ones prefixed by >>)"

>> fs/btrfs/inode.c:8352:13: sparse: sparse: incorrect type in assignment (different base types) @@     expected restricted vm_fault_t [assigned] [usertype] ret @@     got int @@
   fs/btrfs/inode.c:8352:13: sparse:     expected restricted vm_fault_t [assigned] [usertype] ret
   fs/btrfs/inode.c:8352:13: sparse:     got int
>> fs/btrfs/inode.c:8353:13: sparse: sparse: restricted vm_fault_t degrades to integer

fs/btrfs/inode.c: note: in included file (through include/linux/mmzone.h, include/linux/gfp.h, include/linux/slab.h, ...):
include/linux/spinlock.h:394:9: sparse: sparse: context imbalance in 'run_delayed_iput_locked' - unexpected unlock

vim +8352 fs/btrfs/inode.c

8275
8276 /*
8277 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
8278 * called from a page fault handler when a page is first dirtied. Hence we must
8279 * be careful to check for EOF conditions here. We set the page up correctly
8280 * for a written page which means we get ENOSPC checking when writing into
8281 * holes and correct delalloc and unwritten extent mapping on filesystems that
8282 * support these features.
8283 *
8284 * We are not allowed to take the i_mutex here so we have to play games to
8285 * protect against truncate races as the page could now be beyond EOF. Because
8286 * truncate_setsize() writes the inode size before removing pages, once we have
8287 * the page lock we can determine safely if the page is beyond EOF. If it is not
8288 * beyond EOF, then the page is guaranteed safe against truncation until we
8289 * unlock the page.
8290 */
8291 vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
8292 {
8293 struct page *page = vmf->page;
8294 struct inode *inode = file_inode(vmf->vma->vm_file);
8295 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
8296 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
8297 struct btrfs_ordered_extent *ordered;
8298 struct extent_state *cached_state = NULL;
8299 struct extent_changeset *data_reserved = NULL;
8300 char *kaddr;
8301 unsigned long zero_start;
8302 loff_t size;
8303 vm_fault_t ret;
8304 int ret2;
8305 int reserved = 0;
8306 u64 reserved_space;
8307 u64 page_start;
8308 u64 page_end;
8309 u64 end;
8310
8311 reserved_space = PAGE_SIZE;
8312
8313 sb_start_pagefault(inode->i_sb);
8314 page_start = page_offset(page);
8315 page_end = page_start + PAGE_SIZE - 1;
8316 end = page_end;
8317
8318 /*
8319 * Reserving delalloc space after obtaining the page lock can lead to
8320 * deadlock. For example, if a dirty page is locked by this function
8321 * and the call to btrfs_delalloc_reserve_space() ends up triggering
8322 * dirty page write out, then the btrfs_writepage() function could
8323 * end up waiting indefinitely to get a lock on the page currently
8324 * being processed by btrfs_page_mkwrite() function.
8325 */
8326 ret2 = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
8327 page_start, reserved_space);
8328 if (!ret2) {
8329 ret2 = file_update_time(vmf->vma->vm_file);
8330 reserved = 1;
8331 }
8332 if (ret2) {
8333 ret = vmf_error(ret2);
8334 if (reserved)
8335 goto out;
8336 goto out_noreserve;
8337 }
8338
8339 ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
8340 again:
8341 lock_page(page);
8342 size = i_size_read(inode);
8343
8344 if ((page->mapping != inode->i_mapping) ||
8345 (page_start >= size)) {
8346 /* page got truncated out from underneath us */
8347 goto out_unlock;
8348 }
8349 wait_on_page_writeback(page);
8350
8351 lock_extent_bits(io_tree, page_start, page_end, &cached_state);

> 8352		ret = set_page_extent_mapped(page);
> 8353		if (ret < 0)

8354 goto out_unlock;
8355
8356 /*
8357 * we can't set the delalloc bits if there are pending ordered
8358 * extents. Drop our locks and wait for them to finish
8359 */
8360 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
8361 PAGE_SIZE);
8362 if (ordered) {
8363 unlock_extent_cached(io_tree, page_start, page_end,
8364 &cached_state);
8365 unlock_page(page);
8366 btrfs_start_ordered_extent(ordered, 1);
8367 btrfs_put_ordered_extent(ordered);
8368 goto again;
8369 }
8370
8371 if (page->index == ((size - 1) >> PAGE_SHIFT)) {
8372 reserved_space = round_up(size - page_start,
8373 fs_info->sectorsize);
8374 if (reserved_space < PAGE_SIZE) {
8375 end = page_start + reserved_space - 1;
8376 btrfs_delalloc_release_space(BTRFS_I(inode),
8377 data_reserved, page_start,
8378 PAGE_SIZE - reserved_space, true);
8379 }
8380 }
8381
8382 /*
8383 * page_mkwrite gets called when the page is firstly dirtied after it's
8384 * faulted in, but write(2) could also dirty a page and set delalloc
8385 * bits, thus in this case for space account reason, we still need to
8386 * clear any delalloc bits within this page range since we have to
8387 * reserve data&meta space before lock_page() (see above comments).
8388 */
8389 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
8390 EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
8391 EXTENT_DEFRAG, 0, 0, &cached_state);
8392
8393 ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
8394 &cached_state);
8395 if (ret2) {
8396 unlock_extent_cached(io_tree, page_start, page_end,
8397 &cached_state);
8398 ret = VM_FAULT_SIGBUS;
8399 goto out_unlock;
8400 }
8401
8402 /* page is wholly or partially inside EOF */
8403 if (page_start + PAGE_SIZE > size)
8404 zero_start = offset_in_page(size);
8405 else
8406 zero_start = PAGE_SIZE;
8407
8408 if (zero_start != PAGE_SIZE) {
8409 kaddr = kmap(page);
8410 memset(kaddr + zero_start, 0, PAGE_SIZE - zero_start);
8411 flush_dcache_page(page);
8412 kunmap(page);
8413 }
8414 ClearPageChecked(page);
8415 set_page_dirty(page);
8416 SetPageUptodate(page);
8417
8418 BTRFS_I(inode)->last_trans = fs_info->generation;
8419 BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
8420 BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
8421
8422 unlock_extent_cached(io_tree, page_start, page_end, &cached_state);
8423
8424 btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
8425 sb_end_pagefault(inode->i_sb);
8426 extent_changeset_free(data_reserved);
8427 return VM_FAULT_LOCKED;
8428
8429 out_unlock:
8430 unlock_page(page);
8431 out:
8432 btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
8433 btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
8434 reserved_space, (ret != 0));
8435 out_noreserve:
8436 sb_end_pagefault(inode->i_sb);
8437 extent_changeset_free(data_reserved);
8438 return ret;
8439 }
8440

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#27 lore raw

Re: [PATCH v3 20/22] btrfs: introduce btrfs_subpage for data inodes

Quoted 26 lines · kernel test robot

Hi Qu,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on kdave/for-next]
[also build test WARNING on v5.11-rc2 next-20210104]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847
base:   https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next
config: m68k-randconfig-s032-20210106 (attached as .config)
compiler: m68k-linux-gcc (GCC) 9.3.0

reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# apt-get install sparse
# sparse version: v0.6.3-208-g46a52ca4-dirty
# https://github.com/0day-ci/linux/commit/2c54bbf363f66a7c4d489fa0b7967ce5fc960afb
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847 git checkout 2c54bbf363f66a7c4d489fa0b7967ce5fc960afb
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=m68k

Quoted 9 lines

If you fix the issue, kindly add following tag as appropriate

"sparse warnings: (new ones prefixed by >>)"

Quoted 1 line
Quoted 1 line

fs/btrfs/inode.c:8352:13: sparse: sparse: incorrect type in assignment (different base types) @@ expected restricted vm_fault_t [assigned] [usertype] ret @@ got int @@

fs/btrfs/inode.c:8352:13: sparse: expected restricted vm_fault_t [assigned] [usertype] ret
fs/btrfs/inode.c:8352:13: sparse: got int

Quoted 1 line
Quoted 1 line

fs/btrfs/inode.c:8353:13: sparse: sparse: restricted vm_fault_t degrades to integer

Why I always forgot this...

Now it get properly fixed in github. Although the submitted patch is still using @ret other than @ret2.

Is there anyway to let LKP to run on specific branch so that I can avoid similar problems.

Thanks,
Qu

Quoted 176 lines

fs/btrfs/inode.c: note: in included file (through include/linux/mmzone.h, include/linux/gfp.h, include/linux/slab.h, ...):
include/linux/spinlock.h:394:9: sparse: sparse: context imbalance in 'run_delayed_iput_locked' - unexpected unlock

vim +8352 fs/btrfs/inode.c

   8275
   8276	/*
   8277	 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
   8278	 * called from a page fault handler when a page is first dirtied. Hence we must
   8279	 * be careful to check for EOF conditions here. We set the page up correctly
   8280	 * for a written page which means we get ENOSPC checking when writing into
   8281	 * holes and correct delalloc and unwritten extent mapping on filesystems that
   8282	 * support these features.
   8283	 *
   8284	 * We are not allowed to take the i_mutex here so we have to play games to
   8285	 * protect against truncate races as the page could now be beyond EOF.  Because
   8286	 * truncate_setsize() writes the inode size before removing pages, once we have
   8287	 * the page lock we can determine safely if the page is beyond EOF. If it is not
   8288	 * beyond EOF, then the page is guaranteed safe against truncation until we
   8289	 * unlock the page.
   8290	 */
   8291	vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
   8292	{
   8293		struct page *page = vmf->page;
   8294		struct inode *inode = file_inode(vmf->vma->vm_file);
   8295		struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
   8296		struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
   8297		struct btrfs_ordered_extent *ordered;
   8298		struct extent_state *cached_state = NULL;
   8299		struct extent_changeset *data_reserved = NULL;
   8300		char *kaddr;
   8301		unsigned long zero_start;
   8302		loff_t size;
   8303		vm_fault_t ret;
   8304		int ret2;
   8305		int reserved = 0;
   8306		u64 reserved_space;
   8307		u64 page_start;
   8308		u64 page_end;
   8309		u64 end;
   8310
   8311		reserved_space = PAGE_SIZE;
   8312
   8313		sb_start_pagefault(inode->i_sb);
   8314		page_start = page_offset(page);
   8315		page_end = page_start + PAGE_SIZE - 1;
   8316		end = page_end;
   8317
   8318		/*
   8319		 * Reserving delalloc space after obtaining the page lock can lead to
   8320		 * deadlock. For example, if a dirty page is locked by this function
   8321		 * and the call to btrfs_delalloc_reserve_space() ends up triggering
   8322		 * dirty page write out, then the btrfs_writepage() function could
   8323		 * end up waiting indefinitely to get a lock on the page currently
   8324		 * being processed by btrfs_page_mkwrite() function.
   8325		 */
   8326		ret2 = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
   8327						    page_start, reserved_space);
   8328		if (!ret2) {
   8329			ret2 = file_update_time(vmf->vma->vm_file);
   8330			reserved = 1;
   8331		}
   8332		if (ret2) {
   8333			ret = vmf_error(ret2);
   8334			if (reserved)
   8335				goto out;
   8336			goto out_noreserve;
   8337		}
   8338
   8339		ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
   8340	again:
   8341		lock_page(page);
   8342		size = i_size_read(inode);
   8343
   8344		if ((page->mapping != inode->i_mapping) ||
   8345		    (page_start >= size)) {
   8346			/* page got truncated out from underneath us */
   8347			goto out_unlock;
   8348		}
   8349		wait_on_page_writeback(page);
   8350
   8351		lock_extent_bits(io_tree, page_start, page_end, &cached_state);
Quoted 2 lines

8352 ret = set_page_extent_mapped(page);
8353 if (ret < 0)

   8354			goto out_unlock;
   8355
   8356		/*
   8357		 * we can't set the delalloc bits if there are pending ordered
   8358		 * extents.  Drop our locks and wait for them to finish
   8359		 */
   8360		ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
   8361				PAGE_SIZE);
   8362		if (ordered) {
   8363			unlock_extent_cached(io_tree, page_start, page_end,
   8364					     &cached_state);
   8365			unlock_page(page);
   8366			btrfs_start_ordered_extent(ordered, 1);
   8367			btrfs_put_ordered_extent(ordered);
   8368			goto again;
   8369		}
   8370
   8371		if (page->index == ((size - 1) >> PAGE_SHIFT)) {
   8372			reserved_space = round_up(size - page_start,
   8373						  fs_info->sectorsize);
   8374			if (reserved_space < PAGE_SIZE) {
   8375				end = page_start + reserved_space - 1;
   8376				btrfs_delalloc_release_space(BTRFS_I(inode),
   8377						data_reserved, page_start,
   8378						PAGE_SIZE - reserved_space, true);
   8379			}
   8380		}
   8381
   8382		/*
   8383		 * page_mkwrite gets called when the page is firstly dirtied after it's
   8384		 * faulted in, but write(2) could also dirty a page and set delalloc
   8385		 * bits, thus in this case for space account reason, we still need to
   8386		 * clear any delalloc bits within this page range since we have to
   8387		 * reserve data&meta space before lock_page() (see above comments).
   8388		 */
   8389		clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
   8390				  EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
   8391				  EXTENT_DEFRAG, 0, 0, &cached_state);
   8392
   8393		ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
   8394						&cached_state);
   8395		if (ret2) {
   8396			unlock_extent_cached(io_tree, page_start, page_end,
   8397					     &cached_state);
   8398			ret = VM_FAULT_SIGBUS;
   8399			goto out_unlock;
   8400		}
   8401
   8402		/* page is wholly or partially inside EOF */
   8403		if (page_start + PAGE_SIZE > size)
   8404			zero_start = offset_in_page(size);
   8405		else
   8406			zero_start = PAGE_SIZE;
   8407
   8408		if (zero_start != PAGE_SIZE) {
   8409			kaddr = kmap(page);
   8410			memset(kaddr + zero_start, 0, PAGE_SIZE - zero_start);
   8411			flush_dcache_page(page);
   8412			kunmap(page);
   8413		}
   8414		ClearPageChecked(page);
   8415		set_page_dirty(page);
   8416		SetPageUptodate(page);
   8417
   8418		BTRFS_I(inode)->last_trans = fs_info->generation;
   8419		BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
   8420		BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
   8421
   8422		unlock_extent_cached(io_tree, page_start, page_end, &cached_state);
   8423
   8424		btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
   8425		sb_end_pagefault(inode->i_sb);
   8426		extent_changeset_free(data_reserved);
   8427		return VM_FAULT_LOCKED;
   8428
   8429	out_unlock:
   8430		unlock_page(page);
   8431	out:
   8432		btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
   8433		btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
   8434					     reserved_space, (ret != 0));
   8435	out_noreserve:
   8436		sb_end_pagefault(inode->i_sb);
   8437		extent_changeset_free(data_reserved);
   8438		return ret;
   8439	}
   8440

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]

#28 lore raw

Re: [PATCH v3 20/22] btrfs: introduce btrfs_subpage for data inodes

Quoted 50 lines · Qu Wenruo
Quoted 37 lines · kernel test robot

Hi Qu,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on kdave/for-next]
[also build test WARNING on v5.11-rc2 next-20210104]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:
https://github.com/0day-ci/linux/commits/Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847
base: https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git
for-next
config: m68k-randconfig-s032-20210106 (attached as .config)
compiler: m68k-linux-gcc (GCC) 9.3.0
reproduce:
         wget
https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross
-O ~/bin/make.cross
         chmod +x ~/bin/make.cross

         # apt-get install sparse
         # sparse version: v0.6.3-208-g46a52ca4-dirty
         # 
https://github.com/0day-ci/linux/commit/2c54bbf363f66a7c4d489fa0b7967ce5fc960afb
         git remote add linux-review https://github.com/0day-ci/linux
         git fetch --no-tags linux-review 
Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847
         git checkout 2c54bbf363f66a7c4d489fa0b7967ce5fc960afb
         # save the attached .config to linux build tree
         COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 
make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=m68k

If you fix the issue, kindly add following tag as appropriate

Quoted 9 lines

"sparse warnings: (new ones prefixed by >>)"

Quoted 3 lines
Quoted 3 lines

fs/btrfs/inode.c:8352:13: sparse: sparse: incorrect type in assignment (different base types) @@     expected restricted vm_fault_t [assigned] [usertype] ret @@     got int @@

    fs/btrfs/inode.c:8352:13: sparse:     expected restricted vm_fault_t [assigned] [usertype] ret fs/btrfs/inode.c:8352:13: sparse:     got int

Quoted 2 lines
Quoted 2 lines

fs/btrfs/inode.c:8353:13: sparse: sparse: restricted vm_fault_t degrades to integer

Quoted 7 lines

Why I always forgot this...

Now it get properly fixed in github. Although the submitted patch is still using @ret other than @ret2.

Is there anyway to let LKP to run on specific branch so that I can avoid similar problems.

Hi Qu,

LKP can test private branches if you can provide the git tree url, please see
https://github.com/intel/lkp-tests/wiki/LKP-FAQ#how-to-request-testing-a-new-kernel-tree-on-lkp

Best Regards,
Rong Chen

Quoted 216 lines

Thanks,
Qu

Quoted 212 lines

    fs/btrfs/inode.c: note: in included file (through include/linux/mmzone.h, include/linux/gfp.h, include/linux/slab.h, ...):
    include/linux/spinlock.h:394:9: sparse: sparse: context imbalance in 'run_delayed_iput_locked' - unexpected unlock

vim +8352 fs/btrfs/inode.c

   8275
   8276    /*
   8277     * btrfs_page_mkwrite() is not allowed to change the file size as it gets
   8278     * called from a page fault handler when a page is first dirtied. Hence we must
   8279     * be careful to check for EOF conditions here. We set the page up correctly
   8280     * for a written page which means we get ENOSPC checking when writing into
   8281     * holes and correct delalloc and unwritten extent mapping on filesystems that
   8282     * support these features.
   8283     *
   8284     * We are not allowed to take the i_mutex here so we have to play games to
   8285     * protect against truncate races as the page could now be beyond EOF.  Because
   8286     * truncate_setsize() writes the inode size before removing pages, once we have
   8287     * the page lock we can determine safely if the page is beyond EOF. If it is not
   8288     * beyond EOF, then the page is guaranteed safe against truncation until we
   8289     * unlock the page.
   8290     */
   8291    vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf) 8292    {
   8293        struct page *page = vmf->page;
   8294        struct inode *inode = file_inode(vmf->vma->vm_file); 8295        struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 8296        struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
   8297        struct btrfs_ordered_extent *ordered;
   8298        struct extent_state *cached_state = NULL; 8299        struct extent_changeset *data_reserved = NULL; 8300        char *kaddr;
   8301        unsigned long zero_start;
   8302        loff_t size;
   8303        vm_fault_t ret;
   8304        int ret2;
   8305        int reserved = 0;
   8306        u64 reserved_space;
   8307        u64 page_start;
   8308        u64 page_end;
   8309        u64 end;
   8310
   8311        reserved_space = PAGE_SIZE;
   8312
   8313        sb_start_pagefault(inode->i_sb);
   8314        page_start = page_offset(page);
   8315        page_end = page_start + PAGE_SIZE - 1;
   8316        end = page_end;
   8317
   8318        /*
   8319         * Reserving delalloc space after obtaining the page lock can lead to
   8320         * deadlock. For example, if a dirty page is locked by this function
   8321         * and the call to btrfs_delalloc_reserve_space() ends up triggering
   8322         * dirty page write out, then the btrfs_writepage() function could
   8323         * end up waiting indefinitely to get a lock on the page currently
   8324         * being processed by btrfs_page_mkwrite() function. 8325         */
   8326        ret2 = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
   8327                            page_start, reserved_space); 8328        if (!ret2) {
   8329            ret2 = file_update_time(vmf->vma->vm_file); 8330            reserved = 1;
   8331        }
   8332        if (ret2) {
   8333            ret = vmf_error(ret2);
   8334            if (reserved)
   8335                goto out;
   8336            goto out_noreserve;
   8337        }
   8338
   8339        ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */ 8340    again:
   8341        lock_page(page);
   8342        size = i_size_read(inode);
   8343
   8344        if ((page->mapping != inode->i_mapping) || 8345            (page_start >= size)) {
   8346            /* page got truncated out from underneath us */ 8347            goto out_unlock;
   8348        }
   8349        wait_on_page_writeback(page);
   8350
   8351        lock_extent_bits(io_tree, page_start, page_end, &cached_state);

Quoted 2 lines

8352        ret = set_page_extent_mapped(page);
8353        if (ret < 0)

   8354            goto out_unlock;
   8355
   8356        /*
   8357         * we can't set the delalloc bits if there are pending ordered
   8358         * extents.  Drop our locks and wait for them to finish 8359         */
   8360        ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
   8361                PAGE_SIZE);
   8362        if (ordered) {
   8363            unlock_extent_cached(io_tree, page_start, page_end, 8364                         &cached_state);
   8365            unlock_page(page);
   8366            btrfs_start_ordered_extent(ordered, 1); 8367            btrfs_put_ordered_extent(ordered);
   8368            goto again;
   8369        }
   8370
   8371        if (page->index == ((size - 1) >> PAGE_SHIFT)) { 8372            reserved_space = round_up(size - page_start, 8373                          fs_info->sectorsize);
   8374            if (reserved_space < PAGE_SIZE) {
   8375                end = page_start + reserved_space - 1; 8376 btrfs_delalloc_release_space(BTRFS_I(inode),
   8377                        data_reserved, page_start, 8378                        PAGE_SIZE - reserved_space, true); 8379            }
   8380        }
   8381
   8382        /*
   8383         * page_mkwrite gets called when the page is firstly dirtied after it's
   8384         * faulted in, but write(2) could also dirty a page and set delalloc
   8385         * bits, thus in this case for space account reason, we still need to
   8386         * clear any delalloc bits within this page range since we have to
   8387         * reserve data&meta space before lock_page() (see above comments).
   8388         */
   8389        clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
   8390                  EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | 8391                  EXTENT_DEFRAG, 0, 0, &cached_state); 8392
   8393        ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
   8394                        &cached_state);
   8395        if (ret2) {
   8396            unlock_extent_cached(io_tree, page_start, page_end, 8397                         &cached_state);
   8398            ret = VM_FAULT_SIGBUS;
   8399            goto out_unlock;
   8400        }
   8401
   8402        /* page is wholly or partially inside EOF */ 8403        if (page_start + PAGE_SIZE > size)
   8404            zero_start = offset_in_page(size);
   8405        else
   8406            zero_start = PAGE_SIZE;
   8407
   8408        if (zero_start != PAGE_SIZE) {
   8409            kaddr = kmap(page);
   8410            memset(kaddr + zero_start, 0, PAGE_SIZE - zero_start);
   8411            flush_dcache_page(page);
   8412            kunmap(page);
   8413        }
   8414        ClearPageChecked(page);
   8415        set_page_dirty(page);
   8416        SetPageUptodate(page);
   8417
   8418        BTRFS_I(inode)->last_trans = fs_info->generation; 8419        BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
   8420        BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
   8421
   8422        unlock_extent_cached(io_tree, page_start, page_end, &cached_state);
   8423
   8424        btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
   8425        sb_end_pagefault(inode->i_sb);
   8426        extent_changeset_free(data_reserved);
   8427        return VM_FAULT_LOCKED;
   8428
   8429    out_unlock:
   8430        unlock_page(page);
   8431    out:
   8432        btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
   8433        btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
   8434                         reserved_space, (ret != 0)); 8435    out_noreserve:
   8436        sb_end_pagefault(inode->i_sb);
   8437        extent_changeset_free(data_reserved);
   8438        return ret;
   8439    }
   8440

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#29 lore raw

Re: [PATCH v3 20/22] btrfs: introduce btrfs_subpage for data inodes

In reply to Qu Wenruo
Thank you for the patch! Perhaps something to improve:

Hi Qu,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on kdave/for-next]
[also build test WARNING on v5.11-rc2 next-20210108]
[cannot apply to btrfs/next]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Qu-Wenruo/btrfs-add-read-only-support-for-subpage-sector-size/20210106-090847
base:   https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next
config: i386-randconfig-m021-20210108 (attached as .config)
compiler: gcc-9 (Debian 9.3.0-15) 9.3.0

If you fix the issue, kindly add following tag as appropriate

smatch warnings:
fs/btrfs/inode.c:8353 btrfs_page_mkwrite() warn: unsigned 'ret' is never less than zero.

vim +/ret +8353 fs/btrfs/inode.c

8275
8276 /*
8277 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
8278 * called from a page fault handler when a page is first dirtied. Hence we must
8279 * be careful to check for EOF conditions here. We set the page up correctly
8280 * for a written page which means we get ENOSPC checking when writing into
8281 * holes and correct delalloc and unwritten extent mapping on filesystems that
8282 * support these features.
8283 *
8284 * We are not allowed to take the i_mutex here so we have to play games to
8285 * protect against truncate races as the page could now be beyond EOF. Because
8286 * truncate_setsize() writes the inode size before removing pages, once we have
8287 * the page lock we can determine safely if the page is beyond EOF. If it is not
8288 * beyond EOF, then the page is guaranteed safe against truncation until we
8289 * unlock the page.
8290 */
8291 vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)
8292 {
8293 struct page *page = vmf->page;
8294 struct inode *inode = file_inode(vmf->vma->vm_file);
8295 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
8296 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
8297 struct btrfs_ordered_extent *ordered;
8298 struct extent_state *cached_state = NULL;
8299 struct extent_changeset *data_reserved = NULL;
8300 char *kaddr;
8301 unsigned long zero_start;
8302 loff_t size;
8303 vm_fault_t ret;
8304 int ret2;
8305 int reserved = 0;
8306 u64 reserved_space;
8307 u64 page_start;
8308 u64 page_end;
8309 u64 end;
8310
8311 reserved_space = PAGE_SIZE;
8312
8313 sb_start_pagefault(inode->i_sb);
8314 page_start = page_offset(page);
8315 page_end = page_start + PAGE_SIZE - 1;
8316 end = page_end;
8317
8318 /*
8319 * Reserving delalloc space after obtaining the page lock can lead to
8320 * deadlock. For example, if a dirty page is locked by this function
8321 * and the call to btrfs_delalloc_reserve_space() ends up triggering
8322 * dirty page write out, then the btrfs_writepage() function could
8323 * end up waiting indefinitely to get a lock on the page currently
8324 * being processed by btrfs_page_mkwrite() function.
8325 */
8326 ret2 = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
8327 page_start, reserved_space);
8328 if (!ret2) {
8329 ret2 = file_update_time(vmf->vma->vm_file);
8330 reserved = 1;
8331 }
8332 if (ret2) {
8333 ret = vmf_error(ret2);
8334 if (reserved)
8335 goto out;
8336 goto out_noreserve;
8337 }
8338
8339 ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
8340 again:
8341 lock_page(page);
8342 size = i_size_read(inode);
8343
8344 if ((page->mapping != inode->i_mapping) ||
8345 (page_start >= size)) {
8346 /* page got truncated out from underneath us */
8347 goto out_unlock;
8348 }
8349 wait_on_page_writeback(page);
8350
8351 lock_extent_bits(io_tree, page_start, page_end, &cached_state);
8352 ret = set_page_extent_mapped(page);

> 8353		if (ret < 0)

8354 goto out_unlock;
8355
8356 /*
8357 * we can't set the delalloc bits if there are pending ordered
8358 * extents. Drop our locks and wait for them to finish
8359 */
8360 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
8361 PAGE_SIZE);
8362 if (ordered) {
8363 unlock_extent_cached(io_tree, page_start, page_end,
8364 &cached_state);
8365 unlock_page(page);
8366 btrfs_start_ordered_extent(ordered, 1);
8367 btrfs_put_ordered_extent(ordered);
8368 goto again;
8369 }
8370
8371 if (page->index == ((size - 1) >> PAGE_SHIFT)) {
8372 reserved_space = round_up(size - page_start,
8373 fs_info->sectorsize);
8374 if (reserved_space < PAGE_SIZE) {
8375 end = page_start + reserved_space - 1;
8376 btrfs_delalloc_release_space(BTRFS_I(inode),
8377 data_reserved, page_start,
8378 PAGE_SIZE - reserved_space, true);
8379 }
8380 }
8381
8382 /*
8383 * page_mkwrite gets called when the page is firstly dirtied after it's
8384 * faulted in, but write(2) could also dirty a page and set delalloc
8385 * bits, thus in this case for space account reason, we still need to
8386 * clear any delalloc bits within this page range since we have to
8387 * reserve data&meta space before lock_page() (see above comments).
8388 */
8389 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,
8390 EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
8391 EXTENT_DEFRAG, 0, 0, &cached_state);
8392
8393 ret2 = btrfs_set_extent_delalloc(BTRFS_I(inode), page_start, end, 0,
8394 &cached_state);
8395 if (ret2) {
8396 unlock_extent_cached(io_tree, page_start, page_end,
8397 &cached_state);
8398 ret = VM_FAULT_SIGBUS;
8399 goto out_unlock;
8400 }
8401
8402 /* page is wholly or partially inside EOF */
8403 if (page_start + PAGE_SIZE > size)
8404 zero_start = offset_in_page(size);
8405 else
8406 zero_start = PAGE_SIZE;
8407
8408 if (zero_start != PAGE_SIZE) {
8409 kaddr = kmap(page);
8410 memset(kaddr + zero_start, 0, PAGE_SIZE - zero_start);
8411 flush_dcache_page(page);
8412 kunmap(page);
8413 }
8414 ClearPageChecked(page);
8415 set_page_dirty(page);
8416 SetPageUptodate(page);
8417
8418 BTRFS_I(inode)->last_trans = fs_info->generation;
8419 BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
8420 BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
8421
8422 unlock_extent_cached(io_tree, page_start, page_end, &cached_state);
8423
8424 btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
8425 sb_end_pagefault(inode->i_sb);
8426 extent_changeset_free(data_reserved);
8427 return VM_FAULT_LOCKED;
8428
8429 out_unlock:
8430 unlock_page(page);
8431 out:
8432 btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE);
8433 btrfs_delalloc_release_space(BTRFS_I(inode), data_reserved, page_start,
8434 reserved_space, (ret != 0));
8435 out_noreserve:
8436 sb_end_pagefault(inode->i_sb);
8437 extent_changeset_free(data_reserved);
8438 return ret;
8439 }
8440

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

author
#30 lore raw

PATCH v3 21/22 btrfs: integrate page status update for read path into begin/end_page_read()

In reply to Qu Wenruo

In btrfs data page read path, the page status update are handled in two different locations:

btrfs_do_read_page()

  {
	while (cur <= end) {
		/* No need to read from disk */
		if (HOLE/PREALLOC/INLINE){
			memset();
			set_extent_uptodate();
			continue;
		}
		/* Read from disk */
		ret = submit_extent_page(end_bio_extent_readpage);

}

end_bio_extent_readpage()

  {
	endio_readpage_uptodate_page_status();

}

This is fine for sectorsize == PAGE_SIZE case, as for above loop we should only hit one branch and then exit.

But for subpage, there are more works to be done in page status update:
- Page Unlock condition
Unlike regular page size == sectorsize case, we can no longer just unlock a page.
Only the last reader of the page can unlock the page.
This means, we can unlock the page either in the while() loop, or in the endio function.

- Page uptodate condition
Since we have multiple sectors to read for a page, we can only mark the full page uptodate if all sectors are uptodate.

To handle both subpage and regular cases, introduce a pair of functions to help handling page status update:

- being_page_read()
For regular case, it does nothing.
For subpage case, it update the reader counters so that later end_page_read() can know who is the last one to unlock the page.

- end_page_read()
This is just endio_readpage_uptodate_page_status() renamed. The original name is a little too long and too specific for endio.

The only new trick added is the condition for page unlock. Now for subage data, we unlock the page if we're the last reader.

This does not only provide the basis for subpage data read, but also hide the special handling of page read from the main read loop.

---
 fs/btrfs/extent_io.c | 38 +++++++++++++++++++----------
 fs/btrfs/subpage.h   | 57 +++++++++++++++++++++++++++++++++++---------
 2 files changed, 72 insertions(+), 23 deletions(-)
fs/btrfs/extent_io.c +26 -12
index 335a0aa3a6ec..dfbf319fc01d 100644
@@ -2839,8 +2839,17 @@ static void endio_readpage_release_extent(struct processed_extent *processed,
 	processed->uptodate = uptodate;
 }
 
-static void endio_readpage_update_page_status(struct page *page, bool uptodate,
-					      u64 start, u32 len)
+static void begin_data_page_read(struct btrfs_fs_info *fs_info, struct page *page)
+{
+	ASSERT(PageLocked(page));
+	if (fs_info->sectorsize == PAGE_SIZE)
+		return;
+
+	ASSERT(PagePrivate(page));
+	btrfs_subpage_start_reader(fs_info, page, page_offset(page), PAGE_SIZE);
+}
+
+static void end_page_read(struct page *page, bool uptodate, u64 start, u32 len)
 {
 	struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb);
 
@@ -2856,7 +2865,12 @@ static void endio_readpage_update_page_status(struct page *page, bool uptodate,
 
 	if (fs_info->sectorsize == PAGE_SIZE)
 		unlock_page(page);
-	/* Subpage locking will be handled in later patches */
+	else if (is_data_inode(page->mapping->host))
+		/*
+		 * For subpage data, unlock the page if we're the last reader.
+		 * For subpage metadata, page lock is not utilized for read.
+		 */
+		btrfs_subpage_end_reader(fs_info, page, start, len);
 }
 
 /*
@@ -2993,7 +3007,7 @@ static void end_bio_extent_readpage(struct bio *bio)
 		bio_offset += len;
 
 		/* Update page status and unlock */
-		endio_readpage_update_page_status(page, uptodate, start, len);
+		end_page_read(page, uptodate, start, len);
 		endio_readpage_release_extent(&processed, BTRFS_I(inode),
 					      start, end, uptodate);
 	}
@@ -3260,6 +3274,7 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 		      unsigned int read_flags, u64 *prev_em_start)
 {
 	struct inode *inode = page->mapping->host;
+	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 	u64 start = page_offset(page);
 	const u64 end = start + PAGE_SIZE - 1;
 	u64 cur = start;
@@ -3303,6 +3318,7 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 			kunmap_atomic(userpage);
 		}
 	}
+	begin_data_page_read(fs_info, page);
 	while (cur <= end) {
 		bool force_bio_submit = false;
 		u64 disk_bytenr;
@@ -3320,13 +3336,14 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 					    &cached, GFP_NOFS);
 			unlock_extent_cached(tree, cur,
 					     cur + iosize - 1, &cached);
+			end_page_read(page, true, cur, iosize);
 			break;
 		}
 		em = __get_extent_map(inode, page, pg_offset, cur,
 				      end - cur + 1, em_cached);
 		if (IS_ERR_OR_NULL(em)) {
-			SetPageError(page);
 			unlock_extent(tree, cur, end);
+			end_page_read(page, false, cur, end + 1 - cur);
 			break;
 		}
 		extent_offset = cur - em->start;
@@ -3409,6 +3426,7 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 					    &cached, GFP_NOFS);
 			unlock_extent_cached(tree, cur,
 					     cur + iosize - 1, &cached);
+			end_page_read(page, true, cur, iosize);
 			cur = cur + iosize;
 			pg_offset += iosize;
 			continue;
@@ -3418,6 +3436,7 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 				   EXTENT_UPTODATE, 1, NULL)) {
 			check_page_uptodate(tree, page);
 			unlock_extent(tree, cur, cur + iosize - 1);
+			end_page_read(page, true, cur, iosize);
 			cur = cur + iosize;
 			pg_offset += iosize;
 			continue;
@@ -3426,8 +3445,8 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 		 * to date.  Error out
 		 */
 		if (block_start == EXTENT_MAP_INLINE) {
-			SetPageError(page);
 			unlock_extent(tree, cur, cur + iosize - 1);
+			end_page_read(page, false, cur, iosize);
 			cur = cur + iosize;
 			pg_offset += iosize;
 			continue;
@@ -3444,19 +3463,14 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
 			nr++;
 			*bio_flags = this_bio_flag;
 		} else {
-			SetPageError(page);
 			unlock_extent(tree, cur, cur + iosize - 1);
+			end_page_read(page, false, cur, iosize);
 			goto out;
 		}
 		cur = cur + iosize;
 		pg_offset += iosize;
 	}
 out:
-	if (!nr) {
-		if (!PageError(page))
-			SetPageUptodate(page);
-		unlock_page(page);
-	}
 	return ret;
 }
 
fs/btrfs/subpage.h +46 -11

86 lines not on this page · raw message

Signature · 1 line
2.29.2
author
#31 lore raw

PATCH v3 22/22 btrfs: allow RO mount of 4K sector size fs on 64K page system

In reply to Qu Wenruo

This adds the basic RO mount ability for 4K sector size on 64K page system.

Currently we only plan to support 4K and 64K page system.

---
 fs/btrfs/disk-io.c | 24 +++++++++++++++++++++---
 fs/btrfs/super.c   |  7 +++++++
 2 files changed, 28 insertions(+), 3 deletions(-)
fs/btrfs/disk-io.c +21 -3
index 73733250d12c..553835688560 100644
@@ -2484,13 +2484,21 @@ static int validate_super(struct btrfs_fs_info *fs_info,
 		btrfs_err(fs_info, "invalid sectorsize %llu", sectorsize);
 		ret = -EINVAL;
 	}
-	/* Only PAGE SIZE is supported yet */
-	if (sectorsize != PAGE_SIZE) {
+
+	/*
+	 * For 4K page size, we only support 4K sector size.
+	 * For 64K page size, we support RW for 64K sector size, and RO for
+	 * 4K sector size.
+	 */
+	if ((SZ_4K == PAGE_SIZE && sectorsize != PAGE_SIZE) ||
+	    (SZ_64K == PAGE_SIZE && (sectorsize != SZ_4K &&
+				     sectorsize != SZ_64K))) {
 		btrfs_err(fs_info,
-			"sectorsize %llu not supported yet, only support %lu",
+			"sectorsize %llu not supported yet for page size %lu",
 			sectorsize, PAGE_SIZE);
 		ret = -EINVAL;
 	}
+
 	if (!is_power_of_2(nodesize) || nodesize < sectorsize ||
 	    nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
 		btrfs_err(fs_info, "invalid nodesize %llu", nodesize);
@@ -3249,6 +3257,16 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device
 		goto fail_alloc;
 	}
 
+	/* For 4K sector size support, it's only read-only yet */
+	if (PAGE_SIZE == SZ_64K && sectorsize == SZ_4K) {
+		if (!sb_rdonly(sb) || btrfs_super_log_root(disk_super)) {
+			btrfs_err(fs_info,
+				"subpage sector size only support RO yet");
+			err = -EINVAL;
+			goto fail_alloc;
+		}
+	}
+
 	ret = btrfs_init_workqueues(fs_info, fs_devices);
 	if (ret) {
 		err = ret;
fs/btrfs/super.c +7 -0
index 12d7d3be7cd4..5bbc23597a93 100644
@@ -2028,6 +2028,13 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
 			ret = -EINVAL;
 			goto restore;
 		}
+		if (fs_info->sectorsize < PAGE_SIZE) {
+			btrfs_warn(fs_info,
+	"read-write mount is not yet allowed for sector size %u page size %lu",
+				   fs_info->sectorsize, PAGE_SIZE);
+			ret = -EINVAL;
+			goto restore;
+		}
 
 		/*
 		 * NOTE: when remounting with a change that does writes, don't
Signature · 1 line
2.29.2
#32 lore raw
In reply to Qu Wenruo
Quoted 9 lines · Qu Wenruo

Patches can be fetched from github:
https://github.com/adam900710/linux/tree/subpage
Currently the branch also contains partial RW data support (still some out-of-sync subpage data page status).

Great thanks to David for his effort reviewing and merging the preparation patches into misc-next.
Now all previously submitted preparation patches are already in misc-next.

I merged 1, 2, 3, 6 to misc-next as they're obvious and independent. The rest is up for review, I haven't looked closely on the open questions.

Quoted 3 lines

Qu Wenruo (22):
btrfs: extent_io: rename @offset parameter to @disk_bytenr for
submit_extent_page()

Please drop "extent_io:" from any future patch subjects, they get too long already and we haven't been using this prefix consistently anyway.

#33 lore raw
Quoted 6 lines · David Sterba
Quoted 5 lines · Qu Wenruo

Patches can be fetched from github:
https://github.com/adam900710/linux/tree/subpage
Currently the branch also contains partial RW data support (still some out-of-sync subpage data page status).

Quoted 8 lines
Quoted 4 lines

Great thanks to David for his effort reviewing and merging the preparation patches into misc-next.
Now all previously submitted preparation patches are already in misc-next.

I merged 1, 2, 3, 6 to misc-next as they're obvious and independent. The rest is up for review, I haven't looked closely on the open questions.

I just fetched misc-next from github/kernel, and none of the branches have the patches.

Maybe I should be more patient?

Quoted 8 lines
Quoted 4 lines

Qu Wenruo (22):
btrfs: extent_io: rename @offset parameter to @disk_bytenr for
submit_extent_page()

Please drop "extent_io:" from any future patch subjects, they get too long already and we haven't been using this prefix consistently anyway.

Got it.

Thanks,
Qu