Misc BDRV_SECTOR_SIZE updates
v3 cover Misc BDRV_SECTOR_SIZE updates
This series gets rid of all the remaining instances of hardcoded sector sizes in the qcow2 code and adds a check for images whose virtual size is not a multiple of the sector size.
See the individual patches for details.
Berto
v3:
- Patch 2: Use offset_into_cluster() instead of QEMU_IS_ALIGNED
- Patch 3: Rewrite qcow2_write_l1_entry() to use bl.request_alignment [Kevin]
- Patch 4: Remove alignment check in qcow2_co_copy_range_from()
v2: https://lists.gnu.org/archive/html/qemu-block/2020-01/msg00169.html
- Modify output of iotest 080 to make it easier to understand [Nir]
- Use the QEMU_IS_ALIGNED() macro instead of the modulus operator [Nir]
- Tighten some assertions [Kevin]
v1: https://lists.gnu.org/archive/html/qemu-block/2020-01/msg00139.html
Alberto Garcia (5):
qcow2: Don't round the L1 table allocation up to the sector size
qcow2: Tighten cluster_offset alignment assertions
qcow2: Use bs->bl.request_alignment when updating an L1 entry
qcow2: Don't require aligned offsets in qcow2_co_copy_range_from()
qcow2: Use BDRV_SECTOR_SIZE instead of the hardcoded value
block/qcow2-cluster.c | 30 +++++++++++++++++------------- block/qcow2-refcount.c | 2 +- block/qcow2-snapshot.c | 3 +-- block/qcow2.c | 23 +++++++++-------------- 4 files changed, 28 insertions(+), 30 deletions(-)
Signature · 1 line
2.20.1
PATCH v3 1/5 qcow2: Don't round the L1 table allocation up to the sector size
The L1 table is read from disk using the byte-based bdrv_pread() and is never accessed beyond its last element, so there's no need to allocate more memory than that.
--- block/qcow2-cluster.c | 5 ++--- block/qcow2-refcount.c | 2 +- block/qcow2-snapshot.c | 3 +-- block/qcow2.c | 2 +- 4 files changed, 5 insertions(+), 7 deletions(-)
block/qcow2-cluster.c +2 -3
@@ -124,12 +124,11 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,#endif new_l1_size2 =sizeof (uint64_t ) * new_l1_size; - new_l1_table =qemu_try_blockalign (bs->file->bs, -ROUND_UP (new_l1_size2,512 )); + new_l1_table =qemu_try_blockalign (bs->file->bs, new_l1_size2);if (new_l1_table ==NULL ) {return -ENOMEM ; } -memset (new_l1_table,0 ,ROUND_UP (new_l1_size2,512 )); +memset (new_l1_table,0 , new_l1_size2);if (s->l1_size) {memcpy (new_l1_table, s->l1_table, s->l1_size *sizeof (uint64_t ));
block/qcow2-refcount.c +1 -1
@@ -1262,7 +1262,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,* l1_table_offset when it is the current s->l1_table_offset! Be careful * when changing this! */ if (l1_table_offset != s->l1_table_offset) { - l1_table =g_try_malloc0 (ROUND_UP (l1_size2,512 )); + l1_table =g_try_malloc0 (l1_size2);if (l1_size2 && l1_table ==NULL ) { ret = -ENOMEM ; goto fail;
block/qcow2-snapshot.c +1 -2
@@ -1024,8 +1024,7 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,return ret; } new_l1_bytes = sn->l1_size *sizeof (uint64_t ); - new_l1_table =qemu_try_blockalign (bs->file->bs, -ROUND_UP (new_l1_bytes,512 )); + new_l1_table =qemu_try_blockalign (bs->file->bs, new_l1_bytes);if (new_l1_table ==NULL ) {return -ENOMEM ; }
block/qcow2.c +1 -1
@@ -1492,7 +1492,7 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,if (s->l1_size >0 ) { s->l1_table =qemu_try_blockalign (bs->file->bs, -ROUND_UP (s->l1_size *sizeof (uint64_t ),512 )); + s->l1_size *sizeof (uint64_t ));if (s->l1_table ==NULL ) {error_setg (errp,"Could not allocate L1 table" ); ret = -ENOMEM ;
Signature · 1 line
2.20.1
PATCH v3 2/5 qcow2: Tighten cluster_offset alignment assertions
In reply to Alberto Garciaqcow2_alloc_cluster_offset() and qcow2_get_cluster_offset() always return offsets that are cluster-aligned so don't just check that they are sector-aligned.
The check in qcow2_co_preadv_task() is also replaced by an assertion for the same reason.
--- block/qcow2.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
block/qcow2.c +3 -6
@@ -2168,10 +2168,7 @@ static coroutine_fn int qcow2_co_preadv_task(BlockDriverState *bs, offset, bytes, qiov, qiov_offset);case QCOW2_CLUSTER_NORMAL : -if ((file_cluster_offset &511 ) !=0 ) { -return -EIO ; - } - +assert (offset_into_cluster (s, file_cluster_offset) ==0 );if (bs->encrypted) {return qcow2_co_preadv_encrypted (bs, file_cluster_offset, offset, bytes, qiov, qiov_offset);
@@ -2507,7 +2504,7 @@ static coroutine_fn int qcow2_co_pwritev_part( goto out_locked; } -assert ((cluster_offset &511 ) ==0 ); +assert (offset_into_cluster (s, cluster_offset) ==0 ); ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset + offset_in_cluster,
@@ -3897,7 +3894,7 @@ qcow2_co_copy_range_to(BlockDriverState *bs, goto fail; } -assert ((cluster_offset &511 ) ==0 ); +assert (offset_into_cluster (s, cluster_offset) ==0 ); ret =qcow2_pre_write_overlap_check (bs,0 , cluster_offset + offset_in_cluster, cur_bytes, true);
Signature · 1 line
2.20.1
PATCH v3 3/5 qcow2: Use bs->bl.request_alignment when updating an L1 entry
In reply to Alberto GarciaWhen updating an L1 entry the qcow2 driver writes a (512-byte) sector worth of data to avoid a read-modify-write cycle. Instead of always writing 512 bytes we should follow the alignment requirements of the storage backend.
(the only exception is when the alignment is larger than the cluster size because then we could be overwriting data after the L1 table)
--- block/qcow2-cluster.c | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-)
block/qcow2-cluster.c +15 -10
@@ -216,26 +216,31 @@ static int l2_load(BlockDriverState *bs, uint64_t offset, }/* -* Writes one sector of the L1 table to the disk (can't update single entries -* and we really don't want bdrv_pread to perform a read-modify-write) +* Writes an L1 entry to disk (note that depending on the alignment +* requirements this function may write more that just one entry in +* order to prevent bdrv_pwrite from performing a read-modify-write) */ -#define L1_ENTRIES_PER_SECTOR (512 / 8)int qcow2_write_l1_entry (BlockDriverState *bs,int l1_index) {BDRVQcow2State *s = bs->opaque; -uint64_t buf[L1_ENTRIES_PER_SECTOR ] = {0 };int l1_start_index;int i, ret; +int bufsize =MAX (sizeof (uint64_t ), +MIN (bs->file->bs->bl.request_alignment, s->cluster_size)); +int nentries = bufsize /sizeof (uint64_t ); + g_autofree uint64_t *buf = g_try_new0(uint64_t, nentries); - l1_start_index = l1_index & ~(L1_ENTRIES_PER_SECTOR -1 ); -for (i =0 ; i <L1_ENTRIES_PER_SECTOR && l1_start_index + i < s->l1_size; - i++) - { +if (buf ==NULL ) { +return -ENOMEM ; + } + + l1_start_index =QEMU_ALIGN_DOWN (l1_index, nentries); +for (i =0 ; i <MIN (nentries, s->l1_size - l1_start_index); i++) { buf[i] =cpu_to_be64 (s->l1_table[l1_start_index + i]); } ret =qcow2_pre_write_overlap_check (bs,QCOW2_OL_ACTIVE_L1 , - s->l1_table_offset +8 * l1_start_index,sizeof (buf), false); + s->l1_table_offset +8 * l1_start_index, bufsize, false);if (ret <0 ) {return ret; }
@@ -243,7 +248,7 @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)BLKDBG_EVENT (bs->file,BLKDBG_L1_UPDATE ); ret =bdrv_pwrite_sync (bs->file, s->l1_table_offset +8 * l1_start_index, - buf,sizeof (buf)); + buf, bufsize);if (ret <0 ) {return ret; }
Signature · 1 line
2.20.1
Re: [PATCH v3 3/5] qcow2: Use bs->bl.request_alignment when updating an L1 entry
Quoted 5 lines · Alberto Garcia
When updating an L1 entry the qcow2 driver writes a (512-byte) sector worth of data to avoid a read-modify-write cycle. Instead of always writing 512 bytes we should follow the alignment requirements of the storage backend.
Quoted 7 lines
(the only exception is when the alignment is larger than the cluster size because then we could be overwriting data after the L1 table)
Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2-cluster.c | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-)
PATCH v3 4/5 qcow2: Don't require aligned offsets in qcow2_co_copy_range_from()
In reply to Alberto Garciaqemu-img's convert_co_copy_range() operates at the sector level and block_copy() operates at the cluster level so this condition is always true, but it is not necessary to restrict this here, so let's leave it to the driver implementation return an error if there is any.
--- block/qcow2.c | 4 ---- 1 file changed, 4 deletions(-)
block/qcow2.c +0 -4
@@ -3829,10 +3829,6 @@ qcow2_co_copy_range_from(BlockDriverState *bs,case QCOW2_CLUSTER_NORMAL : child = s->data_file; copy_offset +=offset_into_cluster (s, src_offset); -if ((copy_offset &511 ) !=0 ) { - ret = -EIO ; - goto out; - }break ;default :
Signature · 1 line
2.20.1
Re: [PATCH v3 4/5] qcow2: Don't require aligned offsets in qcow2_co_copy_range_from()
Quoted 9 lines · Alberto Garcia
qemu-img's
convert_co_copy_range()operates at the sector level andblock_copy()operates at the cluster level so this condition is always true, but it is not necessary to restrict this here, so let's leave it to the driver implementation return an error if there is any.Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2.c | 4 ---- 1 file changed, 4 deletions(-)
PATCH v3 5/5 qcow2: Use BDRV_SECTOR_SIZE instead of the hardcoded value
In reply to Alberto GarciaThis replaces all remaining instances in the qcow2 code.
--- block/qcow2.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
block/qcow2.c +5 -3
@@ -3273,7 +3273,8 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)/* Validate options and set default values */ if (!QEMU_IS_ALIGNED (qcow2_opts->size,BDRV_SECTOR_SIZE )) { -error_setg (errp,"Image size must be a multiple of 512 bytes" ); +error_setg (errp,"Image size must be a multiple of %u bytes" , + (unsigned )BDRV_SECTOR_SIZE ); ret = -EINVAL ; goto out; }
@@ -3947,8 +3948,9 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,return -ENOTSUP ; } -if (offset &511 ) { -error_setg (errp,"The new size must be a multiple of 512" ); +if (!QEMU_IS_ALIGNED (offset,BDRV_SECTOR_SIZE )) { +error_setg (errp,"The new size must be a multiple of %u" , + (unsigned )BDRV_SECTOR_SIZE );return -EINVAL ; }
Signature · 1 line
2.20.1
Re: [PATCH v3 5/5] qcow2: Use BDRV_SECTOR_SIZE instead of the hardcoded value
Quoted 6 lines · Alberto Garcia
This replaces all remaining instances in the qcow2 code.
Signed-off-by Alberto Garcia <[email protected]>--- block/qcow2.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
Max Reitz
AppliedQuoted 5 lines · Alberto Garcia
This series gets rid of all the remaining instances of hardcoded sector sizes in the qcow2 code and adds a check for images whose virtual size is not a multiple of the sector size.
See the individual patches for details.
Thanks, applied to my block branch:
https://git.xanclic.moe/XanClic/qemu/commits/branch/block
Max