renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-26 22:24:09 +08:00
Code

btrfs: rename struct btrfs_clone_extent_info to a more generic name

Browse Source 
Now that we can use btrfs_clone_extent_info to convey information for a
new prealloc extent as well, and not just for existing extents that are
being cloned, rename it to btrfs_replace_extent_info, which reflects the
fact that this is now more generic and it is used to replace all existing
extents in a file range with the extent described by the structure.

Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Filipe Manana 2020-09-08 11:27:22 +01:00 committed by David Sterba
parent fb870f6cdd
commit bf385648fa
4 changed files with 54 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
fs/btrfs/ctree.h
View File

@ -1194,7 +1194,11 @@ struct btrfs_root {
#endif #endif
}; };
struct btrfs_clone_extent_info { /*
* Structure that conveys information about an extent that is going to replace
* all the extents in a file range.
*/
struct btrfs_replace_extent_info {
u64 disk_offset; u64 disk_offset;
u64 disk_len; u64 disk_len;
u64 data_offset; u64 data_offset;
@ -3086,7 +3090,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
u64 end, int drop_cache); u64 end, int drop_cache);
int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path, int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
const u64 start, const u64 end, const u64 start, const u64 end,
struct btrfs_clone_extent_info *clone_info, struct btrfs_replace_extent_info *extent_info,
struct btrfs_trans_handle **trans_out); struct btrfs_trans_handle **trans_out);
int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
struct btrfs_inode *inode, u64 start, u64 end); struct btrfs_inode *inode, u64 start, u64 end);

92
fs/btrfs/file.c
View File

