haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Block layer patches:

Browse source 
- 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:
Peter Maydell 2020-05-08 14:29:18 +01:00
parent 1b8c458997 47e0b38a13
commit c88f1ffc19
34 changed files with 386 additions and 195 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
block.c
View file

@ -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;

14
block/backup-top.c
View file

@ -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;
}

18
block/backup.c
View file

@ -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;
}

1
block/file-posix.c
View file

@ -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,

4
block/file-win32.c
View file

@ -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,

14
block/gluster.c
View file

@ -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

4
block/nfs.c
View file

@ -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,

25
block/parallels.c
View file

@ -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);

23
block/qcow2.c
View file

@ -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,

1
block/qed.c
View file

@ -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,

6
block/raw-format.c
View file

@ -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,
};

4
block/rbd.c
View file

@ -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,

4
block/sheepdog.c
View file

@ -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,

5
block/ssh.c
View file

@ -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
View file

@ -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
View file

@ -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)

1
include/block/block.h
View file

@ -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,

7
include/block/block_int.h
View file

@ -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.

8
tests/qemu-iotests/041
View file

@ -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)

120
tests/qemu-iotests/055
View file

@ -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'],

4
tests/qemu-iotests/055.out
View file

@ -1,5 +1,5 @@
..............................
........................................
----------------------------------------------------------------------
Ran 30 tests
Ran 40 tests
OK

6
tests/qemu-iotests/059
View file

@ -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

1
tests/qemu-iotests/082
View file

@ -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()
{

2
tests/qemu-iotests/091
View file

@ -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

1
tests/qemu-iotests/109
View file

@ -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

4
tests/qemu-iotests/113
View file

@ -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

1
tests/qemu-iotests/148
View file

@ -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)

6
tests/qemu-iotests/283
View file

@ -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',

2
tests/qemu-iotests/283.out
View file

@ -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
View 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
View 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

3
tests/qemu-iotests/check
View file

@ -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"

37
tests/qemu-iotests/common.rc
View file

@ -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
}

1
tests/qemu-iotests/group
View file

@ -298,3 +298,4 @@
288 quick
289 rw quick
290 rw auto quick
292 rw auto quick