| Message ID | 20181206065903.11343-8-wqu@suse.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | btrfs: Refactor delayed ref parameter list | expand |
On 6.12.18 г. 8:59 ч., Qu Wenruo wrote: > Now we don't need to play the dirty game of reusing @owner for tree block > level. > > Signed-off-by: Qu Wenruo <wqu@suse.com> > --- > fs/btrfs/ctree.h | 6 ++--- > fs/btrfs/extent-tree.c | 58 ++++++++++++++++++++++-------------------- > fs/btrfs/file.c | 20 ++++++++++----- > fs/btrfs/inode.c | 10 +++++--- > fs/btrfs/ioctl.c | 17 ++++++++----- > fs/btrfs/relocation.c | 44 ++++++++++++++++++++------------ > fs/btrfs/tree-log.c | 12 ++++++--- > 7 files changed, 100 insertions(+), 67 deletions(-) > > diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h > index 6f4b1e605736..db3df5ce6087 100644 > --- a/fs/btrfs/ctree.h > +++ b/fs/btrfs/ctree.h > @@ -40,6 +40,7 @@ extern struct kmem_cache *btrfs_bit_radix_cachep; > extern struct kmem_cache *btrfs_path_cachep; > extern struct kmem_cache *btrfs_free_space_cachep; > struct btrfs_ordered_sum; > +struct btrfs_ref; > > #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */ > > @@ -2682,10 +2683,7 @@ int btrfs_free_and_pin_reserved_extent(struct btrfs_fs_info *fs_info, > void btrfs_prepare_extent_commit(struct btrfs_fs_info *fs_info); > int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans); > int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, > - struct btrfs_root *root, > - u64 bytenr, u64 num_bytes, u64 parent, > - u64 root_objectid, u64 owner, u64 offset, > - bool for_reloc); > + struct btrfs_ref *generic_ref); > > int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans); > int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, > diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c > index 70c05ca30d9a..ff60091aef6b 100644 > --- a/fs/btrfs/extent-tree.c > +++ b/fs/btrfs/extent-tree.c > @@ -2026,36 +2026,28 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr, > > /* Can return -ENOMEM */ > int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, > - struct btrfs_root *root, > - u64 bytenr, u64 num_bytes, u64 parent, > - u64 root_objectid, u64 owner, u64 offset, > - bool for_reloc) > + struct btrfs_ref *generic_ref) > { > - struct btrfs_fs_info *fs_info = root->fs_info; > - struct btrfs_ref generic_ref = { 0 }; > + struct btrfs_fs_info *fs_info = trans->fs_info; > int old_ref_mod, new_ref_mod; > int ret; > > - BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID && > - root_objectid == BTRFS_TREE_LOG_OBJECTID); > + BUG_ON(generic_ref->type == BTRFS_REF_NOT_SET || > + !generic_ref->action); Ouch, we should be removing BUG_ONs and not introducing new ones. Make it an assert > + BUG_ON(generic_ref->type == BTRFS_REF_METADATA && > + generic_ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID); Ideally this should also be converted to an assert. I guess it could only happen if the filesystem is corrupted so perhaps is redundant now? > > - btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_REF, bytenr, > - num_bytes, root->root_key.objectid, parent); > - generic_ref.skip_qgroup = for_reloc; > - if (owner < BTRFS_FIRST_FREE_OBJECTID) { > - btrfs_init_tree_ref(&generic_ref, (int)owner, root_objectid); > - ret = btrfs_add_delayed_tree_ref(trans, &generic_ref, > + if (generic_ref->type == BTRFS_REF_METADATA) > + ret = btrfs_add_delayed_tree_ref(trans, generic_ref, > NULL, &old_ref_mod, &new_ref_mod); > - } else { > - btrfs_init_data_ref(&generic_ref, root_objectid, owner, offset); > - ret = btrfs_add_delayed_data_ref(trans, &generic_ref, 0, > + else > + ret = btrfs_add_delayed_data_ref(trans, generic_ref, 0, > &old_ref_mod, &new_ref_mod); > - } > > - btrfs_ref_tree_mod(fs_info, &generic_ref); > + btrfs_ref_tree_mod(fs_info, generic_ref); > > if (ret == 0 && old_ref_mod < 0 && new_ref_mod >= 0) > - add_pinned_bytes(fs_info, &generic_ref); > + add_pinned_bytes(fs_info, generic_ref); > > return ret; > } <snip>
On Mon, Dec 10, 2018 at 11:52:25AM +0200, Nikolay Borisov wrote: > On 6.12.18 г. 8:59 ч., Qu Wenruo wrote: > > Now we don't need to play the dirty game of reusing @owner for tree block > > level. > > > > Signed-off-by: Qu Wenruo <wqu@suse.com> > > --- > > fs/btrfs/ctree.h | 6 ++--- > > fs/btrfs/extent-tree.c | 58 ++++++++++++++++++++++-------------------- > > fs/btrfs/file.c | 20 ++++++++++----- > > fs/btrfs/inode.c | 10 +++++--- > > fs/btrfs/ioctl.c | 17 ++++++++----- > > fs/btrfs/relocation.c | 44 ++++++++++++++++++++------------ > > fs/btrfs/tree-log.c | 12 ++++++--- > > 7 files changed, 100 insertions(+), 67 deletions(-) > > > > diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h > > index 6f4b1e605736..db3df5ce6087 100644 > > --- a/fs/btrfs/ctree.h > > +++ b/fs/btrfs/ctree.h > > @@ -40,6 +40,7 @@ extern struct kmem_cache *btrfs_bit_radix_cachep; > > extern struct kmem_cache *btrfs_path_cachep; > > extern struct kmem_cache *btrfs_free_space_cachep; > > struct btrfs_ordered_sum; > > +struct btrfs_ref; > > > > #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */ > > > > @@ -2682,10 +2683,7 @@ int btrfs_free_and_pin_reserved_extent(struct btrfs_fs_info *fs_info, > > void btrfs_prepare_extent_commit(struct btrfs_fs_info *fs_info); > > int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans); > > int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, > > - struct btrfs_root *root, > > - u64 bytenr, u64 num_bytes, u64 parent, > > - u64 root_objectid, u64 owner, u64 offset, > > - bool for_reloc); > > + struct btrfs_ref *generic_ref); > > > > int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans); > > int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, > > diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c > > index 70c05ca30d9a..ff60091aef6b 100644 > > --- a/fs/btrfs/extent-tree.c > > +++ b/fs/btrfs/extent-tree.c > > @@ -2026,36 +2026,28 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr, > > > > /* Can return -ENOMEM */ > > int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, > > - struct btrfs_root *root, > > - u64 bytenr, u64 num_bytes, u64 parent, > > - u64 root_objectid, u64 owner, u64 offset, > > - bool for_reloc) > > + struct btrfs_ref *generic_ref) > > { > > - struct btrfs_fs_info *fs_info = root->fs_info; > > - struct btrfs_ref generic_ref = { 0 }; > > + struct btrfs_fs_info *fs_info = trans->fs_info; > > int old_ref_mod, new_ref_mod; > > int ret; > > > > - BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID && > > - root_objectid == BTRFS_TREE_LOG_OBJECTID); > > + BUG_ON(generic_ref->type == BTRFS_REF_NOT_SET || > > + !generic_ref->action); > > Ouch, we should be removing BUG_ONs and not introducing new ones. Make > it an assert > > > + BUG_ON(generic_ref->type == BTRFS_REF_METADATA && > > + generic_ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID); > > Ideally this should also be converted to an assert. I guess it could > only happen if the filesystem is corrupted so perhaps is redundant now? I think we need more types of assert, not all BUG_ONs can be replaced by ASSERT as behaviour would change depending ond CONFIG_BTRFS_ASSERTS. IMO the asserts are best suited for development-time checks and cannot replace runtime-checks where the BUG_ON is a big hammer to stop execution otherwise it would cause worse things later. This was mentioned in the past a few times, what we really don't want are new BUG_ONs instead of proper error handling. The rest would be nice to annotate by comments why it's there and that there's really no other way around that. I don't recall all the ideas so am not saying either way for the asserts or bugons. Both would be ok here and full audit of BUG_ONs is one of my long-term projects so it would get sorted eventually.
On 2018/12/11 上午1:28, David Sterba wrote: > On Mon, Dec 10, 2018 at 11:52:25AM +0200, Nikolay Borisov wrote: >> On 6.12.18 г. 8:59 ч., Qu Wenruo wrote: >>> Now we don't need to play the dirty game of reusing @owner for tree block >>> level. >>> >>> Signed-off-by: Qu Wenruo <wqu@suse.com> >>> --- >>> fs/btrfs/ctree.h | 6 ++--- >>> fs/btrfs/extent-tree.c | 58 ++++++++++++++++++++++-------------------- >>> fs/btrfs/file.c | 20 ++++++++++----- >>> fs/btrfs/inode.c | 10 +++++--- >>> fs/btrfs/ioctl.c | 17 ++++++++----- >>> fs/btrfs/relocation.c | 44 ++++++++++++++++++++------------ >>> fs/btrfs/tree-log.c | 12 ++++++--- >>> 7 files changed, 100 insertions(+), 67 deletions(-) >>> >>> diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h >>> index 6f4b1e605736..db3df5ce6087 100644 >>> --- a/fs/btrfs/ctree.h >>> +++ b/fs/btrfs/ctree.h >>> @@ -40,6 +40,7 @@ extern struct kmem_cache *btrfs_bit_radix_cachep; >>> extern struct kmem_cache *btrfs_path_cachep; >>> extern struct kmem_cache *btrfs_free_space_cachep; >>> struct btrfs_ordered_sum; >>> +struct btrfs_ref; >>> >>> #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */ >>> >>> @@ -2682,10 +2683,7 @@ int btrfs_free_and_pin_reserved_extent(struct btrfs_fs_info *fs_info, >>> void btrfs_prepare_extent_commit(struct btrfs_fs_info *fs_info); >>> int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans); >>> int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, >>> - struct btrfs_root *root, >>> - u64 bytenr, u64 num_bytes, u64 parent, >>> - u64 root_objectid, u64 owner, u64 offset, >>> - bool for_reloc); >>> + struct btrfs_ref *generic_ref); >>> >>> int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans); >>> int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, >>> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c >>> index 70c05ca30d9a..ff60091aef6b 100644 >>> --- a/fs/btrfs/extent-tree.c >>> +++ b/fs/btrfs/extent-tree.c >>> @@ -2026,36 +2026,28 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr, >>> >>> /* Can return -ENOMEM */ >>> int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, >>> - struct btrfs_root *root, >>> - u64 bytenr, u64 num_bytes, u64 parent, >>> - u64 root_objectid, u64 owner, u64 offset, >>> - bool for_reloc) >>> + struct btrfs_ref *generic_ref) >>> { >>> - struct btrfs_fs_info *fs_info = root->fs_info; >>> - struct btrfs_ref generic_ref = { 0 }; >>> + struct btrfs_fs_info *fs_info = trans->fs_info; >>> int old_ref_mod, new_ref_mod; >>> int ret; >>> >>> - BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID && >>> - root_objectid == BTRFS_TREE_LOG_OBJECTID); >>> + BUG_ON(generic_ref->type == BTRFS_REF_NOT_SET || >>> + !generic_ref->action); >> >> Ouch, we should be removing BUG_ONs and not introducing new ones. Make >> it an assert Oh I forgot this one, it should be ASSERT(). >> >>> + BUG_ON(generic_ref->type == BTRFS_REF_METADATA && >>> + generic_ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID); >> >> Ideally this should also be converted to an assert. I guess it could >> only happen if the filesystem is corrupted so perhaps is redundant now? This is from the original code, just changed to btrfs_ref interface. Unlike previous easy check, this one could happen by careless caller, just one wrong @ref_root could easily lead to this BUG_ON(). > > I think we need more types of assert, not all BUG_ONs can be replaced by > ASSERT as behaviour would change depending ond CONFIG_BTRFS_ASSERTS. IMO > the asserts are best suited for development-time checks and cannot > replace runtime-checks where the BUG_ON is a big hammer to stop > execution otherwise it would cause worse things later. Yep, so I kept the original BUG_ON(). (Although forgot to use ASSERT() for the new check) > > This was mentioned in the past a few times, what we really don't want > are new BUG_ONs instead of proper error handling. The rest would be nice > to annotate by comments why it's there and that there's really no other > way around that. Then I'd go back to my old practice, return EINVAL/EUCLEAN with proper error message. By that way, we won't continue under all case, and with proper error message to info developer to simplify user debug. The only reason for me not to do this practice this time is, I didn't see much adoption except me. So if there is some positive feedback, I'd like to use such practice more. Thanks, Qu > > I don't recall all the ideas so am not saying either way for the asserts > or bugons. Both would be ok here and full audit of BUG_ONs is one of my > long-term projects so it would get sorted eventually. >
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h index 6f4b1e605736..db3df5ce6087 100644 --- a/fs/btrfs/ctree.h +++ b/fs/btrfs/ctree.h @@ -40,6 +40,7 @@ extern struct kmem_cache *btrfs_bit_radix_cachep; extern struct kmem_cache *btrfs_path_cachep; extern struct kmem_cache *btrfs_free_space_cachep; struct btrfs_ordered_sum; +struct btrfs_ref; #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */ @@ -2682,10 +2683,7 @@ int btrfs_free_and_pin_reserved_extent(struct btrfs_fs_info *fs_info, void btrfs_prepare_extent_commit(struct btrfs_fs_info *fs_info); int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans); int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, - struct btrfs_root *root, - u64 bytenr, u64 num_bytes, u64 parent, - u64 root_objectid, u64 owner, u64 offset, - bool for_reloc); + struct btrfs_ref *generic_ref); int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans); int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index 70c05ca30d9a..ff60091aef6b 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c @@ -2026,36 +2026,28 @@ int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr, /* Can return -ENOMEM */ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, - struct btrfs_root *root, - u64 bytenr, u64 num_bytes, u64 parent, - u64 root_objectid, u64 owner, u64 offset, - bool for_reloc) + struct btrfs_ref *generic_ref) { - struct btrfs_fs_info *fs_info = root->fs_info; - struct btrfs_ref generic_ref = { 0 }; + struct btrfs_fs_info *fs_info = trans->fs_info; int old_ref_mod, new_ref_mod; int ret; - BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID && - root_objectid == BTRFS_TREE_LOG_OBJECTID); + BUG_ON(generic_ref->type == BTRFS_REF_NOT_SET || + !generic_ref->action); + BUG_ON(generic_ref->type == BTRFS_REF_METADATA && + generic_ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID); - btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_REF, bytenr, - num_bytes, root->root_key.objectid, parent); - generic_ref.skip_qgroup = for_reloc; - if (owner < BTRFS_FIRST_FREE_OBJECTID) { - btrfs_init_tree_ref(&generic_ref, (int)owner, root_objectid); - ret = btrfs_add_delayed_tree_ref(trans, &generic_ref, + if (generic_ref->type == BTRFS_REF_METADATA) + ret = btrfs_add_delayed_tree_ref(trans, generic_ref, NULL, &old_ref_mod, &new_ref_mod); - } else { - btrfs_init_data_ref(&generic_ref, root_objectid, owner, offset); - ret = btrfs_add_delayed_data_ref(trans, &generic_ref, 0, + else + ret = btrfs_add_delayed_data_ref(trans, generic_ref, 0, &old_ref_mod, &new_ref_mod); - } - btrfs_ref_tree_mod(fs_info, &generic_ref); + btrfs_ref_tree_mod(fs_info, generic_ref); if (ret == 0 && old_ref_mod < 0 && new_ref_mod >= 0) - add_pinned_bytes(fs_info, &generic_ref); + add_pinned_bytes(fs_info, generic_ref); return ret; } @@ -3212,8 +3204,10 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, u32 nritems; struct btrfs_key key; struct btrfs_file_extent_item *fi; + struct btrfs_ref generic_ref = { 0 }; bool for_reloc = btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC); int i; + int action; int level; int ret = 0; @@ -3231,6 +3225,10 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, parent = buf->start; else parent = 0; + if (inc) + action = BTRFS_ADD_DELAYED_REF; + else + action = BTRFS_DROP_DELAYED_REF; for (i = 0; i < nritems; i++) { if (level == 0) { @@ -3248,11 +3246,14 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi); key.offset -= btrfs_file_extent_offset(buf, fi); + btrfs_init_generic_ref(&generic_ref, action, bytenr, + num_bytes, root->root_key.objectid, + parent); + btrfs_init_data_ref(&generic_ref, ref_root, key.objectid, + key.offset); + generic_ref.skip_qgroup = for_reloc; if (inc) - ret = btrfs_inc_extent_ref(trans, root, bytenr, - num_bytes, parent, ref_root, - key.objectid, key.offset, - for_reloc); + ret = btrfs_inc_extent_ref(trans, &generic_ref); else ret = btrfs_free_extent(trans, root, bytenr, num_bytes, parent, ref_root, @@ -3263,10 +3264,13 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, } else { bytenr = btrfs_node_blockptr(buf, i); num_bytes = fs_info->nodesize; + btrfs_init_generic_ref(&generic_ref, action, bytenr, + num_bytes, root->root_key.objectid, + parent); + btrfs_init_tree_ref(&generic_ref, level - 1, ref_root); + generic_ref.skip_qgroup = for_reloc; if (inc) - ret = btrfs_inc_extent_ref(trans, root, bytenr, - num_bytes, parent, ref_root, - level - 1, 0, for_reloc); + ret = btrfs_inc_extent_ref(trans, &generic_ref); else ret = btrfs_free_extent(trans, root, bytenr, num_bytes, parent, ref_root, diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c index 56414c2ebf1d..35c786334972 100644 --- a/fs/btrfs/file.c +++ b/fs/btrfs/file.c @@ -754,6 +754,7 @@ int __btrfs_drop_extents(struct btrfs_trans_handle *trans, struct btrfs_fs_info *fs_info = root->fs_info; struct extent_buffer *leaf; struct btrfs_file_extent_item *fi; + struct btrfs_ref ref = { 0 }; struct btrfs_key key; struct btrfs_key new_key; u64 ino = btrfs_ino(BTRFS_I(inode)); @@ -909,11 +910,15 @@ int __btrfs_drop_extents(struct btrfs_trans_handle *trans, btrfs_mark_buffer_dirty(leaf); if (update_refs && disk_bytenr > 0) { - ret = btrfs_inc_extent_ref(trans, root, - disk_bytenr, num_bytes, 0, + btrfs_init_generic_ref(&ref, + BTRFS_ADD_DELAYED_REF, + disk_bytenr, num_bytes, + root->root_key.objectid, 0); + btrfs_init_data_ref(&ref, root->root_key.objectid, new_key.objectid, - start - extent_offset, false); + start - extent_offset); + ret = btrfs_inc_extent_ref(trans, &ref); BUG_ON(ret); /* -ENOMEM */ } key.offset = start; @@ -1142,6 +1147,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, struct extent_buffer *leaf; struct btrfs_path *path; struct btrfs_file_extent_item *fi; + struct btrfs_ref ref = { 0 }; struct btrfs_key key; struct btrfs_key new_key; u64 bytenr; @@ -1287,9 +1293,11 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, extent_end - split); btrfs_mark_buffer_dirty(leaf); - ret = btrfs_inc_extent_ref(trans, root, bytenr, num_bytes, - 0, root->root_key.objectid, - ino, orig_offset, false); + btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, bytenr, + num_bytes, root->root_key.objectid, 0); + btrfs_init_data_ref(&ref, root->root_key.objectid, ino, + orig_offset); + ret = btrfs_inc_extent_ref(trans, &ref); if (ret) { btrfs_abort_transaction(trans, ret); goto out; diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 539dd3f7f1bd..aa83f68e22ee 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -2540,6 +2540,7 @@ static noinline int relink_extent_backref(struct btrfs_path *path, struct btrfs_file_extent_item *item; struct btrfs_ordered_extent *ordered; struct btrfs_trans_handle *trans; + struct btrfs_ref ref = { 0 }; struct btrfs_root *root; struct btrfs_key key; struct extent_buffer *leaf; @@ -2710,10 +2711,11 @@ static noinline int relink_extent_backref(struct btrfs_path *path, inode_add_bytes(inode, len); btrfs_release_path(path); - ret = btrfs_inc_extent_ref(trans, root, new->bytenr, - new->disk_len, 0, - backref->root_id, backref->inum, - new->file_pos, false); /* start - extent_offset */ + btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, new->bytenr, + new->disk_len, backref->root_id, 0); + btrfs_init_data_ref(&ref, backref->root_id, backref->inum, + new->file_pos); /* start - extent_offset */ + ret = btrfs_inc_extent_ref(trans, &ref); if (ret) { btrfs_abort_transaction(trans, ret); goto out_free_path; diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index ab9e87eb9a4e..d6115b04134f 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c @@ -4083,14 +4083,17 @@ static int btrfs_clone(struct inode *src, struct inode *inode, datal); if (disko) { + struct btrfs_ref ref = { 0 }; inode_add_bytes(inode, datal); - ret = btrfs_inc_extent_ref(trans, - root, - disko, diskl, 0, - root->root_key.objectid, - btrfs_ino(BTRFS_I(inode)), - new_key.offset - datao, - false); + btrfs_init_generic_ref(&ref, + BTRFS_ADD_DELAYED_REF, disko, + diskl, root->root_key.objectid, + 0); + btrfs_init_data_ref(&ref, + root->root_key.objectid, + btrfs_ino(BTRFS_I(inode)), + new_key.offset - datao); + ret = btrfs_inc_extent_ref(trans, &ref); if (ret) { btrfs_abort_transaction(trans, ret); diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c index 80550c4464f3..7aa240d1f361 100644 --- a/fs/btrfs/relocation.c +++ b/fs/btrfs/relocation.c @@ -1658,6 +1658,8 @@ int replace_file_extents(struct btrfs_trans_handle *trans, nritems = btrfs_header_nritems(leaf); for (i = 0; i < nritems; i++) { + struct btrfs_ref ref = { 0 }; + cond_resched(); btrfs_item_key_to_cpu(leaf, &key, i); if (key.type != BTRFS_EXTENT_DATA_KEY) @@ -1718,10 +1720,12 @@ int replace_file_extents(struct btrfs_trans_handle *trans, dirty = 1; key.offset -= btrfs_file_extent_offset(leaf, fi); - ret = btrfs_inc_extent_ref(trans, root, new_bytenr, - num_bytes, parent, - btrfs_header_owner(leaf), - key.objectid, key.offset, false); + + btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, new_bytenr, + num_bytes, root->root_key.objectid, parent); + btrfs_init_data_ref(&ref, btrfs_header_owner(leaf), + key.objectid, key.offset); + ret = btrfs_inc_extent_ref(trans, &ref); if (ret) { btrfs_abort_transaction(trans, ret); break; @@ -1771,6 +1775,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, struct btrfs_fs_info *fs_info = dest->fs_info; struct extent_buffer *eb; struct extent_buffer *parent; + struct btrfs_ref ref = { 0 }; struct btrfs_key key; u64 old_bytenr; u64 new_bytenr; @@ -1929,14 +1934,18 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, path->slots[level], old_ptr_gen); btrfs_mark_buffer_dirty(path->nodes[level]); - ret = btrfs_inc_extent_ref(trans, src, old_bytenr, - blocksize, path->nodes[level]->start, - src->root_key.objectid, level - 1, 0, - true); + btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, old_bytenr, + blocksize, src->root_key.objectid, + path->nodes[level]->start); + btrfs_init_tree_ref(&ref, level - 1, src->root_key.objectid); + ref.skip_qgroup = true; + ret = btrfs_inc_extent_ref(trans, &ref); BUG_ON(ret); - ret = btrfs_inc_extent_ref(trans, dest, new_bytenr, - blocksize, 0, dest->root_key.objectid, - level - 1, 0, true); + btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, new_bytenr, + blocksize, dest->root_key.objectid, 0); + btrfs_init_tree_ref(&ref, level - 1, dest->root_key.objectid); + ref.skip_qgroup = true; + ret = btrfs_inc_extent_ref(trans, &ref); BUG_ON(ret); ret = btrfs_free_extent(trans, src, new_bytenr, blocksize, @@ -2763,6 +2772,7 @@ static int do_relocation(struct btrfs_trans_handle *trans, rc->backref_cache.path[node->level] = node; list_for_each_entry(edge, &node->upper, list[LOWER]) { struct btrfs_key first_key; + struct btrfs_ref ref = { 0 }; cond_resched(); @@ -2860,11 +2870,13 @@ static int do_relocation(struct btrfs_trans_handle *trans, trans->transid); btrfs_mark_buffer_dirty(upper->eb); - ret = btrfs_inc_extent_ref(trans, root, - node->eb->start, blocksize, - upper->eb->start, - btrfs_header_owner(upper->eb), - node->level, 0, false); + btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, + node->eb->start, blocksize, + root->root_key.objectid, + upper->eb->start); + btrfs_init_tree_ref(&ref, node->level, + btrfs_header_owner(upper->eb)); + ret = btrfs_inc_extent_ref(trans, &ref); BUG_ON(ret); ret = btrfs_drop_subtree(trans, root, eb, upper->eb); diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c index 9e4d274902b8..e4da64088679 100644 --- a/fs/btrfs/tree-log.c +++ b/fs/btrfs/tree-log.c @@ -693,9 +693,11 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans, goto out; if (ins.objectid > 0) { + struct btrfs_ref ref = { 0 }; u64 csum_start; u64 csum_end; LIST_HEAD(ordered_sums); + /* * is this extent already allocated in the extent * allocation tree? If so, just add a reference @@ -703,10 +705,14 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans, ret = btrfs_lookup_data_extent(fs_info, ins.objectid, ins.offset); if (ret == 0) { - ret = btrfs_inc_extent_ref(trans, root, + btrfs_init_generic_ref(&ref, + BTRFS_ADD_DELAYED_REF, ins.objectid, ins.offset, - 0, root->root_key.objectid, - key->objectid, offset, false); + root->root_key.objectid, 0); + btrfs_init_data_ref(&ref, + root->root_key.objectid, + key->objectid, offset); + ret = btrfs_inc_extent_ref(trans, &ref); if (ret) goto out; } else {
Now we don't need to play the dirty game of reusing @owner for tree block level. Signed-off-by: Qu Wenruo <wqu@suse.com> --- fs/btrfs/ctree.h | 6 ++--- fs/btrfs/extent-tree.c | 58 ++++++++++++++++++++++-------------------- fs/btrfs/file.c | 20 ++++++++++----- fs/btrfs/inode.c | 10 +++++--- fs/btrfs/ioctl.c | 17 ++++++++----- fs/btrfs/relocation.c | 44 ++++++++++++++++++++------------ fs/btrfs/tree-log.c | 12 ++++++--- 7 files changed, 100 insertions(+), 67 deletions(-)