btrfs buffered iomap support
Subsystems (5)
cover btrfs buffered iomap support
From: Goldwyn Rodrigues <[email protected]>
This is an attempt to perform the bufered read and write using iomap on btrfs.
I propose these changes as an RFC because I would like to know on your comments on the feasibility of going ahead with the design. It is not feature complete with the most important support missing is multi-device and compression.
Sending to BTRFS mailing only for perspective from btrfs developers first.
Locking sequence change
One of the biggest architecture changes is locking extents before pages. writepage(), called during memory pressure provides the page which is locked already. Perform a best effort locking and work with what is feasible. For truncate->invalidatepage(), lock the pages before calling setsize(). Are there any other areas which need to be covered?
TODO
====
Bio submission for multi-device
Multi-device submission would require some work with respect to asynchronous completions. iomap can merge bio's making it larger than extent_map's map_length. There is a check in btrfs_map_bio which WARN()s on this. Perhaps a more modular approach of having callbacks would be easier to deal with.
Compression
This would require extra flags to iomap, say type IOMAP_ENCODED, which would require iomap to read/write complete extents as opposed to performing I/O on only what is requested. An additional field io_size would be required to know how much of compressed size maps to uncompressed size.
Known issues
============
BIO Submission: described above
Random WARN_ON in kernel/locking/lockdep.c:895 points to memory corruption.
Finally, I have added some questions in the patch headers as well.
Signature · 52 lines
Goldwyn
Goldwyn Rodrigues (31):
iomap: Check if blocksize == PAGE_SIZE in to_iomap_page()
iomap: Add submit_io to writepage_ops
iomap: Export iomap_writepage_end_bio()
iomap: Introduce iomap_readpage_ops
btrfs: writepage() lock extent before pages
btrfs: lock extents while truncating
btrfs: write() perform extent locks before locking page
btrfs: btrfs_em_to_iomap () to convert em to iomap
btrfs: Don't process pages if locked_page is NULL
btrfs: Add btrfs_map_blocks to for iomap_writeback_ops
btrfs: Use submit_io to submit btrfs writeback bios
btrfs: endio sequence for writepage
btrfs: do not checksum for free space inode
btrfs: end EXTENT_MAP_INLINE writeback early
btrfs: Switch to iomap_writepages()
btrfs: remove force_page_uptodate
btrfs: Introduce btrfs_iomap
btrfs: Add btrfs_iomap_release()
btrfs: Add reservation information to btrfs_iomap
btrfs: Carve out btrfs_buffered_iomap_begin() from write path
btrfs: Carve out btrfs_buffered_iomap_end from the write path
btrfs: Set extents delalloc in iomap_end
btrfs: define iomap_page_ops
btrfs: Switch to iomap_file_buffered_write()
btrfs: remove all page related functions
btrfs: use srcmap for read-before-write cases
btrfs: Rename end_bio_extent_readpage to btrfs_readpage_endio
btrfs: iomap_begin() for buffered read
btrfs: Use iomap_readpage_ops to allocate and submit bio
btrfs: Do not call btrfs_io_bio_free_csum() if BTRFS_INODE_NODATASUM
is not set
btrfs: Switch to iomap_readpage() and iomap_readahead()
fs/btrfs/ctree.h | 3 +
fs/btrfs/disk-io.c | 9 +-
fs/btrfs/extent_io.c | 103 +++++--
fs/btrfs/extent_io.h | 4 +
fs/btrfs/file.c | 642 ++++++++++++++---------------------------
fs/btrfs/inode.c | 219 ++++++++++++--
fs/gfs2/aops.c | 4 +-
fs/iomap/buffered-io.c | 80 +++--
fs/xfs/xfs_aops.c | 4 +-
fs/zonefs/super.c | 4 +-
include/linux/iomap.h | 26 +-
11 files changed, 601 insertions(+), 497 deletions(-)
--
2.31.1RFC PATCH 1/31 iomap: Check if blocksize == PAGE_SIZE in to_iomap_page()
From: Goldwyn Rodrigues <[email protected]>
btrfs requires page->private set to get a callback to releasepage(). So, for normal circumstances of blocksize==PAGE_SIZE, btrfs will have page->private set to 1. In order to avoid a crash, check for the blocksize==PAGE_SIZE in to_iomap_page().
--- fs/iomap/buffered-io.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
fs/iomap/buffered-io.c +6 -4
@@ -41,9 +41,11 @@ static inline struct iomap_page *to_iomap_page(struct page *page)*/ VM_BUG_ON_PGFLAGS (PageTail (page), page); -if (page_has_private (page)) -return (struct iomap_page *)page_private (page); -return NULL ; +if (i_blocksize (page->mapping->host) ==PAGE_SIZE ) +return NULL ; +if (!page_has_private (page)) +return NULL ; +return (struct iomap_page *)page_private (page); }static struct bio_set iomap_ioend_bioset;
@@ -163,7 +165,7 @@ iomap_set_range_uptodate(struct page *page, unsigned off, unsigned len)if (PageError (page))return ; -if (page_has_private (page)) +if (i_blocksize (page->mapping->host) !=PAGE_SIZE )iomap_iop_set_range_uptodate (page, off, len);else SetPageUptodate (page);
Signature · 1 line
2.31.1
Re: [RFC PATCH 01/31] iomap: Check if blocksize == PAGE_SIZE in to_iomap_page()
Quoted 3 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
btrfs requires
page->privateset to get a callback toreleasepage().
nit: This is somewhat terse of an explanation and someone not familiar with btrfs might wonder what's going on. In fact, btrfs uses the PagePrivate flag to indicate that the page has undergone CoW and has ordered extents created. And this is in fact problematic because iomap assume page_private is not in use by the underlying fs.
So,
Quoted 36 lines
for normal circumstances of blocksize==PAGE_SIZE, btrfs will have
page->privateset to 1. In order to avoid a crash, check for the blocksize==PAGE_SIZE into_iomap_page().--- fs/iomap/buffered-io.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)fs/iomap/buffered-io.c +6
-4@@ -41,9 +41,11 @@ static inline struct iomap_page *to_iomap_page(struct page *page)*/ VM_BUG_ON_PGFLAGS (PageTail (page), page); -if (page_has_private (page)) -return (struct iomap_page *)page_private (page); -return NULL ; +if (i_blocksize (page->mapping->host) ==PAGE_SIZE ) +return NULL ; +if (!page_has_private (page)) +return NULL ; +return (struct iomap_page *)page_private (page); }static struct bio_set iomap_ioend_bioset;@@ -163,7 +165,7 @@ iomap_set_range_uptodate(struct page *page, unsigned off, unsigned len)if (PageError (page))return ; -if (page_has_private (page)) +if (i_blocksize (page->mapping->host) !=PAGE_SIZE )iomap_iop_set_range_uptodate (page, off, len);else SetPageUptodate (page);
RFC PATCH 2/31 iomap: Add submit_io to writepage_ops
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Filesystems such as btrfs need to perform pre and post bio operations such as csum calculations, device mapping etc.
Add a submit_io() function to writepage_ops so filesystems can control how the bio is submitted.
--- fs/iomap/buffered-io.c | 11 ++++++++++- include/linux/iomap.h | 6 ++++++ 2 files changed, 16 insertions(+), 1 deletion(-)
fs/iomap/buffered-io.c +10 -1
@@ -1209,7 +1209,11 @@ iomap_submit_ioend(struct iomap_writepage_ctx *wpc, struct iomap_ioend *ioend,return error; } -submit_bio (ioend->io_bio); +if (wpc->ops->submit_io) + wpc->ops->submit_io (ioend->io_inode, ioend->io_bio); +else +submit_bio (ioend->io_bio); +return 0 ; }
@@ -1305,8 +1309,13 @@ iomap_add_to_ioend(struct inode *inode, loff_t offset, struct page *page,if (!merged) {if (bio_full (wpc->ioend->io_bio, len)) { +struct bio *bio = wpc->ioend->io_bio; wpc->ioend->io_bio =iomap_chain_bio (wpc->ioend->io_bio); +if (wpc->ops->submit_io) + wpc->ops->submit_io (inode, bio); +else +submit_bio (bio); }bio_add_page (wpc->ioend->io_bio, page, len, poff); }
include/linux/iomap.h +6 -0
@@ -223,6 +223,12 @@ struct iomap_writeback_ops {* we failed to submit any I/O. */ void (*discard_page)(struct page *page,loff_t fileoff); + +/* +* Optional, allows the filesystem to perform a custom submission of +* bio, such as csum calculations or multi-device bio split +*/ +void (*submit_io)(struct inode *inode,struct bio *bio); };struct iomap_writepage_ctx {
Signature · 1 line
2.31.1
Re: [RFC PATCH 02/31] iomap: Add submit_io to writepage_ops
Quoted 32 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
Filesystems such as btrfs need to perform pre and post bio operations such as csum calculations, device mapping etc.
Add a
submit_io()function towritepage_opsso filesystems can control how the bio is submitted.Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/iomap/buffered-io.c | 11 ++++++++++- include/linux/iomap.h | 6 ++++++ 2 files changed, 16 insertions(+), 1 deletion(-)fs/iomap/buffered-io.c +5
-1@@ -1209,7 +1209,11 @@ iomap_submit_ioend(struct iomap_writepage_ctx *wpc, struct iomap_ioend *ioend,return error; } -submit_bio (ioend->io_bio); +if (wpc->ops->submit_io) + wpc->ops->submit_io (ioend->io_inode, ioend->io_bio); +else +submit_bio (ioend->io_bio); +return 0 ; }
fs/iomap/buffered-io.c iomap_add_to_ioend(struct inode *inode, loff_t offset, struct page *page, · line 1318
Quoted 10 lines
fs/iomap/buffered-io.c +5
-0@@ -1305,8 +1309,13 @@ iomap_add_to_ioend(struct inode *inode, loff_t offset, struct page *page,if (!merged) {if (bio_full (wpc->ioend->io_bio, len)) { +struct bio *bio = wpc->ioend->io_bio; wpc->ioend->io_bio =iomap_chain_bio (wpc->ioend->io_bio); +if (wpc->ops->submit_io) + wpc->ops->submit_io (inode, bio); +else +submit_bio (bio);
Why do you submit the bio here? It seems iomap_add_to_ioend is used to build a chain of ioend/bio structures which are then submitted by the loop in iomap_writepage_map. At the very least this change should go into a separate patch whose commit message should explain why do you introduce this new submission point.
Quoted 8 lines
fs/iomap/buffered-io.c +0
-0}bio_add_page (wpc->ioend->io_bio, page, len, poff); }include/linux/iomap.h +0
-0
include/linux/iomap.h struct iomap_writeback_ops { · line 231
Quoted 9 lines
include/linux/iomap.h +6
-0@@ -223,6 +223,12 @@ struct iomap_writeback_ops {* we failed to submit any I/O. */ void (*discard_page)(struct page *page,loff_t fileoff); + +/* +* Optional, allows the filesystem to perform a custom submission of +* bio, such as csum calculations or multi-device bio split +*/ +void (*submit_io)(struct inode *inode,struct bio *bio);
nit: I'm wondering if we have the ->submit_bio callback doesn't it really subsume prepare_ioend.
Quoted 4 lines
include/linux/iomap.h +0
-0};struct iomap_writepage_ctx {
RFC PATCH 3/31 iomap: Export iomap_writepage_end_bio()
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
BTRFS marks ordered extents as uptodate clearing bits such as delalloc after the bio is deemed complete. After marking the extents, btrfs needs to call iomap_writepage_end_bio() to perform housekeeping on the pages:
end of writeback.
--- fs/iomap/buffered-io.c | 3 ++- include/linux/iomap.h | 1 + 2 files changed, 3 insertions(+), 1 deletion(-)
fs/iomap/buffered-io.c +2 -1
@@ -1173,12 +1173,13 @@ iomap_sort_ioends(struct list_head *ioend_list) }EXPORT_SYMBOL_GPL (iomap_sort_ioends); -static void iomap_writepage_end_bio (struct bio *bio) +void iomap_writepage_end_bio (struct bio *bio) {struct iomap_ioend *ioend = bio->bi_private;iomap_finish_ioend (ioend,blk_status_to_errno (bio->bi_status)); } +EXPORT_SYMBOL_GPL (iomap_writepage_end_bio);/* * Submit the final bio for an ioend.
include/linux/iomap.h +1 -0
@@ -238,6 +238,7 @@ struct iomap_writepage_ctx { };void iomap_finish_ioends (struct iomap_ioend *ioend,int error); +void iomap_writepage_end_bio (struct bio *bio);void iomap_ioend_try_merge (struct iomap_ioend *ioend,struct list_head *more_ioends);void iomap_sort_ioends (struct list_head *ioend_list);
Signature · 1 line
2.31.1
RFC PATCH 4/31 iomap: Introduce iomap_readpage_ops
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
iomap_readpage_ops provide additional functions to allocate or submit the bio.
alloc_bio() is used to allocate bio from the filesystem, in case of
btrfs: to allocate btrfs_io_bio.
submit_io() similar to the one introduced with direct I/O, submits the bio.
--- fs/gfs2/aops.c | 4 +-- fs/iomap/buffered-io.c | 56 +++++++++++++++++++++++++++++++----------- fs/xfs/xfs_aops.c | 4 +-- fs/zonefs/super.c | 4 +-- include/linux/iomap.h | 19 ++++++++++++-- 5 files changed, 64 insertions(+), 23 deletions(-)
fs/gfs2/aops.c +2 -2
@@ -474,7 +474,7 @@ static int __gfs2_readpage(void *file, struct page *page)if (!gfs2_is_jdata (ip) || (i_blocksize (inode) ==PAGE_SIZE && !page_has_buffers (page))) { - error =iomap_readpage (page, &gfs2_iomap_ops); + error =iomap_readpage (page, &gfs2_iomap_ops,NULL ); }else if (gfs2_is_stuffed (ip)) { error =stuffed_readpage (ip, page);unlock_page (page);
@@ -563,7 +563,7 @@ static void gfs2_readahead(struct readahead_control *rac)else if (gfs2_is_jdata (ip))mpage_readahead (rac, gfs2_block_map);else -iomap_readahead (rac, &gfs2_iomap_ops); +iomap_readahead (rac, &gfs2_iomap_ops,NULL ); }/**
fs/iomap/buffered-io.c +41 -15
107 lines not on this page · raw message
fs/xfs/xfs_aops.c +2 -2
@@ -535,14 +535,14 @@ xfs_vm_readpage(struct file *unused, struct page *page) { - return iomap_readpage(page, &xfs_read_iomap_ops); + return iomap_readpage(page, &xfs_read_iomap_ops, NULL); } STATIC voidxfs_vm_readahead (struct readahead_control *rac) { -iomap_readahead (rac, &xfs_read_iomap_ops); +iomap_readahead (rac, &xfs_read_iomap_ops,NULL ); } static int
fs/zonefs/super.c +2 -2
@@ -115,12 +115,12 @@ static const struct iomap_ops zonefs_iomap_ops = {static int zonefs_readpage (struct file *unused,struct page *page) { -return iomap_readpage (page, &zonefs_iomap_ops); +return iomap_readpage (page, &zonefs_iomap_ops,NULL ); }static void zonefs_readahead (struct readahead_control *rac) { -iomap_readahead (rac, &zonefs_iomap_ops); +iomap_readahead (rac, &zonefs_iomap_ops,NULL ); }/*
include/linux/iomap.h +17 -2
@@ -157,8 +157,6 @@ loff_t iomap_apply(struct inode *inode, loff_t pos, loff_t length,ssize_t iomap_file_buffered_write (struct kiocb *iocb,struct iov_iter *from,const struct iomap_ops *ops); -int iomap_readpage (struct page *page,const struct iomap_ops *ops); -void iomap_readahead (struct readahead_control *,const struct iomap_ops *ops);int iomap_set_page_dirty (struct page *page);int iomap_is_partially_uptodate (struct page *page,unsigned long from,unsigned long count);
@@ -188,6 +186,23 @@ loff_t iomap_seek_data(struct inode *inode, loff_t offset,sector_t iomap_bmap (struct address_space *mapping,sector_t bno,const struct iomap_ops *ops); +struct iomap_readpage_ops { + +/* allow the filesystem to allocate custom struct bio */ +struct bio *(*alloc_bio)(gfp_t gfp_mask,unsigned short nr_iovecs); + +/* +* Optional, allows the filesystem to perform a custom submission of +* bio, such as csum calculations or multi-device bio split +*/ +void (*submit_io)(struct inode *inode,struct bio *bio); +}; + +int iomap_readpage (struct page *page,const struct iomap_ops *ops, +const struct iomap_readpage_ops *readpage_ops); +void iomap_readahead (struct readahead_control *rac,const struct iomap_ops *ops, +const struct iomap_readpage_ops *readpage_ops); +/* * Structure for writeback I/O completions. */
Signature · 1 line
2.31.1
Re: [RFC PATCH 04/31] iomap: Introduce iomap_readpage_ops
Quoted 20 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
iomap_readpage_opsprovide additional functions to allocate or submit the bio.
alloc_bio()is used to allocate bio from the filesystem, in case of
btrfs: to allocatebtrfs_io_bio.
submit_io()similar to the one introduced with direct I/O, submits the bio.Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/gfs2/aops.c | 4 +-- fs/iomap/buffered-io.c | 56 +++++++++++++++++++++++++++++++----------- fs/xfs/xfs_aops.c | 4 +-- fs/zonefs/super.c | 4 +-- include/linux/iomap.h | 19 ++++++++++++-- 5 files changed, 64 insertions(+), 23 deletions(-)
<snip>
fs/iomap/buffered-io.c iomap_readpage_actor(struct inode *inode, loff_t pos, loff_t length, void *data, · line 287
Quoted 8 lines
fs/iomap/buffered-io.c +2
-2@@ -282,19 +283,31 @@ iomap_readpage_actor(struct inode *inode, loff_t pos, loff_t length, void *data,gfp_t orig_gfp = gfp;unsigned int nr_vecs =DIV_ROUND_UP (length,PAGE_SIZE ); -if (ctx->bio) -submit_bio (ctx->bio); +if (ctx->bio) { +if (ctx->ops && ctx->ops->submit_io)
here you check for the presence of ctx->ops && ctx->ops->some_op
fs/iomap/buffered-io.c iomap_readpage_actor(struct inode *inode, loff_t pos, loff_t length, void *data, · line 295
Quoted 9 lines
fs/iomap/buffered-io.c +5
-1+ ctx->ops->submit_io (inode, ctx->bio); + else + submit_bio(ctx->bio); + }if (ctx->rac)/* same as readahead_gfp_mask */ gfp |= __GFP_NORETRY | __GFP_NOWARN; - ctx->bio =bio_alloc (gfp,bio_max_segs (nr_vecs)); +if (ctx->ops->alloc_bio)
but here you directly check for the presence of ctx->ops->some_op. The correct should be to also check for ctx->ops since other filesystems don't necessarily implement specific readops.
fs/iomap/buffered-io.c iomap_readpage_actor(struct inode *inode, loff_t pos, loff_t length, void *data, · line 306
Quoted 13 lines
fs/iomap/buffered-io.c +6
-2+ ctx->bio = ctx->ops->alloc_bio (gfp, +bio_max_segs (nr_vecs)); + else + ctx->bio = bio_alloc(gfp, bio_max_segs(nr_vecs));/* * If the bio_alloc fails, try it again for a single page to * avoid having to deal with partial page reads. This emulates * what do_mpage_readpage does. */ -if (!ctx->bio) - ctx->bio =bio_alloc (orig_gfp,1 ); +if (!ctx->bio) { +if (ctx->ops->alloc_bio)
ditto about checking for presence of ops.
Quoted 7 lines
fs/iomap/buffered-io.c +4
-0+ ctx->bio = ctx->ops->alloc_bio (orig_gfp,1 ); + else + ctx->bio = bio_alloc(orig_gfp, 1); + } ctx->bio->bi_opf =REQ_OP_READ ;if (ctx->rac) ctx->bio->bi_opf |=REQ_RAHEAD ;
<snip>
fs/iomap/buffered-io.c iomap_readpage(struct page *page, const struct iomap_ops *ops) · line 356
Quoted 6 lines
fs/iomap/buffered-io.c +1
-1@@ -336,7 +353,10 @@ iomap_readpage(struct page *page, const struct iomap_ops *ops) }if (ctx.bio) { -submit_bio (ctx.bio); +if (ctx.ops->submit_io)
readpage_ops can be NULL so you should check for it as well.
Quoted 6 lines
fs/iomap/buffered-io.c +3
-0+ ctx.ops->submit_io (inode, ctx.bio); + else + submit_bio(ctx.bio);WARN_ON_ONCE (!ctx.cur_page_in_bio); }else {WARN_ON_ONCE (ctx.cur_page_in_bio);
<snip>
RFC PATCH 5/31 btrfs: writepage() lock extent before pages
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Lock Order change: Extent locks before page locks
writepage() is called with the page locked. So make an attempt to lock the extents and proceed only if successful.
The new function best_effort_lock_extent() attempts to lock the range provided.
If the entire range was not locked, but it still covers the locked page, work with the reduced range by resetting delalloc_end()
--- fs/btrfs/extent_io.c | 66 ++++++++++++++++++++++++++++++++++---------- 1 file changed, 51 insertions(+), 15 deletions(-)
fs/btrfs/extent_io.c +51 -15
@@ -1488,6 +1488,47 @@ int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end)return 1 ; } +/* +* best_effort_lock_extent() - locks the extent to the best of effort +* making sure the minimum range is locked and the +* delalloc bits are set. If the full requested range is not locked, +* delalloc_end shifts to until the range that can be locked. +*/ +static bool best_effort_lock_extent (struct extent_io_tree *tree,u64 start, +u64 *delalloc_end,u64 min_end,struct extent_state **cached_state) +{ +u64 failed_start; +u64 end = *delalloc_end; +int ret; + + ret =set_extent_bit (tree, start, end,EXTENT_LOCKED ,EXTENT_LOCKED , + &failed_start, cached_state,GFP_NOFS ,NULL ); + +if (!ret) +return false; + +if (failed_start < min_end) { +/* Could not lock the whole range */ +if (failed_start > start) +unlock_extent_cached (tree, start, + failed_start -1 , cached_state); +return false; + }else if (end > failed_start) { +/* Work with what could be locked */ + end = failed_start -1 ; + } + +/* Check if delalloc bits are set */ + ret =test_range_bit (tree, start, end, +EXTENT_DELALLOC ,1 , *cached_state); +if (!ret) { +unlock_extent_cached (tree, start, end -1 , cached_state); +return false; + } + *delalloc_end = end; +return true; +} +void extent_range_clear_dirty_for_io (struct inode *inode,u64 start,u64 end) {unsigned long index = start >>PAGE_SHIFT ;
@@ -2018,7 +2059,16 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode,if (delalloc_end +1 - delalloc_start > max_bytes) delalloc_end = delalloc_start + max_bytes -1 ; -/* step two, lock all the pages after the page that has start */ +/* step two, lock the state bits for the range */ + found =best_effort_lock_extent (tree, delalloc_start, &delalloc_end, + ((page_index (locked_page) +1 ) <<PAGE_SHIFT ), + &cached_state); +if (!found) { +free_extent_state (cached_state); + goto out_failed; + } + +/* step three, lock all the pages after the page that has start */ ret =lock_delalloc_pages (inode, locked_page, delalloc_start, delalloc_end);ASSERT (!ret || ret == -EAGAIN );
@@ -2038,20 +2088,6 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode, } } -/* step three, lock the state bits for the whole range */ -lock_extent_bits (tree, delalloc_start, delalloc_end, &cached_state); - -/* then test to make sure it is all still delalloc */ - ret =test_range_bit (tree, delalloc_start, delalloc_end, -EXTENT_DELALLOC ,1 , cached_state); -if (!ret) { -unlock_extent_cached (tree, delalloc_start, delalloc_end, - &cached_state); -__unlock_for_delalloc (inode, locked_page, - delalloc_start, delalloc_end); -cond_resched (); - goto again; - }free_extent_state (cached_state); *start = delalloc_start; *end = delalloc_end;
Signature · 1 line
2.31.1
Re: [RFC PATCH 05/31] btrfs: writepage() lock extent before pages
Quoted 34 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
Lock Order change: Extent locks before page locks
writepage()is called with the page locked. So make an attempt to lock the extents and proceed only if successful.The new function
best_effort_lock_extent()attempts to lock the range provided.If the entire range was not locked, but it still covers the locked page, work with the reduced range by resetting
delalloc_end()Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/extent_io.c | 66 ++++++++++++++++++++++++++++++++++---------- 1 file changed, 51 insertions(+), 15 deletions(-)fs/btrfs/extent_io.c +8
-0@@ -1488,6 +1488,47 @@ int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end)return 1 ; } +/* +* best_effort_lock_extent() - locks the extent to the best of effort +* making sure the minimum range is locked and the +* delalloc bits are set. If the full requested range is not locked, +* delalloc_end shifts to until the range that can be locked. +*/ +static bool best_effort_lock_extent (struct extent_io_tree *tree,u64 start, +u64 *delalloc_end,u64 min_end,struct extent_state **cached_state)
fs/btrfs/extent_io.c int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) · line 1508
Quoted 10 lines
fs/btrfs/extent_io.c +10
-0+{ +u64 failed_start; +u64 end = *delalloc_end; +int ret; + + ret =set_extent_bit (tree, start, end,EXTENT_LOCKED ,EXTENT_LOCKED , + &failed_start, cached_state,GFP_NOFS ,NULL ); + +if (!ret) +return false;
The locking sequence here seems broken. Based on the behavior of lock_extent_bits :
1. ret = 0 means the range was successfully locked instead you return false.
2. ret can be a number of errors, including EEXIST, the original code basically waits for the extents to be unlocked and retries.
fs/btrfs/extent_io.c int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) · line 1518
Quoted 10 lines
fs/btrfs/extent_io.c +10
-0+ +if (failed_start < min_end) { +/* Could not lock the whole range */ +if (failed_start > start) +unlock_extent_cached (tree, start, + failed_start -1 , cached_state); +return false; + }else if (end > failed_start) { +/* Work with what could be locked */ + end = failed_start -1 ;
nit: Here instead of assigning *delalloc_end to end and doing the check I think it's more straightforward to perform the check with failed_start and *delalloc_end and only then assign failed_start -1 to end.
Quoted 17 lines
fs/btrfs/extent_io.c +13
-0+ } + +/* Check if delalloc bits are set */ + ret =test_range_bit (tree, start, end, +EXTENT_DELALLOC ,1 , *cached_state); +if (!ret) { +unlock_extent_cached (tree, start, end -1 , cached_state); +return false; + } + *delalloc_end = end; +return true; +} +void extent_range_clear_dirty_for_io (struct inode *inode,u64 start,u64 end) {unsigned long index = start >>PAGE_SHIFT ;
fs/btrfs/extent_io.c noinline_for_stack bool find_lock_delalloc_range(struct inode *inode, · line 2064
Quoted 7 lines
fs/btrfs/extent_io.c +3
-1@@ -2018,7 +2059,16 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode,if (delalloc_end +1 - delalloc_start > max_bytes) delalloc_end = delalloc_start + max_bytes -1 ; -/* step two, lock all the pages after the page that has start */ +/* step two, lock the state bits for the range */ + found = best_effort_lock_extent(tree, delalloc_start, &delalloc_end, + ((page_index(locked_page) + 1) << PAGE_SHIFT),
page_index(locked_page)+1 means you'd like to ensure you have locked at least 1 page beyond locked page, correct? This looks a bit arbitrary i.e why 1 page and not 2 for example?
fs/btrfs/extent_io.c noinline_for_stack bool find_lock_delalloc_range(struct inode *inode, · line 2073
Quoted 9 lines
fs/btrfs/extent_io.c +7
-0+ &cached_state); +if (!found) { +free_extent_state (cached_state); + goto out_failed; + } + +/* step three, lock all the pages after the page that has start */ ret =lock_delalloc_pages (inode, locked_page, delalloc_start, delalloc_end);
So now that this has become step 3 and the extents are locked you should implement relevant error handling which would unlock the extents in case of an error.
Quoted 23 lines
fs/btrfs/extent_io.c +0
-14ASSERT (!ret || ret == -EAGAIN );@@ -2038,20 +2088,6 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode, } } -/* step three, lock the state bits for the whole range */ -lock_extent_bits (tree, delalloc_start, delalloc_end, &cached_state); - -/* then test to make sure it is all still delalloc */ - ret =test_range_bit (tree, delalloc_start, delalloc_end, -EXTENT_DELALLOC ,1 , cached_state); -if (!ret) { -unlock_extent_cached (tree, delalloc_start, delalloc_end, - &cached_state); -__unlock_for_delalloc (inode, locked_page, - delalloc_start, delalloc_end); -cond_resched (); - goto again; - }free_extent_state (cached_state); *start = delalloc_start; *end = delalloc_end;
RFC PATCH 6/31 btrfs: lock extents while truncating
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Lock order change: Lock extents before pages.
This removes extent locking in invalidatepages(). invalidatepage() is either called during truncating or while evicting inode. Inode eviction does not require locking.
--- fs/btrfs/inode.c | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-)
fs/btrfs/inode.c +23 -6
@@ -5201,6 +5201,9 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)btrfs_end_transaction (trans); }else {struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +u64 start =round_down (oldsize, fs_info->sectorsize); +u64 end =round_up (newsize, fs_info->sectorsize) -1 ; +struct extent_state **cached =NULL ;if (btrfs_is_zoned (fs_info)) { ret = btrfs_wait_ordered_range(inode,
@@ -5219,7 +5222,10 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)set_bit (BTRFS_INODE_FLUSH_ON_CLOSE , &BTRFS_I (inode)->runtime_flags); +lock_extent_bits (&BTRFS_I (inode)->io_tree, start, end, cached);truncate_setsize (inode, newsize); +unlock_extent_cached (&BTRFS_I (inode)->io_tree, start, end, + cached);inode_dio_wait (inode);
@@ -8322,9 +8328,23 @@ static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)static int btrfs_releasepage (struct page *page,gfp_t gfp_flags) { +struct btrfs_inode *inode =BTRFS_I (page->mapping->host); +struct extent_map *em; +int ret; +if (PageWriteback (page) ||PageDirty (page))return 0 ; -return __btrfs_releasepage (page, gfp_flags); + + em =lookup_extent_mapping (&inode->extent_tree,page_offset (page), +PAGE_SIZE -1 ); +if (!em) +return 0 ; +if (!try_lock_extent (&inode->io_tree, em->start,extent_map_end (em) -1 )) +return 0 ; + ret =__btrfs_releasepage (page, gfp_flags); +unlock_extent (&inode->io_tree, em->start,extent_map_end (em)); +free_extent_map (em); +return ret; }#ifdef CONFIG_MIGRATION
@@ -8398,9 +8418,6 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,return ; } -if (!inode_evicting) -lock_extent_bits (tree, page_start, page_end, &cached_state); - cur = page_start;while (cur < page_end) {struct btrfs_ordered_extent *ordered;
@@ -8458,7 +8475,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,if (!inode_evicting)clear_extent_bit (tree, cur, range_end,EXTENT_DELALLOC | -EXTENT_LOCKED |EXTENT_DO_ACCOUNTING | +EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG ,1 ,0 , &cached_state);spin_lock_irq (&inode->ordered_tree.lock);
@@ -8503,7 +8520,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,*/ btrfs_qgroup_free_data (inode,NULL , cur, range_end +1 - cur);if (!inode_evicting) { -clear_extent_bit (tree, cur, range_end,EXTENT_LOCKED | +clear_extent_bit (tree, cur, range_end,EXTENT_DELALLOC |EXTENT_UPTODATE |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG ,1 , delete_states, &cached_state);
Signature · 1 line
2.31.1
Re: [RFC PATCH 06/31] btrfs: lock extents while truncating
Quoted 7 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
Lock order change: Lock extents before pages.
This removes extent locking in
invalidatepages().invalidatepage()is either called during truncating or while evicting inode. Inode eviction does not require locking.
Imo the changelog of that patch warrants an explicit mention why its correct, namely that it's lifting the locking from btrfs_invalidatepage and putting it in btrfs_setsize, wrapping truncate_setsize which eventually boils down to calling invalidatepage,
Quoted 21 lines
Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/inode.c | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-)fs/btrfs/inode.c +3
-0@@ -5201,6 +5201,9 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)btrfs_end_transaction (trans); }else {struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +u64 start =round_down (oldsize, fs_info->sectorsize); +u64 end =round_up (newsize, fs_info->sectorsize) -1 ; +struct extent_state **cached =NULL ;if (btrfs_is_zoned (fs_info)) { ret = btrfs_wait_ordered_range(inode,
fs/btrfs/inode.c static int btrfs_setsize(struct inode *inode, struct iattr *attr) · line 5228
Quoted 7 lines
fs/btrfs/inode.c +3
-0@@ -5219,7 +5222,10 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)set_bit (BTRFS_INODE_FLUSH_ON_CLOSE , &BTRFS_I (inode)->runtime_flags); +lock_extent_bits (&BTRFS_I (inode)->io_tree, start, end, cached);truncate_setsize (inode, newsize); +unlock_extent_cached (&BTRFS_I (inode)->io_tree, start, end, + cached);
This effectively lifts the granular locking, which is performed on a per-page basis and turns it into one coarse lock, which covers the whole region. This might have some performance repercussions which can go either way:
1. On the one hand you are keeping the whole ranged locked from the start until the page cache is truncated.
2. On the other you reduce the overall number of extent lock/unlocks.
In either we should think about quantifying the impact, if any.
Quoted 57 lines
fs/btrfs/inode.c +17
-6inode_dio_wait (inode);@@ -8322,9 +8328,23 @@ static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)static int btrfs_releasepage (struct page *page,gfp_t gfp_flags) { +struct btrfs_inode *inode =BTRFS_I (page->mapping->host); +struct extent_map *em; +int ret; +if (PageWriteback (page) ||PageDirty (page))return 0 ; -return __btrfs_releasepage (page, gfp_flags); + + em =lookup_extent_mapping (&inode->extent_tree,page_offset (page), +PAGE_SIZE -1 ); +if (!em) +return 0 ; +if (!try_lock_extent (&inode->io_tree, em->start,extent_map_end (em) -1 )) +return 0 ; + ret =__btrfs_releasepage (page, gfp_flags); +unlock_extent (&inode->io_tree, em->start,extent_map_end (em)); +free_extent_map (em); +return ret; }#ifdef CONFIG_MIGRATION @@ -8398,9 +8418,6 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,return ; } -if (!inode_evicting) -lock_extent_bits (tree, page_start, page_end, &cached_state); - cur = page_start;while (cur < page_end) {struct btrfs_ordered_extent *ordered;@@ -8458,7 +8475,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,if (!inode_evicting)clear_extent_bit (tree, cur, range_end,EXTENT_DELALLOC | -EXTENT_LOCKED |EXTENT_DO_ACCOUNTING | +EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG ,1 ,0 , &cached_state);spin_lock_irq (&inode->ordered_tree.lock);@@ -8503,7 +8520,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,*/ btrfs_qgroup_free_data (inode,NULL , cur, range_end +1 - cur);if (!inode_evicting) { -clear_extent_bit (tree, cur, range_end,EXTENT_LOCKED | +clear_extent_bit (tree, cur, range_end,EXTENT_DELALLOC |EXTENT_UPTODATE |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG ,1 , delete_states, &cached_state);
Re: [RFC PATCH 06/31] btrfs: lock extents while truncating
In reply to Goldwyn RodriguesQuoted 51 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
Lock order change: Lock extents before pages.
This removes extent locking in
invalidatepages().invalidatepage()is either called during truncating or while evicting inode. Inode eviction does not require locking.Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/inode.c | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-)fs/btrfs/inode.c +12
-1@@ -5201,6 +5201,9 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)btrfs_end_transaction (trans); }else {struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +u64 start =round_down (oldsize, fs_info->sectorsize); +u64 end =round_up (newsize, fs_info->sectorsize) -1 ; +struct extent_state **cached =NULL ;if (btrfs_is_zoned (fs_info)) { ret = btrfs_wait_ordered_range(inode,@@ -5219,7 +5222,10 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)set_bit (BTRFS_INODE_FLUSH_ON_CLOSE , &BTRFS_I (inode)->runtime_flags); +lock_extent_bits (&BTRFS_I (inode)->io_tree, start, end, cached);truncate_setsize (inode, newsize); +unlock_extent_cached (&BTRFS_I (inode)->io_tree, start, end, + cached);inode_dio_wait (inode);@@ -8322,9 +8328,23 @@ static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)static int btrfs_releasepage (struct page *page,gfp_t gfp_flags) { +struct btrfs_inode *inode =BTRFS_I (page->mapping->host); +struct extent_map *em; +int ret; +if (PageWriteback (page) ||PageDirty (page))return 0 ; -return __btrfs_releasepage (page, gfp_flags); + + em = lookup_extent_mapping(&inode->extent_tree, page_offset(page),
fs/btrfs/inode.c static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags) · line 8348
Quoted 10 lines
fs/btrfs/inode.c +9
-0+ PAGE_SIZE - 1); +if (!em) +return 0 ; +if (!try_lock_extent (&inode->io_tree, em->start,extent_map_end (em) -1 )) +return 0 ; + ret =__btrfs_releasepage (page, gfp_flags); +unlock_extent (&inode->io_tree, em->start,extent_map_end (em)); +free_extent_map (em); +return ret; }
Care to elaborate why this is needed, looking at the code I couldn't find the answer.
Quoted 31 lines
fs/btrfs/inode.c +2
-5#ifdef CONFIG_MIGRATION @@ -8398,9 +8418,6 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,return ; } -if (!inode_evicting) -lock_extent_bits (tree, page_start, page_end, &cached_state); - cur = page_start;while (cur < page_end) {struct btrfs_ordered_extent *ordered;@@ -8458,7 +8475,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,if (!inode_evicting)clear_extent_bit (tree, cur, range_end,EXTENT_DELALLOC | -EXTENT_LOCKED |EXTENT_DO_ACCOUNTING | +EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG ,1 ,0 , &cached_state);spin_lock_irq (&inode->ordered_tree.lock);@@ -8503,7 +8520,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,*/ btrfs_qgroup_free_data (inode,NULL , cur, range_end +1 - cur);if (!inode_evicting) { -clear_extent_bit (tree, cur, range_end,EXTENT_LOCKED | +clear_extent_bit (tree, cur, range_end,EXTENT_DELALLOC |EXTENT_UPTODATE |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG ,1 , delete_states, &cached_state);
RFC PATCH 7/31 btrfs: write() perform extent locks before locking page
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Lock order change: Extent locks before page locks.
While performing writes, lock the extents before locking the pages.
Since pages will no longer involved, lock_and_cleanup_extent_if_need() can be deleted and btrfs_lock_and_flush_ordered_range() is used instead.
--- fs/btrfs/file.c | 95 +++++++++---------------------------------------- 1 file changed, 16 insertions(+), 79 deletions(-)
fs/btrfs/file.c +16 -79
@@ -1407,70 +1407,6 @@ static noinline int prepare_pages(struct inode *inode, struct page **pages, } -/* -* This function locks the extent and properly waits for data=ordered extents -* to finish before allowing the pages to be modified if need. -* -* The return value: -* 1 - the extent is locked -* 0 - the extent is not locked, and everything is OK -* -EAGAIN - need re-prepare the pages -* the other < 0 number - Something wrong happens -*/ -static noinline int -lock_and_cleanup_extent_if_need (struct btrfs_inode *inode,struct page **pages, -size_t num_pages,loff_t pos, -size_t write_bytes, -u64 *lockstart,u64 *lockend, -struct extent_state **cached_state) -{ -struct btrfs_fs_info *fs_info = inode->root->fs_info; -u64 start_pos; -u64 last_pos; -int i; -int ret =0 ; - - start_pos =round_down (pos, fs_info->sectorsize); - last_pos =round_up (pos + write_bytes, fs_info->sectorsize) -1 ; - -if (start_pos < inode->vfs_inode.i_size) { -struct btrfs_ordered_extent *ordered; - -lock_extent_bits (&inode->io_tree, start_pos, last_pos, - cached_state); - ordered =btrfs_lookup_ordered_range (inode, start_pos, - last_pos - start_pos +1 ); -if (ordered && - ordered->file_offset + ordered->num_bytes > start_pos && - ordered->file_offset <= last_pos) { -unlock_extent_cached (&inode->io_tree, start_pos, - last_pos, cached_state); -for (i =0 ; i < num_pages; i++) { -unlock_page (pages[i]); -put_page (pages[i]); - } -btrfs_start_ordered_extent (ordered,1 ); -btrfs_put_ordered_extent (ordered); -return -EAGAIN ; - } -if (ordered) -btrfs_put_ordered_extent (ordered); - - *lockstart = start_pos; - *lockend = last_pos; - ret =1 ; - } - -/* -* We should be called after prepare_pages() which should have locked -* all pages in the range. -*/ -for (i =0 ; i < num_pages; i++) -WARN_ON (!PageLocked (pages[i])); - -return ret; -} -static int check_can_nocow (struct btrfs_inode *inode,loff_t pos,size_t *write_bytes,bool nowait) {
@@ -1693,7 +1629,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,size_t copied;size_t dirty_sectors;size_t num_sectors; -int extents_locked; +int extents_locked = false;/* * Fault pages before locking them in prepare_pages
@@ -1742,7 +1678,15 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, } release_bytes = reserve_bytes; -again: + +if (pos < inode->i_size) { + lockstart =round_down (pos, fs_info->sectorsize); + lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ; +btrfs_lock_and_flush_ordered_range (BTRFS_I (inode), + lockstart, lockend, &cached_state); + extents_locked = true; + } +/* * This is going to setup the pages array with the number of * pages we want, so we don't really need to worry about the
@@ -1754,19 +1698,11 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,if (ret) {btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes); -break ; - } - - extents_locked =lock_and_cleanup_extent_if_need ( -BTRFS_I (inode), pages, - num_pages, pos, write_bytes, &lockstart, - &lockend, &cached_state); -if (extents_locked <0 ) { -if (extents_locked == -EAGAIN ) - goto again; -btrfs_delalloc_release_extents (BTRFS_I (inode), - reserve_bytes); - ret = extents_locked; +if (extents_locked) +unlock_extent_cached (&BTRFS_I (inode)->io_tree, + lockstart, lockend, &cached_state); +else +free_extent_state (cached_state);break ; }
@@ -1831,6 +1767,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, lockstart, lockend, &cached_state); elsefree_extent_state (cached_state ); + extents_locked = false;btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes);if (ret) {
Signature · 1 line
2.31.1
RFC PATCH 8/31 btrfs: btrfs_em_to_iomap () to convert em to iomap
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
btrfs_em_to_iomap() converts and extent map into passed argument struct iomap. It makes sure the information is set close to sectorsize block.
--- fs/btrfs/ctree.h | 2 ++ fs/btrfs/file.c | 22 ++++++++++++++++++++++ 2 files changed, 24 insertions(+)
fs/btrfs/ctree.h +2 -0
@@ -3267,6 +3267,8 @@ int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);int btrfs_check_nocow_lock (struct btrfs_inode *inode,loff_t pos,size_t *write_bytes);void btrfs_check_nocow_unlock (struct btrfs_inode *inode); +void btrfs_em_to_iomap (struct inode *inode,struct extent_map *em, +struct iomap *iomap,loff_t pos);/* tree-defrag.c */ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
fs/btrfs/file.c +22 -0
@@ -1570,6 +1570,28 @@ static int btrfs_write_check(struct kiocb *iocb, struct iov_iter *from,return 0 ; } +void btrfs_em_to_iomap (struct inode *inode, +struct extent_map *em,struct iomap *iomap, +loff_t sector_pos) +{ +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +loff_t diff = sector_pos - em->start; + +if (em->block_start ==EXTENT_MAP_HOLE ) { + iomap->addr =IOMAP_NULL_ADDR ; + iomap->type =IOMAP_HOLE ; + }else if (em->block_start ==EXTENT_MAP_INLINE ) { + iomap->addr =IOMAP_NULL_ADDR ; + iomap->type =IOMAP_INLINE ; + }else { + iomap->addr = em->block_start + diff; + iomap->type =IOMAP_MAPPED ; + } + iomap->offset = em->start + diff; + iomap->bdev = fs_info->fs_devices->latest_bdev; + iomap->length = em->len - diff; +} + static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct iov_iter *i) {
Signature · 1 line
2.31.1
Re: [RFC PATCH 08/31] btrfs: btrfs_em_to_iomap () to convert em to iomap
Quoted 29 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
btrfs_em_to_iomap()converts and extent map into passed argument struct iomap. It makes sure the information is set close to sectorsize block.Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/ctree.h | 2 ++ fs/btrfs/file.c | 22 ++++++++++++++++++++++ 2 files changed, 24 insertions(+)fs/btrfs/ctree.h +2
-0@@ -3267,6 +3267,8 @@ int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);int btrfs_check_nocow_lock (struct btrfs_inode *inode,loff_t pos,size_t *write_bytes);void btrfs_check_nocow_unlock (struct btrfs_inode *inode); +void btrfs_em_to_iomap (struct inode *inode,struct extent_map *em, +struct iomap *iomap,loff_t pos);/* tree-defrag.c */ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,fs/btrfs/file.c +0
-0
fs/btrfs/file.c static int btrfs_write_check(struct kiocb *iocb, struct iov_iter *from, · line 1578
Quoted 9 lines
fs/btrfs/file.c +6
-0@@ -1570,6 +1570,28 @@ static int btrfs_write_check(struct kiocb *iocb, struct iov_iter *from,return 0 ; } +void btrfs_em_to_iomap (struct inode *inode, +struct extent_map *em,struct iomap *iomap, +loff_t sector_pos) +{ +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +loff_t diff = sector_pos - em->start;
rename this variable to offset or em_offset or something like that. diff is too generic and somewhat non-descriptive.
Quoted 20 lines
fs/btrfs/file.c +16
-0+ +if (em->block_start ==EXTENT_MAP_HOLE ) { + iomap->addr =IOMAP_NULL_ADDR ; + iomap->type =IOMAP_HOLE ; + }else if (em->block_start ==EXTENT_MAP_INLINE ) { + iomap->addr =IOMAP_NULL_ADDR ; + iomap->type =IOMAP_INLINE ; + }else { + iomap->addr = em->block_start + diff; + iomap->type =IOMAP_MAPPED ; + } + iomap->offset = em->start + diff; + iomap->bdev = fs_info->fs_devices->latest_bdev; + iomap->length = em->len - diff; +} + static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct iov_iter *i) {
Re: [RFC PATCH 08/31] btrfs: btrfs_em_to_iomap () to convert em to iomap
In reply to Goldwyn RodriguesQuoted 40 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
btrfs_em_to_iomap()converts and extent map into passed argument struct iomap. It makes sure the information is set close to sectorsize block.Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/ctree.h | 2 ++ fs/btrfs/file.c | 22 ++++++++++++++++++++++ 2 files changed, 24 insertions(+)fs/btrfs/ctree.h +2
-0@@ -3267,6 +3267,8 @@ int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);int btrfs_check_nocow_lock (struct btrfs_inode *inode,loff_t pos,size_t *write_bytes);void btrfs_check_nocow_unlock (struct btrfs_inode *inode); +void btrfs_em_to_iomap (struct inode *inode,struct extent_map *em, +struct iomap *iomap,loff_t pos);/* tree-defrag.c */ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,fs/btrfs/file.c +8
-0@@ -1570,6 +1570,28 @@ static int btrfs_write_check(struct kiocb *iocb, struct iov_iter *from,return 0 ; } +void btrfs_em_to_iomap (struct inode *inode, +struct extent_map *em,struct iomap *iomap, +loff_t sector_pos) +{ +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +loff_t diff = sector_pos - em->start; + +if (em->block_start ==EXTENT_MAP_HOLE ) {
fs/btrfs/file.c static int btrfs_write_check(struct kiocb *iocb, struct iov_iter *from, · line 1590
Quoted 10 lines
fs/btrfs/file.c +10
-0+ iomap->addr =IOMAP_NULL_ADDR ; + iomap->type =IOMAP_HOLE ; + }else if (em->block_start ==EXTENT_MAP_INLINE ) { + iomap->addr =IOMAP_NULL_ADDR ; + iomap->type =IOMAP_INLINE ; + }else { + iomap->addr = em->block_start + diff; + iomap->type =IOMAP_MAPPED ; + } + iomap->offset = em->start + diff;
This is really iomap->offset = sector_pos i.e no need to perform the addition.
Quoted 8 lines
fs/btrfs/file.c +4
-0+ iomap->bdev = fs_info->fs_devices->latest_bdev; + iomap->length = em->len - diff; +} + static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct iov_iter *i) {
RFC PATCH 9/31 btrfs: Don't process pages if locked_page is NULL
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
This is an ugly hack so we don't process pages since all page processing is performed in iomap.
Ideally, we would want to change this to remove locked_page argument from the run_delalloc_range()->cow_file_range() calls.
--- fs/btrfs/extent_io.c | 3 +++ fs/btrfs/inode.c | 3 ++- 2 files changed, 5 insertions(+), 1 deletion(-)
fs/btrfs/extent_io.c +3 -0
@@ -2101,6 +2101,9 @@ void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end, {clear_extent_bit (&inode->io_tree, start, end, clear_bits,1 ,0 ,NULL ); +if (!locked_page) +return ; +__process_pages_contig (inode->vfs_inode.i_mapping, locked_page, start, end, page_ops,NULL ); }
fs/btrfs/inode.c +2 -1
@@ -1112,7 +1112,8 @@ static noinline int cow_file_range(struct btrfs_inode *inode,* can't use page_started to determine if it's an * inline extent or a compressed extent. */ -unlock_page (locked_page); +if (locked_page) +unlock_page (locked_page); goto out; }else if (ret <0 ) { goto out_unlock;
Signature · 1 line
2.31.1
RFC PATCH 10/31 btrfs: Add btrfs_map_blocks to for iomap_writeback_ops
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
btrfs_map_blocks() runs delayed allocation range to allcate new CoW space if required and returns the io_map associated with the location to write.
--- fs/btrfs/inode.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+)
fs/btrfs/inode.c +71 -0
@@ -8283,6 +8283,77 @@ int btrfs_readpage(struct file *file, struct page *page)return ret; } +static int find_delalloc_range (struct inode *inode,u64 *start,u64 *end) +{ +struct extent_io_tree *tree = &BTRFS_I (inode)->io_tree; +bool found; +int ret; +struct extent_state *cached =NULL ; + +/* Find the range */ + found =btrfs_find_delalloc_range (tree, start, end, +BTRFS_MAX_EXTENT_SIZE , &cached); +if (!found) +return -EIO ; + +lock_extent (tree, *start, *end); + +/* Verify it is set to delalloc */ + ret =test_range_bit (tree, *start, *end, +EXTENT_DELALLOC ,1 , cached); +return ret; +} + +static int btrfs_set_iomap (struct inode *inode,loff_t pos, +loff_t length,struct iomap *srcmap) +{ +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +loff_t sector_start =round_down (pos, fs_info->sectorsize); +struct extent_map *em; + + em =btrfs_get_extent (BTRFS_I (inode),NULL ,0 , sector_start, length); +if (IS_ERR (em)) +return PTR_ERR (em); + +btrfs_em_to_iomap (inode, em, srcmap, sector_start); + +free_extent_map (em); +return 0 ; +} + +static int btrfs_map_blocks (struct iomap_writepage_ctx *wpc, +struct inode *inode,loff_t offset) +{ +int ret; +unsigned long nr_written;/* unused */ +int page_started;/* unused */ +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +u64 start =round_down (offset, fs_info->sectorsize); +u64 end =0 ; + +/* Check if iomap is valid */ +if (offset >= wpc->iomap.offset && + offset < wpc->iomap.offset + wpc->iomap.length) +return 0 ; + + ret =find_delalloc_range (inode, &start, &end); +if (ret <0 ) +return ret; + + ret =btrfs_run_delalloc_range (BTRFS_I (inode),NULL , + start, end, &page_started, &nr_written,NULL ); +if (ret <0 ) +return ret; + +/* TODO: handle compressed extents */ +return btrfs_set_iomap (inode, offset, end - offset, &wpc->iomap); +} + +static const struct iomap_writeback_ops btrfs_writeback_ops = { + .map_blocks = btrfs_map_blocks, +}; + +static int btrfs_writepage (struct page *page,struct writeback_control *wbc) {struct inode *inode = page->mapping->host;
Signature · 1 line
2.31.1
Re: [RFC PATCH 10/31] btrfs: Add btrfs_map_blocks to for iomap_writeback_ops
Quoted 19 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
btrfs_map_blocks()runs delayed allocation range to allcate new CoW space if required and returns theio_mapassociated with the location to write.Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/inode.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+)fs/btrfs/inode.c +0
-0@@ -8283,6 +8283,77 @@ int btrfs_readpage(struct file *file, struct page *page)return ret; }
<snip>
fs/btrfs/inode.c int btrfs_readpage(struct file *file, struct page *page) · line 8336
Quoted 13 lines
fs/btrfs/inode.c +13
-0+static int btrfs_map_blocks (struct iomap_writepage_ctx *wpc, +struct inode *inode,loff_t offset) +{ +int ret; +unsigned long nr_written;/* unused */ +int page_started;/* unused */ +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +u64 start =round_down (offset, fs_info->sectorsize); +u64 end =0 ; + +/* Check if iomap is valid */ +if (offset >= wpc->iomap.offset && + offset < wpc->iomap.offset + wpc->iomap.length)
use in_range macro from btrfs/misc.h :
if (in_range(offset, wpc->iomap.offset, wpc->iomap.length))
<snip>
RFC PATCH 11/31 btrfs: Use submit_io to submit btrfs writeback bios
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
The submit_io sequence calls set_page_extent_mapped() for data inodes to make sure that page->private is set. Depending on the type of inode: metadata or data, the respective submit_bio function is called.
This will also be used for readpage() sequence.
--- fs/btrfs/inode.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)
fs/btrfs/inode.c +16 -1
@@ -8349,11 +8349,26 @@ static int btrfs_map_blocks(struct iomap_writepage_ctx *wpc,return btrfs_set_iomap (inode, offset, end - offset, &wpc->iomap); } +static void btrfs_buffered_submit_io (struct inode *inode,struct bio *bio) +{ +struct bio_vec *bvec; +struct bvec_iter_all iter_all; + +if (is_data_inode (inode)) +bio_for_each_segment_all (bvec, bio, iter_all) +set_page_extent_mapped (bvec->bv_page); + +if (is_data_inode (inode)) +btrfs_submit_data_bio (inode, bio,0 ,0 ); +else +btrfs_submit_metadata_bio (inode, bio,0 ,0 ); +} +static const struct iomap_writeback_ops btrfs_writeback_ops = { .map_blocks = btrfs_map_blocks, + .submit_io = btrfs_buffered_submit_io, }; -static int btrfs_writepage (struct page *page,struct writeback_control *wbc) {struct inode *inode = page->mapping->host;
Signature · 1 line
2.31.1
Re: [RFC PATCH 11/31] btrfs: Use submit_io to submit btrfs writeback bios
Quoted 23 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
The
submit_iosequence callsset_page_extent_mapped()for data inodes to make sure thatpage->privateis set. Depending on the type of inode: metadata or data, the respectivesubmit_biofunction is called.This will also be used for
readpage()sequence.--- fs/btrfs/inode.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)fs/btrfs/inode.c +3
-0@@ -8349,11 +8349,26 @@ static int btrfs_map_blocks(struct iomap_writepage_ctx *wpc,return btrfs_set_iomap (inode, offset, end - offset, &wpc->iomap); } +static void btrfs_buffered_submit_io (struct inode *inode,struct bio *bio) +{ +struct bio_vec *bvec;
fs/btrfs/inode.c static int btrfs_map_blocks(struct iomap_writepage_ctx *wpc, · line 8364
Quoted 10 lines
fs/btrfs/inode.c +10
-0+struct bvec_iter_all iter_all; + +if (is_data_inode (inode)) +bio_for_each_segment_all (bvec, bio, iter_all) +set_page_extent_mapped (bvec->bv_page); + +if (is_data_inode (inode)) +btrfs_submit_data_bio (inode, bio,0 ,0 ); +else +btrfs_submit_metadata_bio (inode, bio,0 ,0 );
Move the submit_data_bio into the first if() and then submit_metadata_bio into an else clause. That way you'll have just a single check in this function.
Quoted 12 lines
fs/btrfs/inode.c +3
-1+} +static const struct iomap_writeback_ops btrfs_writeback_ops = { .map_blocks = btrfs_map_blocks, + .submit_io = btrfs_buffered_submit_io, }; -static int btrfs_writepage (struct page *page,struct writeback_control *wbc) {struct inode *inode = page->mapping->host;
RFC PATCH 12/31 btrfs: endio sequence for writepage
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Perform extent housekeeping after completion of bio. This calls iomap_writepage_end_bio() to perform end of write sequence for the pages.
--- fs/btrfs/inode.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
fs/btrfs/inode.c +18 -0
@@ -8349,6 +8349,23 @@ static int btrfs_map_blocks(struct iomap_writepage_ctx *wpc,return btrfs_set_iomap (inode, offset, end - offset, &wpc->iomap); } +static void btrfs_writepage_endio (struct bio *bio) +{ +int error =blk_status_to_errno (bio->bi_status); +struct iomap_ioend *ioend = bio->bi_private; +struct btrfs_inode *inode =BTRFS_I (ioend->io_inode); +struct btrfs_fs_info *fs_info =btrfs_sb (ioend->io_inode->i_sb); +struct btrfs_ordered_extent *ordered =NULL ; + +if (!btrfs_dec_test_ordered_pending (inode, &ordered, ioend->io_offset, + ioend->io_size, !error)) +return ; + +btrfs_init_work (&ordered->work, finish_ordered_fn,NULL ,NULL ); +btrfs_queue_work (fs_info->endio_write_workers, &ordered->work); +iomap_writepage_end_bio (bio); +} +static void btrfs_buffered_submit_io (struct inode *inode,struct bio *bio) {struct bio_vec *bvec;
@@ -8358,6 +8375,7 @@ static void btrfs_buffered_submit_io(struct inode *inode, struct bio *bio)bio_for_each_segment_all (bvec, bio, iter_all)set_page_extent_mapped (bvec->bv_page); + bio->bi_end_io = btrfs_writepage_endio;if (is_data_inode (inode))btrfs_submit_data_bio (inode, bio,0 ,0 );else
Signature · 1 line
2.31.1
RFC PATCH 13/31 btrfs: do not checksum for free space inode
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Free space inode writes should not be checksummed.
Q: Now sure why this is required now (as opposed to earlier), but it would fail on writing free_space_inode. How is this avoided in the existing code?
--- fs/btrfs/disk-io.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
fs/btrfs/disk-io.c +6 -3
@@ -946,9 +946,12 @@ blk_status_t btrfs_submit_metadata_bio(struct inode *inode, struct bio *bio, goto out_w_error; ret =btrfs_map_bio (fs_info, bio, mirror_num); }else if (!should_async_write (fs_info,BTRFS_I (inode))) { - ret =btree_csum_one_bio (bio); -if (ret) - goto out_w_error; +/* Do not checksum free space inode */ +if (!btrfs_is_free_space_inode (BTRFS_I (inode))) { + ret =btree_csum_one_bio (bio); +if (ret) + goto out_w_error; + } ret =btrfs_map_bio (fs_info, bio, mirror_num); }else {/*
Signature · 1 line
2.31.1
Re: [RFC PATCH 13/31] btrfs: do not checksum for free space inode
Quoted 20 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
Free space inode writes should not be checksummed.
Q: Now sure why this is required now (as opposed to earlier), but it would fail on writing
free_space_inode. How is this avoided in the existing code?Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/disk-io.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)fs/btrfs/disk-io.c +0
-0@@ -946,9 +946,12 @@ blk_status_t btrfs_submit_metadata_bio(struct inode *inode, struct bio *bio, goto out_w_error; ret =btrfs_map_bio (fs_info, bio, mirror_num);
fs/btrfs/disk-io.c blk_status_t btrfs_submit_metadata_bio(struct inode *inode, struct bio *bio, · line 954
Quoted 10 lines
fs/btrfs/disk-io.c +6
-3}else if (!should_async_write (fs_info,BTRFS_I (inode))) { - ret =btree_csum_one_bio (bio); -if (ret) - goto out_w_error; +/* Do not checksum free space inode */ +if (!btrfs_is_free_space_inode (BTRFS_I (inode))) { + ret =btree_csum_one_bio (bio); +if (ret) + goto out_w_error; + }
Something is broken here, the freespace inode is considered a data inode, this means that this check should always be true i.e this patch is a null op? I.e the only inode you should be writing through submit_metadata_bio is the btree_inode.
Quoted 4 lines
fs/btrfs/disk-io.c +0
-0ret =btrfs_map_bio (fs_info, bio, mirror_num); }else {/*
RFC PATCH 14/31 btrfs: end EXTENT_MAP_INLINE writeback early
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
writes to inline extent maps are finished immediately and does not go through the entire writeback cycle of creation or submission of bios.
--- fs/btrfs/inode.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)
fs/btrfs/inode.c +16 -1
@@ -8346,7 +8346,22 @@ static int btrfs_map_blocks(struct iomap_writepage_ctx *wpc,return ret;/* TODO: handle compressed extents */ -return btrfs_set_iomap (inode, offset, end - offset, &wpc->iomap); + ret =btrfs_set_iomap (inode, offset, end - offset, &wpc->iomap); +if (ret <0 ) { +__endio_write_update_ordered (BTRFS_I (inode), start, end, false); +return ret; + } + +if (wpc->iomap.type ==IOMAP_INLINE ) { +/* +* In case of EXTENT_MAP_INLINE, call endio function +* and reset type to IOMAP_HOLE, so iomap code does not +* perform any action +*/ +__endio_write_update_ordered (BTRFS_I (inode), start, end, true); + wpc->iomap.type =IOMAP_HOLE ; + } +return 0 ; }static void btrfs_writepage_endio (struct bio *bio)
Signature · 1 line
2.31.1
RFC PATCH 15/31 btrfs: Switch to iomap_writepages()
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Switch to iomap_writepages()
--- fs/btrfs/inode.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
fs/btrfs/inode.c +3 -1
@@ -8430,7 +8430,9 @@ static int btrfs_writepage(struct page *page, struct writeback_control *wbc)static int btrfs_writepages (struct address_space *mapping,struct writeback_control *wbc) { -return extent_writepages (mapping, wbc); +struct iomap_writepage_ctx wpc = {0 }; + +return iomap_writepages (mapping, wbc, &wpc, &btrfs_writeback_ops); }static void btrfs_readahead (struct readahead_control *rac)
Signature · 1 line
2.31.1
RFC PATCH 16/31 btrfs: remove force_page_uptodate
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
iomap handles short writes well. Removing force_page_uptodate eases out porting.
Note, this change is not that important because these functions are deleted down the line. This is performed to make the switch easier.
--- fs/btrfs/file.c | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-)
fs/btrfs/file.c +6 -13
@@ -1326,13 +1326,11 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,* on success we return a locked page and 0 */ static int prepare_uptodate_page (struct inode *inode, -struct page *page,u64 pos, -bool force_uptodate) +struct page *page,u64 pos) {int ret =0 ; -if (((pos & (PAGE_SIZE -1 )) || force_uptodate) && - !PageUptodate (page)) { +if ((pos & (PAGE_SIZE -1 )) && !PageUptodate (page)) { ret =btrfs_readpage (NULL , page);if (ret)return ret;
@@ -1354,7 +1352,7 @@ static int prepare_uptodate_page(struct inode *inode,*/ static noinline int prepare_pages(struct inode *inode, struct page **pages,size_t num_pages,loff_t pos, -size_t write_bytes,bool force_uptodate) +size_t write_bytes) {int i;unsigned long index = pos >>PAGE_SHIFT ;
@@ -1379,11 +1377,10 @@ static noinline int prepare_pages(struct inode *inode, struct page **pages, }if (i ==0 ) - err =prepare_uptodate_page (inode, pages[i], pos, - force_uptodate); + err =prepare_uptodate_page (inode, pages[i], pos);if (!err && i == num_pages -1 ) err =prepare_uptodate_page (inode, pages[i], - pos + write_bytes, false); + pos + write_bytes);if (err) {put_page (pages[i]);if (err == -EAGAIN ) {
@@ -1608,7 +1605,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,int nrptrs;ssize_t ret;bool only_release_metadata = false; -bool force_page_uptodate = false;loff_t old_isize =i_size_read (inode);unsigned int ilock_flags =0 ;
@@ -1715,8 +1711,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,* contents of pages from loop to loop */ ret =prepare_pages (inode, pages, num_pages, - pos, write_bytes, - force_page_uptodate); + pos, write_bytes);if (ret) {btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes);
@@ -1743,11 +1738,9 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, nrptrs =1 ;if (copied ==0 ) { - force_page_uptodate = true; dirty_sectors =0 ; dirty_pages =0 ; }else { - force_page_uptodate = false; dirty_pages =DIV_ROUND_UP (copied + offset,PAGE_SIZE ); }
Signature · 1 line
2.31.1
RFC PATCH 17/31 btrfs: Introduce btrfs_iomap
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
A structure which will be used to transfer information from iomap_begin() to iomap_end().
Move all locking information into btrfs_iomap.
--- fs/btrfs/file.c | 44 ++++++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 16 deletions(-)
fs/btrfs/file.c +28 -16
@@ -56,6 +56,15 @@ struct inode_defrag {int cycled; }; +struct btrfs_iomap { + +/* Locking */ +u64 lockstart; +u64 lockend; +struct extent_state *cached_state; +int extents_locked; +}; +static int __compare_inode_defrag (struct inode_defrag *defrag1,struct inode_defrag *defrag2) {
@@ -1599,14 +1608,13 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct page **pages =NULL ;struct extent_changeset *data_reserved =NULL ;u64 release_bytes =0 ; -u64 lockstart; -u64 lockend;size_t num_written =0 ;int nrptrs;ssize_t ret;bool only_release_metadata = false;loff_t old_isize =i_size_read (inode);unsigned int ilock_flags =0 ; +struct btrfs_iomap *bi =NULL ;if (iocb->ki_flags &IOCB_NOWAIT ) ilock_flags |=BTRFS_ILOCK_TRY ;
@@ -1634,6 +1642,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, goto out; } + bi =kzalloc (sizeof (struct btrfs_iomap ),GFP_NOFS ); +if (!bi) { + ret = -ENOMEM ; + goto out; + } +while (iov_iter_count (i) >0 ) {struct extent_state *cached_state =NULL ;size_t offset =offset_in_page (pos);
@@ -1647,7 +1661,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,size_t copied;size_t dirty_sectors;size_t num_sectors; -int extents_locked = false;/* * Fault pages before locking them in prepare_pages
@@ -1658,6 +1671,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,break ; } + bi->extents_locked = false; only_release_metadata = false; sector_offset = pos & (fs_info->sectorsize -1 );
@@ -1698,11 +1712,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, release_bytes = reserve_bytes;if (pos < inode->i_size) { - lockstart =round_down (pos, fs_info->sectorsize); - lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ; + bi->lockstart =round_down (pos, fs_info->sectorsize); + bi->lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ;btrfs_lock_and_flush_ordered_range (BTRFS_I (inode), - lockstart, lockend, &cached_state); - extents_locked = true; + bi->lockstart, bi->lockend, + &cached_state); + bi->extents_locked = true; }/*
@@ -1715,11 +1730,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,if (ret) {btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes); -if (extents_locked) -unlock_extent_cached (&BTRFS_I (inode)->io_tree, - lockstart, lockend, &cached_state); -else -free_extent_state (cached_state);break ; }
@@ -1777,12 +1787,13 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,* as delalloc through btrfs_dirty_pages(). Therefore free any * possible cached extent state to avoid a memory leak. */ -if (extents_locked) +if (bi->extents_locked)unlock_extent_cached (&BTRFS_I (inode)->io_tree, - lockstart, lockend, &cached_state); + bi->lockstart, bi->lockend, + &bi->cached_state);else -free_extent_state (cached_state); - extents_locked = false; +free_extent_state (bi->cached_state); + bi->extents_locked = false;btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes);if (ret) {
@@ -1825,6 +1836,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, iocb->ki_pos += num_written; } out: +kfree (bi);btrfs_inode_unlock (inode, ilock_flags);return num_written ? num_written : ret; }
Signature · 1 line
2.31.1
Re: [RFC PATCH 17/31] btrfs: Introduce btrfs_iomap
Quoted 49 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
A structure which will be used to transfer information from
iomap_begin()toiomap_end().Move all locking information into
btrfs_iomap.Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/file.c | 44 ++++++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 16 deletions(-)fs/btrfs/file.c +10
-2@@ -56,6 +56,15 @@ struct inode_defrag {int cycled; }; +struct btrfs_iomap { + +/* Locking */ +u64 lockstart; +u64 lockend; +struct extent_state *cached_state; +int extents_locked; +}; +static int __compare_inode_defrag (struct inode_defrag *defrag1,struct inode_defrag *defrag2) {@@ -1599,14 +1608,13 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct page **pages =NULL ;struct extent_changeset *data_reserved =NULL ;u64 release_bytes =0 ; -u64 lockstart; -u64 lockend;size_t num_written =0 ;int nrptrs;ssize_t ret;bool only_release_metadata = false;loff_t old_isize =i_size_read (inode);unsigned int ilock_flags =0 ; +struct btrfs_iomap *bi =NULL ;if (iocb->ki_flags &IOCB_NOWAIT ) ilock_flags |=BTRFS_ILOCK_TRY ;
fs/btrfs/file.c static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, · line 1645
Quoted 4 lines
fs/btrfs/file.c +1
-0@@ -1634,6 +1642,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, goto out; } + bi =kzalloc (sizeof (struct btrfs_iomap ),GFP_NOFS );
This is adding an allocation per write. The struct btrfs_iomap is not that big so it could be on stack, but as there are more members added to it in further patches the size could become unsuitable for stack. OTOH some optimization of the member layout can reduce the size, I haven't looked closer.
Quoted 72 lines
fs/btrfs/file.c +16
-14+if (!bi) { + ret = -ENOMEM ; + goto out; + } +while (iov_iter_count (i) >0 ) {struct extent_state *cached_state =NULL ;size_t offset =offset_in_page (pos);@@ -1647,7 +1661,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,size_t copied;size_t dirty_sectors;size_t num_sectors; -int extents_locked = false;/* * Fault pages before locking them in prepare_pages @@ -1658,6 +1671,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,break ; } + bi->extents_locked = false; only_release_metadata = false; sector_offset = pos & (fs_info->sectorsize -1 );@@ -1698,11 +1712,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, release_bytes = reserve_bytes;if (pos < inode->i_size) { - lockstart =round_down (pos, fs_info->sectorsize); - lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ; + bi->lockstart =round_down (pos, fs_info->sectorsize); + bi->lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ;btrfs_lock_and_flush_ordered_range (BTRFS_I (inode), - lockstart, lockend, &cached_state); - extents_locked = true; + bi->lockstart, bi->lockend, + &cached_state); + bi->extents_locked = true; }/* @@ -1715,11 +1730,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,if (ret) {btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes); -if (extents_locked) -unlock_extent_cached (&BTRFS_I (inode)->io_tree, - lockstart, lockend, &cached_state); -else -free_extent_state (cached_state);break ; }@@ -1777,12 +1787,13 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,* as delalloc through btrfs_dirty_pages(). Therefore free any * possible cached extent state to avoid a memory leak. */ -if (extents_locked) +if (bi->extents_locked)unlock_extent_cached (&BTRFS_I (inode)->io_tree, - lockstart, lockend, &cached_state); + bi->lockstart, bi->lockend, + &bi->cached_state);else -free_extent_state (cached_state); - extents_locked = false; +free_extent_state (bi->cached_state); + bi->extents_locked = false;btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes);if (ret) {
fs/btrfs/file.c static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, · line 1839
Quoted 4 lines
fs/btrfs/file.c +1
-0@@ -1825,6 +1836,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, iocb->ki_pos += num_written; } out: +kfree (bi);
It's released in the same function, so that's the lifetime.
Quoted 5 lines
fs/btrfs/file.c +0
-0btrfs_inode_unlock (inode, ilock_flags);return num_written ? num_written : ret; }Signature · 1 line
2.31.1
RFC PATCH 18/31 btrfs: Add btrfs_iomap_release()
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Function to release allocated btrfs_iomap resources.
--- fs/btrfs/file.c | 42 ++++++++++++++++++++++++++++-------------- 1 file changed, 28 insertions(+), 14 deletions(-)
fs/btrfs/file.c +28 -14
@@ -1598,6 +1598,30 @@ void btrfs_em_to_iomap(struct inode *inode, iomap->length = em->len - diff; } +/* +* btrfs_iomap_release - release reservation passed as length and free +* the btrfs_iomap structure +*/ +static void btrfs_iomap_release (struct inode *inode, +loff_t pos,size_t length,struct btrfs_iomap *bi) +{ +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); + +if (length) { +if (bi->metadata_only) { +btrfs_delalloc_release_metadata (BTRFS_I (inode), + length, true); + }else { +btrfs_delalloc_release_space (BTRFS_I (inode), + bi->data_reserved, +round_down (pos, fs_info->sectorsize), + length, true); + } + } +extent_changeset_free (bi->data_reserved); +kfree (bi); +} + static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct iov_iter *i) {
@@ -1817,24 +1841,14 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,kfree (pages); -if (release_bytes) { -if (only_release_metadata) { -btrfs_check_nocow_unlock (BTRFS_I (inode)); -btrfs_delalloc_release_metadata (BTRFS_I (inode), - release_bytes, true); - }else { -btrfs_delalloc_release_space (BTRFS_I (inode), - data_reserved, -round_down (pos, fs_info->sectorsize), - release_bytes, true); - } - } - -extent_changeset_free (data_reserved);if (num_written >0 ) {pagecache_isize_extended (inode, old_isize, iocb->ki_pos); iocb->ki_pos += num_written; } + +if (release_bytes && bi->metadata_only) +btrfs_check_nocow_unlock (BTRFS_I (inode)); +btrfs_iomap_release (inode, pos, release_bytes, bi); out:kfree (bi);btrfs_inode_unlock (inode, ilock_flags);
Signature · 1 line
2.31.1
RFC PATCH 19/31 btrfs: Add reservation information to btrfs_iomap
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Move reservation information into btrfs_iomap.
--- fs/btrfs/file.c | 49 +++++++++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 24 deletions(-)
fs/btrfs/file.c +25 -24
@@ -63,6 +63,11 @@ struct btrfs_iomap {u64 lockend;struct extent_state *cached_state;int extents_locked; + +/* Reservation */ +bool metadata_only; +struct extent_changeset *data_reserved; +size_t reserved_bytes; }; static int __compare_inode_defrag(struct inode_defrag *defrag1,
@@ -1630,12 +1635,10 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct page **pages =NULL ; -struct extent_changeset *data_reserved =NULL ;u64 release_bytes =0 ;size_t num_written =0 ;int nrptrs; -ssize_t ret; -bool only_release_metadata = false; +int ret;loff_t old_isize =i_size_read (inode);unsigned int ilock_flags =0 ;struct btrfs_iomap *bi =NULL ;
@@ -1673,14 +1676,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, }while (iov_iter_count (i) >0 ) { -struct extent_state *cached_state =NULL ;size_t offset =offset_in_page (pos);size_t sector_offset;size_t write_bytes =min (iov_iter_count (i), nrptrs * (size_t )PAGE_SIZE - offset);size_t num_pages; -size_t reserve_bytes;size_t dirty_pages;size_t copied;size_t dirty_sectors;
@@ -1696,12 +1697,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, } bi->extents_locked = false; - only_release_metadata = false; + bi->metadata_only = false; sector_offset = pos & (fs_info->sectorsize -1 ); -extent_changeset_release (data_reserved); +extent_changeset_release (bi->data_reserved); ret =btrfs_check_data_free_space (BTRFS_I (inode), - &data_reserved, pos, + &bi->data_reserved, pos, write_bytes);if (ret <0 ) {/*
@@ -1711,36 +1712,36 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,*/ if (btrfs_check_nocow_lock (BTRFS_I (inode), pos, &write_bytes) >0 ) - only_release_metadata = true; + bi->metadata_only = true;else break ; } num_pages =DIV_ROUND_UP (write_bytes + offset,PAGE_SIZE );WARN_ON (num_pages > nrptrs); - reserve_bytes =round_up (write_bytes + sector_offset, + bi->reserved_bytes =round_up (write_bytes + sector_offset, fs_info->sectorsize); -WARN_ON (reserve_bytes ==0 ); +WARN_ON (bi->reserved_bytes ==0 ); ret =btrfs_delalloc_reserve_metadata (BTRFS_I (inode), - reserve_bytes); + bi->reserved_bytes);if (ret) { -if (!only_release_metadata) +if (!bi->metadata_only)btrfs_free_reserved_data_space (BTRFS_I (inode), - data_reserved, pos, + bi->data_reserved, pos, write_bytes);else btrfs_check_nocow_unlock (BTRFS_I (inode));break ; } - release_bytes = reserve_bytes; + release_bytes = bi->reserved_bytes;if (pos < inode->i_size) { bi->lockstart =round_down (pos, fs_info->sectorsize); bi->lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ;btrfs_lock_and_flush_ordered_range (BTRFS_I (inode), bi->lockstart, bi->lockend, - &cached_state); + &bi->cached_state); bi->extents_locked = true; }
@@ -1753,13 +1754,13 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, pos, write_bytes);if (ret) {btrfs_delalloc_release_extents (BTRFS_I (inode), - reserve_bytes); + bi->reserved_bytes);break ; } copied =btrfs_copy_from_user (pos, write_bytes, pages, i); - num_sectors =BTRFS_BYTES_TO_BLKS (fs_info, reserve_bytes); + num_sectors =BTRFS_BYTES_TO_BLKS (fs_info, bi->reserved_bytes); dirty_sectors =round_up (copied + sector_offset, fs_info->sectorsize); dirty_sectors =BTRFS_BYTES_TO_BLKS (fs_info, dirty_sectors);
@@ -1782,7 +1783,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,if (num_sectors > dirty_sectors) {/* release everything except the sectors we dirtied */ release_bytes -= dirty_sectors << fs_info->sectorsize_bits; -if (only_release_metadata) { +if (bi->metadata_only) {btrfs_delalloc_release_metadata (BTRFS_I (inode), release_bytes, true); }else {
@@ -1792,7 +1793,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, fs_info->sectorsize) + (dirty_pages <<PAGE_SHIFT );btrfs_delalloc_release_space (BTRFS_I (inode), - data_reserved, __pos, + bi->data_reserved, __pos, release_bytes, true); } }
@@ -1802,7 +1803,8 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, ret =btrfs_dirty_pages (BTRFS_I (inode), pages, dirty_pages, pos, copied, - &cached_state, only_release_metadata); + &bi->cached_state, + bi->metadata_only);/* * If we have not locked the extent range, because the range's
@@ -1819,14 +1821,14 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,free_extent_state (bi->cached_state); bi->extents_locked = false; -btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes); +btrfs_delalloc_release_extents (BTRFS_I (inode), bi->reserved_bytes);if (ret) {btrfs_drop_pages (pages, num_pages);break ; } release_bytes =0 ; -if (only_release_metadata) +if (bi->metadata_only)btrfs_check_nocow_unlock (BTRFS_I (inode));btrfs_drop_pages (pages, num_pages);
@@ -1850,7 +1852,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,btrfs_check_nocow_unlock (BTRFS_I (inode));btrfs_iomap_release (inode, pos, release_bytes, bi); out: -kfree (bi);btrfs_inode_unlock (inode, ilock_flags);return num_written ? num_written : ret; }
Signature · 1 line
2.31.1
Re: [RFC PATCH 19/31] btrfs: Add reservation information to btrfs_iomap
Quoted 177 lines · Goldwyn Rodrigues
From: Goldwyn Rodrigues <[email protected]>
Move reservation information into
btrfs_iomap.Signed-off-by Goldwyn Rodrigues <[email protected]>--- fs/btrfs/file.c | 49 +++++++++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 24 deletions(-)fs/btrfs/file.c +25
-23@@ -63,6 +63,11 @@ struct btrfs_iomap {u64 lockend;struct extent_state *cached_state;int extents_locked; + +/* Reservation */ +bool metadata_only; +struct extent_changeset *data_reserved; +size_t reserved_bytes; }; static int __compare_inode_defrag(struct inode_defrag *defrag1,@@ -1630,12 +1635,10 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct page **pages =NULL ; -struct extent_changeset *data_reserved =NULL ;u64 release_bytes =0 ;size_t num_written =0 ;int nrptrs; -ssize_t ret; -bool only_release_metadata = false; +int ret;loff_t old_isize =i_size_read (inode);unsigned int ilock_flags =0 ;struct btrfs_iomap *bi =NULL ;@@ -1673,14 +1676,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, }while (iov_iter_count (i) >0 ) { -struct extent_state *cached_state =NULL ;size_t offset =offset_in_page (pos);size_t sector_offset;size_t write_bytes =min (iov_iter_count (i), nrptrs * (size_t )PAGE_SIZE - offset);size_t num_pages; -size_t reserve_bytes;size_t dirty_pages;size_t copied;size_t dirty_sectors;@@ -1696,12 +1697,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, } bi->extents_locked = false; - only_release_metadata = false; + bi->metadata_only = false; sector_offset = pos & (fs_info->sectorsize -1 ); -extent_changeset_release (data_reserved); +extent_changeset_release (bi->data_reserved); ret =btrfs_check_data_free_space (BTRFS_I (inode), - &data_reserved, pos, + &bi->data_reserved, pos, write_bytes);if (ret <0 ) {/* @@ -1711,36 +1712,36 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,*/ if (btrfs_check_nocow_lock (BTRFS_I (inode), pos, &write_bytes) >0 ) - only_release_metadata = true; + bi->metadata_only = true;else break ; } num_pages =DIV_ROUND_UP (write_bytes + offset,PAGE_SIZE );WARN_ON (num_pages > nrptrs); - reserve_bytes =round_up (write_bytes + sector_offset, + bi->reserved_bytes =round_up (write_bytes + sector_offset, fs_info->sectorsize); -WARN_ON (reserve_bytes ==0 ); +WARN_ON (bi->reserved_bytes ==0 ); ret =btrfs_delalloc_reserve_metadata (BTRFS_I (inode), - reserve_bytes); + bi->reserved_bytes);if (ret) { -if (!only_release_metadata) +if (!bi->metadata_only)btrfs_free_reserved_data_space (BTRFS_I (inode), - data_reserved, pos, + bi->data_reserved, pos, write_bytes);else btrfs_check_nocow_unlock (BTRFS_I (inode));break ; } - release_bytes = reserve_bytes; + release_bytes = bi->reserved_bytes;if (pos < inode->i_size) { bi->lockstart =round_down (pos, fs_info->sectorsize); bi->lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ;btrfs_lock_and_flush_ordered_range (BTRFS_I (inode), bi->lockstart, bi->lockend, - &cached_state); + &bi->cached_state); bi->extents_locked = true; }@@ -1753,13 +1754,13 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, pos, write_bytes);if (ret) {btrfs_delalloc_release_extents (BTRFS_I (inode), - reserve_bytes); + bi->reserved_bytes);break ; } copied =btrfs_copy_from_user (pos, write_bytes, pages, i); - num_sectors =BTRFS_BYTES_TO_BLKS (fs_info, reserve_bytes); + num_sectors =BTRFS_BYTES_TO_BLKS (fs_info, bi->reserved_bytes); dirty_sectors =round_up (copied + sector_offset, fs_info->sectorsize); dirty_sectors =BTRFS_BYTES_TO_BLKS (fs_info, dirty_sectors);@@ -1782,7 +1783,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,if (num_sectors > dirty_sectors) {/* release everything except the sectors we dirtied */ release_bytes -= dirty_sectors << fs_info->sectorsize_bits; -if (only_release_metadata) { +if (bi->metadata_only) {btrfs_delalloc_release_metadata (BTRFS_I (inode), release_bytes, true); }else {@@ -1792,7 +1793,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, fs_info->sectorsize) + (dirty_pages <<PAGE_SHIFT );btrfs_delalloc_release_space (BTRFS_I (inode), - data_reserved, __pos, + bi->data_reserved, __pos, release_bytes, true); } }@@ -1802,7 +1803,8 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, ret =btrfs_dirty_pages (BTRFS_I (inode), pages, dirty_pages, pos, copied, - &cached_state, only_release_metadata); + &bi->cached_state, + bi->metadata_only);/* * If we have not locked the extent range, because the range's @@ -1819,14 +1821,14 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,free_extent_state (bi->cached_state); bi->extents_locked = false; -btrfs_delalloc_release_extents (BTRFS_I (inode), reserve_bytes); +btrfs_delalloc_release_extents (BTRFS_I (inode), bi->reserved_bytes);if (ret) {btrfs_drop_pages (pages, num_pages);break ; } release_bytes =0 ; -if (only_release_metadata) +if (bi->metadata_only)btrfs_check_nocow_unlock (BTRFS_I (inode));btrfs_drop_pages (pages, num_pages);
fs/btrfs/file.c static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, · line 1853
Quoted 4 lines
fs/btrfs/file.c +0
-1@@ -1850,7 +1852,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,btrfs_check_nocow_unlock (BTRFS_I (inode));btrfs_iomap_release (inode, pos, release_bytes, bi); out: -kfree (bi);
Is this intentional? Or I don't see the pairing kfree that happens elsewhere.
Quoted 5 lines
fs/btrfs/file.c +0
-0btrfs_inode_unlock (inode, ilock_flags);return num_written ? num_written : ret; }Signature · 1 line
2.31.1
RFC PATCH 20/31 btrfs: Carve out btrfs_buffered_iomap_begin() from write path
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Carve out reservation and locking from bufferd write sequence in btrfs_buffered_iomap_begin().
Shortcomings: page handling with respect to nrptrs is messed up. However, since we will be passing the responsibility of pages to iomap, this will not be problem.
--- fs/btrfs/file.c | 100 ++++++++++++++++++++++++++++-------------------- 1 file changed, 59 insertions(+), 41 deletions(-)
fs/btrfs/file.c +59 -41
@@ -1627,6 +1627,57 @@ static void btrfs_iomap_release(struct inode *inode,kfree (bi); } +static int btrfs_buffered_iomap_begin (struct inode *inode,loff_t pos, +size_t length,struct btrfs_iomap *bi) +{ +int ret; +size_t write_bytes = length; +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +size_t sector_offset = pos & (fs_info->sectorsize -1 ); + + ret =btrfs_check_data_free_space (BTRFS_I (inode), + &bi->data_reserved, pos, write_bytes); +if (ret <0 ) { +/* +* If we don't have to COW at the offset, reserve +* metadata only. write_bytes may get smaller than +* requested here. +*/ +if (btrfs_check_nocow_lock (BTRFS_I (inode), pos, + &write_bytes) >0 ) + bi->metadata_only = true; +else +return ret; + } + + bi->reserved_bytes =round_up (write_bytes + sector_offset, + fs_info->sectorsize); +WARN_ON (bi->reserved_bytes ==0 ); + ret =btrfs_delalloc_reserve_metadata (BTRFS_I (inode), + bi->reserved_bytes); +if (ret) { +if (!bi->metadata_only) +btrfs_free_reserved_data_space (BTRFS_I (inode), + bi->data_reserved, pos, + write_bytes); +else +btrfs_check_nocow_unlock (BTRFS_I (inode)); +return ret; + } + +if (pos < inode->i_size) { + bi->lockstart =round_down (pos, fs_info->sectorsize); + bi->lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ; +btrfs_lock_and_flush_ordered_range (BTRFS_I (inode), + bi->lockstart, bi->lockend, + &bi->cached_state); + bi->extents_locked = true; + } + +return 0 ; + +} + static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct iov_iter *i) {
@@ -1701,50 +1752,15 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, sector_offset = pos & (fs_info->sectorsize -1 );extent_changeset_release (bi->data_reserved); - ret =btrfs_check_data_free_space (BTRFS_I (inode), - &bi->data_reserved, pos, - write_bytes); -if (ret <0 ) { -/* -* If we don't have to COW at the offset, reserve -* metadata only. write_bytes may get smaller than -* requested here. -*/ -if (btrfs_check_nocow_lock (BTRFS_I (inode), pos, - &write_bytes) >0 ) - bi->metadata_only = true; -else -break ; - } - num_pages =DIV_ROUND_UP (write_bytes + offset,PAGE_SIZE ); -WARN_ON (num_pages > nrptrs); - bi->reserved_bytes =round_up (write_bytes + sector_offset, - fs_info->sectorsize); -WARN_ON (bi->reserved_bytes ==0 ); - ret =btrfs_delalloc_reserve_metadata (BTRFS_I (inode), - bi->reserved_bytes); -if (ret) { -if (!bi->metadata_only) -btrfs_free_reserved_data_space (BTRFS_I (inode), - bi->data_reserved, pos, - write_bytes); -else -btrfs_check_nocow_unlock (BTRFS_I (inode)); -break ; - } - - release_bytes = bi->reserved_bytes; + ret =btrfs_buffered_iomap_begin (inode, pos, write_bytes, + bi); -if (pos < inode->i_size) { - bi->lockstart =round_down (pos, fs_info->sectorsize); - bi->lockend =round_up (pos + write_bytes, fs_info->sectorsize) -1 ; -btrfs_lock_and_flush_ordered_range (BTRFS_I (inode), - bi->lockstart, bi->lockend, - &bi->cached_state); - bi->extents_locked = true; - } +if (ret <0 ) + goto out; + num_pages =DIV_ROUND_UP (write_bytes + offset,PAGE_SIZE ); +WARN_ON (num_pages > nrptrs);/* * This is going to setup the pages array with the number of * pages we want, so we don't really need to worry about the
@@ -1780,6 +1796,8 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, PAGE_SIZE); } + release_bytes = bi->reserved_bytes; +if (num_sectors > dirty_sectors) {/* release everything except the sectors we dirtied */ release_bytes -= dirty_sectors << fs_info->sectorsize_bits;
Signature · 1 line
2.31.1
RFC PATCH 21/31 btrfs: Carve out btrfs_buffered_iomap_end from the write path
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Carve out btrfs_buffered_iomap_end() from the write path to form iomap_end() function for writes.
--- fs/btrfs/file.c | 97 ++++++++++++++++++++++++++++++------------------- 1 file changed, 59 insertions(+), 38 deletions(-)
fs/btrfs/file.c +59 -38
@@ -1678,6 +1678,63 @@ static int btrfs_buffered_iomap_begin(struct inode *inode, loff_t pos, } +static int btrfs_buffered_iomap_end (struct inode *inode,loff_t pos, +loff_t length,ssize_t written,struct btrfs_iomap *bi) +{ +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +size_t num_sectors =BTRFS_BYTES_TO_BLKS (fs_info, bi->reserved_bytes); +size_t dirty_sectors =0 ; +int dirty_pages =0 ; +int sector_offset = pos & (fs_info->sectorsize -1 ); + +if (written) { + dirty_sectors =round_up (written + sector_offset, + fs_info->sectorsize); + dirty_sectors =BTRFS_BYTES_TO_BLKS (fs_info, dirty_sectors); + dirty_pages =DIV_ROUND_UP (written +offset_in_page (pos), +PAGE_SIZE ); + } + +/* Release excess reservations */ +if (num_sectors > dirty_sectors) { +size_t release_bytes = bi->reserved_bytes - + (dirty_sectors << fs_info->sb->s_blocksize_bits); +if (bi->metadata_only) { +btrfs_delalloc_release_metadata (BTRFS_I (inode), + release_bytes, true); + }else { +u64 p; + + p =round_down (pos, + fs_info->sectorsize) + + (dirty_pages <<PAGE_SHIFT ); +btrfs_delalloc_release_space (BTRFS_I (inode), + bi->data_reserved, p, + release_bytes, true); + } + } + +/* +* If we have not locked the extent range, because the range's +* start offset is >= i_size, we might still have a non-NULL +* cached extent state, acquired while marking the extent range +* as delalloc through btrfs_dirty_pages(). Therefore free any +* possible cached extent state to avoid a memory leak. +*/ +if (bi->extents_locked) +unlock_extent_cached (&BTRFS_I (inode)->io_tree, + bi->lockstart, bi->lockend, + &bi->cached_state); +else +free_extent_state (bi->cached_state); + +btrfs_delalloc_release_extents (BTRFS_I (inode), bi->reserved_bytes); +if (bi->metadata_only) +btrfs_check_nocow_unlock (BTRFS_I (inode)); + +return 0 ; +} + static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct iov_iter *i) {
@@ -1736,7 +1793,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,size_t dirty_pages;size_t copied;size_t dirty_sectors; -size_t num_sectors;/* * Fault pages before locking them in prepare_pages
@@ -1776,7 +1832,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, copied =btrfs_copy_from_user (pos, write_bytes, pages, i); - num_sectors =BTRFS_BYTES_TO_BLKS (fs_info, bi->reserved_bytes); dirty_sectors =round_up (copied + sector_offset, fs_info->sectorsize); dirty_sectors =BTRFS_BYTES_TO_BLKS (fs_info, dirty_sectors);
@@ -1796,26 +1851,6 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, PAGE_SIZE); } - release_bytes = bi->reserved_bytes; - -if (num_sectors > dirty_sectors) { -/* release everything except the sectors we dirtied */ - release_bytes -= dirty_sectors << fs_info->sectorsize_bits; -if (bi->metadata_only) { -btrfs_delalloc_release_metadata (BTRFS_I (inode), - release_bytes, true); - }else { -u64 __pos; - - __pos =round_down (pos, - fs_info->sectorsize) + - (dirty_pages <<PAGE_SHIFT ); -btrfs_delalloc_release_space (BTRFS_I (inode), - bi->data_reserved, __pos, - release_bytes, true); - } - } - release_bytes =round_up (copied + sector_offset, fs_info->sectorsize);
@@ -1824,27 +1859,13 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, &bi->cached_state, bi->metadata_only); -/* -* If we have not locked the extent range, because the range's -* start offset is >= i_size, we might still have a non-NULL -* cached extent state, acquired while marking the extent range -* as delalloc through btrfs_dirty_pages(). Therefore free any -* possible cached extent state to avoid a memory leak. -*/ -if (bi->extents_locked) -unlock_extent_cached (&BTRFS_I (inode)->io_tree, - bi->lockstart, bi->lockend, - &bi->cached_state); -else -free_extent_state (bi->cached_state); - bi->extents_locked = false; - -btrfs_delalloc_release_extents (BTRFS_I (inode), bi->reserved_bytes);if (ret) {btrfs_drop_pages (pages, num_pages);break ; } +btrfs_buffered_iomap_end (inode, pos, write_bytes, copied, bi); + release_bytes =0 ;if (bi->metadata_only)btrfs_check_nocow_unlock (BTRFS_I (inode));
Signature · 1 line
2.31.1
RFC PATCH 22/31 btrfs: Set extents delalloc in iomap_end
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Since the new code path would not be calling btrfs_dirty_pages(), set extent delalloc for the extent just written.
In order to make the flow easier, modify btrfs_buffered_iomap_end() to use written_block_end and block_end to calculate respective written and length sectorsize boundaries.
--- fs/btrfs/file.c | 58 +++++++++++++++++++++++-------------------------- 1 file changed, 27 insertions(+), 31 deletions(-)
fs/btrfs/file.c +27 -31
@@ -1682,44 +1682,38 @@ static int btrfs_buffered_iomap_end(struct inode *inode, loff_t pos, loff_t length, ssize_t written, struct btrfs_iomap *bi) { struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); -size_t num_sectors =BTRFS_BYTES_TO_BLKS (fs_info, bi->reserved_bytes); -size_t dirty_sectors =0 ; -int dirty_pages =0 ; -int sector_offset = pos & (fs_info->sectorsize -1 ); - -if (written) { - dirty_sectors =round_up (written + sector_offset, - fs_info->sectorsize); - dirty_sectors =BTRFS_BYTES_TO_BLKS (fs_info, dirty_sectors); - dirty_pages =DIV_ROUND_UP (written +offset_in_page (pos), -PAGE_SIZE ); - } +int ret =0 ; +size_t release_bytes =0 ; +u64 start =round_down (pos, fs_info->sectorsize); +u64 written_block_end =round_up (pos + written, fs_info->sectorsize) -1 ; +u64 block_end =round_up (pos + length, fs_info->sectorsize) -1 ; +int extra_bits =0 ; -/* Release excess reservations */ -if (num_sectors > dirty_sectors) { -size_t release_bytes = bi->reserved_bytes - - (dirty_sectors << fs_info->sb->s_blocksize_bits); -if (bi->metadata_only) { -btrfs_delalloc_release_metadata (BTRFS_I (inode), - release_bytes, true); - }else { -u64 p; +if (written ==0 ) + release_bytes = bi->reserved_bytes; +else if (written < length) + release_bytes = block_end - written_block_end +1 ; - p =round_down (pos, - fs_info->sectorsize) + - (dirty_pages <<PAGE_SHIFT ); -btrfs_delalloc_release_space (BTRFS_I (inode), - bi->data_reserved, p, - release_bytes, true); - } - } +if (bi->metadata_only) + extra_bits |=EXTENT_NORESERVE ; + +clear_extent_bit (&BTRFS_I (inode)->io_tree, start, written_block_end, +EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG , +0 ,0 , &bi->cached_state); + + ret =btrfs_set_extent_delalloc (BTRFS_I (inode), start, + written_block_end, extra_bits, &bi->cached_state); + +/* In case of error, release everything in btrfs_iomap_release() */ +if (ret <0 ) + release_bytes = bi->reserved_bytes;/* * If we have not locked the extent range, because the range's * start offset is >= i_size, we might still have a non-NULL * cached extent state, acquired while marking the extent range -* as delalloc through btrfs_dirty_pages(). Therefore free any -* possible cached extent state to avoid a memory leak. +* as delalloc. Therefore free any possible cached extent state +* to avoid a memory leak. */ if (bi->extents_locked) unlock_extent_cached(&BTRFS_I(inode)->io_tree,
@@ -1732,6 +1726,8 @@ static int btrfs_buffered_iomap_end(struct inode *inode, loff_t pos,if (bi->metadata_only)btrfs_check_nocow_unlock (BTRFS_I (inode)); +btrfs_iomap_release (inode, pos, release_bytes, bi); +return 0 ; }
Signature · 1 line
2.31.1
RFC PATCH 23/31 btrfs: define iomap_page_ops
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
The page_done() sets page->private to EXTENT_PAGE_PRIVATE if not already set. The check is in set_page_extent_mapped().
--- fs/btrfs/file.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
fs/btrfs/file.c +11 -0
@@ -467,6 +467,17 @@ static void btrfs_drop_pages(struct page **pages, size_t num_pages) } } +static void btrfs_page_done (struct inode *inode,loff_t pos, +unsigned int copied,struct page *page, +struct iomap *iomap) +{ +set_page_extent_mapped (page); +} + +static const struct iomap_page_ops btrfs_iomap_page_ops = { + .page_done = btrfs_page_done, +}; +/* * After btrfs_copy_from_user(), update the following things for delalloc: * - Mark newly dirtied pages as DELALLOC in the io tree.
Signature · 1 line
2.31.1
RFC PATCH 24/31 btrfs: Switch to iomap_file_buffered_write()
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Move allocation of btrfs_iomap into iomap_begin(). Change begin()/end() functions to fill iomap data structure.
--- fs/btrfs/file.c | 157 +++++++++--------------------------------------- 1 file changed, 27 insertions(+), 130 deletions(-)
fs/btrfs/file.c +27 -130
@@ -1639,12 +1639,18 @@ static void btrfs_iomap_release(struct inode *inode, }static int btrfs_buffered_iomap_begin (struct inode *inode,loff_t pos, -size_t length,struct btrfs_iomap *bi) +loff_t length,unsigned int flags,struct iomap *iomap, +struct iomap *srcmap) {int ret;size_t write_bytes = length;struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);size_t sector_offset = pos & (fs_info->sectorsize -1 ); +struct btrfs_iomap *bi; + + bi =kzalloc (sizeof (struct btrfs_iomap ),GFP_NOFS ); +if (!bi) +return -ENOMEM ; ret =btrfs_check_data_free_space (BTRFS_I (inode), &bi->data_reserved, pos, write_bytes);
@@ -1685,14 +1691,25 @@ static int btrfs_buffered_iomap_begin(struct inode *inode, loff_t pos, bi->extents_locked = true; } + iomap->private = bi; + iomap->length =round_up (write_bytes + sector_offset, + fs_info->sectorsize); + iomap->offset =round_down (pos, fs_info->sectorsize); + iomap->addr =IOMAP_NULL_ADDR ; + iomap->type =IOMAP_DELALLOC ; + iomap->bdev = fs_info->fs_devices->latest_bdev; + iomap->page_ops = &btrfs_iomap_page_ops; +return 0 ; }static int btrfs_buffered_iomap_end (struct inode *inode,loff_t pos, -loff_t length,ssize_t written,struct btrfs_iomap *bi) +loff_t length,ssize_t written,unsigned flags, +struct iomap *iomap) {struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +struct btrfs_iomap *bi = iomap->private;int ret =0 ;size_t release_bytes =0 ;u64 start =round_down (pos, fs_info->sectorsize);
@@ -1742,21 +1759,19 @@ static int btrfs_buffered_iomap_end(struct inode *inode, loff_t pos,return 0 ; } +const struct iomap_ops btrfs_buffered_iomap_ops = { + .iomap_begin = btrfs_buffered_iomap_begin, + .iomap_end = btrfs_buffered_iomap_end, +}; + static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,struct iov_iter *i) {struct file *file = iocb->ki_filp; -loff_t pos;struct inode *inode =file_inode (file); -struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); -struct page **pages =NULL ; -u64 release_bytes =0 ;size_t num_written =0 ; -int nrptrs;int ret; -loff_t old_isize =i_size_read (inode);unsigned int ilock_flags =0 ; -struct btrfs_iomap *bi =NULL ;if (iocb->ki_flags &IOCB_NOWAIT ) ilock_flags |=BTRFS_ILOCK_TRY ;
@@ -1773,130 +1788,12 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,if (ret <0 ) goto out; - pos = iocb->ki_pos; - nrptrs =min (DIV_ROUND_UP (iov_iter_count (i),PAGE_SIZE ), -PAGE_SIZE / (sizeof (struct page *))); - nrptrs =min (nrptrs, current->nr_dirtied_pause - current->nr_dirtied); - nrptrs =max (nrptrs,8 ); - pages =kmalloc_array (nrptrs,sizeof (struct page *),GFP_KERNEL ); -if (!pages) { - ret = -ENOMEM ; - goto out; - } + num_written =iomap_file_buffered_write (iocb, i, + &btrfs_buffered_iomap_ops); - bi =kzalloc (sizeof (struct btrfs_iomap ),GFP_NOFS ); -if (!bi) { - ret = -ENOMEM ; - goto out; - } - -while (iov_iter_count (i) >0 ) { -size_t offset =offset_in_page (pos); -size_t sector_offset; -size_t write_bytes =min (iov_iter_count (i), - nrptrs * (size_t )PAGE_SIZE - - offset); -size_t num_pages; -size_t dirty_pages; -size_t copied; -size_t dirty_sectors; - -/* -* Fault pages before locking them in prepare_pages -* to avoid recursive lock -*/ -if (unlikely (iov_iter_fault_in_readable (i, write_bytes))) { - ret = -EFAULT ; -break ; - } - - bi->extents_locked = false; - bi->metadata_only = false; - sector_offset = pos & (fs_info->sectorsize -1 ); - -extent_changeset_release (bi->data_reserved); - - ret =btrfs_buffered_iomap_begin (inode, pos, write_bytes, - bi); - -if (ret <0 ) - goto out; - - num_pages =DIV_ROUND_UP (write_bytes + offset,PAGE_SIZE ); -WARN_ON (num_pages > nrptrs); -/* -* This is going to setup the pages array with the number of -* pages we want, so we don't really need to worry about the -* contents of pages from loop to loop -*/ - ret =prepare_pages (inode, pages, num_pages, - pos, write_bytes); -if (ret) { -btrfs_delalloc_release_extents (BTRFS_I (inode), - bi->reserved_bytes); -break ; - } - - copied =btrfs_copy_from_user (pos, write_bytes, pages, i); - - dirty_sectors =round_up (copied + sector_offset, - fs_info->sectorsize); - dirty_sectors =BTRFS_BYTES_TO_BLKS (fs_info, dirty_sectors); - -/* -* if we have trouble faulting in the pages, fall -* back to one page at a time -*/ -if (copied < write_bytes) - nrptrs =1 ; - -if (copied ==0 ) { - dirty_sectors =0 ; - dirty_pages =0 ; - }else { - dirty_pages =DIV_ROUND_UP (copied + offset, -PAGE_SIZE ); - } - - release_bytes =round_up (copied + sector_offset, - fs_info->sectorsize); - - ret =btrfs_dirty_pages (BTRFS_I (inode), pages, - dirty_pages, pos, copied, - &bi->cached_state, - bi->metadata_only); - -if (ret) { -btrfs_drop_pages (pages, num_pages); -break ; - } - -btrfs_buffered_iomap_end (inode, pos, write_bytes, copied, bi); - - release_bytes =0 ; -if (bi->metadata_only) -btrfs_check_nocow_unlock (BTRFS_I (inode)); - -btrfs_drop_pages (pages, num_pages); - -cond_resched (); - -balance_dirty_pages_ratelimited (inode->i_mapping); - - pos += copied; - num_written += copied; - } - -kfree (pages); - -if (num_written >0 ) { -pagecache_isize_extended (inode, old_isize, iocb->ki_pos); +if (num_written >0 ) iocb->ki_pos += num_written; - } -if (release_bytes && bi->metadata_only) -btrfs_check_nocow_unlock (BTRFS_I (inode)); -btrfs_iomap_release (inode, pos, release_bytes, bi); out:btrfs_inode_unlock (inode, ilock_flags);return num_written ? num_written : ret;
Signature · 1 line
2.31.1
RFC PATCH 25/31 btrfs: remove all page related functions
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Cleanup after switching to iomap writes. Remove all page handling functions.
--- fs/btrfs/file.c | 156 ------------------------------------------------ 1 file changed, 156 deletions(-)
fs/btrfs/file.c +0 -156
@@ -394,79 +394,6 @@ int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)return 0 ; } -/* simple helper to fault in pages and copy. This should go away -* and be replaced with calls into generic code. -*/ -static noinline int btrfs_copy_from_user(loff_t pos, size_t write_bytes, -struct page **prepared_pages, -struct iov_iter *i) -{ -size_t copied =0 ; -size_t total_copied =0 ; -int pg =0 ; -int offset =offset_in_page (pos); - -while (write_bytes >0 ) { -size_t count =min_t (size_t, -PAGE_SIZE - offset, write_bytes); -struct page *page = prepared_pages[pg]; -/* -* Copy data from userspace to the current page -*/ - copied =iov_iter_copy_from_user_atomic (page, i, offset, count); - -/* Flush processor's dcache for this page */ -flush_dcache_page (page); - -/* -* if we get a partial write, we can end up with -* partially up to date pages. These add -* a lot of complexity, so make sure they don't -* happen by forcing this copy to be retried. -* -* The rest of the btrfs_file_write code will fall -* back to page at a time copies after we return 0. -*/ -if (!PageUptodate (page) && copied < count) - copied =0 ; - -iov_iter_advance (i, copied); - write_bytes -= copied; - total_copied += copied; - -/* Return to btrfs_file_write_iter to fault page */ -if (unlikely (copied ==0 )) -break ; - -if (copied <PAGE_SIZE - offset) { - offset += copied; - }else { - pg++; - offset =0 ; - } - } -return total_copied; -} - -/* -* unlocks pages after btrfs_file_write is done with them -*/ -static void btrfs_drop_pages (struct page **pages,size_t num_pages) -{ -size_t i; -for (i =0 ; i < num_pages; i++) { -/* page checked is some magic around finding pages that -* have been modified without going through btrfs_set_page_dirty -* clear it here. There should be no need to mark the pages -* accessed as prepare_pages should have marked them accessed -* in prepare_pages via find_or_create_page() -*/ -ClearPageChecked (pages[i]); -unlock_page (pages[i]); -put_page (pages[i]); - } -} -static void btrfs_page_done (struct inode *inode,loff_t pos,unsigned int copied,struct page *page,struct iomap *iomap)
@@ -1346,89 +1273,6 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,return ret; } -/* -* on error we return an unlocked page and the error value -* on success we return a locked page and 0 -*/ -static int prepare_uptodate_page (struct inode *inode, -struct page *page,u64 pos) -{ -int ret =0 ; - -if ((pos & (PAGE_SIZE -1 )) && !PageUptodate (page)) { - ret =btrfs_readpage (NULL , page); -if (ret) -return ret; -lock_page (page); -if (!PageUptodate (page)) { -unlock_page (page); -return -EIO ; - } -if (page->mapping != inode->i_mapping) { -unlock_page (page); -return -EAGAIN ; - } - } -return 0 ; -} - -/* -* this just gets pages into the page cache and locks them down. -*/ -static noinline int prepare_pages(struct inode *inode, struct page **pages, -size_t num_pages,loff_t pos, -size_t write_bytes) -{ -int i; -unsigned long index = pos >>PAGE_SHIFT ; -gfp_t mask =btrfs_alloc_write_mask (inode->i_mapping); -int err =0 ; -int faili; - -for (i =0 ; i < num_pages; i++) { -again: - pages[i] =find_or_create_page (inode->i_mapping, index + i, - mask | __GFP_WRITE); -if (!pages[i]) { - faili = i -1 ; - err = -ENOMEM ; - 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); -if (!err && i == num_pages -1 ) - err =prepare_uptodate_page (inode, pages[i], - pos + write_bytes); -if (err) { -put_page (pages[i]); -if (err == -EAGAIN ) { - err =0 ; - goto again; - } - faili = i -1 ; - goto fail; - } -wait_on_page_writeback (pages[i]); - } - -return 0 ; -fail: -while (faili >=0 ) { -unlock_page (pages[faili]); -put_page (pages[faili]); - faili--; - } -return err; - -} -static int check_can_nocow (struct btrfs_inode *inode,loff_t pos,size_t *write_bytes,bool nowait) {
Signature · 1 line
2.31.1
RFC PATCH 26/31 btrfs: use srcmap for read-before-write cases
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
srcmap supplies the iomap structure to read from in case the write is not aligned to blocksize boundaries.
Note, range is already locked, so no extent locking is required.
--- fs/btrfs/file.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)
fs/btrfs/file.c +30 -0
@@ -64,6 +64,9 @@ struct btrfs_iomap {struct extent_state *cached_state;int extents_locked; +/* Source extent-map in order to read from in case not sector aligned */ +struct extent_map *em; +/* Reservation */ bool metadata_only;struct extent_changeset *data_reserved;
@@ -1479,6 +1482,7 @@ static void btrfs_iomap_release(struct inode *inode, } }extent_changeset_free (bi->data_reserved); +free_extent_map (bi->em);kfree (bi); }
@@ -1491,11 +1495,37 @@ static int btrfs_buffered_iomap_begin(struct inode *inode, loff_t pos,struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);size_t sector_offset = pos & (fs_info->sectorsize -1 );struct btrfs_iomap *bi; +loff_t end = pos + length; bi =kzalloc (sizeof (struct btrfs_iomap ),GFP_NOFS );if (!bi)return -ENOMEM ; +if ((pos & (PAGE_SIZE -1 ) || end & (PAGE_SIZE -1 ))) { +loff_t isize =i_size_read (inode); + +if (pos >= isize) { + srcmap->addr =IOMAP_NULL_ADDR ; + srcmap->type =IOMAP_HOLE ; + srcmap->offset = isize; + srcmap->length = end - isize; + }else { + bi->em =btrfs_get_extent (BTRFS_I (inode),NULL ,0 , + pos - sector_offset, length); +if (IS_ERR (bi->em)) { +kfree (bi); +return PTR_ERR (bi->em); + } +btrfs_em_to_iomap (inode, bi->em, srcmap, + pos - sector_offset); + } + } + +if ((srcmap->type !=IOMAP_HOLE ) && + (end > srcmap->offset + srcmap->length)) + write_bytes = srcmap->offset + srcmap->length - pos; + + ret =btrfs_check_data_free_space (BTRFS_I (inode), &bi->data_reserved, pos, write_bytes);if (ret <0 ) {
Signature · 1 line
2.31.1
RFC PATCH 27/31 btrfs: Rename end_bio_extent_readpage to btrfs_readpage_endio
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Also, declare it in extent_io.h so it may be used by bio submission function.
--- fs/btrfs/extent_io.c | 12 ++++++------ fs/btrfs/extent_io.h | 1 + 2 files changed, 7 insertions(+), 6 deletions(-)
fs/btrfs/extent_io.c +6 -6
@@ -2970,7 +2970,7 @@ static void begin_page_read(struct btrfs_fs_info *fs_info, struct page *page)/* * Find extent buffer for a givne bytenr. * -* This is for end_bio_extent_readpage(), thus we can't do any unsafe locking +* This is for btrfs_readpage_endio(), thus we can't do any unsafe locking * in endio context. */ static struct extent_buffer *find_extent_buffer_readpage(
@@ -3007,7 +3007,7 @@ static struct extent_buffer *find_extent_buffer_readpage(* Scheduling is not allowed, so the extent state tree is expected * to have one and only one object corresponding to this IO. */ -static void end_bio_extent_readpage (struct bio *bio) +void btrfs_readpage_endio (struct bio *bio) {struct bio_vec *bvec;struct btrfs_io_bio *io_bio =btrfs_io_bio (bio);
@@ -3035,7 +3035,7 @@ static void end_bio_extent_readpage(struct bio *bio)u32 len;btrfs_debug (fs_info, -"end_bio_extent_readpage: bi_sector=%llu, err=%d, mirror=%u" , +"btrfs_readpage_endio: bi_sector=%llu, err=%d, mirror=%u" , bio->bi_iter.bi_sector, bio->bi_status, io_bio->mirror_num); tree = &BTRFS_I (inode)->io_tree;
@@ -3687,7 +3687,7 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached, ret =submit_extent_page (REQ_OP_READ | read_flags,NULL , bio_ctrl, page, disk_bytenr, iosize, pg_offset, - end_bio_extent_readpage,0 , + btrfs_readpage_endio,0 , this_bio_flag, force_bio_submit);if (!ret) {
@@ -6411,7 +6411,7 @@ static int read_extent_buffer_subpage(struct extent_buffer *eb, int wait, ret =submit_extent_page (REQ_OP_READ |REQ_META ,NULL , &bio_ctrl, page, eb->start, eb->len, eb->start -page_offset (page), - end_bio_extent_readpage, mirror_num,0 , + btrfs_readpage_endio, mirror_num,0 , true);if (ret) {/*
@@ -6513,7 +6513,7 @@ int read_extent_buffer_pages(struct extent_buffer *eb, int wait, int mirror_num)ClearPageError (page); err =submit_extent_page (REQ_OP_READ |REQ_META ,NULL , &bio_ctrl, page,page_offset (page), -PAGE_SIZE ,0 , end_bio_extent_readpage, +PAGE_SIZE ,0 , btrfs_readpage_endio, mirror_num,0 , false);if (err) {/*
fs/btrfs/extent_io.h +1 -0
@@ -287,6 +287,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start, unsigned int pg_offset, int mirror_num);void end_extent_writepage (struct page *page,int err,u64 start,u64 end);int btrfs_repair_eb_io_failure (const struct extent_buffer *eb,int mirror_num); +void btrfs_readpage_endio (struct bio *bio);/* * When IO fails, either with EIO or csum verification fails, we
Signature · 1 line
2.31.1
RFC PATCH 28/31 btrfs: iomap_begin() for buffered read
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Lock the extents before performing a read.
Convert the offset/length to iomap by calling btrfs_em_to_iomap(). If reading from a hole, unlock the extent because iomap provides page with zeros set.
Lock only the range on which iomap I/O can be performed. If iomap is lesser than requested range, unlock extents beyond iomap range.
--- fs/btrfs/inode.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+)
fs/btrfs/inode.c +50 -0
@@ -8267,6 +8267,56 @@ static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,return extent_fiemap (BTRFS_I (inode), fieinfo, start, len); } + +static int btrfs_read_iomap_begin (struct inode *inode,loff_t pos, +loff_t length,unsigned int flags,struct iomap *iomap, +struct iomap *srcmap) +{ +struct extent_state *cached_state =NULL ; +struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); +struct extent_map *em; +u64 start =round_down (pos, fs_info->sectorsize); +u64 end =round_up (pos + length, fs_info->sectorsize) -1 ; + +/* Lock the extent */ +btrfs_lock_and_flush_ordered_range (BTRFS_I (inode), + start, end, &cached_state); + + em =btrfs_get_extent (BTRFS_I (inode),NULL ,0 , start, end - start +1 ); +if (IS_ERR (em)) +return PTR_ERR (em); + +btrfs_em_to_iomap (inode, em, iomap, start); + iomap->private = em; + +if (iomap->type ==IOMAP_HOLE ) { +unlock_extent_cached (&BTRFS_I (inode)->io_tree, + start, end, &cached_state); + }else if (end > iomap->offset + iomap->length) { +/* Unlock part beyond iomap */ +unlock_extent_cached (&BTRFS_I (inode)->io_tree, + iomap->offset + iomap->length, + end, &cached_state); + } + +return 0 ; +} + +static int btrfs_read_iomap_end (struct inode *inode,loff_t pos, +loff_t length,ssize_t written,unsigned int flags, +struct iomap *iomap) +{ +struct extent_map *em = iomap->private; + +free_extent_map (em); +return 0 ; +} + +const struct iomap_ops btrfs_buffered_read_iomap_ops = { + .iomap_begin = btrfs_read_iomap_begin, + .iomap_end = btrfs_read_iomap_end, +}; +int btrfs_readpage (struct file *file,struct page *page) {struct btrfs_inode *inode =BTRFS_I (page->mapping->host);
Signature · 1 line
2.31.1
RFC PATCH 29/31 btrfs: Use iomap_readpage_ops to allocate and submit bio
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Set the alloc_io() and submit_io() functions of iomap_readpage_ops While performing readpage, the an btrfs_io_bio is allocated to fill csums and check data csums.
--- fs/btrfs/ctree.h | 1 + fs/btrfs/extent_io.c | 10 ++++++++++ fs/btrfs/extent_io.h | 3 +++ fs/btrfs/inode.c | 9 +++++++-- 4 files changed, 21 insertions(+), 2 deletions(-)
fs/btrfs/ctree.h +1 -0
@@ -3214,6 +3214,7 @@ void btrfs_inode_unlock(struct inode *inode, unsigned int ilock_flags);void btrfs_update_inode_bytes (struct btrfs_inode *inode,const u64 add_bytes,const u64 del_bytes); +void btrfs_buffered_submit_io (struct inode *inode,struct bio *bio);/* ioctl.c */ long btrfs_ioctl (struct file *file,unsigned int cmd,unsigned long arg);
fs/btrfs/extent_io.c +10 -0
@@ -7284,3 +7284,13 @@ void btrfs_readahead_node_child(struct extent_buffer *node, int slot)btrfs_node_ptr_generation (node, slot), btrfs_header_level(node) - 1); } + +static struct bio *btrfs_readpage_alloc_bio (gfp_t gfp_mask,unsigned short nr) +{ +return btrfs_io_bio_alloc (nr); +} + +const struct iomap_readpage_ops btrfs_iomap_readpage_ops = { + .alloc_bio = btrfs_readpage_alloc_bio, + .submit_io = btrfs_buffered_submit_io, +};
fs/btrfs/extent_io.h +3 -0
@@ -7,6 +7,7 @@#include <linux/refcount.h> #include <linux/fiemap.h> #include <linux/btrfs_tree.h> +#include <linux/iomap.h> #include "ulist.h" /*
@@ -313,6 +314,8 @@ int btrfs_repair_one_sector(struct inode *inode, u64 start, int failed_mirror, submit_bio_hook_t *submit_bio_hook); +extern const struct iomap_readpage_ops btrfs_iomap_readpage_ops; +#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS bool find_lock_delalloc_range(struct inode *inode, struct page *locked_page, u64 *start,
fs/btrfs/inode.c +7 -2
@@ -35,6 +35,7 @@#include "misc.h" #include "ctree.h" #include "disk-io.h" +#include "extent_io.h" #include "transaction.h" #include "btrfs_inode.h" #include "print-tree.h"
@@ -8431,7 +8432,7 @@ static void btrfs_writepage_endio(struct bio *bio)iomap_writepage_end_bio (bio); } -static void btrfs_buffered_submit_io (struct inode *inode,struct bio *bio) +void btrfs_buffered_submit_io (struct inode *inode,struct bio *bio) {struct bio_vec *bvec;struct bvec_iter_all iter_all;
@@ -8440,7 +8441,11 @@ static void btrfs_buffered_submit_io(struct inode *inode, struct bio *bio)bio_for_each_segment_all (bvec, bio, iter_all)set_page_extent_mapped (bvec->bv_page); - bio->bi_end_io = btrfs_writepage_endio; +if (bio_op (bio) ==REQ_OP_WRITE ) + bio->bi_end_io = btrfs_writepage_endio; +else + bio->bi_end_io = btrfs_readpage_endio; +if (is_data_inode (inode))btrfs_submit_data_bio (inode, bio,0 ,0 );else
Signature · 1 line
2.31.1
RFC PATCH 30/31 btrfs: Do not call btrfs_io_bio_free_csum() if BTRFS_INODE_NODATASUM is not set
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Q: Not sure why this patch is required. But there are cases when I received a would fail at kfree(io_bio->csum). io_bio->csum_inline would be set to some random value. What would cause this?
--- fs/btrfs/extent_io.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
fs/btrfs/extent_io.c +8 -4
@@ -3013,6 +3013,7 @@ void btrfs_readpage_endio(struct bio *bio)struct btrfs_io_bio *io_bio =btrfs_io_bio (bio);struct extent_io_tree *tree, *failure_tree;struct processed_extent processed = {0 }; +struct inode *inode;/* * The offset to the beginning of a bio, since one bio can never be * larger than UINT_MAX, u32 here is enough.
@@ -3026,14 +3027,16 @@ void btrfs_readpage_endio(struct bio *bio)bio_for_each_segment_all (bvec, bio, iter_all) {bool uptodate = !bio->bi_status;struct page *page = bvec->bv_page; -struct inode *inode = page->mapping->host; -struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb); -const u32 sectorsize = fs_info->sectorsize; +struct btrfs_fs_info *fs_info; +u32 sectorsize;unsigned int error_bitmap = (unsigned int )-1 ;u64 start;u64 end;u32 len; + inode = page->mapping->host; + fs_info =btrfs_sb (inode->i_sb); + sectorsize = fs_info->sectorsize; btrfs_debug(fs_info, "btrfs_readpage_endio: bi_sector=%llu, err=%d, mirror=%u", bio->bi_iter.bi_sector, bio->bi_status,
@@ -3140,7 +3143,8 @@ void btrfs_readpage_endio(struct bio *bio) }/* Release the last extent */ endio_readpage_release_extent (&processed,NULL ,0 ,0 , false); -btrfs_io_bio_free_csum (io_bio); +if (!(BTRFS_I (inode)->flags &BTRFS_INODE_NODATASUM )) +btrfs_io_bio_free_csum (io_bio);bio_put (bio); }
Signature · 1 line
2.31.1
RFC PATCH 31/31 btrfs: Switch to iomap_readpage() and iomap_readahead()
In reply to Goldwyn RodriguesFrom: Goldwyn Rodrigues <[email protected]>
Use iomap readpage and readahead sequences.
--- fs/btrfs/inode.c | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-)
fs/btrfs/inode.c +4 -13
@@ -8320,18 +8320,8 @@ const struct iomap_ops btrfs_buffered_read_iomap_ops = {int btrfs_readpage (struct file *file,struct page *page) { -struct btrfs_inode *inode =BTRFS_I (page->mapping->host); -u64 start =page_offset (page); -u64 end = start +PAGE_SIZE -1 ; -struct btrfs_bio_ctrl bio_ctrl = {0 }; -int ret; - -btrfs_lock_and_flush_ordered_range (inode, start, end,NULL ); - - ret =btrfs_do_readpage (page,NULL , &bio_ctrl,0 ,NULL ); -if (bio_ctrl.bio) - ret =submit_one_bio (bio_ctrl.bio,0 , bio_ctrl.bio_flags); -return ret; +return iomap_readpage (page, &btrfs_buffered_read_iomap_ops, + &btrfs_iomap_readpage_ops); }static int find_delalloc_range (struct inode *inode,u64 *start,u64 *end)
@@ -8492,7 +8482,8 @@ static int btrfs_writepages(struct address_space *mapping,static void btrfs_readahead (struct readahead_control *rac) { -extent_readahead (rac); +iomap_readahead (rac, &btrfs_buffered_read_iomap_ops, + &btrfs_iomap_readpage_ops); }static int __btrfs_releasepage (struct page *page,gfp_t gfp_flags)
Signature · 1 line
2.31.1