Block layer patches:
- qcow2: Fix preallocation on block devices - backup: Make sure that source and target size match - vmdk: Fix zero cluster handling - Follow-up cleanups and fixes for the truncate changes - iotests: Skip more tests if required drivers are missing -----BEGIN PGP SIGNATURE----- iQJFBAABCAAvFiEE3D3rFZqa+V09dFb+fwmycsiPL9YFAl61UxsRHGt3b2xmQHJl ZGhhdC5jb20ACgkQfwmycsiPL9YKOw//eLnOs99gIPE37LUOK3RwQ4PSlSHPOYQX ElA6zv4XSV7oy6UtqpeMn+kDXe2rGDUktdX+TY7WZIcq341RGAktCJnjf4uDSnyS SU4sGazrCbI6j1FIaVmCQU9SpqH2taAv/ZdtsIpmbf9lpHXZayknwO/3q0r2+KoQ MUfu87xBw7x0SV/HICJeDBoCLWQN8pz3Ter4BfcMeDrXQgpnYztarkezg/ahm9D0 R3dyZH6YDxoETIXZll2yIeC6rHan6/Ptc2D7pB/w3rFNDsmqevGR3XqwB6Sky4cD QveNHJgOIx79NOFtRz7foJGUNr/KjE0K4rECuoDrPeMuJQUXOMPlFNbmKgjryBwb v3fpDfY1u3E3EorKtJEUlngr8ptaoXS5aDxPZpjhAIfevrCplkznLsXXMOTnHtHc S4vuSYcfVvSMAh5jDbgcCEc+16AM0icY3fXuN1u5ZMck/iPtCuj64gF0WFO4GFvk V+WREE49eYCZ/wdma+FdWog4af2MZxo5TSJ3JOncRr1HVcosvXPnsOr55HhC8H5t E95LRMiNba9uP8T3eyU8xfXWhMBtoCQM8l763WcRVOnm+r7VMfZ2proxnI/LD0QE PxzPc22Pl/NwPZ5ozIDyklT0MFVNl2uvBYMsn/nydkrW/6prYgZ1A1kRVis/Jhka jzAmXM3eiFY= =TIWU -----END PGP SIGNATURE----- Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging Block layer patches: - qcow2: Fix preallocation on block devices - backup: Make sure that source and target size match - vmdk: Fix zero cluster handling - Follow-up cleanups and fixes for the truncate changes - iotests: Skip more tests if required drivers are missing # gpg: Signature made Fri 08 May 2020 13:39:55 BST # gpg: using RSA key DC3DEB159A9AF95D3D7456FE7F09B272C88F2FD6 # gpg: issuer "kwolf@redhat.com" # gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>" [full] # Primary key fingerprint: DC3D EB15 9A9A F95D 3D74 56FE 7F09 B272 C88F 2FD6 * remotes/kevin/tags/for-upstream: (30 commits) block: Drop unused .bdrv_has_zero_init_truncate vhdx: Rework truncation logic parallels: Rework truncation logic ssh: Support BDRV_REQ_ZERO_WRITE for truncate sheepdog: Support BDRV_REQ_ZERO_WRITE for truncate rbd: Support BDRV_REQ_ZERO_WRITE for truncate nfs: Support BDRV_REQ_ZERO_WRITE for truncate file-win32: Support BDRV_REQ_ZERO_WRITE for truncate gluster: Drop useless has_zero_init callback qcow2: Fix preallocation on block devices iotests/055: Use cache.no-flush for vmdk target iotests: Backup with different source/target size backup: Make sure that source and target size match backup: Improve error for bdrv_getlength() failure iotests/283: Use consistent size for source and target iotests: vmdk: Enable zeroed_grained=on by default vmdk: Flush only once in vmdk_L2update() vmdk: Don't update L2 table for zero write on zero cluster vmdk: Fix partial overwrite of zero cluster vmdk: Fix zero cluster allocation ... Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
commit
c88f1ffc19
21
block.c
21
block.c
|
@ -5284,27 +5284,6 @@ int bdrv_has_zero_init(BlockDriverState *bs)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int bdrv_has_zero_init_truncate(BlockDriverState *bs)
|
||||
{
|
||||
if (!bs->drv) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (bs->backing) {
|
||||
/* Depends on the backing image length, but better safe than sorry */
|
||||
return 0;
|
||||
}
|
||||
if (bs->drv->bdrv_has_zero_init_truncate) {
|
||||
return bs->drv->bdrv_has_zero_init_truncate(bs);
|
||||
}
|
||||
if (bs->file && bs->drv->is_filter) {
|
||||
return bdrv_has_zero_init_truncate(bs->file->bs);
|
||||
}
|
||||
|
||||
/* safe default */
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
|
||||
{
|
||||
BlockDriverInfo bdi;
|
||||
|
|
|
@ -148,8 +148,10 @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
|
|||
*
|
||||
* Share write to target (child_file), to not interfere
|
||||
* with guest writes to its disk which may be in target backing chain.
|
||||
* Can't resize during a backup block job because we check the size
|
||||
* only upfront.
|
||||
*/
|
||||
*nshared = BLK_PERM_ALL;
|
||||
*nshared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
|
||||
*nperm = BLK_PERM_WRITE;
|
||||
} else {
|
||||
/* Source child */
|
||||
|
@ -159,7 +161,7 @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
|
|||
if (perm & BLK_PERM_WRITE) {
|
||||
*nperm = *nperm | BLK_PERM_CONSISTENT_READ;
|
||||
}
|
||||
*nshared &= ~BLK_PERM_WRITE;
|
||||
*nshared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -192,11 +194,13 @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
|
|||
{
|
||||
Error *local_err = NULL;
|
||||
BDRVBackupTopState *state;
|
||||
BlockDriverState *top = bdrv_new_open_driver(&bdrv_backup_top_filter,
|
||||
filter_node_name,
|
||||
BDRV_O_RDWR, errp);
|
||||
BlockDriverState *top;
|
||||
bool appended = false;
|
||||
|
||||
assert(source->total_sectors == target->total_sectors);
|
||||
|
||||
top = bdrv_new_open_driver(&bdrv_backup_top_filter, filter_node_name,
|
||||
BDRV_O_RDWR, errp);
|
||||
if (!top) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -340,7 +340,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
|
|||
BlockCompletionFunc *cb, void *opaque,
|
||||
JobTxn *txn, Error **errp)
|
||||
{
|
||||
int64_t len;
|
||||
int64_t len, target_len;
|
||||
BackupBlockJob *job = NULL;
|
||||
int64_t cluster_size;
|
||||
BdrvRequestFlags write_flags;
|
||||
|
@ -400,8 +400,20 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
|
|||
|
||||
len = bdrv_getlength(bs);
|
||||
if (len < 0) {
|
||||
error_setg_errno(errp, -len, "unable to get length for '%s'",
|
||||
bdrv_get_device_name(bs));
|
||||
error_setg_errno(errp, -len, "Unable to get length for '%s'",
|
||||
bdrv_get_device_or_node_name(bs));
|
||||
goto error;
|
||||
}
|
||||
|
||||
target_len = bdrv_getlength(target);
|
||||
if (target_len < 0) {
|
||||
error_setg_errno(errp, -target_len, "Unable to get length for '%s'",
|
||||
bdrv_get_device_or_node_name(bs));
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (target_len != len) {
|
||||
error_setg(errp, "Source and target image have different sizes");
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
|
|
@ -3100,7 +3100,6 @@ BlockDriver bdrv_file = {
|
|||
.bdrv_co_create = raw_co_create,
|
||||
.bdrv_co_create_opts = raw_co_create_opts,
|
||||
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
||||
.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
|
||||
.bdrv_co_block_status = raw_co_block_status,
|
||||
.bdrv_co_invalidate_cache = raw_co_invalidate_cache,
|
||||
.bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
|
||||
|
|
|
@ -408,6 +408,9 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
|
|||
win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs));
|
||||
}
|
||||
|
||||
/* When extending regular files, we get zeros from the OS */
|
||||
bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
|
||||
|
||||
ret = 0;
|
||||
fail:
|
||||
qemu_opts_del(opts);
|
||||
|
@ -638,7 +641,6 @@ BlockDriver bdrv_file = {
|
|||
.bdrv_close = raw_close,
|
||||
.bdrv_co_create_opts = raw_co_create_opts,
|
||||
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
||||
.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
|
||||
|
||||
.bdrv_aio_preadv = raw_aio_preadv,
|
||||
.bdrv_aio_pwritev = raw_aio_pwritev,
|
||||
|
|
|
@ -1359,12 +1359,6 @@ static int64_t qemu_gluster_allocated_file_size(BlockDriverState *bs)
|
|||
}
|
||||
}
|
||||
|
||||
static int qemu_gluster_has_zero_init(BlockDriverState *bs)
|
||||
{
|
||||
/* GlusterFS volume could be backed by a block device */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Find allocation range in @bs around offset @start.
|
||||
* May change underlying file descriptor's file offset.
|
||||
|
@ -1569,8 +1563,6 @@ static BlockDriver bdrv_gluster = {
|
|||
.bdrv_co_readv = qemu_gluster_co_readv,
|
||||
.bdrv_co_writev = qemu_gluster_co_writev,
|
||||
.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,
|
||||
.bdrv_has_zero_init = qemu_gluster_has_zero_init,
|
||||
.bdrv_has_zero_init_truncate = qemu_gluster_has_zero_init,
|
||||
#ifdef CONFIG_GLUSTERFS_DISCARD
|
||||
.bdrv_co_pdiscard = qemu_gluster_co_pdiscard,
|
||||
#endif
|
||||
|
@ -1601,8 +1593,6 @@ static BlockDriver bdrv_gluster_tcp = {
|
|||
.bdrv_co_readv = qemu_gluster_co_readv,
|
||||
.bdrv_co_writev = qemu_gluster_co_writev,
|
||||
.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,
|
||||
.bdrv_has_zero_init = qemu_gluster_has_zero_init,
|
||||
.bdrv_has_zero_init_truncate = qemu_gluster_has_zero_init,
|
||||
#ifdef CONFIG_GLUSTERFS_DISCARD
|
||||
.bdrv_co_pdiscard = qemu_gluster_co_pdiscard,
|
||||
#endif
|
||||
|
@ -1633,8 +1623,6 @@ static BlockDriver bdrv_gluster_unix = {
|
|||
.bdrv_co_readv = qemu_gluster_co_readv,
|
||||
.bdrv_co_writev = qemu_gluster_co_writev,
|
||||
.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,
|
||||
.bdrv_has_zero_init = qemu_gluster_has_zero_init,
|
||||
.bdrv_has_zero_init_truncate = qemu_gluster_has_zero_init,
|
||||
#ifdef CONFIG_GLUSTERFS_DISCARD
|
||||
.bdrv_co_pdiscard = qemu_gluster_co_pdiscard,
|
||||
#endif
|
||||
|
@ -1671,8 +1659,6 @@ static BlockDriver bdrv_gluster_rdma = {
|
|||
.bdrv_co_readv = qemu_gluster_co_readv,
|
||||
.bdrv_co_writev = qemu_gluster_co_writev,
|
||||
.bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,
|
||||
.bdrv_has_zero_init = qemu_gluster_has_zero_init,
|
||||
.bdrv_has_zero_init_truncate = qemu_gluster_has_zero_init,
|
||||
#ifdef CONFIG_GLUSTERFS_DISCARD
|
||||
.bdrv_co_pdiscard = qemu_gluster_co_pdiscard,
|
||||
#endif
|
||||
|
|
|
@ -620,6 +620,9 @@ static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags,
|
|||
}
|
||||
|
||||
bs->total_sectors = ret;
|
||||
if (client->has_zero_init) {
|
||||
bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -869,7 +872,6 @@ static BlockDriver bdrv_nfs = {
|
|||
.create_opts = &nfs_create_opts,
|
||||
|
||||
.bdrv_has_zero_init = nfs_has_zero_init,
|
||||
.bdrv_has_zero_init_truncate = nfs_has_zero_init,
|
||||
.bdrv_get_allocated_file_size = nfs_get_allocated_file_size,
|
||||
.bdrv_co_truncate = nfs_file_co_truncate,
|
||||
|
||||
|
|
|
@ -166,7 +166,7 @@ static int64_t block_status(BDRVParallelsState *s, int64_t sector_num,
|
|||
static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
|
||||
int nb_sectors, int *pnum)
|
||||
{
|
||||
int ret;
|
||||
int ret = 0;
|
||||
BDRVParallelsState *s = bs->opaque;
|
||||
int64_t pos, space, idx, to_allocate, i, len;
|
||||
|
||||
|
@ -196,14 +196,24 @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
|
|||
}
|
||||
if (s->data_end + space > (len >> BDRV_SECTOR_BITS)) {
|
||||
space += s->prealloc_size;
|
||||
/*
|
||||
* We require the expanded size to read back as zero. If the
|
||||
* user permitted truncation, we try that; but if it fails, we
|
||||
* force the safer-but-slower fallocate.
|
||||
*/
|
||||
if (s->prealloc_mode == PRL_PREALLOC_MODE_TRUNCATE) {
|
||||
ret = bdrv_truncate(bs->file,
|
||||
(s->data_end + space) << BDRV_SECTOR_BITS,
|
||||
false, PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE,
|
||||
NULL);
|
||||
if (ret == -ENOTSUP) {
|
||||
s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
|
||||
}
|
||||
}
|
||||
if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) {
|
||||
ret = bdrv_pwrite_zeroes(bs->file,
|
||||
s->data_end << BDRV_SECTOR_BITS,
|
||||
space << BDRV_SECTOR_BITS, 0);
|
||||
} else {
|
||||
ret = bdrv_truncate(bs->file,
|
||||
(s->data_end + space) << BDRV_SECTOR_BITS,
|
||||
false, PREALLOC_MODE_OFF, 0, NULL);
|
||||
}
|
||||
if (ret < 0) {
|
||||
return ret;
|
||||
|
@ -828,6 +838,7 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
|
|||
qemu_opt_get_size_del(opts, PARALLELS_OPT_PREALLOC_SIZE, 0);
|
||||
s->prealloc_size = MAX(s->tracks, s->prealloc_size >> BDRV_SECTOR_BITS);
|
||||
buf = qemu_opt_get_del(opts, PARALLELS_OPT_PREALLOC_MODE);
|
||||
/* prealloc_mode can be downgraded later during allocate_clusters */
|
||||
s->prealloc_mode = qapi_enum_parse(&prealloc_mode_lookup, buf,
|
||||
PRL_PREALLOC_MODE_FALLOCATE,
|
||||
&local_err);
|
||||
|
@ -836,10 +847,6 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
|
|||
goto fail_options;
|
||||
}
|
||||
|
||||
if (!bdrv_has_zero_init_truncate(bs->file->bs)) {
|
||||
s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
|
||||
}
|
||||
|
||||
if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_INACTIVE)) {
|
||||
s->header->inuse = cpu_to_le32(HEADER_INUSE_MAGIC);
|
||||
ret = parallels_update_header(bs);
|
||||
|
|
|
@ -4107,7 +4107,7 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
|
|||
{
|
||||
int64_t allocation_start, host_offset, guest_offset;
|
||||
int64_t clusters_allocated;
|
||||
int64_t old_file_size, new_file_size;
|
||||
int64_t old_file_size, last_cluster, new_file_size;
|
||||
uint64_t nb_new_data_clusters, nb_new_l2_tables;
|
||||
|
||||
/* With a data file, preallocation means just allocating the metadata
|
||||
|
@ -4127,7 +4127,13 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
|
|||
ret = old_file_size;
|
||||
goto fail;
|
||||
}
|
||||
old_file_size = ROUND_UP(old_file_size, s->cluster_size);
|
||||
|
||||
last_cluster = qcow2_get_last_cluster(bs, old_file_size);
|
||||
if (last_cluster >= 0) {
|
||||
old_file_size = (last_cluster + 1) * s->cluster_size;
|
||||
} else {
|
||||
old_file_size = ROUND_UP(old_file_size, s->cluster_size);
|
||||
}
|
||||
|
||||
nb_new_data_clusters = DIV_ROUND_UP(offset - old_length,
|
||||
s->cluster_size);
|
||||
|
@ -4242,15 +4248,17 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
|
|||
* requires a cluster-aligned start. The end may be unaligned if it is
|
||||
* at the end of the image (which it is here).
|
||||
*/
|
||||
ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
|
||||
if (ret < 0) {
|
||||
error_setg_errno(errp, -ret, "Failed to zero out new clusters");
|
||||
goto fail;
|
||||
if (offset > zero_start) {
|
||||
ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
|
||||
if (ret < 0) {
|
||||
error_setg_errno(errp, -ret, "Failed to zero out new clusters");
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
/* Write explicit zeros for the unaligned head */
|
||||
if (zero_start > old_length) {
|
||||
uint64_t len = zero_start - old_length;
|
||||
uint64_t len = MIN(zero_start, offset) - old_length;
|
||||
uint8_t *buf = qemu_blockalign0(bs, len);
|
||||
QEMUIOVector qiov;
|
||||
qemu_iovec_init_buf(&qiov, buf, len);
|
||||
|
@ -5613,7 +5621,6 @@ BlockDriver bdrv_qcow2 = {
|
|||
.bdrv_co_create_opts = qcow2_co_create_opts,
|
||||
.bdrv_co_create = qcow2_co_create,
|
||||
.bdrv_has_zero_init = qcow2_has_zero_init,
|
||||
.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
|
||||
.bdrv_co_block_status = qcow2_co_block_status,
|
||||
|
||||
.bdrv_co_preadv_part = qcow2_co_preadv_part,
|
||||
|
|
|
@ -1675,7 +1675,6 @@ static BlockDriver bdrv_qed = {
|
|||
.bdrv_co_create = bdrv_qed_co_create,
|
||||
.bdrv_co_create_opts = bdrv_qed_co_create_opts,
|
||||
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
||||
.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
|
||||
.bdrv_co_block_status = bdrv_qed_co_block_status,
|
||||
.bdrv_co_readv = bdrv_qed_co_readv,
|
||||
.bdrv_co_writev = bdrv_qed_co_writev,
|
||||
|
|
|
@ -414,11 +414,6 @@ static int raw_has_zero_init(BlockDriverState *bs)
|
|||
return bdrv_has_zero_init(bs->file->bs);
|
||||
}
|
||||
|
||||
static int raw_has_zero_init_truncate(BlockDriverState *bs)
|
||||
{
|
||||
return bdrv_has_zero_init_truncate(bs->file->bs);
|
||||
}
|
||||
|
||||
static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
|
||||
const char *filename,
|
||||
QemuOpts *opts,
|
||||
|
@ -582,7 +577,6 @@ BlockDriver bdrv_raw = {
|
|||
.bdrv_co_ioctl = &raw_co_ioctl,
|
||||
.create_opts = &raw_create_opts,
|
||||
.bdrv_has_zero_init = &raw_has_zero_init,
|
||||
.bdrv_has_zero_init_truncate = &raw_has_zero_init_truncate,
|
||||
.strong_runtime_opts = raw_strong_runtime_opts,
|
||||
.mutable_opts = mutable_opts,
|
||||
};
|
||||
|
|
|
@ -817,6 +817,9 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
|
|||
}
|
||||
}
|
||||
|
||||
/* When extending regular files, we get zeros from the OS */
|
||||
bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
|
||||
|
||||
r = 0;
|
||||
goto out;
|
||||
|
||||
|
@ -1310,7 +1313,6 @@ static BlockDriver bdrv_rbd = {
|
|||
.bdrv_co_create = qemu_rbd_co_create,
|
||||
.bdrv_co_create_opts = qemu_rbd_co_create_opts,
|
||||
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
||||
.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
|
||||
.bdrv_get_info = qemu_rbd_getinfo,
|
||||
.create_opts = &qemu_rbd_create_opts,
|
||||
.bdrv_getlength = qemu_rbd_getlength,
|
||||
|
|
|
@ -1654,6 +1654,7 @@ static int sd_open(BlockDriverState *bs, QDict *options, int flags,
|
|||
memcpy(&s->inode, buf, sizeof(s->inode));
|
||||
|
||||
bs->total_sectors = s->inode.vdi_size / BDRV_SECTOR_SIZE;
|
||||
bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
|
||||
pstrcpy(s->name, sizeof(s->name), vdi);
|
||||
qemu_co_mutex_init(&s->lock);
|
||||
qemu_co_mutex_init(&s->queue_lock);
|
||||
|
@ -3225,7 +3226,6 @@ static BlockDriver bdrv_sheepdog = {
|
|||
.bdrv_co_create = sd_co_create,
|
||||
.bdrv_co_create_opts = sd_co_create_opts,
|
||||
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
||||
.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
|
||||
.bdrv_getlength = sd_getlength,
|
||||
.bdrv_get_allocated_file_size = sd_get_allocated_file_size,
|
||||
.bdrv_co_truncate = sd_co_truncate,
|
||||
|
@ -3264,7 +3264,6 @@ static BlockDriver bdrv_sheepdog_tcp = {
|
|||
.bdrv_co_create = sd_co_create,
|
||||
.bdrv_co_create_opts = sd_co_create_opts,
|
||||
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
||||
.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
|
||||
.bdrv_getlength = sd_getlength,
|
||||
.bdrv_get_allocated_file_size = sd_get_allocated_file_size,
|
||||
.bdrv_co_truncate = sd_co_truncate,
|
||||
|
@ -3303,7 +3302,6 @@ static BlockDriver bdrv_sheepdog_unix = {
|
|||
.bdrv_co_create = sd_co_create,
|
||||
.bdrv_co_create_opts = sd_co_create_opts,
|
||||
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
||||
.bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
|
||||
.bdrv_getlength = sd_getlength,
|
||||
.bdrv_get_allocated_file_size = sd_get_allocated_file_size,
|
||||
.bdrv_co_truncate = sd_co_truncate,
|
||||
|
|
|
@ -883,6 +883,10 @@ static int ssh_file_open(BlockDriverState *bs, QDict *options, int bdrv_flags,
|
|||
/* Go non-blocking. */
|
||||
ssh_set_blocking(s->session, 0);
|
||||
|
||||
if (s->attrs->type == SSH_FILEXFER_TYPE_REGULAR) {
|
||||
bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
|
||||
}
|
||||
|
||||
qapi_free_BlockdevOptionsSsh(opts);
|
||||
|
||||
return 0;
|
||||
|
@ -1393,7 +1397,6 @@ static BlockDriver bdrv_ssh = {
|
|||
.bdrv_co_create_opts = ssh_co_create_opts,
|
||||
.bdrv_close = ssh_close,
|
||||
.bdrv_has_zero_init = ssh_has_zero_init,
|
||||
.bdrv_has_zero_init_truncate = ssh_has_zero_init,
|
||||
.bdrv_co_readv = ssh_co_readv,
|
||||
.bdrv_co_writev = ssh_co_writev,
|
||||
.bdrv_getlength = ssh_getlength,
|
||||
|
|
89
block/vhdx.c
89
block/vhdx.c
|
@ -1240,12 +1240,16 @@ exit:
|
|||
/*
|
||||
* Allocate a new payload block at the end of the file.
|
||||
*
|
||||
* Allocation will happen at 1MB alignment inside the file
|
||||
* Allocation will happen at 1MB alignment inside the file.
|
||||
*
|
||||
* If @need_zero is set on entry but not cleared on return, then truncation
|
||||
* could not guarantee that the new portion reads as zero, and the caller
|
||||
* will take care of it instead.
|
||||
*
|
||||
* Returns the file offset start of the new payload block
|
||||
*/
|
||||
static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
|
||||
uint64_t *new_offset)
|
||||
uint64_t *new_offset, bool *need_zero)
|
||||
{
|
||||
int64_t current_len;
|
||||
|
||||
|
@ -1262,6 +1266,17 @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (*need_zero) {
|
||||
int ret;
|
||||
|
||||
ret = bdrv_truncate(bs->file, *new_offset + s->block_size, false,
|
||||
PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE, NULL);
|
||||
if (ret != -ENOTSUP) {
|
||||
*need_zero = false;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
|
||||
PREALLOC_MODE_OFF, 0, NULL);
|
||||
}
|
||||
|
@ -1355,18 +1370,38 @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
|
|||
/* in this case, we need to preserve zero writes for
|
||||
* data that is not part of this write, so we must pad
|
||||
* the rest of the buffer to zeroes */
|
||||
|
||||
/* if we are on a posix system with ftruncate() that extends
|
||||
* a file, then it is zero-filled for us. On Win32, the raw
|
||||
* layer uses SetFilePointer and SetFileEnd, which does not
|
||||
* zero fill AFAIK */
|
||||
|
||||
/* Queue another write of zero buffers if the underlying file
|
||||
* does not zero-fill on file extension */
|
||||
|
||||
if (bdrv_has_zero_init_truncate(bs->file->bs) == 0) {
|
||||
use_zero_buffers = true;
|
||||
|
||||
use_zero_buffers = true;
|
||||
/* fall through */
|
||||
case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */
|
||||
case PAYLOAD_BLOCK_UNMAPPED:
|
||||
case PAYLOAD_BLOCK_UNMAPPED_v095:
|
||||
case PAYLOAD_BLOCK_UNDEFINED:
|
||||
bat_prior_offset = sinfo.file_offset;
|
||||
ret = vhdx_allocate_block(bs, s, &sinfo.file_offset,
|
||||
&use_zero_buffers);
|
||||
if (ret < 0) {
|
||||
goto exit;
|
||||
}
|
||||
/*
|
||||
* once we support differencing files, this may also be
|
||||
* partially present
|
||||
*/
|
||||
/* update block state to the newly specified state */
|
||||
vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry,
|
||||
&bat_entry_offset,
|
||||
PAYLOAD_BLOCK_FULLY_PRESENT);
|
||||
bat_update = true;
|
||||
/*
|
||||
* Since we just allocated a block, file_offset is the
|
||||
* beginning of the payload block. It needs to be the
|
||||
* write address, which includes the offset into the
|
||||
* block, unless the entire block needs to read as
|
||||
* zeroes but truncation was not able to provide them,
|
||||
* in which case we need to fill in the rest.
|
||||
*/
|
||||
if (!use_zero_buffers) {
|
||||
sinfo.file_offset += sinfo.block_offset;
|
||||
} else {
|
||||
/* zero fill the front, if any */
|
||||
if (sinfo.block_offset) {
|
||||
iov1.iov_len = sinfo.block_offset;
|
||||
|
@ -1378,7 +1413,7 @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
|
|||
}
|
||||
|
||||
/* our actual data */
|
||||
qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
|
||||
qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
|
||||
sinfo.bytes_avail);
|
||||
|
||||
/* zero fill the back, if any */
|
||||
|
@ -1393,29 +1428,7 @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
|
|||
sectors_to_write += iov2.iov_len >> BDRV_SECTOR_BITS;
|
||||
}
|
||||
}
|
||||
/* fall through */
|
||||
case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */
|
||||
case PAYLOAD_BLOCK_UNMAPPED:
|
||||
case PAYLOAD_BLOCK_UNMAPPED_v095:
|
||||
case PAYLOAD_BLOCK_UNDEFINED:
|
||||
bat_prior_offset = sinfo.file_offset;
|
||||
ret = vhdx_allocate_block(bs, s, &sinfo.file_offset);
|
||||
if (ret < 0) {
|
||||
goto exit;
|
||||
}
|
||||
/* once we support differencing files, this may also be
|
||||
* partially present */
|
||||
/* update block state to the newly specified state */
|
||||
vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry,
|
||||
&bat_entry_offset,
|
||||
PAYLOAD_BLOCK_FULLY_PRESENT);
|
||||
bat_update = true;
|
||||
/* since we just allocated a block, file_offset is the
|
||||
* beginning of the payload block. It needs to be the
|
||||
* write address, which includes the offset into the block */
|
||||
if (!use_zero_buffers) {
|
||||
sinfo.file_offset += sinfo.block_offset;
|
||||
}
|
||||
|
||||
/* fall through */
|
||||
case PAYLOAD_BLOCK_FULLY_PRESENT:
|
||||
/* if the file offset address is in the header zone,
|
||||
|
|
47
block/vmdk.c
47
block/vmdk.c
|
@ -180,7 +180,7 @@ typedef struct VmdkMetaData {
|
|||
unsigned int l1_index;
|
||||
unsigned int l2_index;
|
||||
unsigned int l2_offset;
|
||||
int valid;
|
||||
bool new_allocation;
|
||||
uint32_t *l2_cache_entry;
|
||||
} VmdkMetaData;
|
||||
|
||||
|
@ -1340,7 +1340,9 @@ static void vmdk_refresh_limits(BlockDriverState *bs, Error **errp)
|
|||
* get_whole_cluster
|
||||
*
|
||||
* Copy backing file's cluster that covers @sector_num, otherwise write zero,
|
||||
* to the cluster at @cluster_sector_num.
|
||||
* to the cluster at @cluster_sector_num. If @zeroed is true, we're overwriting
|
||||
* a zeroed cluster in the current layer and must not copy data from the
|
||||
* backing file.
|
||||
*
|
||||
* If @skip_start_sector < @skip_end_sector, the relative range
|
||||
* [@skip_start_sector, @skip_end_sector) is not copied or written, and leave
|
||||
|
@ -1351,18 +1353,21 @@ static int get_whole_cluster(BlockDriverState *bs,
|
|||
uint64_t cluster_offset,
|
||||
uint64_t offset,
|
||||
uint64_t skip_start_bytes,
|
||||
uint64_t skip_end_bytes)
|
||||
uint64_t skip_end_bytes,
|
||||
bool zeroed)
|
||||
{
|
||||
int ret = VMDK_OK;
|
||||
int64_t cluster_bytes;
|
||||
uint8_t *whole_grain;
|
||||
bool copy_from_backing;
|
||||
|
||||
/* For COW, align request sector_num to cluster start */
|
||||
cluster_bytes = extent->cluster_sectors << BDRV_SECTOR_BITS;
|
||||
offset = QEMU_ALIGN_DOWN(offset, cluster_bytes);
|
||||
whole_grain = qemu_blockalign(bs, cluster_bytes);
|
||||
copy_from_backing = bs->backing && !zeroed;
|
||||
|
||||
if (!bs->backing) {
|
||||
if (!copy_from_backing) {
|
||||
memset(whole_grain, 0, skip_start_bytes);
|
||||
memset(whole_grain + skip_end_bytes, 0, cluster_bytes - skip_end_bytes);
|
||||
}
|
||||
|
@ -1377,7 +1382,7 @@ static int get_whole_cluster(BlockDriverState *bs,
|
|||
|
||||
/* Read backing data before skip range */
|
||||
if (skip_start_bytes > 0) {
|
||||
if (bs->backing) {
|
||||
if (copy_from_backing) {
|
||||
/* qcow2 emits this on bs->file instead of bs->backing */
|
||||
BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
|
||||
ret = bdrv_pread(bs->backing, offset, whole_grain,
|
||||
|
@ -1397,7 +1402,7 @@ static int get_whole_cluster(BlockDriverState *bs,
|
|||
}
|
||||
/* Read backing data after skip range */
|
||||
if (skip_end_bytes < cluster_bytes) {
|
||||
if (bs->backing) {
|
||||
if (copy_from_backing) {
|
||||
/* qcow2 emits this on bs->file instead of bs->backing */
|
||||
BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
|
||||
ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
|
||||
|
@ -1430,7 +1435,7 @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
|
|||
offset = cpu_to_le32(offset);
|
||||
/* update L2 table */
|
||||
BLKDBG_EVENT(extent->file, BLKDBG_L2_UPDATE);
|
||||
if (bdrv_pwrite_sync(extent->file,
|
||||
if (bdrv_pwrite(extent->file,
|
||||
((int64_t)m_data->l2_offset * 512)
|
||||
+ (m_data->l2_index * sizeof(offset)),
|
||||
&offset, sizeof(offset)) < 0) {
|
||||
|
@ -1439,13 +1444,16 @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
|
|||
/* update backup L2 table */
|
||||
if (extent->l1_backup_table_offset != 0) {
|
||||
m_data->l2_offset = extent->l1_backup_table[m_data->l1_index];
|
||||
if (bdrv_pwrite_sync(extent->file,
|
||||
if (bdrv_pwrite(extent->file,
|
||||
((int64_t)m_data->l2_offset * 512)
|
||||
+ (m_data->l2_index * sizeof(offset)),
|
||||
&offset, sizeof(offset)) < 0) {
|
||||
return VMDK_ERROR;
|
||||
}
|
||||
}
|
||||
if (bdrv_flush(extent->file->bs) < 0) {
|
||||
return VMDK_ERROR;
|
||||
}
|
||||
if (m_data->l2_cache_entry) {
|
||||
*m_data->l2_cache_entry = offset;
|
||||
}
|
||||
|
@ -1492,7 +1500,7 @@ static int get_cluster_offset(BlockDriverState *bs,
|
|||
unsigned int l2_size_bytes = extent->l2_size * extent->entry_size;
|
||||
|
||||
if (m_data) {
|
||||
m_data->valid = 0;
|
||||
m_data->new_allocation = false;
|
||||
}
|
||||
if (extent->flat) {
|
||||
*cluster_offset = extent->flat_start_offset;
|
||||
|
@ -1572,6 +1580,12 @@ static int get_cluster_offset(BlockDriverState *bs,
|
|||
extent->l2_cache_counts[min_index] = 1;
|
||||
found:
|
||||
l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size;
|
||||
if (m_data) {
|
||||
m_data->l1_index = l1_index;
|
||||
m_data->l2_index = l2_index;
|
||||
m_data->l2_offset = l2_offset;
|
||||
m_data->l2_cache_entry = ((uint32_t *)l2_table) + l2_index;
|
||||
}
|
||||
|
||||
if (extent->sesparse) {
|
||||
cluster_sector = le64_to_cpu(((uint64_t *)l2_table)[l2_index]);
|
||||
|
@ -1625,16 +1639,13 @@ static int get_cluster_offset(BlockDriverState *bs,
|
|||
* or inappropriate VM shutdown.
|
||||
*/
|
||||
ret = get_whole_cluster(bs, extent, cluster_sector * BDRV_SECTOR_SIZE,
|
||||
offset, skip_start_bytes, skip_end_bytes);
|
||||
offset, skip_start_bytes, skip_end_bytes,
|
||||
zeroed);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
if (m_data) {
|
||||
m_data->valid = 1;
|
||||
m_data->l1_index = l1_index;
|
||||
m_data->l2_index = l2_index;
|
||||
m_data->l2_offset = l2_offset;
|
||||
m_data->l2_cache_entry = ((uint32_t *)l2_table) + l2_index;
|
||||
m_data->new_allocation = true;
|
||||
}
|
||||
}
|
||||
*cluster_offset = cluster_sector << BDRV_SECTOR_BITS;
|
||||
|
@ -1990,7 +2001,7 @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
|
|||
error_report("Could not write to allocated cluster"
|
||||
" for streamOptimized");
|
||||
return -EIO;
|
||||
} else {
|
||||
} else if (!zeroed) {
|
||||
/* allocate */
|
||||
ret = get_cluster_offset(bs, extent, &m_data, offset,
|
||||
true, &cluster_offset, 0, 0);
|
||||
|
@ -2005,7 +2016,7 @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
|
|||
offset_in_cluster == 0 &&
|
||||
n_bytes >= extent->cluster_sectors * BDRV_SECTOR_SIZE) {
|
||||
n_bytes = extent->cluster_sectors * BDRV_SECTOR_SIZE;
|
||||
if (!zero_dry_run) {
|
||||
if (!zero_dry_run && ret != VMDK_ZEROED) {
|
||||
/* update L2 tables */
|
||||
if (vmdk_L2update(extent, &m_data, VMDK_GTE_ZEROED)
|
||||
!= VMDK_OK) {
|
||||
|
@ -2021,7 +2032,7 @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
|
|||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
if (m_data.valid) {
|
||||
if (m_data.new_allocation) {
|
||||
/* update L2 tables */
|
||||
if (vmdk_L2update(extent, &m_data,
|
||||
cluster_offset >> BDRV_SECTOR_BITS)
|
||||
|
|
|
@ -430,7 +430,6 @@ int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
|
|||
int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
|
||||
int bdrv_has_zero_init_1(BlockDriverState *bs);
|
||||
int bdrv_has_zero_init(BlockDriverState *bs);
|
||||
int bdrv_has_zero_init_truncate(BlockDriverState *bs);
|
||||
bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
|
||||
bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
|
||||
int bdrv_block_status(BlockDriverState *bs, int64_t offset,
|
||||
|
|
|
@ -449,16 +449,9 @@ struct BlockDriver {
|
|||
/*
|
||||
* Returns 1 if newly created images are guaranteed to contain only
|
||||
* zeros, 0 otherwise.
|
||||
* Must return 0 if .bdrv_has_zero_init_truncate() returns 0.
|
||||
*/
|
||||
int (*bdrv_has_zero_init)(BlockDriverState *bs);
|
||||
|
||||
/*
|
||||
* Returns 1 if new areas added by growing the image with
|
||||
* PREALLOC_MODE_OFF contain only zeros, 0 otherwise.
|
||||
*/
|
||||
int (*bdrv_has_zero_init_truncate)(BlockDriverState *bs);
|
||||
|
||||
/* Remove fd handlers, timers, and other event loop callbacks so the event
|
||||
* loop is no longer in use. Called with no in-flight requests and in
|
||||
* depth-first traversal order with parents before child nodes.
|
||||
|
|
|
@ -904,8 +904,6 @@ class TestRepairQuorum(iotests.QMPTestCase):
|
|||
pass
|
||||
|
||||
def test_complete(self):
|
||||
self.assert_no_active_block_jobs()
|
||||
|
||||
result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
|
||||
sync='full', node_name="repair0", replaces="img1",
|
||||
target=quorum_repair_img, format=iotests.imgfmt)
|
||||
|
@ -919,8 +917,6 @@ class TestRepairQuorum(iotests.QMPTestCase):
|
|||
'target image does not match source after mirroring')
|
||||
|
||||
def test_cancel(self):
|
||||
self.assert_no_active_block_jobs()
|
||||
|
||||
result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
|
||||
sync='full', node_name="repair0", replaces="img1",
|
||||
target=quorum_repair_img, format=iotests.imgfmt)
|
||||
|
@ -932,8 +928,6 @@ class TestRepairQuorum(iotests.QMPTestCase):
|
|||
self.assert_has_block_node(None, quorum_img3)
|
||||
|
||||
def test_cancel_after_ready(self):
|
||||
self.assert_no_active_block_jobs()
|
||||
|
||||
result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
|
||||
sync='full', node_name="repair0", replaces="img1",
|
||||
target=quorum_repair_img, format=iotests.imgfmt)
|
||||
|
@ -948,8 +942,6 @@ class TestRepairQuorum(iotests.QMPTestCase):
|
|||
'target image does not match source after mirroring')
|
||||
|
||||
def test_pause(self):
|
||||
self.assert_no_active_block_jobs()
|
||||
|
||||
result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
|
||||
sync='full', node_name="repair0", replaces="img1",
|
||||
target=quorum_repair_img, format=iotests.imgfmt)
|
||||
|
|
|
@ -48,8 +48,10 @@ class TestSingleDrive(iotests.QMPTestCase):
|
|||
def setUp(self):
|
||||
qemu_img('create', '-f', iotests.imgfmt, blockdev_target_img, str(image_len))
|
||||
|
||||
self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
|
||||
self.vm.add_drive(blockdev_target_img, interface="none")
|
||||
self.vm = iotests.VM()
|
||||
self.vm.add_drive('blkdebug::' + test_img, 'node-name=source')
|
||||
self.vm.add_drive(blockdev_target_img, 'node-name=target',
|
||||
interface="none")
|
||||
if iotests.qemu_default_machine == 'pc':
|
||||
self.vm.add_drive(None, 'media=cdrom', 'ide')
|
||||
self.vm.launch()
|
||||
|
@ -112,6 +114,41 @@ class TestSingleDrive(iotests.QMPTestCase):
|
|||
def test_pause_blockdev_backup(self):
|
||||
self.do_test_pause('blockdev-backup', 'drive1', blockdev_target_img)
|
||||
|
||||
def do_test_resize_blockdev_backup(self, device, node):
|
||||
def pre_finalize():
|
||||
result = self.vm.qmp('block_resize', device=device, size=65536)
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
|
||||
result = self.vm.qmp('block_resize', node_name=node, size=65536)
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
|
||||
result = self.vm.qmp('blockdev-backup', job_id='job0', device='drive0',
|
||||
target='drive1', sync='full', auto_finalize=False,
|
||||
auto_dismiss=False)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
self.vm.run_job('job0', auto_finalize=False, pre_finalize=pre_finalize)
|
||||
|
||||
def test_source_resize_blockdev_backup(self):
|
||||
self.do_test_resize_blockdev_backup('drive0', 'source')
|
||||
|
||||
def test_target_resize_blockdev_backup(self):
|
||||
self.do_test_resize_blockdev_backup('drive1', 'target')
|
||||
|
||||
def do_test_target_size(self, size):
|
||||
result = self.vm.qmp('block_resize', device='drive1', size=size)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
result = self.vm.qmp('blockdev-backup', job_id='job0', device='drive0',
|
||||
target='drive1', sync='full')
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
|
||||
def test_small_target(self):
|
||||
self.do_test_target_size(image_len // 2)
|
||||
|
||||
def test_large_target(self):
|
||||
self.do_test_target_size(image_len * 2)
|
||||
|
||||
def test_medium_not_found(self):
|
||||
if iotests.qemu_default_machine != 'pc':
|
||||
return
|
||||
|
@ -450,10 +487,9 @@ class TestSingleTransaction(iotests.QMPTestCase):
|
|||
self.assert_no_active_block_jobs()
|
||||
|
||||
|
||||
class TestDriveCompression(iotests.QMPTestCase):
|
||||
class TestCompressedToQcow2(iotests.QMPTestCase):
|
||||
image_len = 64 * 1024 * 1024 # MB
|
||||
fmt_supports_compression = [{'type': 'qcow2', 'args': ()},
|
||||
{'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized')}]
|
||||
target_fmt = {'type': 'qcow2', 'args': (), 'drive-opts': ''}
|
||||
|
||||
def tearDown(self):
|
||||
self.vm.shutdown()
|
||||
|
@ -463,19 +499,22 @@ class TestDriveCompression(iotests.QMPTestCase):
|
|||
except OSError:
|
||||
pass
|
||||
|
||||
def do_prepare_drives(self, fmt, args, attach_target):
|
||||
self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
|
||||
def do_prepare_drives(self, attach_target):
|
||||
self.vm = iotests.VM().add_drive('blkdebug::' + test_img,
|
||||
opts=self.target_fmt['drive-opts'])
|
||||
|
||||
qemu_img('create', '-f', fmt, blockdev_target_img,
|
||||
str(TestDriveCompression.image_len), *args)
|
||||
qemu_img('create', '-f', self.target_fmt['type'], blockdev_target_img,
|
||||
str(self.image_len), *self.target_fmt['args'])
|
||||
if attach_target:
|
||||
self.vm.add_drive(blockdev_target_img,
|
||||
img_format=fmt, interface="none")
|
||||
img_format=self.target_fmt['type'],
|
||||
interface="none",
|
||||
opts=self.target_fmt['drive-opts'])
|
||||
|
||||
self.vm.launch()
|
||||
|
||||
def do_test_compress_complete(self, cmd, format, attach_target, **args):
|
||||
self.do_prepare_drives(format['type'], format['args'], attach_target)
|
||||
def do_test_compress_complete(self, cmd, attach_target, **args):
|
||||
self.do_prepare_drives(attach_target)
|
||||
|
||||
self.assert_no_active_block_jobs()
|
||||
|
||||
|
@ -486,21 +525,21 @@ class TestDriveCompression(iotests.QMPTestCase):
|
|||
|
||||
self.vm.shutdown()
|
||||
self.assertTrue(iotests.compare_images(test_img, blockdev_target_img,
|
||||
iotests.imgfmt, format['type']),
|
||||
iotests.imgfmt,
|
||||
self.target_fmt['type']),
|
||||
'target image does not match source after backup')
|
||||
|
||||
def test_complete_compress_drive_backup(self):
|
||||
for format in TestDriveCompression.fmt_supports_compression:
|
||||
self.do_test_compress_complete('drive-backup', format, False,
|
||||
target=blockdev_target_img, mode='existing')
|
||||
self.do_test_compress_complete('drive-backup', False,
|
||||
target=blockdev_target_img,
|
||||
mode='existing')
|
||||
|
||||
def test_complete_compress_blockdev_backup(self):
|
||||
for format in TestDriveCompression.fmt_supports_compression:
|
||||
self.do_test_compress_complete('blockdev-backup', format, True,
|
||||
target='drive1')
|
||||
self.do_test_compress_complete('blockdev-backup',
|
||||
True, target='drive1')
|
||||
|
||||
def do_test_compress_cancel(self, cmd, format, attach_target, **args):
|
||||
self.do_prepare_drives(format['type'], format['args'], attach_target)
|
||||
def do_test_compress_cancel(self, cmd, attach_target, **args):
|
||||
self.do_prepare_drives(attach_target)
|
||||
|
||||
self.assert_no_active_block_jobs()
|
||||
|
||||
|
@ -514,17 +553,16 @@ class TestDriveCompression(iotests.QMPTestCase):
|
|||
self.vm.shutdown()
|
||||
|
||||
def test_compress_cancel_drive_backup(self):
|
||||
for format in TestDriveCompression.fmt_supports_compression:
|
||||
self.do_test_compress_cancel('drive-backup', format, False,
|
||||
target=blockdev_target_img, mode='existing')
|
||||
self.do_test_compress_cancel('drive-backup', False,
|
||||
target=blockdev_target_img,
|
||||
mode='existing')
|
||||
|
||||
def test_compress_cancel_blockdev_backup(self):
|
||||
for format in TestDriveCompression.fmt_supports_compression:
|
||||
self.do_test_compress_cancel('blockdev-backup', format, True,
|
||||
target='drive1')
|
||||
self.do_test_compress_cancel('blockdev-backup', True,
|
||||
target='drive1')
|
||||
|
||||
def do_test_compress_pause(self, cmd, format, attach_target, **args):
|
||||
self.do_prepare_drives(format['type'], format['args'], attach_target)
|
||||
def do_test_compress_pause(self, cmd, attach_target, **args):
|
||||
self.do_prepare_drives(attach_target)
|
||||
|
||||
self.assert_no_active_block_jobs()
|
||||
|
||||
|
@ -550,18 +588,28 @@ class TestDriveCompression(iotests.QMPTestCase):
|
|||
|
||||
self.vm.shutdown()
|
||||
self.assertTrue(iotests.compare_images(test_img, blockdev_target_img,
|
||||
iotests.imgfmt, format['type']),
|
||||
iotests.imgfmt,
|
||||
self.target_fmt['type']),
|
||||
'target image does not match source after backup')
|
||||
|
||||
def test_compress_pause_drive_backup(self):
|
||||
for format in TestDriveCompression.fmt_supports_compression:
|
||||
self.do_test_compress_pause('drive-backup', format, False,
|
||||
target=blockdev_target_img, mode='existing')
|
||||
self.do_test_compress_pause('drive-backup', False,
|
||||
target=blockdev_target_img,
|
||||
mode='existing')
|
||||
|
||||
def test_compress_pause_blockdev_backup(self):
|
||||
for format in TestDriveCompression.fmt_supports_compression:
|
||||
self.do_test_compress_pause('blockdev-backup', format, True,
|
||||
target='drive1')
|
||||
self.do_test_compress_pause('blockdev-backup', True,
|
||||
target='drive1')
|
||||
|
||||
|
||||
class TestCompressedToVmdk(TestCompressedToQcow2):
|
||||
target_fmt = {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized'),
|
||||
'drive-opts': 'cache.no-flush=on'}
|
||||
|
||||
@iotests.skip_if_unsupported(['vmdk'])
|
||||
def setUp(self):
|
||||
pass
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
iotests.main(supported_fmts=['raw', 'qcow2'],
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
..............................
|
||||
........................................
|
||||
----------------------------------------------------------------------
|
||||
Ran 30 tests
|
||||
Ran 40 tests
|
||||
|
||||
OK
|
||||
|
|
|
@ -41,9 +41,9 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
|
|||
_supported_fmt vmdk
|
||||
_supported_proto file
|
||||
_supported_os Linux
|
||||
_unsupported_imgopts "subformat=monolithicFlat" \
|
||||
"subformat=twoGbMaxExtentFlat" \
|
||||
"subformat=twoGbMaxExtentSparse"
|
||||
|
||||
# We test all kinds of VMDK options here, so ignore user-specified options
|
||||
IMGOPTS=""
|
||||
|
||||
capacity_offset=16
|
||||
granularity_offset=20
|
||||
|
|
|
@ -38,6 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
|
|||
|
||||
_supported_fmt qcow2
|
||||
_supported_proto file nfs
|
||||
_require_drivers bochs
|
||||
|
||||
run_qemu_img()
|
||||
{
|
||||
|
|
|
@ -46,8 +46,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
|
|||
_supported_fmt qcow2
|
||||
_supported_proto file
|
||||
_supported_os Linux
|
||||
_default_cache_mode none
|
||||
_supported_cache_modes writethrough none writeback
|
||||
_default_cache_mode none writeback
|
||||
|
||||
size=1G
|
||||
|
||||
|
|
|
@ -42,6 +42,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
|
|||
_supported_fmt raw
|
||||
_supported_proto file
|
||||
_supported_os Linux
|
||||
_require_drivers qcow qcow2 qed vdi vmdk vpc
|
||||
|
||||
qemu_comm_method=qmp
|
||||
|
||||
|
|
|
@ -37,8 +37,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
|
|||
. ./common.rc
|
||||
. ./common.filter
|
||||
|
||||
# Some of these test cases use bochs, but others do use raw, so this
|
||||
# is only half a lie.
|
||||
# Some of these test cases use bochs, but others do use raw
|
||||
_require_drivers bochs
|
||||
_supported_fmt raw
|
||||
_supported_proto file
|
||||
_supported_os Linux
|
||||
|
|
|
@ -47,6 +47,7 @@ sector = "%d"
|
|||
''' % bad_sector)
|
||||
file.close()
|
||||
|
||||
@iotests.skip_if_unsupported(['quorum'])
|
||||
def setUp(self):
|
||||
driveopts = ['driver=quorum', 'vote-threshold=2']
|
||||
driveopts.append('read-pattern=%s' % self.read_pattern)
|
||||
|
|
|
@ -74,7 +74,11 @@ to check that crash is fixed :)
|
|||
vm = iotests.VM()
|
||||
vm.launch()
|
||||
|
||||
vm.qmp_log('blockdev-add', **{'node-name': 'target', 'driver': 'null-co'})
|
||||
vm.qmp_log('blockdev-add', **{
|
||||
'node-name': 'target',
|
||||
'driver': 'null-co',
|
||||
'size': size,
|
||||
})
|
||||
|
||||
vm.qmp_log('blockdev-add', **{
|
||||
'node-name': 'source',
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
{"execute": "blockdev-add", "arguments": {"driver": "null-co", "node-name": "target"}}
|
||||
{"execute": "blockdev-add", "arguments": {"driver": "null-co", "node-name": "target", "size": 1048576}}
|
||||
{"return": {}}
|
||||
{"execute": "blockdev-add", "arguments": {"driver": "blkdebug", "image": {"driver": "null-co", "node-name": "base", "size": 1048576}, "node-name": "source"}}
|
||||
{"return": {}}
|
||||
|
|
73
tests/qemu-iotests/292
Executable file
73
tests/qemu-iotests/292
Executable file
|
@ -0,0 +1,73 @@
|
|||
#!/usr/bin/env bash
|
||||
#
|
||||
# Test resizing a qcow2 image with a backing file
|
||||
#
|
||||
# Copyright (C) 2020 Igalia, S.L.
|
||||
# Author: Alberto Garcia <berto@igalia.com>
|
||||
#
|
||||
# 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=berto@igalia.com
|
||||
|
||||
seq=`basename $0`
|
||||
echo "QA output created by $seq"
|
||||
|
||||
status=1 # failure is the default!
|
||||
|
||||
_cleanup()
|
||||
{
|
||||
_cleanup_test_img
|
||||
}
|
||||
trap "_cleanup; exit \$status" 0 1 2 3 15
|
||||
|
||||
# get standard environment, filters and checks
|
||||
. ./common.rc
|
||||
. ./common.filter
|
||||
|
||||
_supported_fmt qcow2
|
||||
_supported_proto file
|
||||
_supported_os Linux
|
||||
|
||||
echo '### Create the backing image'
|
||||
BACKING_IMG="$TEST_IMG.base"
|
||||
TEST_IMG="$BACKING_IMG" _make_test_img 1M
|
||||
|
||||
echo '### Fill the backing image with data (0x11)'
|
||||
$QEMU_IO -c 'write -P 0x11 0 1M' "$BACKING_IMG" | _filter_qemu_io
|
||||
|
||||
echo '### Create the top image'
|
||||
_make_test_img -F "$IMGFMT" -b "$BACKING_IMG"
|
||||
|
||||
echo '### Fill the top image with data (0x22)'
|
||||
$QEMU_IO -c 'write -P 0x22 0 1M' "$TEST_IMG" | _filter_qemu_io
|
||||
|
||||
# Both offsets are part of the same cluster.
|
||||
echo '### Shrink the image to 520k'
|
||||
$QEMU_IMG resize --shrink "$TEST_IMG" 520k
|
||||
echo '### Grow the image to 567k'
|
||||
$QEMU_IMG resize "$TEST_IMG" 567k
|
||||
|
||||
echo '### Check that the tail of the image reads as zeroes'
|
||||
$QEMU_IO -c 'read -P 0x22 0 520k' "$TEST_IMG" | _filter_qemu_io
|
||||
$QEMU_IO -c 'read -P 0x00 520k 47k' "$TEST_IMG" | _filter_qemu_io
|
||||
|
||||
echo '### Show output of qemu-img map'
|
||||
$QEMU_IMG map "$TEST_IMG" | _filter_testdir
|
||||
|
||||
# success, all done
|
||||
echo "*** done"
|
||||
rm -f $seq.full
|
||||
status=0
|
24
tests/qemu-iotests/292.out
Normal file
24
tests/qemu-iotests/292.out
Normal file
|
@ -0,0 +1,24 @@
|
|||
QA output created by 292
|
||||
### Create the backing image
|
||||
Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576
|
||||
### Fill the backing image with data (0x11)
|
||||
wrote 1048576/1048576 bytes at offset 0
|
||||
1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
|
||||
### Create the top image
|
||||
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT.base backing_fmt=IMGFMT
|
||||
### Fill the top image with data (0x22)
|
||||
wrote 1048576/1048576 bytes at offset 0
|
||||
1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
|
||||
### Shrink the image to 520k
|
||||
Image resized.
|
||||
### Grow the image to 567k
|
||||
Image resized.
|
||||
### Check that the tail of the image reads as zeroes
|
||||
read 532480/532480 bytes at offset 0
|
||||
520 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
|
||||
read 48128/48128 bytes at offset 532480
|
||||
47 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
|
||||
### Show output of qemu-img map
|
||||
Offset Length Mapped to File
|
||||
0 0x8dc00 0x50000 TEST_DIR/t.qcow2
|
||||
*** done
|
|
@ -546,6 +546,9 @@ fi
|
|||
if [ "$IMGFMT" == "luks" ] && ! (echo "$IMGOPTS" | grep "iter-time=" > /dev/null); then
|
||||
IMGOPTS=$(_optstr_add "$IMGOPTS" "iter-time=10")
|
||||
fi
|
||||
if [ "$IMGFMT" == "vmdk" ] && ! (echo "$IMGOPTS" | grep "zeroed_grain=" > /dev/null); then
|
||||
IMGOPTS=$(_optstr_add "$IMGOPTS" "zeroed_grain=on")
|
||||
fi
|
||||
|
||||
if [ -z "$SAMPLE_IMG_DIR" ]; then
|
||||
SAMPLE_IMG_DIR="$source_iotests/sample_images"
|
||||
|
|
|
@ -673,11 +673,44 @@ _supported_cache_modes()
|
|||
_notrun "not suitable for cache mode: $CACHEMODE"
|
||||
}
|
||||
|
||||
# Check whether the filesystem supports O_DIRECT
|
||||
_check_o_direct()
|
||||
{
|
||||
$QEMU_IMG create -f raw "$TEST_IMG".test_o_direct 1M > /dev/null
|
||||
out=$($QEMU_IO -f raw -t none -c quit "$TEST_IMG".test_o_direct 2>&1)
|
||||
rm -f "$TEST_IMG".test_o_direct
|
||||
|
||||
[[ "$out" != *"O_DIRECT"* ]]
|
||||
}
|
||||
|
||||
_require_o_direct()
|
||||
{
|
||||
if ! _check_o_direct; then
|
||||
_notrun "file system on $TEST_DIR does not support O_DIRECT"
|
||||
fi
|
||||
}
|
||||
|
||||
_check_cache_mode()
|
||||
{
|
||||
if [ $CACHEMODE == "none" ] || [ $CACHEMODE == "directsync" ]; then
|
||||
_require_o_direct
|
||||
fi
|
||||
}
|
||||
|
||||
_check_cache_mode
|
||||
|
||||
# $1 - cache mode to use by default
|
||||
# $2 - (optional) cache mode to use by default if O_DIRECT is not supported
|
||||
_default_cache_mode()
|
||||
{
|
||||
if $CACHEMODE_IS_DEFAULT; then
|
||||
CACHEMODE="$1"
|
||||
QEMU_IO="$QEMU_IO --cache $1"
|
||||
if [ -z "$2" ] || _check_o_direct; then
|
||||
CACHEMODE="$1"
|
||||
else
|
||||
CACHEMODE="$2"
|
||||
fi
|
||||
QEMU_IO="$QEMU_IO --cache $CACHEMODE"
|
||||
_check_cache_mode
|
||||
return
|
||||
fi
|
||||
}
|
||||
|
|
|
@ -298,3 +298,4 @@
|
|||
288 quick
|
||||
289 rw quick
|
||||
290 rw auto quick
|
||||
292 rw auto quick
|
||||
|
|
Loading…
Reference in a new issue