Enhance record_file_blocks() function to handle reserved ranges.
Unlike most of file extents, ext* data in reserved ranges are not mapped
on disk with 1:1 bytenr.
So we can't use bytenr directly.
But thanks for calling create_ext2_image_v2() before copying inodes, we
have a image in convert subvolume as a logical <-> disk bytenr mapping.
So use it to handle reserved ranges for record_file_blocks().
Signed-off-by: Qu Wenruo <quwen...@cn.fujitsu.com>
---
btrfs-convert.c | 99 +++++++++++++++++++++++++++++++++++++++++++++++++++------
1 file changed, 90 insertions(+), 9 deletions(-)
diff --git a/btrfs-convert.c b/btrfs-convert.c
index 657fc1d..993ee80 100644
--- a/btrfs-convert.c
+++ b/btrfs-convert.c
@@ -464,7 +464,9 @@ static int csum_disk_extent(struct btrfs_trans_handle
*trans,
struct blk_iterate_data {
struct btrfs_trans_handle *trans;
struct btrfs_root *root;
+ struct btrfs_root *convert_root;
struct btrfs_inode_item *inode;
+ u64 convert_ino;
u64 objectid;
u64 first_block;
u64 disk_block;
@@ -480,6 +482,8 @@ static void init_blk_iterate_data(struct blk_iterate_data
*data,
struct btrfs_inode_item *inode,
u64 objectid, int checksum)
{
+ struct btrfs_key key;
+
data->trans = trans;
data->root = root;
data->inode = inode;
@@ -490,25 +494,100 @@ static void init_blk_iterate_data(struct
blk_iterate_data *data,
data->boundary = (u64)-1;
data->checksum = checksum;
data->errcode = 0;
+
+ key.objectid = CONV_IMAGE_SUBVOL_OBJECTID;
+ key.type = BTRFS_ROOT_ITEM_KEY;
+ key.offset = (u64)-1;
+ data->convert_root = btrfs_read_fs_root(root->fs_info, &key);
+ /* Impossible since previously we just opened that subvolume */
+ BUG_ON(!data->convert_root || IS_ERR(data->convert_root));
+ data->convert_ino = BTRFS_FIRST_FREE_OBJECTID + 1;
}
static int record_file_blocks(struct blk_iterate_data *data,
u64 file_block, u64 disk_block, u64 num_blocks)
{
- int ret;
+ int ret = 0;
struct btrfs_root *root = data->root;
+ struct btrfs_root *convert_root = data->convert_root;
+ struct btrfs_path *path;
u64 file_pos = file_block * root->sectorsize;
- u64 disk_bytenr = disk_block * root->sectorsize;
+ u64 old_disk_bytenr = disk_block * root->sectorsize;
u64 num_bytes = num_blocks * root->sectorsize;
- ret = btrfs_record_file_extent(data->trans, data->root,
- data->objectid, data->inode, file_pos,
- disk_bytenr, num_bytes);
-
- if (ret || !data->checksum || disk_bytenr == 0)
- return ret;
+ u64 cur_off = old_disk_bytenr;
- return csum_disk_extent(data->trans, data->root, disk_bytenr,
+ if (old_disk_bytenr == 0)
+ return btrfs_record_file_extent(data->trans, root,
+ data->objectid, data->inode, file_pos, 0,
num_bytes);
+ path = btrfs_alloc_path();
+ if (!path)
+ return -ENOMEM;
+ /*
+ * Since the logical mapping of converted image is not all 1:1,
+ * especially for the reserved ranges, so we shouldn't use disk_bytenr
+ * directly, but search in convert_subvolume.
+ * Which acts like another logical <-> disk mapping layer.
+ */
+ while (cur_off < old_disk_bytenr + num_bytes) {
+ struct btrfs_key key;
+ struct btrfs_file_extent_item *fi;
+ struct extent_buffer *node;
+ int slot;
+ u64 extent_disk_bytenr;
+ u64 extent_num_bytes;
+ u64 real_disk_bytenr;
+ u64 cur_len;
+
+ key.objectid = data->convert_ino;
+ key.type = BTRFS_EXTENT_DATA_KEY;
+ key.offset = cur_off;
+
+ ret = btrfs_search_slot(NULL, convert_root, &key, path, 0, 0);
+ if (ret < 0)
+ break;
+ if (ret > 0) {
+ ret = btrfs_previous_item(convert_root, path,
+ data->convert_ino,
+ BTRFS_EXTENT_DATA_KEY);
+ if (ret < 0)
+ break;
+ if (ret > 0) {
+ ret = -ENOENT;
+ break;
+ }
+ }
+ node = path->nodes[0];
+ slot = path->slots[0];
+ btrfs_item_key_to_cpu(node, &key, slot);
+ BUG_ON(key.type != BTRFS_EXTENT_DATA_KEY ||
+ key.objectid != data->convert_ino ||
+ key.offset > cur_off);
+ fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
+ extent_disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
+ extent_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
+ BUG_ON(cur_off - key.offset >= extent_num_bytes);
+ btrfs_release_path(path);
+
+ real_disk_bytenr = cur_off - key.offset + extent_disk_bytenr;
+ cur_len = min(key.offset + extent_num_bytes,
+ old_disk_bytenr + num_bytes) - cur_off;
+ ret = btrfs_record_file_extent(data->trans, data->root,
+ data->objectid, data->inode, file_pos,
+ real_disk_bytenr, cur_len);
+ if (ret < 0)
+ break;
+ cur_off += cur_len;
+ file_pos += cur_len;
+ /*
+ * Here we don't need to care about data checksum
+ * As all the ext* data is already calculated for csum, so no
+ * need to calculate it again
+ */
+ }
+
+ btrfs_free_path(path);
+ return ret;
}
static int block_iterate_proc(u64 disk_block, u64 file_block,
@@ -1638,6 +1717,8 @@ static int create_ext2_image_v2(struct btrfs_root *root,
&ino);
if (ret < 0)
goto out;
+ /* Shouldn't happen, and we need this const ino for later use */
+ BUG_ON(ino != BTRFS_FIRST_FREE_OBJECTID + 1);
ret = btrfs_new_inode(trans, root, ino, 0600 | S_IFREG);
if (ret < 0)
goto out;
--
2.6.2
--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