@ -2573,8 +2573,8 @@ static int btrfs_punch_hole_lock_range(struct inode *inode,
static int btrfs_insert_clone_extent(struct btrfs_trans_handle *trans, static int btrfs_insert_clone_extent(struct btrfs_trans_handle *trans,
struct inode *inode, struct inode *inode,
struct btrfs_path *path, struct btrfs_path *path,
struct btrfs_clone_extent_info *clone_info, struct btrfs_replace_extent_info *extent_info,
const u64 clone_len) const u64 replace_len)
{ {
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
struct btrfs_root *root = BTRFS_I(inode)->root; struct btrfs_root *root = BTRFS_I(inode)->root;
@ -2585,67 +2585,67 @@ static int btrfs_insert_clone_extent(struct btrfs_trans_handle *trans,
struct btrfs_ref ref = { 0 }; struct btrfs_ref ref = { 0 };
int ret; int ret;
if (clone_len == 0) if (replace_len == 0)
return 0; return 0;
if (clone_info->disk_offset == 0 && if (extent_info->disk_offset == 0 &&
btrfs_fs_incompat(fs_info, NO_HOLES)) btrfs_fs_incompat(fs_info, NO_HOLES))
return 0; return 0;
key.objectid = btrfs_ino(BTRFS_I(inode)); key.objectid = btrfs_ino(BTRFS_I(inode));
key.type = BTRFS_EXTENT_DATA_KEY; key.type = BTRFS_EXTENT_DATA_KEY;
key.offset = clone_info->file_offset; key.offset = extent_info->file_offset;
ret = btrfs_insert_empty_item(trans, root, path, &key, ret = btrfs_insert_empty_item(trans, root, path, &key,
sizeof(struct btrfs_file_extent_item)); sizeof(struct btrfs_file_extent_item));
if (ret) if (ret)
return ret; return ret;
leaf = path->nodes[0]; leaf = path->nodes[0];
slot = path->slots[0]; slot = path->slots[0];
write_extent_buffer(leaf, clone_info->extent_buf, write_extent_buffer(leaf, extent_info->extent_buf,
btrfs_item_ptr_offset(leaf, slot), btrfs_item_ptr_offset(leaf, slot),
sizeof(struct btrfs_file_extent_item)); sizeof(struct btrfs_file_extent_item));
extent = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); extent = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
ASSERT(btrfs_file_extent_type(leaf, extent) != BTRFS_FILE_EXTENT_INLINE); ASSERT(btrfs_file_extent_type(leaf, extent) != BTRFS_FILE_EXTENT_INLINE);
btrfs_set_file_extent_offset(leaf, extent, clone_info->data_offset); btrfs_set_file_extent_offset(leaf, extent, extent_info->data_offset);
btrfs_set_file_extent_num_bytes(leaf, extent, clone_len); btrfs_set_file_extent_num_bytes(leaf, extent, replace_len);
if (clone_info->is_new_extent) if (extent_info->is_new_extent)
btrfs_set_file_extent_generation(leaf, extent, trans->transid); btrfs_set_file_extent_generation(leaf, extent, trans->transid);
btrfs_mark_buffer_dirty(leaf); btrfs_mark_buffer_dirty(leaf);
btrfs_release_path(path); btrfs_release_path(path);
ret = btrfs_inode_set_file_extent_range(BTRFS_I(inode), ret = btrfs_inode_set_file_extent_range(BTRFS_I(inode),
clone_info->file_offset, clone_len); extent_info->file_offset, replace_len);
if (ret) if (ret)
return ret; return ret;
/* If it's a hole, nothing more needs to be done. */ /* If it's a hole, nothing more needs to be done. */
if (clone_info->disk_offset == 0) if (extent_info->disk_offset == 0)
return 0; return 0;
inode_add_bytes(inode, clone_len); inode_add_bytes(inode, replace_len);
if (clone_info->is_new_extent && clone_info->insertions == 0) { if (extent_info->is_new_extent && extent_info->insertions == 0) {
key.objectid = clone_info->disk_offset; key.objectid = extent_info->disk_offset;
key.type = BTRFS_EXTENT_ITEM_KEY; key.type = BTRFS_EXTENT_ITEM_KEY;
key.offset = clone_info->disk_len; key.offset = extent_info->disk_len;
ret = btrfs_alloc_reserved_file_extent(trans, root, ret = btrfs_alloc_reserved_file_extent(trans, root,
btrfs_ino(BTRFS_I(inode)), btrfs_ino(BTRFS_I(inode)),
clone_info->file_offset, extent_info->file_offset,
clone_info->qgroup_reserved, extent_info->qgroup_reserved,
&key); &key);
} else { } else {
u64 ref_offset; u64 ref_offset;
btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF,
clone_info->disk_offset, extent_info->disk_offset,
clone_info->disk_len, 0); extent_info->disk_len, 0);
ref_offset = clone_info->file_offset - clone_info->data_offset; ref_offset = extent_info->file_offset - extent_info->data_offset;
btrfs_init_data_ref(&ref, root->root_key.objectid, btrfs_init_data_ref(&ref, root->root_key.objectid,
btrfs_ino(BTRFS_I(inode)), ref_offset); btrfs_ino(BTRFS_I(inode)), ref_offset);
ret = btrfs_inc_extent_ref(trans, &ref); ret = btrfs_inc_extent_ref(trans, &ref);
} }
clone_info->insertions++; extent_info->insertions++;
return ret; return ret;
} }
@ -2653,15 +2653,15 @@ static int btrfs_insert_clone_extent(struct btrfs_trans_handle *trans,
/* /*
* The respective range must have been previously locked, as well as the inode. * The respective range must have been previously locked, as well as the inode.
* The end offset is inclusive (last byte of the range). * The end offset is inclusive (last byte of the range).
* @clone_info is NULL for fallocate's hole punching and non-NULL for extent * @extent_info is NULL for fallocate's hole punching and non-NULL when replacing
* cloning. * the file range with an extent.
* When cloning, we don't want to end up in a state where we dropped extents * When not punching a hole, we don't want to end up in a state where we dropped
* without inserting a new one, so we must abort the transaction to avoid a * extents without inserting a new one, so we must abort the transaction to avoid
* corruption. * a corruption.
*/ */
int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path, int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
const u64 start, const u64 end, const u64 start, const u64 end,
struct btrfs_clone_extent_info *clone_info, struct btrfs_replace_extent_info *extent_info,
struct btrfs_trans_handle **trans_out) struct btrfs_trans_handle **trans_out)
{ {
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@ -2690,10 +2690,10 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
/* /*
* 1 - update the inode * 1 - update the inode
* 1 - removing the extents in the range * 1 - removing the extents in the range
* 1 - adding the hole extent if no_holes isn't set or if we are cloning * 1 - adding the hole extent if no_holes isn't set or if we are
* an extent * replacing the range with a new extent
*/ */
if (!btrfs_fs_incompat(fs_info, NO_HOLES) || clone_info) if (!btrfs_fs_incompat(fs_info, NO_HOLES) || extent_info)
rsv_count = 3; rsv_count = 3;
else else
rsv_count = 2; rsv_count = 2;
@ -2723,7 +2723,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
* returned by __btrfs_drop_extents() without having * returned by __btrfs_drop_extents() without having
* changed anything in the file. * changed anything in the file.
*/ */
if (clone_info && !clone_info->is_new_extent && if (extent_info && !extent_info->is_new_extent &&
ret && ret != -EOPNOTSUPP) ret && ret != -EOPNOTSUPP)
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);
break; break;
@ -2731,7 +2731,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
trans->block_rsv = &fs_info->trans_block_rsv; trans->block_rsv = &fs_info->trans_block_rsv;
if (!clone_info && cur_offset < drop_end && if (!extent_info && cur_offset < drop_end &&
cur_offset < ino_size) { cur_offset < ino_size) {
ret = fill_holes(trans, BTRFS_I(inode), path, ret = fill_holes(trans, BTRFS_I(inode), path,
cur_offset, drop_end); cur_offset, drop_end);
@ -2745,7 +2745,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);
break; break;
} }
} else if (!clone_info && cur_offset < drop_end) { } else if (!extent_info && cur_offset < drop_end) {
/* /*
* We are past the i_size here, but since we didn't * We are past the i_size here, but since we didn't
* insert holes we need to clear the mapped area so we * insert holes we need to clear the mapped area so we
@ -2765,18 +2765,18 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
} }
} }
if (clone_info && drop_end > clone_info->file_offset) { if (extent_info && drop_end > extent_info->file_offset) {
u64 clone_len = drop_end - clone_info->file_offset; u64 replace_len = drop_end - extent_info->file_offset;
ret = btrfs_insert_clone_extent(trans, inode, path, ret = btrfs_insert_clone_extent(trans, inode, path,
clone_info, clone_len); extent_info, replace_len);
if (ret) { if (ret) {
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);
break; break;
} }
clone_info->data_len -= clone_len; extent_info->data_len -= replace_len;
clone_info->data_offset += clone_len; extent_info->data_offset += replace_len;
clone_info->file_offset += clone_len; extent_info->file_offset += replace_len;
} }
cur_offset = drop_end; cur_offset = drop_end;
@ -2800,7 +2800,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
BUG_ON(ret); /* shouldn't happen */ BUG_ON(ret); /* shouldn't happen */
trans->block_rsv = rsv; trans->block_rsv = rsv;
if (!clone_info) { if (!extent_info) {
ret = find_first_non_hole(inode, &cur_offset, &len); ret = find_first_non_hole(inode, &cur_offset, &len);
if (unlikely(ret < 0)) if (unlikely(ret < 0))
break; break;
@ -2819,7 +2819,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
* than 16Mb would force the full fsync any way (when * than 16Mb would force the full fsync any way (when
* try_release_extent_mapping() is invoked during page cache truncation. * try_release_extent_mapping() is invoked during page cache truncation.
*/ */
if (clone_info && !clone_info->is_new_extent) if (extent_info && !extent_info->is_new_extent)
set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
&BTRFS_I(inode)->runtime_flags); &BTRFS_I(inode)->runtime_flags);
@ -2845,7 +2845,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
* (because it's useless) or if it represents a 0 bytes range (when * (because it's useless) or if it represents a 0 bytes range (when
* cur_offset == drop_end). * cur_offset == drop_end).
*/ */
if (!clone_info && cur_offset < ino_size && cur_offset < drop_end) { if (!extent_info && cur_offset < ino_size && cur_offset < drop_end) {
ret = fill_holes(trans, BTRFS_I(inode), path, ret = fill_holes(trans, BTRFS_I(inode), path,
cur_offset, drop_end); cur_offset, drop_end);
if (ret) { if (ret) {
@ -2853,7 +2853,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);
goto out_trans; goto out_trans;
} }
} else if (!clone_info && cur_offset < drop_end) { } else if (!extent_info && cur_offset < drop_end) {
/* See the comment in the loop above for the reasoning here. */ /* See the comment in the loop above for the reasoning here. */
ret = btrfs_inode_clear_file_extent_range(BTRFS_I(inode), ret = btrfs_inode_clear_file_extent_range(BTRFS_I(inode),
cur_offset, drop_end - cur_offset); cur_offset, drop_end - cur_offset);
@ -2863,9 +2863,9 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
} }
} }
if (clone_info) { if (extent_info) {
ret = btrfs_insert_clone_extent(trans, inode, path, clone_info, ret = btrfs_insert_clone_extent(trans, inode, path, extent_info,
clone_info->data_len); extent_info->data_len);
if (ret) { if (ret) {
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);
goto out_trans; goto out_trans;

2
fs/btrfs/inode.c
View File

@ -9582,7 +9582,7 @@ static struct btrfs_trans_handle *insert_prealloc_file_extent(
u64 file_offset) u64 file_offset)
{ {
struct btrfs_file_extent_item stack_fi; struct btrfs_file_extent_item stack_fi;
struct btrfs_clone_extent_info extent_info; struct btrfs_replace_extent_info extent_info;
struct btrfs_trans_handle *trans = trans_in; struct btrfs_trans_handle *trans = trans_in;
struct btrfs_path *path; struct btrfs_path *path;
u64 start = ins->objectid; u64 start = ins->objectid;

2
fs/btrfs/reflink.c
View File

@ -439,7 +439,7 @@ process_slot:
if (type == BTRFS_FILE_EXTENT_REG || if (type == BTRFS_FILE_EXTENT_REG ||
type == BTRFS_FILE_EXTENT_PREALLOC) { type == BTRFS_FILE_EXTENT_PREALLOC) {
struct btrfs_clone_extent_info clone_info; struct btrfs_replace_extent_info clone_info;
/* /*
* a | --- range to clone ---| b * a | --- range to clone ---| b