don't create inline extents in fallback_to_cow
Hi all,
this is a little thing I found during code inspection, let me know if the fix makes sense or if there is some other good way to avoid dropping the page_started flag on the floor here.
Diffstat:
inode.c | 83 ++++++++++++++++++++++++++++++++-------------------------------- 1 file changed, 42 insertions(+), 41 deletions(-)
PATCH 1/2 btrfs: pass a flags argument to cow_file_range
The int used as bool unlock is not a very good way to describe the behavior, and the next patch will have to add another beahvior modifier. Switch to pass a flag instead, with an inital CFR_KEEP_LOCKED flag that specifies the pages should always be kept locked. This is the inverse of the old unlock argument for the reason that it requires a flag for the exceptional behavior.
--- fs/btrfs/inode.c | 51 ++++++++++++++++++++++-------------------------- 1 file changed, 23 insertions(+), 28 deletions(-)
fs/btrfs/inode.c +23 -28
@@ -124,11 +124,13 @@ static struct kmem_cache *btrfs_inode_cachep;static int btrfs_setsize (struct inode *inode,struct iattr *attr);static int btrfs_truncate (struct btrfs_inode *inode,bool skip_writeback); + +#define CFR_KEEP_LOCKED (1 << 0) static noinline int cow_file_range(struct btrfs_inode *inode,struct page *locked_page,u64 start,u64 end,int *page_started, -unsigned long *nr_written,int unlock, -u64 *done_offset); +unsigned long *nr_written,u64 *done_offset, +u32 flags); static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start, u64 len, u64 orig_start, u64 block_start, u64 block_len, u64 orig_block_len,
@@ -1148,7 +1150,7 @@ static int submit_uncompressed_range(struct btrfs_inode *inode,* can directly submit them without interruption. */ ret =cow_file_range (inode, locked_page, start, end, &page_started, - &nr_written,0 ,NULL ); + &nr_written,NULL ,CFR_KEEP_LOCKED );/* Inline extent inserted, page gets unlocked and everything is done */ if (page_started)return 0 ;
@@ -1362,25 +1364,18 @@ static u64 get_extent_allocation_hint(struct btrfs_inode *inode, u64 start,* locked_page is the page that writepage had locked already. We use * it to make sure we don't do extra locks or unlocks. * -* *page_started is set to one if we unlock locked_page and do everything -* required to start IO on it. It may be clean and already done with -* IO when we return. -* -* When unlock == 1, we unlock the pages in successfully allocated regions. -* When unlock == 0, we leave them locked for writing them out. +* When this function fails, it unlocks all pages except @locked_page. * -* However, we unlock all the pages except @locked_page in case of failure. +* When this function successfully creates an inline extent, it sets page_started +* to 1 and unlocks all pages including locked_page and starts I/O on them. +* (In reality inline extents are limited to a single page, so locked_page is +* the only page handled anyway). * -* In summary, page locking state will be as follow: +* When this function succeed and creates a normal extent, the page locking +* status depends on the passed in flags: * -* - page_started == 1 (return value) -* - All the pages are unlocked. IO is started. -* - Note that this can happen only on success -* - unlock == 1 -* - All the pages except @locked_page are unlocked in any case -* - unlock == 0 -* - On success, all the pages are locked for writing out them -* - On failure, all the pages except @locked_page are unlocked +* - If CFR_KEEP_LOCKED is set, all pages are kept locked. +* - Else all pages except for @locked_page are unlocked. * * When a failure happens in the second or later iteration of the * while-loop, the ordered extents created in previous iterations are kept
@@ -1391,8 +1386,8 @@ static u64 get_extent_allocation_hint(struct btrfs_inode *inode, u64 start, static noinline int cow_file_range(struct btrfs_inode *inode,struct page *locked_page,u64 start,u64 end,int *page_started, -unsigned long *nr_written,int unlock, -u64 *done_offset) +unsigned long *nr_written,u64 *done_offset, +u32 flags) {struct btrfs_root *root = inode->root;struct btrfs_fs_info *fs_info = root->fs_info;
@@ -1558,7 +1553,7 @@ static noinline int cow_file_range(struct btrfs_inode *inode,* Do set the Ordered (Private2) bit so we know this page was * properly setup for writepage. */ - page_ops = unlock ?PAGE_UNLOCK :0 ; + page_ops = (flags &CFR_KEEP_LOCKED ) ?0 :PAGE_UNLOCK ; page_ops |=PAGE_SET_ORDERED ; extent_clear_unlock_delalloc(inode, start, start + ram_size - 1,
@@ -1627,10 +1622,10 @@ static noinline int cow_file_range(struct btrfs_inode *inode,* EXTENT_DEFRAG | EXTENT_CLEAR_META_RESV are handled by the cleanup * function. * -* However, in case of unlock == 0, we still need to unlock the pages -* (except @locked_page) to ensure all the pages are unlocked. +* However, in case of CFR_KEEP_LOCKED, we still need to unlock the +* pages (except @locked_page) to ensure all the pages are unlocked. */ -if (!unlock && orig_start < start) { +if ((flags &CFR_KEEP_LOCKED ) && orig_start < start) {if (!locked_page)mapping_set_error (inode->vfs_inode.i_mapping, ret); extent_clear_unlock_delalloc(inode, orig_start, start - 1,
@@ -1836,7 +1831,7 @@ static noinline int run_delalloc_zoned(struct btrfs_inode *inode,while (start <= end) { ret =cow_file_range (inode, locked_page, start, end, page_started, - nr_written,0 , &done_offset); + nr_written, &done_offset,CFR_KEEP_LOCKED );if (ret && ret != -EAGAIN )return ret;
@@ -1956,7 +1951,7 @@ static int fallback_to_cow(struct btrfs_inode *inode, struct page *locked_page, }return cow_file_range (inode, locked_page, start, end, page_started, - nr_written,1 ,NULL ); + nr_written,NULL ,0 ); }struct can_nocow_file_extent_args {
@@ -2433,7 +2428,7 @@ int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct page *locked_page page_started, nr_written, wbc); else ret =cow_file_range (inode, locked_page, start, end, - page_started, nr_written,1 ,NULL ); + page_started, nr_written,NULL ,0 ); out:ASSERT (ret <=0 );
Signature · 1 line
2.39.2
PATCH 2/2 btrfs: don't create inline extents in fallback_to_cow
In reply to Christoph HellwigFor nodatacow files, run_delalloc_nocow can still fall back to COW allocations when required and calls to fallback_to_cow helper for that. For such an allocation we can have multiple ordered_extents for existing extents that NOCOW overwrites and new allocations that fallback_to_cow creates. If one of the new extents is an inline extent, the writepages could would have to avoid normal page writeback for them as indicated by the page_started return argument, whichrun_delalloc_nocow can't return. Fix this by never creating inline
extents from fallback_to_cow.
--- fs/btrfs/inode.c | 34 ++++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 14 deletions(-)
fs/btrfs/inode.c +20 -14
@@ -126,6 +126,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr);static int btrfs_truncate (struct btrfs_inode *inode,bool skip_writeback);#define CFR_KEEP_LOCKED (1 << 0) +#define CFR_NOINLINE (1 << 1) static noinline int cow_file_range(struct btrfs_inode *inode, struct page *locked_page, u64 start, u64 end, int *page_started,
@@ -1426,7 +1427,8 @@ static noinline int cow_file_range(struct btrfs_inode *inode,* This means we can trigger inline extent even if we didn't want to. * So here we skip inline extent creation completely. */ -if (start ==0 && fs_info->sectorsize ==PAGE_SIZE ) { +if (start ==0 && fs_info->sectorsize ==PAGE_SIZE && + !(flags &CFR_NOINLINE )) {u64 actual_end =min_t (u64,i_size_read (&inode->vfs_inode), end +1 );
@@ -1889,15 +1891,17 @@ static noinline int csum_exist_in_range(struct btrfs_fs_info *fs_info, }static int fallback_to_cow (struct btrfs_inode *inode,struct page *locked_page, -const u64 start,const u64 end, -int *page_started,unsigned long *nr_written) +const u64 start,const u64 end) {const bool is_space_ino =btrfs_is_free_space_inode (inode);const bool is_reloc_ino =btrfs_is_data_reloc_root (inode->root);const u64 range_bytes = end +1 - start;struct extent_io_tree *io_tree = &inode->io_tree; +int page_started =0 ; +unsigned long nr_written;u64 range_start = start;u64 count; +int ret;/* * If EXTENT_NORESERVE is set it means that when the buffered write was
@@ -1950,8 +1954,15 @@ static int fallback_to_cow(struct btrfs_inode *inode, struct page *locked_page, NULL); } -return cow_file_range (inode, locked_page, start, end, page_started, - nr_written,NULL ,0 ); +/* +* Don't try to create inline extents, as a mix of inline extent that +* is written out and unlocked directly and a normal nocow extent +* doesn't work. +*/ + ret =cow_file_range (inode, locked_page, start, end, &page_started, + &nr_written,NULL ,CFR_NOINLINE ); +ASSERT (!page_started); +return ret; }struct can_nocow_file_extent_args {
@@ -2100,9 +2111,7 @@ static int can_nocow_file_extent(struct btrfs_path *path,*/ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,struct page *locked_page, -const u64 start,const u64 end, -int *page_started, -unsigned long *nr_written) +const u64 start,const u64 end) {struct btrfs_fs_info *fs_info = inode->root->fs_info;struct btrfs_root *root = inode->root;
@@ -2270,8 +2279,7 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,*/ if (cow_start != (u64)-1 ) { ret =fallback_to_cow (inode, locked_page, - cow_start, found_key.offset -1 , - page_started, nr_written); + cow_start, found_key.offset -1 );if (ret) goto error; cow_start = (u64)-1 ;
@@ -2352,8 +2360,7 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,if (cow_start != (u64)-1 ) { cur_offset = end; - ret =fallback_to_cow (inode, locked_page, cow_start, end, - page_started, nr_written); + ret =fallback_to_cow (inode, locked_page, cow_start, end);if (ret) goto error; }
@@ -2412,8 +2419,7 @@ int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct page *locked_page* preallocated inodes. */ ASSERT (!zoned ||btrfs_is_data_reloc_root (inode->root)); - ret =run_delalloc_nocow (inode, locked_page, start, end, - page_started, nr_written); + ret =run_delalloc_nocow (inode, locked_page, start, end); goto out; }
Signature · 1 line
2.39.2