bcachefs: fiemap delalloc support and cleanup
v2 cover bcachefs: fiemap delalloc support and cleanup
Hi all,
Here's v2 of the fiemap delalloc processing patch. The main feedback to v1 was around the organization of the code, so this tries to clean that up a bit. Otherwise the functionality/behavior is intended to be pretty much the same as v1. The main difference is that bch2_fiemap() is broken down into helpers to clarify between when it's processing extents vs. holes, and to generally separate extent key processing from the high level scan.
The series is currently posted to my CI branch. I don't _think_ there are any immediate regressions after having a look through the failures on the head commit (as well as via my own local testing), but ISTM that the variance/failure count on the baseline branches has increased a bit from where we were at a few weeks or so ago...
Brian
v2:
- Clean up bch2_fiemap() a bit to use processing helpers.
- Added patch for sync flag fixup.
v1: https://lore.kernel.org/linux-bcachefs/[email protected]/
Brian Foster (4):
bcachefs: drop duplicate fiemap sync flag
bcachefs: track current fiemap offset in start variable
bcachefs: refactor fiemap processing into extent helper and struct
bcachefs: add fiemap delalloc extent detection
fs/bcachefs/fs.c | 156 ++++++++++++++++++++++++++++++++++------------- 1 file changed, 113 insertions(+), 43 deletions(-)
Signature · 1 line
2.42.0
PATCH v2 1/4 bcachefs: drop duplicate fiemap sync flag
FIEMAP_FLAG_SYNC handling was deliberately moved into core code in commit 45dd052e67ad ("fs: handle FIEMAP_FLAG_SYNC in fiemap_prep"), released in kernel v5.8. Update bcachefs accordingly.
--- fs/bcachefs/fs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/bcachefs/fs.c +1 -1
@@ -897,7 +897,7 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,u32 snapshot;int ret =0 ; - ret =fiemap_prep (&ei->v, info, start, &len,FIEMAP_FLAG_SYNC ); + ret =fiemap_prep (&ei->v, info, start, &len,0 );if (ret)return ret;
Signature · 1 line
2.42.0
PATCH v2 2/4 bcachefs: track current fiemap offset in start variable
In reply to Brian Foster--- fs/bcachefs/fs.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/bcachefs/fs.c +2 -2
@@ -945,6 +945,7 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,bch2_bkey_buf_realloc (&prev, c, k.k->u64s); sectors =min (sectors, k.k->size - offset_into_extent); + start = iter.pos.offset + sectors; bch2_cut_front(POS(k.k->p.inode, bkey_start_offset(k.k) +
@@ -965,8 +966,7 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,bkey_copy (prev.k, cur.k); have_extent = true; -bch2_btree_iter_set_pos (&iter, -POS (iter.pos.inode, iter.pos.offset + sectors)); +bch2_btree_iter_set_pos (&iter,POS (iter.pos.inode, start)); } start = iter.pos.offset;bch2_trans_iter_exit (trans, &iter);
Signature · 1 line
2.42.0
PATCH v2 3/4 bcachefs: refactor fiemap processing into extent helper and struct
In reply to Brian FosterThe bulk of the loop in bch2_fiemap() involves processing the current extent key from the iter, including following indirections and trimming the extent size and such. This patch makes a few changes to reduce the size of the loop and facilitate future changes to support delalloc extents.
Define a new bch_fiemap_extent structure to wrap the bkey buffer that holds the extent key to report to userspace along with associated fiemap flags. Update bch2_fill_extent() to take the bch_fiemap_extent as a param instead of the individual fields. Finally, lift the bulk of the extent processing into a bch2_fiemap_extent() helper that takes the current key and formats the bch_fiemap_extent appropriately for the fill function.
No functional changes intended by this patch.
--- fs/bcachefs/fs.c | 90 +++++++++++++++++++++++++++++------------------- 1 file changed, 55 insertions(+), 35 deletions(-)
fs/bcachefs/fs.c +55 -35
@@ -826,10 +826,18 @@ static int bch2_tmpfile(struct mnt_idmap *idmap,return finish_open_simple (file,0 ); } +struct bch_fiemap_extent { +struct bkey_buf kbuf; +unsigned flags; +}; +static int bch2_fill_extent (struct bch_fs *c,struct fiemap_extent_info *info, -struct bkey_s_c k,unsigned flags) +struct bch_fiemap_extent *fe) { +struct bkey_s_c k =bkey_i_to_s_c (fe->kbuf.k); +unsigned flags = fe->flags; +if (bkey_extent_is_direct_data (k.k)) {struct bkey_ptrs_c ptrs =bch2_bkey_ptrs_c (k);const union bch_extent_entry *entry;
@@ -882,6 +890,39 @@ static int bch2_fill_extent(struct bch_fs *c, } } +static int bch2_fiemap_extent (struct btree_trans *trans, +struct btree_iter *iter,struct bkey_s_c k, +struct bch_fiemap_extent *cur) +{ +unsigned offset_into_extent, sectors; +enum btree_id data_btree = BTREE_ID_extents; +int ret; + + offset_into_extent = iter->pos.offset -bkey_start_offset (k.k); + sectors = k.k->size - offset_into_extent; + +bch2_bkey_buf_reassemble (&cur->kbuf, trans->c, k); + + ret =bch2_read_indirect_extent (trans, &data_btree, &offset_into_extent, + &cur->kbuf); +if (ret) +return ret; + + k =bkey_i_to_s_c (cur->kbuf.k); + sectors =min (sectors, k.k->size - offset_into_extent); + +bch2_cut_front (POS (k.k->p.inode, +bkey_start_offset (k.k) + offset_into_extent), + cur->kbuf.k); +bch2_key_resize (&cur->kbuf.k->k, sectors); + cur->kbuf.k->k.p = iter->pos; + cur->kbuf.k->k.p.offset += cur->kbuf.k->k.size; + + cur->flags =0 ; + +return 0 ; +} +static int bch2_fiemap (struct inode *vinode,struct fiemap_extent_info *info,u64 start,u64 len) {
@@ -890,9 +931,8 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,struct btree_trans *trans;struct btree_iter iter;struct bkey_s_c k; -struct bkey_buf cur, prev; +struct bch_fiemap_extent cur, prev;struct bpos end =POS (ei->v.i_ino, (start + len) >>9 ); -unsigned offset_into_extent, sectors;bool have_extent = false;u32 snapshot;int ret =0 ;
@@ -906,8 +946,8 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info, start >>=9 ; -bch2_bkey_buf_init (&cur); -bch2_bkey_buf_init (&prev); +bch2_bkey_buf_init (&cur.kbuf); +bch2_bkey_buf_init (&prev.kbuf); trans =bch2_trans_get (c); retry:bch2_trans_begin (trans);
@@ -922,7 +962,6 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,while (!(ret =btree_trans_too_many_iters (trans)) && (k =bch2_btree_iter_peek_upto (&iter, end)).k && !(ret =bkey_err (k))) { -enum btree_id data_btree = BTREE_ID_extents;if (!bkey_extent_is_data (k.k) && k.k->type != KEY_TYPE_reservation) {
@@ -930,40 +969,21 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,continue ; } - offset_into_extent = iter.pos.offset - -bkey_start_offset (k.k); - sectors = k.k->size - offset_into_extent; - -bch2_bkey_buf_reassemble (&cur, c, k); - - ret =bch2_read_indirect_extent (trans, &data_btree, - &offset_into_extent, &cur); + ret =bch2_fiemap_extent (trans, &iter, k, &cur);if (ret)break ; - - k =bkey_i_to_s_c (cur.k); -bch2_bkey_buf_realloc (&prev, c, k.k->u64s); - - sectors =min (sectors, k.k->size - offset_into_extent); - start = iter.pos.offset + sectors; - -bch2_cut_front (POS (k.k->p.inode, -bkey_start_offset (k.k) + - offset_into_extent), - cur.k); -bch2_key_resize (&cur.k->k, sectors); - cur.k->k.p = iter.pos; - cur.k->k.p.offset += cur.k->k.size; +bch2_bkey_buf_realloc (&prev.kbuf, c, cur.kbuf.k->k.u64s); + start = cur.kbuf.k->k.p.offset;if (have_extent) {bch2_trans_unlock (trans); - ret =bch2_fill_extent (c, info, -bkey_i_to_s_c (prev.k),0 ); + ret =bch2_fill_extent (c, info, &prev);if (ret)break ; } -bkey_copy (prev.k, cur.k); +bkey_copy (prev.kbuf.k, cur.kbuf.k); + prev.flags = cur.flags; have_extent = true;bch2_btree_iter_set_pos (&iter,POS (iter.pos.inode, start));
@@ -976,13 +996,13 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,if (!ret && have_extent) {bch2_trans_unlock (trans); - ret =bch2_fill_extent (c, info,bkey_i_to_s_c (prev.k), -FIEMAP_EXTENT_LAST ); + prev.flags |=FIEMAP_EXTENT_LAST ; + ret =bch2_fill_extent (c, info, &prev); }bch2_trans_put (trans); -bch2_bkey_buf_exit (&cur, c); -bch2_bkey_buf_exit (&prev, c); +bch2_bkey_buf_exit (&cur.kbuf, c); +bch2_bkey_buf_exit (&prev.kbuf, c);return ret <0 ? ret :0 ; }
Signature · 1 line
2.42.0
PATCH v2 4/4 bcachefs: add fiemap delalloc extent detection
In reply to Brian Fosterbcachefs currently populates fiemap data from the extents btree. This works correctly when the fiemap sync flag is provided, but if not, it skips all delalloc extents that have not yet been flushed. This is because delalloc extents from buffered writes are first stored as reservation in the pagecache, and only become resident in the extents btree after writeback completes.
Update the fiemap implementation to process holes between extents by scanning pagecache for data, via seek data/hole. If a valid data range is found over a hole in the extent btree, fake up an extent key and flag the extent as delalloc for reporting to userspace.
Note that this does not necessarily change behavior for the case where there is dirty pagecache over already written extents, where when in COW mode, writeback will allocate new blocks for the underlying ranges. The existing behavior is consistent with btrfs and it is recommended to use the sync flag for the most up to date extent state from fiemap.
--- fs/bcachefs/fs.c | 64 ++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 57 insertions(+), 7 deletions(-)
fs/bcachefs/fs.c +57 -7
@@ -923,6 +923,41 @@ static int bch2_fiemap_extent(struct btree_trans *trans,return 0 ; } +/* +* Scan a range of pagecache that corresponds to a file mapping hole in the +* extent btree. If found, fake up an extent key so it looks like a delalloc +* extent to the rest of the fiemap processing code. +*/ +static bool +bch2_fiemap_hole (struct inode *vinode,u64 start,u64 end, +struct bch_fiemap_extent *cur) +{ +struct bch_fs *c = vinode->i_sb->s_fs_info; +struct bch_inode_info *ei =to_bch_ei (vinode); +struct bkey_i_extent *delextent; +struct bch_extent_ptr ptr = {}; + + start =bch2_seek_pagecache_data (vinode, start, end,0 , false); +if (start >= end) +return false; + end =bch2_seek_pagecache_hole (vinode, start, end,0 , false); + +/* +* Create a fake extent key in the buffer. We have to add a dummy extent +* pointer for the fill code to add an extent entry. It's explicitly +* zeroed to reflect delayed allocation (i.e. phys offset 0). +*/ +bch2_bkey_buf_realloc (&cur->kbuf, c,sizeof (*delextent) /sizeof (u64)); + delextent =bkey_extent_init (cur->kbuf.k); + delextent->k.p =POS (ei->v.i_ino, start >>9 ); +bch2_key_resize (&delextent->k, (end - start) >>9 ); +bch2_bkey_append_ptr (&delextent->k_i, ptr); + + cur->flags =FIEMAP_EXTENT_DELALLOC ; + +return true; +} +static int bch2_fiemap (struct inode *vinode,struct fiemap_extent_info *info,u64 start,u64 len) {
@@ -962,16 +997,31 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,while (!(ret =btree_trans_too_many_iters (trans)) && (k =bch2_btree_iter_peek_upto (&iter, end)).k && !(ret =bkey_err (k))) { +/* +* If a hole exists before the start of the next key, scan that +* range in pagecache for delalloc data that might be pending +* writeback and report it as delalloc. Otherwise, process the +* key. +*/ +if (iter.pos.offset <= start || + !bch2_fiemap_hole (vinode, start <<9 , iter.pos.offset <<9 , + &cur)) { +if (!bkey_extent_is_data (k.k) && + k.k->type != KEY_TYPE_reservation) { + start =bkey_start_offset (k.k) + k.k->size; +bch2_btree_iter_advance (&iter); +continue ; + } -if (!bkey_extent_is_data (k.k) && - k.k->type != KEY_TYPE_reservation) { -bch2_btree_iter_advance (&iter); -continue ; + ret =bch2_fiemap_extent (trans, &iter, k, &cur); +if (ret) +break ; } - ret =bch2_fiemap_extent (trans, &iter, k, &cur); -if (ret) -break ; +/* +* Store the current extent in prev so we can flag the last +* extent on the way out. +*/ bch2_bkey_buf_realloc (&prev.kbuf, c, cur.kbuf.k->k.u64s); start = cur.kbuf.k->k.p.offset;
Signature · 1 line
2.42.0