block: Fix resize (extending) of short overlays
PATCH v5 2/9 block: Add flags to bdrv(_co)_truncate()
In reply to Kevin WolfNow that block drivers can support flags for .bdrv_co_truncate, expose the parameter in the node level interfaces bdrv_co_truncate() and bdrv_truncate().
--- include/block/block.h | 5 +++-- block/block-backend.c | 2 +- block/crypto.c | 2 +- block/io.c | 12 +++++++----- block/parallels.c | 6 +++--- block/qcow.c | 4 ++-- block/qcow2-refcount.c | 2 +- block/qcow2.c | 15 +++++++++------ block/raw-format.c | 2 +- block/vhdx-log.c | 2 +- block/vhdx.c | 2 +- block/vmdk.c | 2 +- tests/test-block-iothread.c | 6 +++--- 13 files changed, 34 insertions(+), 28 deletions(-)
include/block/block.h +3 -2
@@ -339,9 +339,10 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,void bdrv_refresh_filename (BlockDriverState *bs); int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, -PreallocMode prealloc,Error **errp); +PreallocMode prealloc,BdrvRequestFlags flags, +Error **errp);int bdrv_truncate (BdrvChild *child,int64_t offset,bool exact, -PreallocMode prealloc,Error **errp); +PreallocMode prealloc,BdrvRequestFlags flags,Error **errp);int64_t bdrv_nb_sectors (BlockDriverState *bs);int64_t bdrv_getlength (BlockDriverState *bs);
block/block-backend.c +1 -1
@@ -2144,7 +2144,7 @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,return -ENOMEDIUM ; } -return bdrv_truncate (blk->root, offset, exact, prealloc, errp); +return bdrv_truncate (blk->root, offset, exact, prealloc,0 , errp); } int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
block/crypto.c +1 -1
@@ -313,7 +313,7 @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, offset += payload_offset; -return bdrv_co_truncate (bs->file, offset, exact, prealloc, errp); +return bdrv_co_truncate (bs->file, offset, exact, prealloc,0 , errp); }static void block_crypto_close (BlockDriverState *bs)
block/io.c +7 -5
@@ -3339,12 +3339,12 @@ static void bdrv_parent_cb_resize(BlockDriverState *bs)* 'offset' bytes in length. */ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, -PreallocMode prealloc,Error **errp) +PreallocMode prealloc,BdrvRequestFlags flags, +Error **errp) {BlockDriverState *bs = child->bs;BlockDriver *drv = bs->drv;BdrvTrackedRequest req; -BdrvRequestFlags flags =0 ;int64_t old_size, new_bytes;int ret;
@@ -3402,7 +3402,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, } ret = drv->bdrv_co_truncate (bs, offset, exact, prealloc, flags, errp); }else if (bs->file && drv->is_filter) { - ret =bdrv_co_truncate (bs->file, offset, exact, prealloc, errp); + ret =bdrv_co_truncate (bs->file, offset, exact, prealloc, flags, errp); }else {error_setg (errp,"Image format driver does not support resize" ); ret = -ENOTSUP ;
@@ -3435,6 +3435,7 @@ typedef struct TruncateCo {int64_t offset;bool exact;PreallocMode prealloc; +BdrvRequestFlags flags;Error **errp;int ret; } TruncateCo;
@@ -3443,12 +3444,12 @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque) {TruncateCo *tco = opaque; tco->ret =bdrv_co_truncate (tco->child, tco->offset, tco->exact, - tco->prealloc, tco->errp); + tco->prealloc, tco->flags, tco->errp);aio_wait_kick (); }int bdrv_truncate (BdrvChild *child,int64_t offset,bool exact, -PreallocMode prealloc,Error **errp) +PreallocMode prealloc,BdrvRequestFlags flags,Error **errp) {Coroutine *co;TruncateCo tco = {
@@ -3456,6 +3457,7 @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact, .offset = offset, .exact = exact, .prealloc = prealloc, + .flags = flags, .errp = errp, .ret = NOT_DONE, };
block/parallels.c +3 -3
@@ -203,7 +203,7 @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, }else { ret =bdrv_truncate (bs->file, (s->data_end + space) <<BDRV_SECTOR_BITS , - false,PREALLOC_MODE_OFF ,NULL ); + false,PREALLOC_MODE_OFF ,0 ,NULL ); }if (ret <0 ) {return ret;
@@ -493,7 +493,7 @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,* That means we have to pass exact=true. */ ret =bdrv_truncate (bs->file, res->image_end_offset, true, -PREALLOC_MODE_OFF , &local_err); +PREALLOC_MODE_OFF ,0 , &local_err);if (ret <0 ) {error_report_err (local_err); res->check_errors++;
@@ -889,7 +889,7 @@ static void parallels_close(BlockDriverState *bs)/* errors are ignored, so we might as well pass exact=true */ bdrv_truncate (bs->file, s->data_end <<BDRV_SECTOR_BITS , true, -PREALLOC_MODE_OFF ,NULL ); +PREALLOC_MODE_OFF ,0 ,NULL ); }g_free (s->bat_dirty_bmap);
block/qcow.c +2 -2
@@ -480,7 +480,7 @@ static int get_cluster_offset(BlockDriverState *bs,return -E2BIG ; } ret =bdrv_truncate (bs->file, cluster_offset + s->cluster_size, - false,PREALLOC_MODE_OFF ,NULL ); + false,PREALLOC_MODE_OFF ,0 ,NULL );if (ret <0 ) {return ret; }
@@ -1035,7 +1035,7 @@ static int qcow_make_empty(BlockDriverState *bs) l1_length) < 0)return -1 ; ret =bdrv_truncate (bs->file, s->l1_table_offset + l1_length, false, -PREALLOC_MODE_OFF ,NULL ); +PREALLOC_MODE_OFF ,0 ,NULL );if (ret <0 )return ret;
block/qcow2-refcount.c +1 -1
@@ -2018,7 +2018,7 @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res, } ret =bdrv_truncate (bs->file, offset + s->cluster_size, false, -PREALLOC_MODE_OFF , &local_err); +PREALLOC_MODE_OFF ,0 , &local_err);if (ret <0 ) {error_report_err (local_err); goto resize_fail;
block/qcow2.c +9 -6
@@ -3095,7 +3095,7 @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset, mode =PREALLOC_MODE_OFF ; } ret =bdrv_co_truncate (s->data_file, host_offset + cur_bytes, false, - mode, errp); + mode,0 , errp);if (ret <0 ) {return ret; }
@@ -4061,7 +4061,7 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,* always fulfilled, so there is no need to pass it on.) */ bdrv_co_truncate (bs->file, (last_cluster +1 ) * s->cluster_size, - false,PREALLOC_MODE_OFF , &local_err); + false,PREALLOC_MODE_OFF ,0 , &local_err);if (local_err) {warn_reportf_err (local_err,"Failed to truncate the tail of the image: " );
@@ -4083,7 +4083,8 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,* file should be resized to the exact target size, too, * so we pass @exact here. */ - ret =bdrv_co_truncate (s->data_file, offset, exact, prealloc, errp); + ret =bdrv_co_truncate (s->data_file, offset, exact, prealloc,0 , + errp);if (ret <0 ) { goto fail; }
@@ -4169,7 +4170,8 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, new_file_size = allocation_start + nb_new_data_clusters * s->cluster_size;/* Image file grows, so @exact does not matter */ - ret =bdrv_co_truncate (bs->file, new_file_size, false, prealloc, errp); + ret =bdrv_co_truncate (bs->file, new_file_size, false, prealloc,0 , + errp);if (ret <0 ) {error_prepend (errp,"Failed to resize underlying file: " ); qcow2_free_clusters(bs, allocation_start,
@@ -4348,7 +4350,8 @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs,if (len <0 ) {return len; } -return bdrv_co_truncate (bs->file, len, false,PREALLOC_MODE_OFF ,NULL ); +return bdrv_co_truncate (bs->file, len, false,PREALLOC_MODE_OFF ,0 , +NULL ); }if (offset_into_cluster (s, offset)) {
@@ -4563,7 +4566,7 @@ static int make_completely_empty(BlockDriverState *bs) } ret =bdrv_truncate (bs->file, (3 + l1_clusters) * s->cluster_size, false, -PREALLOC_MODE_OFF , &local_err); +PREALLOC_MODE_OFF ,0 , &local_err);if (ret <0 ) {error_report_err (local_err); goto fail;
block/raw-format.c +1 -1
@@ -387,7 +387,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, s->size = offset; offset += s->offset; -return bdrv_co_truncate (bs->file, offset, exact, prealloc, errp); +return bdrv_co_truncate (bs->file, offset, exact, prealloc,0 , errp); }static void raw_eject (BlockDriverState *bs,bool eject_flag)
block/vhdx-log.c +1 -1
@@ -558,7 +558,7 @@ static int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s, goto exit; } ret =bdrv_truncate (bs->file, new_file_size, false, -PREALLOC_MODE_OFF ,NULL ); +PREALLOC_MODE_OFF ,0 ,NULL );if (ret <0 ) { goto exit; }
block/vhdx.c +1 -1
@@ -1264,7 +1264,7 @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s, }return bdrv_truncate (bs->file, *new_offset + s->block_size, false, -PREALLOC_MODE_OFF ,NULL ); +PREALLOC_MODE_OFF ,0 ,NULL ); }/*
block/vmdk.c +1 -1
@@ -2077,7 +2077,7 @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset, } length =QEMU_ALIGN_UP (length,BDRV_SECTOR_SIZE ); ret =bdrv_truncate (s->extents[i].file, length, false, -PREALLOC_MODE_OFF ,NULL ); +PREALLOC_MODE_OFF ,0 ,NULL );if (ret <0 ) {return ret; }
tests/test-block-iothread.c +3 -3
@@ -186,18 +186,18 @@ static void test_sync_op_truncate(BdrvChild *c)int ret;/* Normal success path */ - ret =bdrv_truncate (c,65536 , false,PREALLOC_MODE_OFF ,NULL ); + ret =bdrv_truncate (c,65536 , false,PREALLOC_MODE_OFF ,0 ,NULL ); g_assert_cmpint(ret, ==, 0);/* Early error: Negative offset */ - ret =bdrv_truncate (c,-2 , false,PREALLOC_MODE_OFF ,NULL ); + ret =bdrv_truncate (c,-2 , false,PREALLOC_MODE_OFF ,0 ,NULL ); g_assert_cmpint(ret, ==, -EINVAL);/* Error: Read-only image */ c->bs->read_only = true; c->bs->open_flags &= ~BDRV_O_RDWR ; - ret =bdrv_truncate (c,65536 , false,PREALLOC_MODE_OFF ,NULL ); + ret =bdrv_truncate (c,65536 , false,PREALLOC_MODE_OFF ,0 ,NULL ); g_assert_cmpint(ret, ==, -EACCES); c->bs->read_only = false;
Signature · 1 line
2.25.3
PATCH v5 1/9 block: Add flags to BlockDriver.bdrv_co_truncate()
In reply to Kevin WolfThis adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate() driver callbacks, and a supported_truncate_flags field in BlockDriverState that allows drivers to advertise support for request flags in the context of truncate.
For now, we always pass 0 and no drivers declare support for any flag.
--- include/block/block_int.h | 10 +++++++++- block/crypto.c | 3 ++- block/file-posix.c | 2 +- block/file-win32.c | 2 +- block/gluster.c | 1 + block/io.c | 8 +++++++- block/iscsi.c | 2 +- block/nfs.c | 3 ++- block/qcow2.c | 2 +- block/qed.c | 1 + block/raw-format.c | 2 +- block/rbd.c | 1 + block/sheepdog.c | 4 ++-- block/ssh.c | 2 +- tests/test-block-iothread.c | 3 ++- 15 files changed, 33 insertions(+), 13 deletions(-)
include/block/block_int.h +9 -1
@@ -355,7 +355,7 @@ struct BlockDriver {*/ int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc, -Error **errp); +BdrvRequestFlags flags,Error **errp);int64_t (*bdrv_getlength)(BlockDriverState *bs);bool has_variable_length;
@@ -847,6 +847,14 @@ struct BlockDriverState {/* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA, * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */ unsigned int supported_zero_flags; +/* +* Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE). +* +* If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure +* that any added space reads as all zeros. If this can't be guaranteed, +* the operation must fail. +*/ +unsigned int supported_truncate_flags;/* the following member gives a name to every node on the bs graph. */ char node_name[32 ];
block/crypto.c +2 -1
@@ -299,7 +299,8 @@ static int block_crypto_co_create_generic(BlockDriverState *bs, static int coroutine_fnblock_crypto_co_truncate (BlockDriverState *bs,int64_t offset,bool exact, -PreallocMode prealloc,Error **errp) +PreallocMode prealloc,BdrvRequestFlags flags, +Error **errp) {BlockCrypto *crypto = bs->opaque; uint64_t payload_offset =
block/file-posix.c +1 -1
@@ -2080,7 +2080,7 @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset, static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc, -Error **errp) +BdrvRequestFlags flags,Error **errp) {BDRVRawState *s = bs->opaque;struct stat st;
block/file-win32.c +1 -1
@@ -469,7 +469,7 @@ static void raw_close(BlockDriverState *bs) static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc, -Error **errp) +BdrvRequestFlags flags,Error **errp) {BDRVRawState *s = bs->opaque;LONG low, high;
block/gluster.c +1 -0
@@ -1228,6 +1228,7 @@ static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,int64_t offset, bool exact, PreallocMode prealloc, + BdrvRequestFlags flags, Error **errp) { BDRVGlusterState *s = bs->opaque;
block/io.c +7 -1
@@ -3344,6 +3344,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,BlockDriverState *bs = child->bs;BlockDriver *drv = bs->drv;BdrvTrackedRequest req; +BdrvRequestFlags flags =0 ;int64_t old_size, new_bytes;int ret;
@@ -3394,7 +3395,12 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, }if (drv->bdrv_co_truncate) { - ret = drv->bdrv_co_truncate (bs, offset, exact, prealloc, errp); +if (flags & ~bs->supported_truncate_flags) { +error_setg (errp,"Block driver does not support requested flags" ); + ret = -ENOTSUP ; + goto out; + } + ret = drv->bdrv_co_truncate (bs, offset, exact, prealloc, flags, errp); }else if (bs->file && drv->is_filter) { ret =bdrv_co_truncate (bs->file, offset, exact, prealloc, errp); }else {
block/iscsi.c +1 -1
@@ -2124,7 +2124,7 @@ static void iscsi_reopen_commit(BDRVReopenState *reopen_state) static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc, -Error **errp) +BdrvRequestFlags flags,Error **errp) {IscsiLun *iscsilun = bs->opaque;int64_t cur_length;
block/nfs.c +2 -1
@@ -755,7 +755,8 @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs) static int coroutine_fnnfs_file_co_truncate (BlockDriverState *bs,int64_t offset,bool exact, -PreallocMode prealloc,Error **errp) +PreallocMode prealloc,BdrvRequestFlags flags, +Error **errp) {NFSClient *client = bs->opaque;int ret;
block/qcow2.c +1 -1
@@ -3964,7 +3964,7 @@ fail: static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc, -Error **errp) +BdrvRequestFlags flags,Error **errp) {BDRVQcow2State *s = bs->opaque;uint64_t old_length;
block/qed.c +1 -0
@@ -1467,6 +1467,7 @@ static int coroutine_fn bdrv_qed_co_truncate(BlockDriverState *bs,int64_t offset, bool exact, PreallocMode prealloc, + BdrvRequestFlags flags, Error **errp) { BDRVQEDState *s = bs->opaque;
block/raw-format.c +1 -1
@@ -371,7 +371,7 @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp) static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc, -Error **errp) +BdrvRequestFlags flags,Error **errp) {BDRVRawState *s = bs->opaque;
block/rbd.c +1 -0
@@ -1108,6 +1108,7 @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs,int64_t offset, bool exact, PreallocMode prealloc, + BdrvRequestFlags flags, Error **errp) { int r;
block/sheepdog.c +2 -2
@@ -2288,7 +2288,7 @@ static int64_t sd_getlength(BlockDriverState *bs) static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc, -Error **errp) +BdrvRequestFlags flags,Error **errp) {BDRVSheepdogState *s = bs->opaque;int ret, fd;
@@ -2604,7 +2604,7 @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,assert (!flags);if (offset > s->inode.vdi_size) { - ret =sd_co_truncate (bs, offset, false,PREALLOC_MODE_OFF ,NULL ); + ret =sd_co_truncate (bs, offset, false,PREALLOC_MODE_OFF ,0 ,NULL );if (ret <0 ) {return ret; }
block/ssh.c +1 -1
@@ -1298,7 +1298,7 @@ static int64_t ssh_getlength(BlockDriverState *bs) static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,bool exact,PreallocMode prealloc, -Error **errp) +BdrvRequestFlags flags,Error **errp) {BDRVSSHState *s = bs->opaque;
tests/test-block-iothread.c +2 -1
@@ -46,7 +46,8 @@ static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs, static int coroutine_fnbdrv_test_co_truncate (BlockDriverState *bs,int64_t offset,bool exact, -PreallocMode prealloc,Error **errp) +PreallocMode prealloc,BdrvRequestFlags flags, +Error **errp) {return 0 ; }
Signature · 1 line
2.25.3
v5 cover block: Fix resize (extending) of short overlays
v5:
- Fixed file-win32 [Patchew]
- Fixed zeroing in qcow2 for unaligned requests + tests [Vladimir]
- Made raw-format code more consistent [Eric]
- Leave output for existing iotests cases unchanged [Vladimir]
v4:
- Rewrote the series to move the actual zeroing to the block drivers so that error paths can work correctly and potentially long-running fallback to writing explicit zeroes is avoided.
- Fixed output filtering order in the test case [Max]
v3:
- Don't allow blocking the monitor for a zero write in block_resize (even though we can already blockfor other reasons there). This is mainly responsible for the increased complexity compared to v2. Personally, I think this is not an improvement over v2, but if this is what it takes to fix a corruption issue in 4.2... [Max]
- Don't use huge image files in the test case [Vladimir]
v2:
- Switched order of bs->total_sectors update and zero write [Vladimir]
- Fixed coding style [Vladimir]
- Changed the commit message to contain what was in the cover letter
- Test all preallocation modes
- Test allocation status with qemu-io 'map' [Vladimir]
Kevin Wolf (9):
block: Add flags to BlockDriver.bdrv_co_truncate()
block: Add flags to bdrv(_co)_truncate()
block-backend: Add flags to blk_truncate()
qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
block: truncate: Don't make backing file data visible
iotests: Filter testfiles out in filter_img_info()
iotests: Test committing to short backing file
include/block/block.h | 5 +- include/block/block_int.h | 10 +- include/sysemu/block-backend.h | 2 +- block.c | 3 +- block/block-backend.c | 4 +- block/commit.c | 4 +- block/crypto.c | 7 +- block/file-posix.c | 6 +- block/file-win32.c | 2 +- block/gluster.c | 1 + block/io.c | 32 +++- block/iscsi.c | 2 +- block/mirror.c | 2 +- block/nfs.c | 3 +- block/parallels.c | 6 +- block/qcow.c | 4 +- block/qcow2-refcount.c | 2 +- block/qcow2.c | 51 +++++-- block/qed.c | 3 +- block/raw-format.c | 6 +- block/rbd.c | 1 + block/sheepdog.c | 4 +- block/ssh.c | 2 +- block/vdi.c | 2 +- block/vhdx-log.c | 2 +- block/vhdx.c | 6 +- block/vmdk.c | 8 +- block/vpc.c | 2 +- blockdev.c | 2 +- qemu-img.c | 2 +- qemu-io-cmds.c | 2 +- tests/test-block-iothread.c | 9 +- tests/qemu-iotests/iotests.py | 5 +- tests/qemu-iotests/274 | 157 ++++++++++++++++++++ tests/qemu-iotests/274.out | 260 +++++++++++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 36 files changed, 558 insertions(+), 62 deletions(-) create mode 100755 tests/qemu-iotests/274 create mode 100644 tests/qemu-iotests/274.out
Signature · 1 line
2.25.3
PATCH v5 6/9 file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the OS, so we can advertise the flag and just ignore it.
--- block/file-posix.c | 4 ++++ 1 file changed, 4 insertions(+)
block/file-posix.c +4 -0
@@ -702,6 +702,10 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,#endif bs->supported_zero_flags =BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ; +if (S_ISREG (st.st_mode)) { +/* When extending regular files, we get zeros from the OS */ + bs->supported_truncate_flags =BDRV_REQ_ZERO_WRITE ; + } ret =0 ; fail:if (filename && (bdrv_flags &BDRV_O_TEMPORARY )) {
Signature · 1 line
2.25.3
PATCH v5 3/9 block-backend: Add flags to blk_truncate()
In reply to Kevin WolfNow that node level interface bdrv_truncate() supports passing request flags to the block driver, expose this on the BlockBackend level, too.
--- include/sysemu/block-backend.h | 2 +- block.c | 3 ++- block/block-backend.c | 4 ++-- block/commit.c | 4 ++-- block/crypto.c | 2 +- block/mirror.c | 2 +- block/qcow2.c | 4 ++-- block/qed.c | 2 +- block/vdi.c | 2 +- block/vhdx.c | 4 ++-- block/vmdk.c | 6 +++--- block/vpc.c | 2 +- blockdev.c | 2 +- qemu-img.c | 2 +- qemu-io-cmds.c | 2 +- 15 files changed, 22 insertions(+), 21 deletions(-)
include/sysemu/block-backend.h +1 -1
@@ -237,7 +237,7 @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,int blk_pwrite_compressed (BlockBackend *blk,int64_t offset,const void *buf,int bytes);int blk_truncate (BlockBackend *blk,int64_t offset,bool exact, -PreallocMode prealloc,Error **errp); +PreallocMode prealloc,BdrvRequestFlags flags,Error **errp);int blk_pdiscard (BlockBackend *blk,int64_t offset,int bytes);int blk_save_vmstate (BlockBackend *blk,const uint8_t *buf,int64_t pos,int size);
block.c +2 -1
@@ -548,7 +548,8 @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,int64_t size;int ret; - ret =blk_truncate (blk, minimum_size, false,PREALLOC_MODE_OFF , &local_err); + ret =blk_truncate (blk, minimum_size, false,PREALLOC_MODE_OFF ,0 , + &local_err);if (ret <0 && ret != -ENOTSUP ) {error_propagate (errp, local_err);return ret;
block/block-backend.c +2 -2
@@ -2137,14 +2137,14 @@ int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf, }int blk_truncate (BlockBackend *blk,int64_t offset,bool exact, -PreallocMode prealloc,Error **errp) +PreallocMode prealloc,BdrvRequestFlags flags,Error **errp) {if (!blk_is_available (blk)) {error_setg (errp,"No medium inserted" );return -ENOMEDIUM ; } -return bdrv_truncate (blk->root, offset, exact, prealloc,0 , errp); +return bdrv_truncate (blk->root, offset, exact, prealloc, flags, errp); } int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
block/commit.c +2 -2
@@ -133,7 +133,7 @@ static int coroutine_fn commit_run(Job *job, Error **errp) }if (base_len < len) { - ret =blk_truncate (s->base, len, false,PREALLOC_MODE_OFF ,NULL ); + ret =blk_truncate (s->base, len, false,PREALLOC_MODE_OFF ,0 ,NULL );if (ret) { goto out; }
@@ -458,7 +458,7 @@ int bdrv_commit(BlockDriverState *bs)* grow the backing file image if possible. If not possible, * we must return an error */ if (length > backing_length) { - ret =blk_truncate (backing, length, false,PREALLOC_MODE_OFF , + ret =blk_truncate (backing, length, false,PREALLOC_MODE_OFF ,0 , &local_err);if (ret <0 ) {error_report_err (local_err);
block/crypto.c +1 -1
@@ -115,7 +115,7 @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,* which will be used by the crypto header */ return blk_truncate (data->blk, data->size + headerlen, false, - data->prealloc, errp); + data->prealloc,0 , errp); }
block/mirror.c +1 -1
@@ -900,7 +900,7 @@ static int coroutine_fn mirror_run(Job *job, Error **errp)if (s->bdev_length > base_length) { ret =blk_truncate (s->target, s->bdev_length, false, -PREALLOC_MODE_OFF ,NULL ); +PREALLOC_MODE_OFF ,0 ,NULL );if (ret <0 ) { goto immediate_exit; }
block/qcow2.c +2 -2
@@ -3511,7 +3511,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)/* Okay, now that we have a valid image, let's give it the right size */ ret =blk_truncate (blk, qcow2_opts->size, false, qcow2_opts->preallocation, - errp); +0 , errp);if (ret <0 ) {error_prepend (errp,"Could not resize image: " ); goto out;
@@ -5374,7 +5374,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,* Amending image options should ensure that the image has * exactly the given new values, so pass exact=true here. */ - ret =blk_truncate (blk, new_size, true,PREALLOC_MODE_OFF , errp); + ret =blk_truncate (blk, new_size, true,PREALLOC_MODE_OFF ,0 , errp);blk_unref (blk);if (ret <0 ) {return ret;
block/qed.c +1 -1
@@ -677,7 +677,7 @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,* The QED format associates file length with allocation status, * so a new file (which is empty) must have a length of 0. */ - ret =blk_truncate (blk,0 , true,PREALLOC_MODE_OFF , errp); + ret =blk_truncate (blk,0 , true,PREALLOC_MODE_OFF ,0 , errp);if (ret <0 ) { goto out; }
block/vdi.c +1 -1
@@ -875,7 +875,7 @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,if (image_type ==VDI_TYPE_STATIC ) { ret =blk_truncate (blk, offset + blocks * block_size, false, -PREALLOC_MODE_OFF , errp); +PREALLOC_MODE_OFF ,0 , errp);if (ret <0 ) {error_prepend (errp,"Failed to statically allocate file" ); goto exit;
block/vhdx.c +2 -2
@@ -1703,13 +1703,13 @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,/* All zeroes, so we can just extend the file - the end of the BAT * is the furthest thing we have written yet */ ret =blk_truncate (blk, data_file_offset, false,PREALLOC_MODE_OFF , - errp); +0 , errp);if (ret <0 ) { goto exit; } }else if (type ==VHDX_TYPE_FIXED ) { ret =blk_truncate (blk, data_file_offset + image_size, false, -PREALLOC_MODE_OFF , errp); +PREALLOC_MODE_OFF ,0 , errp);if (ret <0 ) { goto exit; }
block/vmdk.c +3 -3
@@ -2118,7 +2118,7 @@ static int vmdk_init_extent(BlockBackend *blk,int gd_buf_size;if (flat) { - ret =blk_truncate (blk, filesize, false,PREALLOC_MODE_OFF , errp); + ret =blk_truncate (blk, filesize, false,PREALLOC_MODE_OFF ,0 , errp); goto exit; } magic =cpu_to_be32 (VMDK4_MAGIC );
@@ -2182,7 +2182,7 @@ static int vmdk_init_extent(BlockBackend *blk, } ret =blk_truncate (blk,le64_to_cpu (header.grain_offset) <<9 , false, -PREALLOC_MODE_OFF , errp); +PREALLOC_MODE_OFF ,0 , errp);if (ret <0 ) { goto exit; }
@@ -2523,7 +2523,7 @@ static int coroutine_fn vmdk_co_do_create(int64_t size,/* bdrv_pwrite write padding zeros to align to sector, we don't need that * for description file */ if (desc_offset ==0 ) { - ret =blk_truncate (blk, desc_len, false,PREALLOC_MODE_OFF , errp); + ret =blk_truncate (blk, desc_len, false,PREALLOC_MODE_OFF ,0 , errp);if (ret <0 ) { goto exit; }
block/vpc.c +1 -1
@@ -898,7 +898,7 @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,/* Add footer to total size */ total_size +=HEADER_SIZE ; - ret =blk_truncate (blk, total_size, false,PREALLOC_MODE_OFF , errp); + ret =blk_truncate (blk, total_size, false,PREALLOC_MODE_OFF ,0 , errp);if (ret <0 ) {return ret; }
blockdev.c +1 -1
@@ -2741,7 +2741,7 @@ void qmp_block_resize(bool has_device, const char *device, }bdrv_drained_begin (bs); - ret =blk_truncate (blk, size, false,PREALLOC_MODE_OFF , errp); + ret =blk_truncate (blk, size, false,PREALLOC_MODE_OFF ,0 , errp);bdrv_drained_end (bs); out:
qemu-img.c +1 -1
@@ -3866,7 +3866,7 @@ static int img_resize(int argc, char **argv)* resizing, so pass @exact=true. It is of no use to report * success when the image has not actually been resized. */ - ret =blk_truncate (blk, total_size, true, prealloc, &err); + ret =blk_truncate (blk, total_size, true, prealloc,0 , &err);if (!ret) {qprintf (quiet,"Image resized.\n" ); }else {
qemu-io-cmds.c +1 -1
@@ -1715,7 +1715,7 @@ static int truncate_f(BlockBackend *blk, int argc, char **argv)* exact=true. It is better to err on the "emit more errors" side * than to be overly permissive. */ - ret =blk_truncate (blk, offset, true,PREALLOC_MODE_OFF , &local_err); + ret =blk_truncate (blk, offset, true,PREALLOC_MODE_OFF ,0 , &local_err);if (ret <0 ) {error_report_err (local_err);return ret;
Signature · 1 line
2.25.3
PATCH v5 4/9 qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Kevin WolfIf BDRV_REQ_ZERO_WRITE is set and we're extending the image, calling qcow2_cluster_zeroize() with flags=0 does the right thing: It doesn't undo any previous preallocation, but just adds the zero flag to all relevant L2 entries. If an external data file is in use, a write_zeroes request to the data file is made instead.
--- block/qcow2.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)
block/qcow2.c +30 -0
@@ -1726,6 +1726,7 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options, bs->supported_zero_flags = header.version >=3 ?BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK :0 ; + bs->supported_truncate_flags =BDRV_REQ_ZERO_WRITE ;/* Repair image if dirty */ if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
@@ -4214,6 +4215,35 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,g_assert_not_reached (); } +if ((flags &BDRV_REQ_ZERO_WRITE ) && offset > old_length) { +uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size); +uint64_t zero_end =QEMU_ALIGN_UP (offset, s->cluster_size); + +/* Use zero clusters as much as we can */ + ret =qcow2_cluster_zeroize (bs, zero_start, zero_end - zero_start,0 ); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Failed to zero out the new area" ); + goto fail; + } + +/* Write explicit zeros for the unaligned head */ +if (zero_start > old_length) { +uint8_t *buf =qemu_blockalign0 (bs, s->cluster_size); +QEMUIOVector qiov; +qemu_iovec_init_buf (&qiov, buf, zero_start - old_length); + +qemu_co_mutex_unlock (&s->lock); + ret =qcow2_co_pwritev_part (bs, old_length, qiov.size, &qiov,0 ,0 ); +qemu_co_mutex_lock (&s->lock); + +qemu_vfree (buf); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Failed to zero out the new area" ); + goto fail; + } + } + } +if (prealloc !=PREALLOC_MODE_OFF ) {/* Flush metadata before actually changing the image size */ ret =qcow2_write_caches (bs);
Signature · 1 line
2.25.3
PATCH v5 5/9 raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Kevin WolfThe raw format driver can simply forward the flag and let its bs->file child take care of actually providing the zeros.
--- block/raw-format.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
block/raw-format.c +3 -1
@@ -387,7 +387,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, s->size = offset; offset += s->offset; -return bdrv_co_truncate (bs->file, offset, exact, prealloc,0 , errp); +return bdrv_co_truncate (bs->file, offset, exact, prealloc, flags, errp); }static void raw_eject (BlockDriverState *bs,bool eject_flag)
@@ -445,6 +445,8 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags, bs->supported_zero_flags =BDRV_REQ_WRITE_UNCHANGED | ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & bs->file->bs->supported_zero_flags); + bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags & +BDRV_REQ_ZERO_WRITE ;if (bs->probed && !bdrv_is_read_only (bs)) {bdrv_refresh_filename (bs->file->bs);
Signature · 1 line
2.25.3
PATCH v5 9/9 iotests: Test committing to short backing file
In reply to Kevin Wolf--- tests/qemu-iotests/274 | 157 ++++++++++++++++++++++ tests/qemu-iotests/274.out | 260 +++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 418 insertions(+) create mode 100755 tests/qemu-iotests/274 create mode 100644 tests/qemu-iotests/274.out
tests/qemu-iotests/274 new file +157 -0
@@ -0,0 +1,157 @@ +#!/usr/bin/env python3 +# +# Copyright (C) 2019 Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# +# Creator/Owner: Kevin Wolf <[email protected]> +# +# Some tests for short backing files and short overlays + +import iotests +import os + +iotests.verify_image_format(supported_fmts=['qcow2']) +iotests.verify_platform(['linux']) + +size_short = 1 * 1024 * 1024 +size_long = 2 * 1024 * 1024 +size_diff = size_long - size_short + +def create_chain(): + iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, + str(size_long)) + iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid, + str(size_short)) + iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top, + str(size_long)) + + iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base) + +def create_vm(): + vm = iotests.VM() + vm.add_blockdev('file,filename=%s,node-name=base-file' % (base)) + vm.add_blockdev('%s,file=base-file,node-name=base' % (iotests.imgfmt)) + vm.add_blockdev('file,filename=%s,node-name=mid-file' % (mid)) + vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base' % (iotests.imgfmt)) + vm.add_drive(top, 'backing=mid,node-name=top') + return vm + +with iotests.FilePath('base') as base, \ + iotests.FilePath('mid') as mid, \ + iotests.FilePath('top') as top: + + iotests.log('== Commit tests ==') + + create_chain() + + iotests.log('=== Check visible data ===') + + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top) + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top) + + iotests.log('=== Checking allocation status ===') + + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, + '-c', 'alloc %d %d' % (size_short, size_diff), + base) + + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, + '-c', 'alloc %d %d' % (size_short, size_diff), + mid) + + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, + '-c', 'alloc %d %d' % (size_short, size_diff), + top) + + iotests.log('=== Checking map ===') + + iotests.qemu_img_log('map', '--output=json', base) + iotests.qemu_img_log('map', '--output=human', base) + iotests.qemu_img_log('map', '--output=json', mid) + iotests.qemu_img_log('map', '--output=human', mid) + iotests.qemu_img_log('map', '--output=json', top) + iotests.qemu_img_log('map', '--output=human', top) + + iotests.log('=== Testing qemu-img commit (top -> mid) ===') + + iotests.qemu_img_log('commit', top) + iotests.img_info_log(mid) + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid) + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid) + + iotests.log('=== Testing HMP commit (top -> mid) ===') + + create_chain() + with create_vm() as vm: + vm.launch() + vm.qmp_log('human-monitor-command', command_line='commit drive0') + + iotests.img_info_log(mid) + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid) + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid) + + iotests.log('=== Testing QMP active commit (top -> mid) ===') + + create_chain() + with create_vm() as vm: + vm.launch() + vm.qmp_log('block-commit', device='top', base_node='mid', + job_id='job0', auto_dismiss=False) + vm.run_job('job0', wait=5) + + iotests.img_info_log(mid) + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid) + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid) + + + iotests.log('== Resize tests ==') + + # Use different sizes for different allocation modes: + # + # We want to have at least one test where 32 bit truncation in the size of + # the overlapping area becomes visible. This is covered by the + # prealloc='off' case (1G to 6G is an overlap of 5G). + # + # However, we can only do this for modes that don't preallocate data + # because otherwise we might run out of space on the test host. + # + # We also want to test some unaligned combinations. + for (prealloc, base_size, top_size_old, top_size_new, off) in [ + ('off', '6G', '1G', '8G', '5G'), + ('metadata', '32G', '30G', '33G', '31G'), + ('falloc', '10M', '5M', '15M', '9M'), + ('full', '16M', '8M', '12M', '11M'), + ('off', '384k', '253k', '512k', '253k'), + ('off', '400k', '256k', '512k', '336k'), + ('off', '512k', '256k', '500k', '436k')]: + + iotests.log('=== preallocation=%s ===' % prealloc) + iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size) + iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top, + top_size_old) + iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base) + + # After this, 0 to base_size should be allocated/zeroed + # base_size to top_size_new should be unallocated with + # preallocation=off and allocated with preallocation enabled + iotests.qemu_img_log('resize', '-f', iotests.imgfmt, + '--preallocation', prealloc, top, top_size_new) + iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top) + + # Metadata preallocation doesn't have a defined result on the file + # system level with respect to holes, so skip it here + iotests.qemu_io_log('-c', 'map', top) + if prealloc != 'metadata': + iotests.qemu_img_log('map', '--output=json', top)
tests/qemu-iotests/274.out new file +260 -0
260 lines not on this page · raw message
tests/qemu-iotests/group +1 -0
@@ -286,6 +286,7 @@ 270 rw backing quick 272 rw 273 backing quick +274 rw backing 277 rw quick 279 rw backing quick 280 rw migration quick
Signature · 1 line
2.25.3
PATCH v5 8/9 iotests: Filter testfiles out in filter_img_info()
In reply to Kevin WolfWe want to keep TEST_IMG for the full path of the main test image, but filter_testfiles() must be called for other test images before replacing other things like the image format because the test directory path could contain the format as a substring.
Insert a filter_testfiles() call between both.
--- tests/qemu-iotests/iotests.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
tests/qemu-iotests/iotests.py +3 -2
@@ -338,8 +338,9 @@ def filter_img_info(output, filename): for line in output.split('\n'): if 'disk size' in line or 'actual-size' in line: continue - line = line.replace(filename, 'TEST_IMG') \ - .replace(imgfmt, 'IMGFMT') + line = line.replace(filename, 'TEST_IMG') + line = filter_testfiles(line) + line = line.replace(imgfmt, 'IMGFMT') line = re.sub('iters: [0-9]+', 'iters: XXX', line) line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line) line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line)
Signature · 1 line
2.25.3
PATCH v5 7/9 block: truncate: Don't make backing file data visible
In reply to Kevin WolfWhen extending the size of an image that has a backing file larger than its old size, make sure that the backing file data doesn't become visible in the guest, but the added area is properly zeroed out.
Consider the following scenario where the overlay is shorter than its backing file:
base.qcow2: AAAAAAAA
overlay.qcow2: BBBB
When resizing (extending) overlay.qcow2, the new blocks should not stay unallocated and make the additional As from base.qcow2 visible like before this patch, but zeros should be read.
A similar case happens with the various variants of a commit job when an intermediate file is short (- for unallocated):
base.qcow2: A-A-AAAA
mid.qcow2: BB-B
top.qcow2: C--C--C-After commit top.qcow2 to mid.qcow2, the following happens:
mid.qcow2: CB-C00C0 (correct result)
mid.qcow2: CB-C--C- (before this fix)
Without the fix, blocks that previously read as zeros on top.qcow2 suddenly turn into A.
--- block/io.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
block/io.c +14 -0
@@ -3394,6 +3394,20 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, goto out; } +/* +* If the image has a backing file that is large enough that it would +* provide data for the new area, we cannot leave it unallocated because +* then the backing file content would become visible. Instead, zero-fill +* the new area. +* +* Note that if the image has a backing file, but was opened without the +* backing file, taking care of keeping things consistent with that backing +* file is the user's responsibility. +*/ +if (new_bytes && bs->backing) { + flags |=BDRV_REQ_ZERO_WRITE ; + } +if (drv->bdrv_co_truncate) {if (flags & ~bs->supported_truncate_flags) {error_setg (errp,"Block driver does not support requested flags" );
Signature · 1 line
2.25.3
Re: [PATCH v5 4/9] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Kevin WolfQuoted 13 lines · Kevin Wolf
If
BDRV_REQ_ZERO_WRITEis set and we're extending the image, callingqcow2_cluster_zeroize()with flags=0 does the right thing: It doesn't undo any previous preallocation, but just adds the zero flag to all relevant L2 entries. If an external data file is in use, awrite_zeroesrequest to the data file is made instead.Signed-off-by Kevin Wolf <[email protected]>--- block/qcow2.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)
block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4220
Quoted 6 lines
block/qcow2.c +3
-0@@ -4214,6 +4215,35 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,g_assert_not_reached (); } +if ((flags &BDRV_REQ_ZERO_WRITE ) && offset > old_length) { +uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size); +uint64_t zero_end =QEMU_ALIGN_UP (offset, s->cluster_size);
This rounds up beyond the new size...
block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4223
Quoted 3 lines
block/qcow2.c +3
-0+ +/* Use zero clusters as much as we can */ + ret =qcow2_cluster_zeroize (bs, zero_start, zero_end - zero_start,0 );
and then requests that the extra be zeroed. Does that always work, even when it results in pdrv_co_pwrite_zeroes beyond the end of s->data_file?
If so,
otherwise, you may have to treat the tail specially, the same way you treated an unaligned head.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 5/9] raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Kevin WolfQuoted 8 lines · Kevin Wolf
The raw format driver can simply forward the flag and let its
bs->filechild take care of actually providing the zeros.Signed-off-by Kevin Wolf <[email protected]>--- block/raw-format.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
Quoted 23 lines
block/raw-format.c +3
-1@@ -387,7 +387,7 @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, s->size = offset; offset += s->offset; -return bdrv_co_truncate (bs->file, offset, exact, prealloc,0 , errp); +return bdrv_co_truncate (bs->file, offset, exact, prealloc, flags, errp); }static void raw_eject (BlockDriverState *bs,bool eject_flag)@@ -445,6 +445,8 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags, bs->supported_zero_flags =BDRV_REQ_WRITE_UNCHANGED | ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & bs->file->bs->supported_zero_flags); + bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags & +BDRV_REQ_ZERO_WRITE ;if (bs->probed && !bdrv_is_read_only (bs)) {bdrv_refresh_filename (bs->file->bs);
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 4/9] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Eric BlakeAm 22.04.2020 um 17:33 hat Eric Blake geschrieben:
Quoted 22 lines · Kevin Wolf
Quoted 13 lines
If
BDRV_REQ_ZERO_WRITEis set and we're extending the image, callingqcow2_cluster_zeroize()with flags=0 does the right thing: It doesn't undo any previous preallocation, but just adds the zero flag to all relevant L2 entries. If an external data file is in use, awrite_zeroesrequest to the data file is made instead.Signed-off-by Kevin Wolf <[email protected]>--- block/qcow2.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4219
Quoted 5 lines
block/qcow2.c +3
-0@@ -4214,6 +4215,35 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,g_assert_not_reached (); } +if ((flags &BDRV_REQ_ZERO_WRITE ) && offset > old_length) { +uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size); +uint64_t zero_end =QEMU_ALIGN_UP (offset, s->cluster_size);This rounds up beyond the new size...
Quoted 6 lines
block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4223
Quoted 3 lines
block/qcow2.c +3
-0+ +/* Use zero clusters as much as we can */ + ret =qcow2_cluster_zeroize (bs, zero_start, zero_end - zero_start,0 );and then requests that the extra be zeroed. Does that always work, even when it results in
pdrv_co_pwrite_zeroesbeyond the end ofs->data_file?
You mean the data_file_is_raw() path in qcow2_cluster_zeroize()? It's currently not a code path that is run because we only set BDRV_REQ_ZERO_WRITE for truncate if the image has a backing file, and data_file_is_raw() doesn't work with backing files.
But hypothetically, if someone called truncate with BDRV_REQ_ZERO_WRITE for such a file, I think it would fail.
Quoted 6 lines
If so,
Reviewed-by Eric Blake <[email protected]>otherwise, you may have to treat the tail specially, the same way you treated an unaligned head.
Actually, do I even need to round the tail?
/* Caller must pass aligned values, except at image end */
assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
end_offset == bs->total_sectors << BDRV_SECTOR_BITS);So qcow2_cluster_zeroize() seems to accept the unaligned tail. It would still set the zero flag for the partial last cluster and for the external data file, bdrv_co_pwrite_zeroes() would have the correct size.
Kevin
Re: [PATCH v5 4/9] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
Quoted 13 lines · Kevin Wolf
Quoted 13 lines
block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4219
Quoted 6 lines
block/qcow2.c +3
-0@@ -4214,6 +4215,35 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,g_assert_not_reached (); } +if ((flags &BDRV_REQ_ZERO_WRITE ) && offset > old_length) { +uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size); +uint64_t zero_end =QEMU_ALIGN_UP (offset, s->cluster_size);This rounds up beyond the new size...
Quoted 3 lines
block/qcow2.c +3
-0+ +/* Use zero clusters as much as we can */ + ret =qcow2_cluster_zeroize (bs, zero_start, zero_end - zero_start,0 );
Quoted 7 lines
Quoted 2 lines
and then requests that the extra be zeroed. Does that always work, even when it results in
pdrv_co_pwrite_zeroesbeyond the end ofs->data_file?You mean the
data_file_is_raw()path inqcow2_cluster_zeroize()? It's currently not a code path that is run because we only setBDRV_REQ_ZERO_WRITEfor truncate if the image has a backing file, anddata_file_is_raw()doesn't work with backing files.
Good point.
Quoted 13 lines
But hypothetically, if someone called truncate with
BDRV_REQ_ZERO_WRITEfor such a file, I think it would fail.Quoted 6 lines
If so,
Reviewed-by Eric Blake <[email protected]>otherwise, you may have to treat the tail specially, the same way you treated an unaligned head.
Actually, do I even need to round the tail?
Quoted 8 lines
/* Caller must pass aligned values, except at image end */ assert(QEMU_IS_ALIGNED(offset, s->cluster_size)); assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) || end_offset == bs->total_sectors << BDRV_SECTOR_BITS);So
qcow2_cluster_zeroize()seems to accept the unaligned tail. It would still set the zero flag for the partial last cluster and for the external data file,bdrv_co_pwrite_zeroes()would have the correct size.
Then I'm in favor of NOT rounding the tail. That's an easy enough change and we've now justified that it does what we want, so R-b stands with that one-line tweak.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v5 1/9] block: Add flags to BlockDriver.bdrv_co_truncate()
In reply to Kevin WolfQuoted 19 lines · Kevin Wolf
This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate() driver callbacks, and a
supported_truncate_flagsfield in BlockDriverState that allows drivers to advertise support for request flags in the context of truncate.For now, we always pass 0 and no drivers declare support for any flag.
Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>--- include/block/block_int.h | 10 +++++++++- block/crypto.c | 3 ++- block/file-posix.c | 2 +- block/file-win32.c | 2 +- block/gluster.c | 1 + block/io.c | 8 +++++++- block/iscsi.c | 2 +- block/nfs.c | 3 ++-
Quoted 8 lines
block/qcow2.c | 2 +- block/qed.c | 1 + block/raw-format.c | 2 +- block/rbd.c | 1 + block/sheepdog.c | 4 ++-- block/ssh.c | 2 +- tests/test-block-iothread.c | 3 ++- 15 files changed, 33 insertions(+), 13 deletions(-)
(I know I haven’t complained before, so *shrug*, but I wonder now whether it actually makes sense to have the same BdrvRequestFlags for all request types. Or why we have the same flags type for read, write, and zero-write already.)
Re: [PATCH v5 2/9] block: Add flags to bdrv(_co)_truncate()
In reply to Kevin WolfQuoted 7 lines · Kevin Wolf
Now that block drivers can support flags for .bdrv_co_truncate, expose the parameter in the node level interfaces
bdrv_co_truncate()andbdrv_truncate().Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>
Quoted 15 lines
--- include/block/block.h | 5 +++-- block/block-backend.c | 2 +- block/crypto.c | 2 +- block/io.c | 12 +++++++----- block/parallels.c | 6 +++--- block/qcow.c | 4 ++-- block/qcow2-refcount.c | 2 +- block/qcow2.c | 15 +++++++++------ block/raw-format.c | 2 +- block/vhdx-log.c | 2 +- block/vhdx.c | 2 +- block/vmdk.c | 2 +- tests/test-block-iothread.c | 6 +++--- 13 files changed, 34 insertions(+), 28 deletions(-)
Re: [PATCH v5 3/9] block-backend: Add flags to blk_truncate()
In reply to Kevin WolfQuoted 15 lines · Kevin Wolf
Now that node level interface
bdrv_truncate()supports passing request flags to the block driver, expose this on the BlockBackend level, too.Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>--- include/sysemu/block-backend.h | 2 +- block.c | 3 ++- block/block-backend.c | 4 ++-- block/commit.c | 4 ++-- block/crypto.c | 2 +- block/mirror.c | 2 +- block/qcow2.c | 4 ++-- block/qed.c | 2 +-
Quoted 8 lines
block/vdi.c | 2 +- block/vhdx.c | 4 ++-- block/vmdk.c | 6 +++--- block/vpc.c | 2 +- blockdev.c | 2 +- qemu-img.c | 2 +- qemu-io-cmds.c | 2 +- 15 files changed, 22 insertions(+), 21 deletions(-)
Re: [PATCH v5 4/9] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Kevin WolfQuoted 15 lines · Kevin Wolf
If
BDRV_REQ_ZERO_WRITEis set and we're extending the image, callingqcow2_cluster_zeroize()with flags=0 does the right thing: It doesn't undo any previous preallocation, but just adds the zero flag to all relevant L2 entries. If an external data file is in use, awrite_zeroesrequest to the data file is made instead.Signed-off-by Kevin Wolf <[email protected]>--- block/qcow2.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)block/qcow2.c +0
-0
[...]
block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4223
Quoted 10 lines
block/qcow2.c +6
-0@@ -4214,6 +4215,35 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,g_assert_not_reached (); } +if ((flags &BDRV_REQ_ZERO_WRITE ) && offset > old_length) { +uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size); +uint64_t zero_end =QEMU_ALIGN_UP (offset, s->cluster_size); + +/* Use zero clusters as much as we can */ + ret =qcow2_cluster_zeroize (bs, zero_start, zero_end - zero_start,0 );
It’s kind of a pity that this changes the cluster mappings that were established when using falloc/full preallocation already (i.e., they become preallocated zero clusters then, so when writing to them, we need COW again).
But falloc/full preallocation do not guarantee that the new data is zero, so I suppose this is the only thing we can reasonably do.
I personally don’t really care about whether zero_end is aligned or not, so either way:
Re: [PATCH v5 5/9] raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Kevin WolfQuoted 7 lines · Kevin Wolf
The raw format driver can simply forward the flag and let its
bs->filechild take care of actually providing the zeros.Signed-off-by Kevin Wolf <[email protected]>--- block/raw-format.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
Re: [PATCH v5 6/9] file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Kevin WolfQuoted 9 lines · Kevin Wolf
For regular files, we always get
BDRV_REQ_ZERO_WRITEbehaviour from the OS, so we can advertise the flag and just ignore it.Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>--- block/file-posix.c | 4 ++++ 1 file changed, 4 insertions(+)
Re: [PATCH v5 7/9] block: truncate: Don't make backing file data visible
In reply to Kevin WolfQuoted 46 lines · Kevin Wolf
When extending the size of an image that has a backing file larger than its old size, make sure that the backing file data doesn't become visible in the guest, but the added area is properly zeroed out.
Consider the following scenario where the overlay is shorter than its backing file:
base.qcow2: AAAAAAAA
overlay.qcow2: BBBBWhen resizing (extending) overlay.qcow2, the new blocks should not stay unallocated and make the additional As from base.qcow2 visible like before this patch, but zeros should be read.
A similar case happens with the various variants of a commit job when an intermediate file is short (- for unallocated):
base.qcow2: A-A-AAAA mid.qcow2: BB-B top.qcow2: C--C--C-After commit top.qcow2 to mid.qcow2, the following happens:
mid.qcow2: CB-C00C0 (correct result)
mid.qcow2: CB-C--C- (before this fix)Without the fix, blocks that previously read as zeros on top.qcow2 suddenly turn into A.
Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Alberto Garcia <[email protected]>--- block/io.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)block/io.c +3
-0@@ -3394,6 +3394,20 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, goto out; } +/* +* If the image has a backing file that is large enough that it would +* provide data for the new area, we cannot leave it unallocated because
block/io.c int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, · line 3409
Quoted 10 lines
block/io.c +10
-0+* then the backing file content would become visible. Instead, zero-fill +* the new area. +* +* Note that if the image has a backing file, but was opened without the +* backing file, taking care of keeping things consistent with that backing +* file is the user's responsibility. +*/ +if (new_bytes && bs->backing) { + flags |=BDRV_REQ_ZERO_WRITE ; + }
This breaks growing any non-qcow2 image with any backing file. Do we care about that?
The comment says something about “a backing file that is large enough that it would provide data for the new area”, but that condition doesn’t appear in the code. Should it? (If it did, I think the number of cases this change broke would be much smaller.)
If it was deliberate to not have that condition here, and if we decide that we don’t care about non-qcow2 formats here, then I think at least the error message deserves some improvement over “qemu-img: Block driver does not support requested flags”.
Max
Re: [PATCH v5 8/9] iotests: Filter testfiles out in filter_img_info()
In reply to Kevin WolfQuoted 11 lines · Kevin Wolf
We want to keep
TEST_IMGfor the full path of the main test image, butfilter_testfiles()must be called for other test images before replacing other things like the image format because the test directory path could contain the format as a substring.Insert a
filter_testfiles()call between both.Signed-off-by Kevin Wolf <[email protected]>--- tests/qemu-iotests/iotests.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
Re: [PATCH v5 9/9] iotests: Test committing to short backing file
In reply to Kevin WolfQuoted 8 lines · Kevin Wolf
Signed-off-by Kevin Wolf <[email protected]>--- tests/qemu-iotests/274 | 157 ++++++++++++++++++++++ tests/qemu-iotests/274.out | 260 +++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 418 insertions(+) create mode 100755 tests/qemu-iotests/274 create mode 100644 tests/qemu-iotests/274.out
Re: [PATCH v5 1/9] block: Add flags to BlockDriver.bdrv_co_truncate()
In reply to Max ReitzAm 23.04.2020 um 11:41 hat Max Reitz geschrieben:
Quoted 29 lines · Kevin Wolf
Quoted 19 lines
This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate() driver callbacks, and a
supported_truncate_flagsfield in BlockDriverState that allows drivers to advertise support for request flags in the context of truncate.For now, we always pass 0 and no drivers declare support for any flag.
Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>--- include/block/block_int.h | 10 +++++++++- block/crypto.c | 3 ++- block/file-posix.c | 2 +- block/file-win32.c | 2 +- block/gluster.c | 1 + block/io.c | 8 +++++++- block/iscsi.c | 2 +- block/nfs.c | 3 ++-Quoted 8 lines
block/qcow2.c | 2 +- block/qed.c | 1 + block/raw-format.c | 2 +- block/rbd.c | 1 + block/sheepdog.c | 4 ++-- block/ssh.c | 2 +- tests/test-block-iothread.c | 3 ++- 15 files changed, 33 insertions(+), 13 deletions(-)
Quoted 4 lines
(I know I haven’t complained before, so *shrug*, but I wonder now whether it actually makes sense to have the same BdrvRequestFlags for all request types. Or why we have the same flags type for read, write, and zero-write already.)
Yeah, nothing this series introduces. I wonder, too, but as long as we have enough bits to cover flags for all request types, and because we have overlaps between the request types, it might be easier to have only one set of flags. So it might be accidental, but I actually feel the current state isn't bad.
Kevin
Re: [PATCH v5 7/9] block: truncate: Don't make backing file data visible
In reply to Max ReitzAm 23.04.2020 um 13:14 hat Max Reitz geschrieben:
Quoted 66 lines · Kevin Wolf
Quoted 46 lines
When extending the size of an image that has a backing file larger than its old size, make sure that the backing file data doesn't become visible in the guest, but the added area is properly zeroed out.
Consider the following scenario where the overlay is shorter than its backing file:
base.qcow2: AAAAAAAA
overlay.qcow2: BBBBWhen resizing (extending) overlay.qcow2, the new blocks should not stay unallocated and make the additional As from base.qcow2 visible like before this patch, but zeros should be read.
A similar case happens with the various variants of a commit job when an intermediate file is short (- for unallocated):
base.qcow2: A-A-AAAA mid.qcow2: BB-B top.qcow2: C--C--C-After commit top.qcow2 to mid.qcow2, the following happens:
mid.qcow2: CB-C00C0 (correct result)
mid.qcow2: CB-C--C- (before this fix)Without the fix, blocks that previously read as zeros on top.qcow2 suddenly turn into A.
Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Alberto Garcia <[email protected]>--- block/io.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)block/io.c +3
-0@@ -3394,6 +3394,20 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, goto out; } +/* +* If the image has a backing file that is large enough that it would +* provide data for the new area, we cannot leave it unallocated because block/io.c int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, · line 3409
Quoted 10 lines
block/io.c +10
-0+* then the backing file content would become visible. Instead, zero-fill +* the new area. +* +* Note that if the image has a backing file, but was opened without the +* backing file, taking care of keeping things consistent with that backing +* file is the user's responsibility. +*/ +if (new_bytes && bs->backing) { + flags |=BDRV_REQ_ZERO_WRITE ; + }This breaks growing any non-qcow2 image with any backing file. Do we care about that?
The comment says something about “a backing file that is large enough that it would provide data for the new area”, but that condition doesn’t appear in the code. Should it? (If it did, I think the number of cases this change broke would be much smaller.)
Quoted 4 lines
If it was deliberate to not have that condition here, and if we decide that we don’t care about non-qcow2 formats here, then I think at least the error message deserves some improvement over “qemu-img: Block driver does not support requested flags”.
This was not deliberate. v3 had the check and I'm not sure why I removed it. Probably because the new approach felt so much simpler and I was glad that I could throw away complicated code that I threw away more than I should have...
Kevin
Re: [PATCH v5 4/9] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Eric BlakeAm 22.04.2020 um 18:14 hat Eric Blake geschrieben:
Quoted 43 lines · Kevin Wolf
Quoted 14 lines
Quoted 14 lines
block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4219
Quoted 7 lines
block/qcow2.c +3
-0@@ -4214,6 +4215,35 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,g_assert_not_reached (); } +if ((flags &BDRV_REQ_ZERO_WRITE ) && offset > old_length) { +uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size); +uint64_t zero_end =QEMU_ALIGN_UP (offset, s->cluster_size);This rounds up beyond the new size...
Quoted 3 lines
block/qcow2.c +3
-0+ +/* Use zero clusters as much as we can */ + ret =qcow2_cluster_zeroize (bs, zero_start, zero_end - zero_start,0 );Quoted 7 lines
Quoted 2 lines
and then requests that the extra be zeroed. Does that always work, even when it results in
pdrv_co_pwrite_zeroesbeyond the end ofs->data_file?You mean the
data_file_is_raw()path inqcow2_cluster_zeroize()? It's currently not a code path that is run because we only setBDRV_REQ_ZERO_WRITEfor truncate if the image has a backing file, anddata_file_is_raw()doesn't work with backing files.Good point.
Quoted 18 lines
But hypothetically, if someone called truncate with
BDRV_REQ_ZERO_WRITEfor such a file, I think it would fail.Quoted 6 lines
If so,
Reviewed-by Eric Blake <[email protected]>otherwise, you may have to treat the tail specially, the same way you treated an unaligned head.
Actually, do I even need to round the tail?
/* Caller must pass aligned values, except at image end */ assert(QEMU_IS_ALIGNED(offset, s->cluster_size)); assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) || end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
Quoted 7 lines
Quoted 3 lines
So
qcow2_cluster_zeroize()seems to accept the unaligned tail. It would still set the zero flag for the partial last cluster and for the external data file,bdrv_co_pwrite_zeroes()would have the correct size.Then I'm in favor of NOT rounding the tail. That's an easy enough change and we've now justified that it does what we want, so R-b stands with that one-line tweak.
Would have been too easy... bs->total_sectors isn't updated yet, so the assertion does fail.
I can make the assertion check end_offset >= ... instead. That should still check what we wanted to check here and allow the unaligned extension.
This feels like the better option to me compared to updating bs->total_sectors earlier and then undoing that change in every error path.
Kevin
Re: [PATCH v5 4/9] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Max ReitzAm 23.04.2020 um 12:53 hat Max Reitz geschrieben:
Quoted 35 lines · Kevin Wolf
Quoted 15 lines
If
BDRV_REQ_ZERO_WRITEis set and we're extending the image, callingqcow2_cluster_zeroize()with flags=0 does the right thing: It doesn't undo any previous preallocation, but just adds the zero flag to all relevant L2 entries. If an external data file is in use, awrite_zeroesrequest to the data file is made instead.Signed-off-by Kevin Wolf <[email protected]>--- block/qcow2.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)block/qcow2.c +0
-0[...]
block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4223
Quoted 10 lines
block/qcow2.c +6
-0@@ -4214,6 +4215,35 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,g_assert_not_reached (); } +if ((flags &BDRV_REQ_ZERO_WRITE ) && offset > old_length) { +uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size); +uint64_t zero_end =QEMU_ALIGN_UP (offset, s->cluster_size); + +/* Use zero clusters as much as we can */ + ret =qcow2_cluster_zeroize (bs, zero_start, zero_end - zero_start,0 );It’s kind of a pity that this changes the cluster mappings that were established when using falloc/full preallocation already (i.e., they become preallocated zero clusters then, so when writing to them, we need COW again).
Quoted 2 lines
But falloc/full preallocation do not guarantee that the new data is zero, so I suppose this is the only thing we can reasonably do.
If we really want, I guess we could make full preallocation first try passing BDRV_REQ_ZERO_WRITE to the protocol layer and if that succeeds, we could skip setting the zero cluster flag at the qcow2 level.
Feels like a separate patch, though.
Kevin
Re: [PATCH v5 4/9] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
Quoted 36 lines · Kevin Wolf
Am 23.04.2020 um 12:53 hat Max Reitz geschrieben:
Quoted 35 lines · Kevin Wolf
Quoted 15 lines
If
BDRV_REQ_ZERO_WRITEis set and we're extending the image, callingqcow2_cluster_zeroize()with flags=0 does the right thing: It doesn't undo any previous preallocation, but just adds the zero flag to all relevant L2 entries. If an external data file is in use, awrite_zeroesrequest to the data file is made instead.Signed-off-by Kevin Wolf <[email protected]>--- block/qcow2.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)block/qcow2.c +0
-0[...]
block/qcow2.c static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, · line 4223
Quoted 10 lines
block/qcow2.c +6
-0@@ -4214,6 +4215,35 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,g_assert_not_reached (); } +if ((flags &BDRV_REQ_ZERO_WRITE ) && offset > old_length) { +uint64_t zero_start =QEMU_ALIGN_UP (old_length, s->cluster_size); +uint64_t zero_end =QEMU_ALIGN_UP (offset, s->cluster_size); + +/* Use zero clusters as much as we can */ + ret =qcow2_cluster_zeroize (bs, zero_start, zero_end - zero_start,0 );It’s kind of a pity that this changes the cluster mappings that were established when using falloc/full preallocation already (i.e., they become preallocated zero clusters then, so when writing to them, we need COW again).
Quoted 6 lines
Quoted 2 lines
But falloc/full preallocation do not guarantee that the new data is zero, so I suppose this is the only thing we can reasonably do.
If we really want, I guess we could make full preallocation first try passing
BDRV_REQ_ZERO_WRITEto the protocol layer and if that succeeds, we could skip setting the zero cluster flag at the qcow2 level.
That might be nice.
Quoted 1 line
Feels like a separate patch, though.
Definitely, yes.
Max
Re: [PATCH v5 4/9] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
In reply to Kevin WolfQuoted 9 lines · Kevin Wolf
Quoted 8 lines
Quoted 4 lines
So
qcow2_cluster_zeroize()seems to accept the unaligned tail. It would still set the zero flag for the partial last cluster and for the external data file,bdrv_co_pwrite_zeroes()would have the correct size.Then I'm in favor of NOT rounding the tail. That's an easy enough change and we've now justified that it does what we want, so R-b stands with that one-line tweak.
Quoted 6 lines
Would have been too easy...
bs->total_sectorsisn't updated yet, so the assertion does fail.I can make the assertion check
end_offset>= ... instead. That should still check what we wanted to check here and allow the unaligned extension.
Yes, that works for me.
Quoted 4 lines
This feels like the better option to me compared to updating
bs->total_sectorsearlier and then undoing that change in every error path.
Indeed.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org