ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Block layer patches: 

- iotests: Fix output of qemu-io related tests
 - Don't ignore bdrv_set_aio_context() for nodes with bs->drv = NUL
 - vmdk: Set vmdk parent backing_format to vmdk
 - qcow2: Preallocation fixes (especially for external data files)
 - Add linear-buffer-based APIs (as wrappers around qiov-based ones)
 - Various code cleanups and small corner case fixes
 -----BEGIN PGP SIGNATURE-----
 
 iQIcBAABAgAGBQJcyGstAAoJEH8JsnLIjy/WyqEQAKgKSGg8rWZ5B94VkwswuIzi
 Mabz41KJg3kfIzPIhFWxNUE3kjWnrozExbyRc/LWIQRWwE44SANO+lVU4k1fzVDO
 1ilP4FZ2eUv4CTnhZaELXIKXuhdKPiDq9CkWeQQpRxBSXJqlZsEhEABEX/goVU/0
 mxmDmIWd8sQxtRYRDJwYHCBbTAGanzDHfmba970HtbPQUHNRQKhbvwP03MoSBf33
 DCG5r5tZu+VwBv2dsfXOrMj80FJlpaEcALKe0hYboh+lklY7G7vUo/gAVtCrbC2V
 6rYHcEYopdp5/pIQSMieYVvwe01SFjX4B6Q68cdWMYWxX+LRP7wv6dM2KDY1Woql
 Ngi/3kVt1UzRNGe9n+T9N4Ye9rI3ITbD4Nn5hP1E32kpqzEA1Y/AizWjrfQyQScp
 69po8Ih7EH9IPtW0PwQvlL2YrqAiJHKiTm+fxBTCYbrPk3ThBHxsTXS80uVbbtvy
 V9EzUuIhugzv7a7cKNG1h4cpCNUl/D3VdD+SIT35miegM/kyoiwYF4R7jUbtoNRT
 BC6A+znkH1qHBtwIFfzQnqyjcqFz6Zi3auSUyJBlKPCMfiIpaTkuDn91EA5R/SyE
 VHpnrTtWzfjrWYMGYWFCb+Q/JRSJvLuwpimQODVKNwCqcGLGPtbZvzqqR6kNfdoK
 6ukmGysLCqa7uAO/UC+0
 =ZVvj
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging

Block layer patches:

- iotests: Fix output of qemu-io related tests
- Don't ignore bdrv_set_aio_context() for nodes with bs->drv = NUL
- vmdk: Set vmdk parent backing_format to vmdk
- qcow2: Preallocation fixes (especially for external data files)
- Add linear-buffer-based APIs (as wrappers around qiov-based ones)
- Various code cleanups and small corner case fixes

# gpg: Signature made Tue 30 Apr 2019 16:35:09 BST
# gpg:                using RSA key 7F09B272C88F2FD6
# 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: (27 commits)
  block/qed: add missed coroutine_fn markers
  iotests: Check that images are in read-only mode after block-commit
  commit: Make base read-only if there is an early failure
  qemu-img: use buffer-based io
  block/stream: use buffer-based io
  block/commit: use buffer-based io
  block/backup: use buffer-based io
  block/parallels: use buffer-based io
  block/qed: use buffer-based io
  block/qcow: use buffer-based io
  block/qcow2: use buffer-based io
  block: introduce byte-based io helpers
  qcow2: Fix error handling in the compression code
  qcow2: Fix qcow2_make_empty() with external data file
  qemu-img: Make create hint at protocol options
  iotests: Perform the correct test in 082
  qcow2: Fix full preallocation with external data file
  qcow2: Add errp to preallocate_co()
  qcow2: Avoid COW during metadata preallocation
  qemu-img: Saner printing of large file sizes
  ...

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2019-04-30 17:06:57 +01:00
parent c4bfdd5947 54277a2aab
commit f75d15231e
75 changed files with 696 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
block.c
View File

@ -5672,10 +5672,6 @@ void bdrv_detach_aio_context(BlockDriverState *bs)
BdrvAioNotifier *baf, *baf_tmp; BdrvAioNotifier *baf, *baf_tmp;
BdrvChild *child; BdrvChild *child;
if (!bs->drv) {
return;
}
assert(!bs->walking_aio_notifiers); assert(!bs->walking_aio_notifiers);
bs->walking_aio_notifiers = true; bs->walking_aio_notifiers = true;
QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) { QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
@ -5690,7 +5686,7 @@ void bdrv_detach_aio_context(BlockDriverState *bs)
*/ */
bs->walking_aio_notifiers = false; bs->walking_aio_notifiers = false;
if (bs->drv->bdrv_detach_aio_context) { if (bs->drv && bs->drv->bdrv_detach_aio_context) {
bs->drv->bdrv_detach_aio_context(bs); bs->drv->bdrv_detach_aio_context(bs);
} }
QLIST_FOREACH(child, &bs->children, next) { QLIST_FOREACH(child, &bs->children, next) {
@ -5709,10 +5705,6 @@ void bdrv_attach_aio_context(BlockDriverState *bs,
BdrvAioNotifier *ban, *ban_tmp; BdrvAioNotifier *ban, *ban_tmp;
BdrvChild *child; BdrvChild *child;
if (!bs->drv) {
return;
}
if (bs->quiesce_counter) { if (bs->quiesce_counter) {
aio_disable_external(new_context); aio_disable_external(new_context);
} }
@ -5722,7 +5714,7 @@ void bdrv_attach_aio_context(BlockDriverState *bs,
QLIST_FOREACH(child, &bs->children, next) { QLIST_FOREACH(child, &bs->children, next) {
bdrv_attach_aio_context(child->bs, new_context); bdrv_attach_aio_context(child->bs, new_context);
} }
if (bs->drv->bdrv_attach_aio_context) { if (bs->drv && bs->drv->bdrv_attach_aio_context) {
bs->drv->bdrv_attach_aio_context(bs, new_context); bs->drv->bdrv_attach_aio_context(bs, new_context);
} }

14
block/backup.c
View File

@ -107,7 +107,6 @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job,
void **bounce_buffer) void **bounce_buffer)
{ {
int ret; int ret;
QEMUIOVector qiov;
BlockBackend *blk = job->common.blk; BlockBackend *blk = job->common.blk;
int nbytes; int nbytes;
int read_flags = is_write_notifier ? BDRV_REQ_NO_SERIALISING : 0; int read_flags = is_write_notifier ? BDRV_REQ_NO_SERIALISING : 0;
@ -118,9 +117,8 @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job,
if (!*bounce_buffer) { if (!*bounce_buffer) {
*bounce_buffer = blk_blockalign(blk, job->cluster_size); *bounce_buffer = blk_blockalign(blk, job->cluster_size);
} }
qemu_iovec_init_buf(&qiov, *bounce_buffer, nbytes);
ret = blk_co_preadv(blk, start, qiov.size, &qiov, read_flags); ret = blk_co_pread(blk, start, nbytes, *bounce_buffer, read_flags);
if (ret < 0) { if (ret < 0) {
trace_backup_do_cow_read_fail(job, start, ret); trace_backup_do_cow_read_fail(job, start, ret);
if (error_is_read) { if (error_is_read) {
@ -129,13 +127,13 @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job,
goto fail; goto fail;
} }
if (qemu_iovec_is_zero(&qiov)) { if (buffer_is_zero(*bounce_buffer, nbytes)) {
ret = blk_co_pwrite_zeroes(job->target, start, ret = blk_co_pwrite_zeroes(job->target, start,
qiov.size, write_flags | BDRV_REQ_MAY_UNMAP); nbytes, write_flags | BDRV_REQ_MAY_UNMAP);
} else { } else {
ret = blk_co_pwritev(job->target, start, ret = blk_co_pwrite(job->target, start,
qiov.size, &qiov, write_flags | nbytes, *bounce_buffer, write_flags |
(job->compress ? BDRV_REQ_WRITE_COMPRESSED : 0)); (job->compress ? BDRV_REQ_WRITE_COMPRESSED : 0));
} }
if (ret < 0) { if (ret < 0) {
trace_backup_do_cow_write_fail(job, start, ret); trace_backup_do_cow_write_fail(job, start, ret);

8
block/commit.c
View File

@ -48,16 +48,15 @@ static int coroutine_fn commit_populate(BlockBackend *bs, BlockBackend *base,
void *buf) void *buf)
{ {
int ret = 0; int ret = 0;
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
assert(bytes < SIZE_MAX); assert(bytes < SIZE_MAX);
ret = blk_co_preadv(bs, offset, qiov.size, &qiov, 0); ret = blk_co_pread(bs, offset, bytes, buf, 0);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = blk_co_pwritev(base, offset, qiov.size, &qiov, 0); ret = blk_co_pwrite(base, offset, bytes, buf, 0);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -384,6 +383,9 @@ fail:
if (s->top) { if (s->top) {
blk_unref(s->top); blk_unref(s->top);
} }
if (s->base_read_only) {
bdrv_reopen_set_read_only(base, true, NULL);
}
job_early_fail(&s->common.job); job_early_fail(&s->common.job);
/* commit_top_bs has to be replaced after deleting the block job, /* commit_top_bs has to be replaced after deleting the block job,
* otherwise this would fail because of lack of permissions. */ * otherwise this would fail because of lack of permissions. */

14
block/parallels.c
View File

@ -220,20 +220,18 @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
if (bs->backing) { if (bs->backing) {
int64_t nb_cow_sectors = to_allocate * s->tracks; int64_t nb_cow_sectors = to_allocate * s->tracks;
int64_t nb_cow_bytes = nb_cow_sectors << BDRV_SECTOR_BITS; int64_t nb_cow_bytes = nb_cow_sectors << BDRV_SECTOR_BITS;
QEMUIOVector qiov = void *buf = qemu_blockalign(bs, nb_cow_bytes);
QEMU_IOVEC_INIT_BUF(qiov, qemu_blockalign(bs, nb_cow_bytes),
nb_cow_bytes);
ret = bdrv_co_preadv(bs->backing, idx * s->tracks * BDRV_SECTOR_SIZE, ret = bdrv_co_pread(bs->backing, idx * s->tracks * BDRV_SECTOR_SIZE,
nb_cow_bytes, &qiov, 0); nb_cow_bytes, buf, 0);
if (ret < 0) { if (ret < 0) {
qemu_vfree(qemu_iovec_buf(&qiov)); qemu_vfree(buf);
return ret; return ret;
} }
ret = bdrv_co_pwritev(bs->file, s->data_end * BDRV_SECTOR_SIZE, ret = bdrv_co_pwritev(bs->file, s->data_end * BDRV_SECTOR_SIZE,
nb_cow_bytes, &qiov, 0); nb_cow_bytes, buf, 0);
qemu_vfree(qemu_iovec_buf(&qiov)); qemu_vfree(buf);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }

49
block/qapi.c
View File

@ -631,42 +631,13 @@ BlockStatsList *qmp_query_blockstats(bool has_query_nodes,
return head; return head;
} }
#define NB_SUFFIXES 4
static char *get_human_readable_size(char *buf, int buf_size, int64_t size)
{
static const char suffixes[NB_SUFFIXES] = {'K', 'M', 'G', 'T'};
int64_t base;
int i;
if (size <= 999) {
snprintf(buf, buf_size, "%" PRId64, size);
} else {
base = 1024;
for (i = 0; i < NB_SUFFIXES; i++) {
if (size < (10 * base)) {
snprintf(buf, buf_size, "%0.1f%c",
(double)size / base,
suffixes[i]);
break;
} else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
snprintf(buf, buf_size, "%" PRId64 "%c",
((size + (base >> 1)) / base),
suffixes[i]);
break;
}
base = base * 1024;
}
}
return buf;
}
void bdrv_snapshot_dump(QEMUSnapshotInfo *sn) void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
{ {
char buf1[128], date_buf[128], clock_buf[128]; char date_buf[128], clock_buf[128];
struct tm tm; struct tm tm;
time_t ti; time_t ti;
int64_t secs; int64_t secs;
char *sizing = NULL;
if (!sn) { if (!sn) {
qemu_printf("%-10s%-20s%7s%20s%15s", qemu_printf("%-10s%-20s%7s%20s%15s",
@ -683,13 +654,14 @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
(int)((secs / 60) % 60), (int)((secs / 60) % 60),
(int)(secs % 60), (int)(secs % 60),
(int)((sn->vm_clock_nsec / 1000000) % 1000)); (int)((sn->vm_clock_nsec / 1000000) % 1000));
sizing = size_to_str(sn->vm_state_size);
qemu_printf("%-10s%-20s%7s%20s%15s", qemu_printf("%-10s%-20s%7s%20s%15s",
sn->id_str, sn->name, sn->id_str, sn->name,
get_human_readable_size(buf1, sizeof(buf1), sizing,
sn->vm_state_size),
date_buf, date_buf,
clock_buf); clock_buf);
} }
g_free(sizing);
} }
static void dump_qdict(int indentation, QDict *dict); static void dump_qdict(int indentation, QDict *dict);
@ -787,14 +759,13 @@ void bdrv_image_info_specific_dump(ImageInfoSpecific *info_spec)
void bdrv_image_info_dump(ImageInfo *info) void bdrv_image_info_dump(ImageInfo *info)
{ {
char size_buf[128], dsize_buf[128]; char *size_buf, *dsize_buf;
if (!info->has_actual_size) { if (!info->has_actual_size) {
snprintf(dsize_buf, sizeof(dsize_buf), "unavailable"); dsize_buf = g_strdup("unavailable");
} else { } else {
get_human_readable_size(dsize_buf, sizeof(dsize_buf), dsize_buf = size_to_str(info->actual_size);
info->actual_size);
} }
get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size); size_buf = size_to_str(info->virtual_size);
qemu_printf("image: %s\n" qemu_printf("image: %s\n"
"file format: %s\n" "file format: %s\n"
"virtual size: %s (%" PRId64 " bytes)\n" "virtual size: %s (%" PRId64 " bytes)\n"
@ -802,6 +773,8 @@ void bdrv_image_info_dump(ImageInfo *info)
info->filename, info->format, size_buf, info->filename, info->format, size_buf,
info->virtual_size, info->virtual_size,
dsize_buf); dsize_buf);
g_free(size_buf);
g_free(dsize_buf);
if (info->has_encrypted && info->encrypted) { if (info->has_encrypted && info->encrypted) {
qemu_printf("encrypted: yes\n"); qemu_printf("encrypted: yes\n");

19
block/qcow.c
View File

@ -631,7 +631,6 @@ static coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
int offset_in_cluster; int offset_in_cluster;
int ret = 0, n; int ret = 0, n;
uint64_t cluster_offset; uint64_t cluster_offset;
QEMUIOVector hd_qiov;
uint8_t *buf; uint8_t *buf;
void *orig_buf; void *orig_buf;
@ -663,11 +662,10 @@ static coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
if (!cluster_offset) { if (!cluster_offset) {
if (bs->backing) { if (bs->backing) {
/* read from the base image */ /* read from the base image */
qemu_iovec_init_buf(&hd_qiov, buf, n);
qemu_co_mutex_unlock(&s->lock); qemu_co_mutex_unlock(&s->lock);
/* qcow2 emits this on bs->file instead of bs->backing */ /* qcow2 emits this on bs->file instead of bs->backing */
BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
ret = bdrv_co_preadv(bs->backing, offset, n, &hd_qiov, 0); ret = bdrv_co_pread(bs->backing, offset, n, buf, 0);
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
if (ret < 0) { if (ret < 0) {
break; break;
@ -688,11 +686,10 @@ static coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
ret = -EIO; ret = -EIO;
break; break;
} }
qemu_iovec_init_buf(&hd_qiov, buf, n);
qemu_co_mutex_unlock(&s->lock); qemu_co_mutex_unlock(&s->lock);
BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
ret = bdrv_co_preadv(bs->file, cluster_offset + offset_in_cluster, ret = bdrv_co_pread(bs->file, cluster_offset + offset_in_cluster,
n, &hd_qiov, 0); n, buf, 0);
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
if (ret < 0) { if (ret < 0) {
break; break;
@ -731,7 +728,6 @@ static coroutine_fn int qcow_co_pwritev(BlockDriverState *bs, uint64_t offset,
int offset_in_cluster; int offset_in_cluster;
uint64_t cluster_offset; uint64_t cluster_offset;
int ret = 0, n; int ret = 0, n;
QEMUIOVector hd_qiov;
uint8_t *buf; uint8_t *buf;
void *orig_buf; void *orig_buf;
@ -776,11 +772,10 @@ static coroutine_fn int qcow_co_pwritev(BlockDriverState *bs, uint64_t offset,
} }
} }
qemu_iovec_init_buf(&hd_qiov, buf, n);
qemu_co_mutex_unlock(&s->lock); qemu_co_mutex_unlock(&s->lock);
BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
ret = bdrv_co_pwritev(bs->file, cluster_offset + offset_in_cluster, ret = bdrv_co_pwrite(bs->file, cluster_offset + offset_in_cluster,
n, &hd_qiov, 0); n, buf, 0);
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
if (ret < 0) { if (ret < 0) {
break; break;
@ -1056,7 +1051,6 @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov) uint64_t bytes, QEMUIOVector *qiov)
{ {
BDRVQcowState *s = bs->opaque; BDRVQcowState *s = bs->opaque;
QEMUIOVector hd_qiov;
z_stream strm; z_stream strm;
int ret, out_len; int ret, out_len;
uint8_t *buf, *out_buf; uint8_t *buf, *out_buf;
@ -1122,9 +1116,8 @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
} }
cluster_offset &= s->cluster_offset_mask; cluster_offset &= s->cluster_offset_mask;
qemu_iovec_init_buf(&hd_qiov, out_buf, out_len);
BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED); BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0); ret = bdrv_co_pwrite(bs->file, cluster_offset, out_len, out_buf, 0);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }

80
block/qcow2.c
View File

@ -2721,11 +2721,13 @@ static int qcow2_set_up_encryption(BlockDriverState *bs,
* Returns: 0 on success, -errno on failure. * Returns: 0 on success, -errno on failure.
*/ */
static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset, static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
uint64_t new_length) uint64_t new_length, PreallocMode mode,
Error **errp)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
uint64_t bytes; uint64_t bytes;
uint64_t host_offset = 0; uint64_t host_offset = 0;
int64_t file_length;
unsigned int cur_bytes; unsigned int cur_bytes;
int ret; int ret;
QCowL2Meta *meta; QCowL2Meta *meta;
@ -2734,10 +2736,11 @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
bytes = new_length - offset; bytes = new_length - offset;
while (bytes) { while (bytes) {
cur_bytes = MIN(bytes, INT_MAX); cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size));
ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes, ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,
&host_offset, &meta); &host_offset, &meta);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "Allocating clusters failed");
return ret; return ret;
} }
@ -2746,6 +2749,7 @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
ret = qcow2_alloc_cluster_link_l2(bs, meta); ret = qcow2_alloc_cluster_link_l2(bs, meta);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "Mapping clusters failed");
qcow2_free_any_clusters(bs, meta->alloc_offset, qcow2_free_any_clusters(bs, meta->alloc_offset,
meta->nb_clusters, QCOW2_DISCARD_NEVER); meta->nb_clusters, QCOW2_DISCARD_NEVER);
return ret; return ret;
@ -2770,10 +2774,18 @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
* all of the allocated clusters (otherwise we get failing reads after * all of the allocated clusters (otherwise we get failing reads after
* EOF). Extend the image to the last allocated sector. * EOF). Extend the image to the last allocated sector.
*/ */
if (host_offset != 0) { file_length = bdrv_getlength(s->data_file->bs);
uint8_t data = 0; if (file_length < 0) {
ret = bdrv_pwrite(s->data_file, (host_offset + cur_bytes) - 1, error_setg_errno(errp, -file_length, "Could not get file size");
&data, 1); return file_length;
}
if (host_offset + cur_bytes > file_length) {
if (mode == PREALLOC_MODE_METADATA) {
mode = PREALLOC_MODE_OFF;
}
ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, mode,
errp);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -3745,12 +3757,17 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
switch (prealloc) { switch (prealloc) {
case PREALLOC_MODE_OFF: case PREALLOC_MODE_OFF:
if (has_data_file(bs)) {
ret = bdrv_co_truncate(s->data_file, offset, prealloc, errp);
if (ret < 0) {
goto fail;
}
}
break; break;
case PREALLOC_MODE_METADATA: case PREALLOC_MODE_METADATA:
ret = preallocate_co(bs, old_length, offset); ret = preallocate_co(bs, old_length, offset, prealloc, errp);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "Preallocation failed");
goto fail; goto fail;
} }
break; break;
@ -3766,9 +3783,8 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
/* With a data file, preallocation means just allocating the metadata /* With a data file, preallocation means just allocating the metadata
* and forwarding the truncate request to the data file */ * and forwarding the truncate request to the data file */
if (has_data_file(bs)) { if (has_data_file(bs)) {
ret = preallocate_co(bs, old_length, offset); ret = preallocate_co(bs, old_length, offset, prealloc, errp);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "Preallocation failed");
goto fail; goto fail;
} }
break; break;
@ -3882,16 +3898,6 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
bs->total_sectors = offset / BDRV_SECTOR_SIZE; bs->total_sectors = offset / BDRV_SECTOR_SIZE;
if (has_data_file(bs)) {
if (prealloc == PREALLOC_MODE_METADATA) {
prealloc = PREALLOC_MODE_OFF;
}
ret = bdrv_co_truncate(s->data_file, offset, prealloc, errp);
if (ret < 0) {
goto fail;
}
}
/* write updated header.size */ /* write updated header.size */
offset = cpu_to_be64(offset); offset = cpu_to_be64(offset);
ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
@ -3923,8 +3929,8 @@ fail:
* @src - source buffer, @src_size bytes * @src - source buffer, @src_size bytes
* *
* Returns: compressed size on success * Returns: compressed size on success
* -1 destination buffer is not enough to store compressed data * -ENOMEM destination buffer is not enough to store compressed data
* -2 on any other error * -EIO on any other error
*/ */
static ssize_t qcow2_compress(void *dest, size_t dest_size, static ssize_t qcow2_compress(void *dest, size_t dest_size,
const void *src, size_t src_size) const void *src, size_t src_size)
@ -3937,7 +3943,7 @@ static ssize_t qcow2_compress(void *dest, size_t dest_size,
ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-12, 9, Z_DEFAULT_STRATEGY); -12, 9, Z_DEFAULT_STRATEGY);
if (ret != Z_OK) { if (ret != Z_OK) {
return -2; return -EIO;
} }
/* strm.next_in is not const in old zlib versions, such as those used on /* strm.next_in is not const in old zlib versions, such as those used on
@ -3951,7 +3957,7 @@ static ssize_t qcow2_compress(void *dest, size_t dest_size,
if (ret == Z_STREAM_END) { if (ret == Z_STREAM_END) {
ret = dest_size - strm.avail_out; ret = dest_size - strm.avail_out;
} else { } else {
ret = (ret == Z_OK ? -1 : -2); ret = (ret == Z_OK ? -ENOMEM : -EIO);
} }
deflateEnd(&strm); deflateEnd(&strm);
@ -4088,9 +4094,8 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov) uint64_t bytes, QEMUIOVector *qiov)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
QEMUIOVector hd_qiov;
int ret; int ret;
size_t out_len; ssize_t out_len;
uint8_t *buf, *out_buf; uint8_t *buf, *out_buf;
uint64_t cluster_offset; uint64_t cluster_offset;
@ -4129,16 +4134,16 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1, out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1,
buf, s->cluster_size); buf, s->cluster_size);
if (out_len == -2) { if (out_len == -ENOMEM) {
ret = -EINVAL;
goto fail;
} else if (out_len == -1) {
/* could not compress: write normal cluster */ /* could not compress: write normal cluster */
ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0); ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }
goto success; goto success;
} else if (out_len < 0) {
ret = -EINVAL;
goto fail;
} }
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
@ -4155,10 +4160,8 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
goto fail; goto fail;
} }
qemu_iovec_init_buf(&hd_qiov, out_buf, out_len);
BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED); BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
ret = bdrv_co_pwritev(s->data_file, cluster_offset, out_len, &hd_qiov, 0); ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }
@ -4181,7 +4184,6 @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
int ret = 0, csize, nb_csectors; int ret = 0, csize, nb_csectors;
uint64_t coffset; uint64_t coffset;
uint8_t *buf, *out_buf; uint8_t *buf, *out_buf;
QEMUIOVector local_qiov;
int offset_in_cluster = offset_into_cluster(s, offset); int offset_in_cluster = offset_into_cluster(s, offset);
coffset = file_cluster_offset & s->cluster_offset_mask; coffset = file_cluster_offset & s->cluster_offset_mask;
@ -4192,12 +4194,11 @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
if (!buf) { if (!buf) {
return -ENOMEM; return -ENOMEM;
} }
qemu_iovec_init_buf(&local_qiov, buf, csize);
out_buf = qemu_blockalign(bs, s->cluster_size); out_buf = qemu_blockalign(bs, s->cluster_size);
BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED); BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
ret = bdrv_co_preadv(bs->file, coffset, csize, &local_qiov, 0); ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }
@ -4378,14 +4379,17 @@ static int qcow2_make_empty(BlockDriverState *bs)
if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps && if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps &&
3 + l1_clusters <= s->refcount_block_size && 3 + l1_clusters <= s->refcount_block_size &&
s->crypt_method_header != QCOW_CRYPT_LUKS) { s->crypt_method_header != QCOW_CRYPT_LUKS &&
!has_data_file(bs)) {
/* The following function only works for qcow2 v3 images (it /* The following function only works for qcow2 v3 images (it
* requires the dirty flag) and only as long as there are no * requires the dirty flag) and only as long as there are no
* features that reserve extra clusters (such as snapshots, * features that reserve extra clusters (such as snapshots,
* LUKS header, or persistent bitmaps), because it completely * LUKS header, or persistent bitmaps), because it completely
* empties the image. Furthermore, the L1 table and three * empties the image. Furthermore, the L1 table and three
* additional clusters (image header, refcount table, one * additional clusters (image header, refcount table, one
* refcount block) have to fit inside one refcount block. */ * refcount block) have to fit inside one refcount block. It
* only resets the image file, i.e. does not work with an
* external data file. */
return make_completely_empty(bs); return make_completely_empty(bs);
} }

4
block/qed-check.c
View File

@ -106,7 +106,7 @@ static unsigned int qed_check_l2_table(QEDCheck *check, QEDTable *table)
/** /**
* Descend tables and check each cluster is referenced once only * Descend tables and check each cluster is referenced once only
*/ */
static int qed_check_l1_table(QEDCheck *check, QEDTable *table) static int coroutine_fn qed_check_l1_table(QEDCheck *check, QEDTable *table)
{ {
BDRVQEDState *s = check->s; BDRVQEDState *s = check->s;
unsigned int i, num_invalid_l1 = 0; unsigned int i, num_invalid_l1 = 0;
@ -218,7 +218,7 @@ static void qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result)
} }
/* Called with table_lock held. */ /* Called with table_lock held. */
int qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix) int coroutine_fn qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix)
{ {
QEDCheck check = { QEDCheck check = {
.s = s, .s = s,

45
block/qed-table.c
View File

@ -19,24 +19,25 @@
#include "qemu/bswap.h" #include "qemu/bswap.h"
/* Called with table_lock held. */ /* Called with table_lock held. */
static int qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table) static int coroutine_fn qed_read_table(BDRVQEDState *s, uint64_t offset,
QEDTable *table)
{ {
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF( unsigned int bytes = s->header.cluster_size * s->header.table_size;
qiov, table->offsets, s->header.cluster_size * s->header.table_size);
int noffsets; int noffsets;
int i, ret; int i, ret;
trace_qed_read_table(s, offset, table); trace_qed_read_table(s, offset, table);
qemu_co_mutex_unlock(&s->table_lock); qemu_co_mutex_unlock(&s->table_lock);
ret = bdrv_preadv(s->bs->file, offset, &qiov); ret = bdrv_co_pread(s->bs->file, offset, bytes, table->offsets, 0);
qemu_co_mutex_lock(&s->table_lock); qemu_co_mutex_lock(&s->table_lock);
if (ret < 0) { if (ret < 0) {
goto out; goto out;
} }
/* Byteswap offsets */ /* Byteswap offsets */
noffsets = qiov.size / sizeof(uint64_t); noffsets = bytes / sizeof(uint64_t);
for (i = 0; i < noffsets; i++) { for (i = 0; i < noffsets; i++) {
table->offsets[i] = le64_to_cpu(table->offsets[i]); table->offsets[i] = le64_to_cpu(table->offsets[i]);
} }
@ -60,13 +61,13 @@ out:
* *
* Called with table_lock held. * Called with table_lock held.
*/ */
static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, static int coroutine_fn qed_write_table(BDRVQEDState *s, uint64_t offset,
unsigned int index, unsigned int n, bool flush) QEDTable *table, unsigned int index,
unsigned int n, bool flush)
{ {
unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1; unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;
unsigned int start, end, i; unsigned int start, end, i;
QEDTable *new_table; QEDTable *new_table;
QEMUIOVector qiov;
size_t len_bytes; size_t len_bytes;
int ret; int ret;
@ -79,7 +80,6 @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
len_bytes = (end - start) * sizeof(uint64_t); len_bytes = (end - start) * sizeof(uint64_t);
new_table = qemu_blockalign(s->bs, len_bytes); new_table = qemu_blockalign(s->bs, len_bytes);
qemu_iovec_init_buf(&qiov, new_table->offsets, len_bytes);
/* Byteswap table */ /* Byteswap table */
for (i = start; i < end; i++) { for (i = start; i < end; i++) {
@ -91,7 +91,7 @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
offset += start * sizeof(uint64_t); offset += start * sizeof(uint64_t);
qemu_co_mutex_unlock(&s->table_lock); qemu_co_mutex_unlock(&s->table_lock);
ret = bdrv_pwritev(s->bs->file, offset, &qiov); ret = bdrv_co_pwrite(s->bs->file, offset, len_bytes, new_table->offsets, 0);
qemu_co_mutex_lock(&s->table_lock); qemu_co_mutex_lock(&s->table_lock);
trace_qed_write_table_cb(s, table, flush, ret); trace_qed_write_table_cb(s, table, flush, ret);
if (ret < 0) { if (ret < 0) {
@ -111,27 +111,29 @@ out:
return ret; return ret;
} }
int qed_read_l1_table_sync(BDRVQEDState *s) int coroutine_fn qed_read_l1_table_sync(BDRVQEDState *s)
{ {
return qed_read_table(s, s->header.l1_table_offset, s->l1_table); return qed_read_table(s, s->header.l1_table_offset, s->l1_table);
} }
/* Called with table_lock held. */ /* Called with table_lock held. */
int qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n) int coroutine_fn qed_write_l1_table(BDRVQEDState *s, unsigned int index,
unsigned int n)
{ {
BLKDBG_EVENT(s->bs->file, BLKDBG_L1_UPDATE); BLKDBG_EVENT(s->bs->file, BLKDBG_L1_UPDATE);
return qed_write_table(s, s->header.l1_table_offset, return qed_write_table(s, s->header.l1_table_offset,
s->l1_table, index, n, false); s->l1_table, index, n, false);
} }
int qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, int coroutine_fn qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index,
unsigned int n) unsigned int n)
{ {
return qed_write_l1_table(s, index, n); return qed_write_l1_table(s, index, n);
} }
/* Called with table_lock held. */ /* Called with table_lock held. */
int qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset) int coroutine_fn qed_read_l2_table(BDRVQEDState *s, QEDRequest *request,
uint64_t offset)
{ {
int ret; int ret;
@ -168,22 +170,25 @@ int qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset)
return ret; return ret;
} }
int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, uint64_t offset) int coroutine_fn qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
uint64_t offset)
{ {
return qed_read_l2_table(s, request, offset); return qed_read_l2_table(s, request, offset);
} }
/* Called with table_lock held. */ /* Called with table_lock held. */
int qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, int coroutine_fn qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, bool flush) unsigned int index, unsigned int n,
bool flush)
{ {
BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE); BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE);
return qed_write_table(s, request->l2_table->offset, return qed_write_table(s, request->l2_table->offset,
request->l2_table->table, index, n, flush); request->l2_table->table, index, n, flush);
} }
int qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request, int coroutine_fn qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, bool flush) unsigned int index, unsigned int n,
bool flush)
{ {
return qed_write_l2_table(s, request, index, n, flush); return qed_write_l2_table(s, request, index, n, flush);
} }

11
block/qed.c
View File

@ -113,15 +113,13 @@ static int coroutine_fn qed_write_header(BDRVQEDState *s)
int nsectors = DIV_ROUND_UP(sizeof(QEDHeader), BDRV_SECTOR_SIZE); int nsectors = DIV_ROUND_UP(sizeof(QEDHeader), BDRV_SECTOR_SIZE);
size_t len = nsectors * BDRV_SECTOR_SIZE; size_t len = nsectors * BDRV_SECTOR_SIZE;
uint8_t *buf; uint8_t *buf;
QEMUIOVector qiov;
int ret; int ret;
assert(s->allocating_acb || s->allocating_write_reqs_plugged); assert(s->allocating_acb || s->allocating_write_reqs_plugged);
buf = qemu_blockalign(s->bs, len); buf = qemu_blockalign(s->bs, len);
qemu_iovec_init_buf(&qiov, buf, len);
ret = bdrv_co_preadv(s->bs->file, 0, qiov.size, &qiov, 0); ret = bdrv_co_pread(s->bs->file, 0, len, buf, 0);
if (ret < 0) { if (ret < 0) {
goto out; goto out;
} }
@ -129,7 +127,7 @@ static int coroutine_fn qed_write_header(BDRVQEDState *s)
/* Update header */ /* Update header */
qed_header_cpu_to_le(&s->header, (QEDHeader *) buf); qed_header_cpu_to_le(&s->header, (QEDHeader *) buf);
ret = bdrv_co_pwritev(s->bs->file, 0, qiov.size, &qiov, 0); ret = bdrv_co_pwrite(s->bs->file, 0, len, buf, 0);
if (ret < 0) { if (ret < 0) {
goto out; goto out;
} }
@ -1606,8 +1604,9 @@ static void coroutine_fn bdrv_qed_co_invalidate_cache(BlockDriverState *bs,
} }
} }
static int bdrv_qed_co_check(BlockDriverState *bs, BdrvCheckResult *result, static int coroutine_fn bdrv_qed_co_check(BlockDriverState *bs,
BdrvCheckMode fix) BdrvCheckResult *result,
BdrvCheckMode fix)
{ {
BDRVQEDState *s = bs->opaque; BDRVQEDState *s = bs->opaque;
int ret; int ret;

28
block/qed.h
View File

@ -201,17 +201,21 @@ void qed_commit_l2_cache_entry(L2TableCache *l2_cache, CachedL2Table *l2_table);
/** /**
* Table I/O functions * Table I/O functions
*/ */
int qed_read_l1_table_sync(BDRVQEDState *s); int coroutine_fn qed_read_l1_table_sync(BDRVQEDState *s);
int qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n); int coroutine_fn qed_write_l1_table(BDRVQEDState *s, unsigned int index,
int qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, unsigned int n);
unsigned int n); int coroutine_fn qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index,
int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, unsigned int n);
uint64_t offset); int coroutine_fn qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
int qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset); uint64_t offset);
int qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, int coroutine_fn qed_read_l2_table(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, bool flush); uint64_t offset);
int qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request, int coroutine_fn qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n, bool flush); unsigned int index, unsigned int n,
bool flush);
int coroutine_fn qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
unsigned int index, unsigned int n,
bool flush);
/** /**
* Cluster functions * Cluster functions
@ -223,7 +227,7 @@ int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,
/** /**
* Consistency check * Consistency check
*/ */
int qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix); int coroutine_fn qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix);
QEDTable *qed_alloc_table(BDRVQEDState *s); QEDTable *qed_alloc_table(BDRVQEDState *s);

4
block/stream.c
View File

@ -42,12 +42,10 @@ static int coroutine_fn stream_populate(BlockBackend *blk,
int64_t offset, uint64_t bytes, int64_t offset, uint64_t bytes,
void *buf) void *buf)
{ {
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
assert(bytes < SIZE_MAX); assert(bytes < SIZE_MAX);
/* Copy-on-read the unallocated clusters */ /* Copy-on-read the unallocated clusters */
return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ); return blk_co_pread(blk, offset, bytes, buf, BDRV_REQ_COPY_ON_READ);
} }
static void stream_abort(Job *job) static void stream_abort(Job *job)

2
block/vhdx-log.c
View File

@ -551,7 +551,7 @@ static int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s,
} }
if (file_length < desc_entries->hdr.last_file_offset) { if (file_length < desc_entries->hdr.last_file_offset) {
new_file_size = desc_entries->hdr.last_file_offset; new_file_size = desc_entries->hdr.last_file_offset;
if (new_file_size % (1024*1024)) { if (new_file_size % (1 * MiB)) {
/* round up to nearest 1MB boundary */ /* round up to nearest 1MB boundary */
new_file_size = QEMU_ALIGN_UP(new_file_size, MiB); new_file_size = QEMU_ALIGN_UP(new_file_size, MiB);
if (new_file_size > INT64_MAX) { if (new_file_size > INT64_MAX) {

7
block/vhdx.c
View File

@ -1175,7 +1175,7 @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
*new_offset = current_len; *new_offset = current_len;
/* per the spec, the address for a block is in units of 1MB */ /* per the spec, the address for a block is in units of 1MB */
*new_offset = ROUND_UP(*new_offset, 1024 * 1024); *new_offset = ROUND_UP(*new_offset, 1 * MiB);
if (*new_offset > INT64_MAX) { if (*new_offset > INT64_MAX) {
return -EINVAL; return -EINVAL;
} }
@ -1338,7 +1338,7 @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
case PAYLOAD_BLOCK_FULLY_PRESENT: case PAYLOAD_BLOCK_FULLY_PRESENT:
/* if the file offset address is in the header zone, /* if the file offset address is in the header zone,
* there is a problem */ * there is a problem */
if (sinfo.file_offset < (1024 * 1024)) { if (sinfo.file_offset < (1 * MiB)) {
ret = -EFAULT; ret = -EFAULT;
goto error_bat_restore; goto error_bat_restore;
} }
@ -1889,7 +1889,8 @@ static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
return -EINVAL; return -EINVAL;
} }
if (block_size > VHDX_BLOCK_SIZE_MAX) { if (block_size > VHDX_BLOCK_SIZE_MAX) {
error_setg(errp, "Block size must not exceed %d", VHDX_BLOCK_SIZE_MAX); error_setg(errp, "Block size must not exceed %" PRId64,
VHDX_BLOCK_SIZE_MAX);
return -EINVAL; return -EINVAL;
} }

16
block/vhdx.h
View File

@ -17,13 +17,11 @@
#ifndef BLOCK_VHDX_H #ifndef BLOCK_VHDX_H
#define BLOCK_VHDX_H #define BLOCK_VHDX_H
#include "qemu/units.h"
#define KiB (1 * 1024)
#define MiB (KiB * 1024)
#define GiB (MiB * 1024)
#define TiB ((uint64_t) GiB * 1024)
#define DEFAULT_LOG_SIZE 1048576 /* 1MiB */ #define DEFAULT_LOG_SIZE 1048576 /* 1MiB */
/* Note: can't use 1 * MiB, because it's passed to stringify() */
/* Structures and fields present in the VHDX file */ /* Structures and fields present in the VHDX file */
/* The header section has the following blocks, /* The header section has the following blocks,
@ -36,7 +34,7 @@
* 0.........64KB...........128KB........192KB..........256KB................1MB * 0.........64KB...........128KB........192KB..........256KB................1MB
*/ */
#define VHDX_HEADER_BLOCK_SIZE (64 * 1024) #define VHDX_HEADER_BLOCK_SIZE (64 * KiB)
#define VHDX_FILE_ID_OFFSET 0 #define VHDX_FILE_ID_OFFSET 0
#define VHDX_HEADER1_OFFSET (VHDX_HEADER_BLOCK_SIZE * 1) #define VHDX_HEADER1_OFFSET (VHDX_HEADER_BLOCK_SIZE * 1)
@ -85,7 +83,7 @@ typedef struct QEMU_PACKED MSGUID {
#define guid_eq(a, b) \ #define guid_eq(a, b) \
(memcmp(&(a), &(b), sizeof(MSGUID)) == 0) (memcmp(&(a), &(b), sizeof(MSGUID)) == 0)
#define VHDX_HEADER_SIZE (4 * 1024) /* although the vhdx_header struct in disk #define VHDX_HEADER_SIZE (4 * KiB) /* although the vhdx_header struct in disk
is only 582 bytes, for purposes of crc is only 582 bytes, for purposes of crc
the header is the first 4KB of the 64KB the header is the first 4KB of the 64KB
block */ block */
@ -161,8 +159,8 @@ typedef struct QEMU_PACKED VHDXRegionTableEntry {
/* ---- LOG ENTRY STRUCTURES ---- */ /* ---- LOG ENTRY STRUCTURES ---- */
#define VHDX_LOG_MIN_SIZE (1024 * 1024) #define VHDX_LOG_MIN_SIZE (1 * MiB)
#define VHDX_LOG_SECTOR_SIZE 4096 #define VHDX_LOG_SECTOR_SIZE (4 * KiB)
#define VHDX_LOG_HDR_SIZE 64 #define VHDX_LOG_HDR_SIZE 64
#define VHDX_LOG_SIGNATURE 0x65676f6c #define VHDX_LOG_SIGNATURE 0x65676f6c
typedef struct QEMU_PACKED VHDXLogEntryHeader { typedef struct QEMU_PACKED VHDXLogEntryHeader {

2
block/vmdk.c
View File

@ -397,6 +397,8 @@ static int vmdk_parent_open(BlockDriverState *bs)
pstrcpy(bs->auto_backing_file, end_name - p_name + 1, p_name); pstrcpy(bs->auto_backing_file, end_name - p_name + 1, p_name);
pstrcpy(bs->backing_file, sizeof(bs->backing_file), pstrcpy(bs->backing_file, sizeof(bs->backing_file),
bs->auto_backing_file); bs->auto_backing_file);
pstrcpy(bs->backing_format, sizeof(bs->backing_format),
"vmdk");
} }
out: out:

4
block/vpc.c
View File

@ -639,8 +639,10 @@ vpc_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
qemu_iovec_reset(&local_qiov); qemu_iovec_reset(&local_qiov);
qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes); qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
qemu_co_mutex_unlock(&s->lock);
ret = bdrv_co_preadv(bs->file, image_offset, n_bytes, ret = bdrv_co_preadv(bs->file, image_offset, n_bytes,
&local_qiov, 0); &local_qiov, 0);
qemu_co_mutex_lock(&s->lock);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }
@ -697,8 +699,10 @@ vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
qemu_iovec_reset(&local_qiov); qemu_iovec_reset(&local_qiov);
qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes); qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
qemu_co_mutex_unlock(&s->lock);
ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes, ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes,
&local_qiov, 0); &local_qiov, 0);
qemu_co_mutex_lock(&s->lock);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }

16
include/block/block_int.h
View File

@ -925,6 +925,22 @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
int64_t offset, unsigned int bytes, QEMUIOVector *qiov, int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
BdrvRequestFlags flags); BdrvRequestFlags flags);
static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags)
{
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
return bdrv_co_preadv(child, offset, bytes, &qiov, flags);
}
static inline int coroutine_fn bdrv_co_pwrite(BdrvChild *child,
int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags)
{
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
return bdrv_co_pwritev(child, offset, bytes, &qiov, flags);
}
extern unsigned int bdrv_drain_all_count; extern unsigned int bdrv_drain_all_count;
void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent); void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent);
void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent); void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent);

19
include/sysemu/block-backend.h
View File

@ -124,6 +124,25 @@ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset, int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
unsigned int bytes, QEMUIOVector *qiov, unsigned int bytes, QEMUIOVector *qiov,
BdrvRequestFlags flags); BdrvRequestFlags flags);
static inline int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset,
unsigned int bytes, void *buf,
BdrvRequestFlags flags)
{
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
return blk_co_preadv(blk, offset, bytes, &qiov, flags);
}
static inline int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset,
unsigned int bytes, void *buf,
BdrvRequestFlags flags)
{
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
}
int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset, int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
int bytes, BdrvRequestFlags flags); int bytes, BdrvRequestFlags flags);
BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset, BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,

26
qemu-img.c
View File

@ -267,9 +267,20 @@ static int print_block_option_help(const char *filename, const char *fmt)
create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
} }
printf("Supported options:\n"); if (filename) {
printf("Supported options:\n");
} else {
printf("Supported %s options:\n", fmt);
}
qemu_opts_print_help(create_opts, false); qemu_opts_print_help(create_opts, false);
qemu_opts_free(create_opts); qemu_opts_free(create_opts);
if (!filename) {
printf("\n"
"The protocol level may support further options.\n"
"Specify the target filename to include those options.\n");
}
return 0; return 0;
} }
@ -1669,7 +1680,6 @@ static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
int nb_sectors, uint8_t *buf) int nb_sectors, uint8_t *buf)
{ {
int n, ret; int n, ret;
QEMUIOVector qiov;
assert(nb_sectors <= s->buf_sectors); assert(nb_sectors <= s->buf_sectors);
while (nb_sectors > 0) { while (nb_sectors > 0) {
@ -1685,11 +1695,10 @@ static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
bs_sectors = s->src_sectors[src_cur]; bs_sectors = s->src_sectors[src_cur];
n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset)); n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
qemu_iovec_init_buf(&qiov, buf, n << BDRV_SECTOR_BITS);
ret = blk_co_preadv( ret = blk_co_pread(
blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS, blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS,
n << BDRV_SECTOR_BITS, &qiov, 0); n << BDRV_SECTOR_BITS, buf, 0);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1708,7 +1717,6 @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
enum ImgConvertBlockStatus status) enum ImgConvertBlockStatus status)
{ {
int ret; int ret;
QEMUIOVector qiov;
while (nb_sectors > 0) { while (nb_sectors > 0) {
int n = nb_sectors; int n = nb_sectors;
@ -1736,10 +1744,8 @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
(s->compressed && (s->compressed &&
!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE))) !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
{ {
qemu_iovec_init_buf(&qiov, buf, n << BDRV_SECTOR_BITS); ret = blk_co_pwrite(s->target, sector_num << BDRV_SECTOR_BITS,
n << BDRV_SECTOR_BITS, buf, flags);
ret = blk_co_pwritev(s->target, sector_num << BDRV_SECTOR_BITS,
n << BDRV_SECTOR_BITS, &qiov, flags);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }

168
tests/qemu-iotests/026.out
View File

@ -14,8 +14,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l1_update; errno: 5; imm: off; once: off; write Event: l1_update; errno: 5; imm: off; once: off; write
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
1 leaked clusters were found on the image. 1 leaked clusters were found on the image.
@ -23,8 +23,8 @@ This means waste of disk space, but no harm to data.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l1_update; errno: 5; imm: off; once: off; write -b Event: l1_update; errno: 5; imm: off; once: off; write -b
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
1 leaked clusters were found on the image. 1 leaked clusters were found on the image.
@ -42,8 +42,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l1_update; errno: 28; imm: off; once: off; write Event: l1_update; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
1 leaked clusters were found on the image. 1 leaked clusters were found on the image.
@ -51,8 +51,8 @@ This means waste of disk space, but no harm to data.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l1_update; errno: 28; imm: off; once: off; write -b Event: l1_update; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
1 leaked clusters were found on the image. 1 leaked clusters were found on the image.
@ -134,8 +134,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l2_update; errno: 5; imm: off; once: off; write Event: l2_update; errno: 5; imm: off; once: off; write
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
127 leaked clusters were found on the image. 127 leaked clusters were found on the image.
@ -143,8 +143,8 @@ This means waste of disk space, but no harm to data.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l2_update; errno: 5; imm: off; once: off; write -b Event: l2_update; errno: 5; imm: off; once: off; write -b
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
127 leaked clusters were found on the image. 127 leaked clusters were found on the image.
@ -162,8 +162,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l2_update; errno: 28; imm: off; once: off; write Event: l2_update; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
127 leaked clusters were found on the image. 127 leaked clusters were found on the image.
@ -171,8 +171,8 @@ This means waste of disk space, but no harm to data.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l2_update; errno: 28; imm: off; once: off; write -b Event: l2_update; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
127 leaked clusters were found on the image. 127 leaked clusters were found on the image.
@ -190,15 +190,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l2_alloc_write; errno: 5; imm: off; once: off; write Event: l2_alloc_write; errno: 5; imm: off; once: off; write
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l2_alloc_write; errno: 5; imm: off; once: off; write -b Event: l2_alloc_write; errno: 5; imm: off; once: off; write -b
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
1 leaked clusters were found on the image. 1 leaked clusters were found on the image.
@ -216,15 +216,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l2_alloc_write; errno: 28; imm: off; once: off; write Event: l2_alloc_write; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l2_alloc_write; errno: 28; imm: off; once: off; write -b Event: l2_alloc_write; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
1 leaked clusters were found on the image. 1 leaked clusters were found on the image.
@ -242,15 +242,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: write_aio; errno: 5; imm: off; once: off; write Event: write_aio; errno: 5; imm: off; once: off; write
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: write_aio; errno: 5; imm: off; once: off; write -b Event: write_aio; errno: 5; imm: off; once: off; write -b
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -266,15 +266,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: write_aio; errno: 28; imm: off; once: off; write Event: write_aio; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: write_aio; errno: 28; imm: off; once: off; write -b Event: write_aio; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -290,15 +290,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_load; errno: 5; imm: off; once: off; write Event: refblock_load; errno: 5; imm: off; once: off; write
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_load; errno: 5; imm: off; once: off; write -b Event: refblock_load; errno: 5; imm: off; once: off; write -b
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -314,15 +314,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_load; errno: 28; imm: off; once: off; write Event: refblock_load; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_load; errno: 28; imm: off; once: off; write -b Event: refblock_load; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -338,15 +338,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_update_part; errno: 5; imm: off; once: off; write Event: refblock_update_part; errno: 5; imm: off; once: off; write
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_update_part; errno: 5; imm: off; once: off; write -b Event: refblock_update_part; errno: 5; imm: off; once: off; write -b
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -362,15 +362,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_update_part; errno: 28; imm: off; once: off; write Event: refblock_update_part; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_update_part; errno: 28; imm: off; once: off; write -b Event: refblock_update_part; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -386,15 +386,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc; errno: 5; imm: off; once: off; write Event: refblock_alloc; errno: 5; imm: off; once: off; write
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc; errno: 5; imm: off; once: off; write -b Event: refblock_alloc; errno: 5; imm: off; once: off; write -b
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -410,15 +410,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc; errno: 28; imm: off; once: off; write Event: refblock_alloc; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc; errno: 28; imm: off; once: off; write -b Event: refblock_alloc; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -477,8 +477,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_hookup; errno: 28; imm: off; once: off; write Event: refblock_alloc_hookup; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
55 leaked clusters were found on the image. 55 leaked clusters were found on the image.
@ -486,8 +486,8 @@ This means waste of disk space, but no harm to data.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_hookup; errno: 28; imm: off; once: off; write -b Event: refblock_alloc_hookup; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
251 leaked clusters were found on the image. 251 leaked clusters were found on the image.
@ -505,15 +505,15 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_write; errno: 28; imm: off; once: off; write Event: refblock_alloc_write; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_write; errno: 28; imm: off; once: off; write -b Event: refblock_alloc_write; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -529,8 +529,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_write_blocks; errno: 28; imm: off; once: off; write Event: refblock_alloc_write_blocks; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
10 leaked clusters were found on the image. 10 leaked clusters were found on the image.
@ -538,8 +538,8 @@ This means waste of disk space, but no harm to data.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_write_blocks; errno: 28; imm: off; once: off; write -b Event: refblock_alloc_write_blocks; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
23 leaked clusters were found on the image. 23 leaked clusters were found on the image.
@ -557,8 +557,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_write_table; errno: 28; imm: off; once: off; write Event: refblock_alloc_write_table; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
10 leaked clusters were found on the image. 10 leaked clusters were found on the image.
@ -566,8 +566,8 @@ This means waste of disk space, but no harm to data.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_write_table; errno: 28; imm: off; once: off; write -b Event: refblock_alloc_write_table; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
23 leaked clusters were found on the image. 23 leaked clusters were found on the image.
@ -585,8 +585,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_switch_table; errno: 28; imm: off; once: off; write Event: refblock_alloc_switch_table; errno: 28; imm: off; once: off; write
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
10 leaked clusters were found on the image. 10 leaked clusters were found on the image.
@ -594,8 +594,8 @@ This means waste of disk space, but no harm to data.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: refblock_alloc_switch_table; errno: 28; imm: off; once: off; write -b Event: refblock_alloc_switch_table; errno: 28; imm: off; once: off; write -b
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
23 leaked clusters were found on the image. 23 leaked clusters were found on the image.
@ -631,8 +631,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l1_grow_write_table; errno: 5; imm: off; once: off Event: l1_grow_write_table; errno: 5; imm: off; once: off
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -643,8 +643,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l1_grow_write_table; errno: 28; imm: off; once: off Event: l1_grow_write_table; errno: 28; imm: off; once: off
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
No errors were found on the image. No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
@ -655,8 +655,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l1_grow_activate_table; errno: 5; imm: off; once: off Event: l1_grow_activate_table; errno: 5; imm: off; once: off
Failed to flush the L2 table cache: Input/output error qemu-io: Failed to flush the L2 table cache: Input/output error
Failed to flush the refcount block cache: Input/output error qemu-io: Failed to flush the refcount block cache: Input/output error
write failed: Input/output error write failed: Input/output error
96 leaked clusters were found on the image. 96 leaked clusters were found on the image.
@ -669,8 +669,8 @@ No errors were found on the image.
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
Event: l1_grow_activate_table; errno: 28; imm: off; once: off Event: l1_grow_activate_table; errno: 28; imm: off; once: off
Failed to flush the L2 table cache: No space left on device qemu-io: Failed to flush the L2 table cache: No space left on device
Failed to flush the refcount block cache: No space left on device qemu-io: Failed to flush the refcount block cache: No space left on device
write failed: No space left on device write failed: No space left on device
96 leaked clusters were found on the image. 96 leaked clusters were found on the image.

6
tests/qemu-iotests/043.out
View File

@ -22,19 +22,19 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/
== finite chain of length 3 (human) == == finite chain of length 3 (human) ==
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: TEST_DIR/t.IMGFMT.2.base backing file: TEST_DIR/t.IMGFMT.2.base
image: TEST_DIR/t.IMGFMT.2.base image: TEST_DIR/t.IMGFMT.2.base
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: TEST_DIR/t.IMGFMT.1.base backing file: TEST_DIR/t.IMGFMT.1.base
image: TEST_DIR/t.IMGFMT.1.base image: TEST_DIR/t.IMGFMT.1.base
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 65536 cluster_size: 65536
== finite chain of length 3 (json) == == finite chain of length 3 (json) ==

2
tests/qemu-iotests/053.out
View File

@ -9,7 +9,7 @@ wrote 512/512 bytes at offset 0
No errors were found on the image. No errors were found on the image.
== Checking compressed image virtual disk size == == Checking compressed image virtual disk size ==
virtual size: 512 (512 bytes) virtual size: 512 B (512 bytes)
== Verifying the compressed image == == Verifying the compressed image ==
read 512/512 bytes at offset 0 read 512/512 bytes at offset 0

10
tests/qemu-iotests/059.out
View File

@ -16,7 +16,7 @@ can't open device TEST_DIR/t.vmdk: L1 size too big
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 2.0G (2147483648 bytes) virtual size: 2 GiB (2147483648 bytes)
=== Testing monolithicFlat with zeroed_grain === === Testing monolithicFlat with zeroed_grain ===
qemu-img: TEST_DIR/t.IMGFMT: Flat image can't enable zeroed grain qemu-img: TEST_DIR/t.IMGFMT: Flat image can't enable zeroed grain
@ -26,8 +26,8 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicF
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMaxExtentFlat Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMaxExtentFlat
image: TEST_DIR/t.vmdk image: TEST_DIR/t.vmdk
file format: vmdk file format: vmdk
virtual size: 1.0T (1073741824000 bytes) virtual size: 0.977 TiB (1073741824000 bytes)
disk size: 16K disk size: 16 KiB
Format specific information: Format specific information:
cid: XXXXXXXX cid: XXXXXXXX
parent cid: XXXXXXXX parent cid: XXXXXXXX
@ -2055,7 +2055,7 @@ can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"i
=== Testing version 3 === === Testing version 3 ===
image: TEST_DIR/iotest-version3.IMGFMT image: TEST_DIR/iotest-version3.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 16G (17179869184 bytes) virtual size: 16 GiB (17179869184 bytes)
cluster_size: 65536 cluster_size: 65536
read 512/512 bytes at offset 0 read 512/512 bytes at offset 0
512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@ -2262,7 +2262,7 @@ read 512/512 bytes at offset 64931328
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104 subformat=monolithicFlat Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104 subformat=monolithicFlat
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 4.0T (4398046511104 bytes) virtual size: 4 TiB (4398046511104 bytes)
wrote 512/512 bytes at offset 966367641600 wrote 512/512 bytes at offset 966367641600
512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
e100000000: 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a ................ e100000000: 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a ................

16
tests/qemu-iotests/060.out
View File

@ -13,14 +13,14 @@ write failed: Input/output error
incompatible_features 0x2 incompatible_features 0x2
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
lazy refcounts: false lazy refcounts: false
refcount bits: 16 refcount bits: 16
corrupt: true corrupt: true
can't open device TEST_DIR/t.IMGFMT: IMGFMT: Image is corrupt; cannot be opened read/write qemu-io: can't open device TEST_DIR/t.IMGFMT: IMGFMT: Image is corrupt; cannot be opened read/write
no file open, try 'help open' no file open, try 'help open'
read 512/512 bytes at offset 0 read 512/512 bytes at offset 0
512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@ -267,7 +267,7 @@ No errors were found on the image.
=== Testing zero refcount table size === === Testing zero refcount table size ===
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.IMGFMT: Image does not contain a reference count table qemu-io: can't open device TEST_DIR/t.IMGFMT: Image does not contain a reference count table
ERROR cluster 0 refcount=0 reference=1 ERROR cluster 0 refcount=0 reference=1
ERROR cluster 3 refcount=0 reference=1 ERROR cluster 3 refcount=0 reference=1
Rebuilding refcount structure Rebuilding refcount structure
@ -296,7 +296,7 @@ Can't get refcount for cluster 2: Input/output error
Can't get refcount for cluster 3: Input/output error Can't get refcount for cluster 3: Input/output error
Rebuilding refcount structure Rebuilding refcount structure
Repairing cluster 1 refcount=1 reference=0 Repairing cluster 1 refcount=1 reference=0
can't open device TEST_DIR/t.IMGFMT: Could not repair dirty image: Input/output error qemu-io: can't open device TEST_DIR/t.IMGFMT: Could not repair dirty image: Input/output error
--- Repairing --- --- Repairing ---
Leaked cluster 1 refcount=1 reference=0 Leaked cluster 1 refcount=1 reference=0
Repairing cluster 1 refcount=1 reference=0 Repairing cluster 1 refcount=1 reference=0
@ -364,10 +364,10 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
qcow2: Marking image as corrupt: Refblock at 0xffffff00000000 is not covered by the refcount structures; further corruption events will be suppressed qcow2: Marking image as corrupt: Refblock at 0xffffff00000000 is not covered by the refcount structures; further corruption events will be suppressed
qemu-img: Failed to discard unused refblocks: Input/output error qemu-img: Failed to discard unused refblocks: Input/output error
--- Checking and retrying --- --- Checking and retrying ---
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
No errors were found on the image. No errors were found on the image.
Image resized. Image resized.
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
=== Discarding a non-covered in-bounds refblock === === Discarding a non-covered in-bounds refblock ===
@ -375,10 +375,10 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
qcow2: Marking image as corrupt: Refblock at 0x1000000000 is not covered by the refcount structures; further corruption events will be suppressed qcow2: Marking image as corrupt: Refblock at 0x1000000000 is not covered by the refcount structures; further corruption events will be suppressed
qemu-img: Failed to discard unused refblocks: Input/output error qemu-img: Failed to discard unused refblocks: Input/output error
--- Checking and retrying --- --- Checking and retrying ---
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
No errors were found on the image. No errors were found on the image.
Image resized. Image resized.
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
=== Discarding a refblock covered by an unaligned refblock === === Discarding a refblock covered by an unaligned refblock ===

12
tests/qemu-iotests/061.out
View File

@ -495,7 +495,7 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 data_file=TEST_DIR/t.IM
qemu-img: Cannot downgrade an image with a data file qemu-img: Cannot downgrade an image with a data file
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -515,7 +515,7 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 data_file=TEST_DIR/t.IM
qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Could not open 'foo': No such file or directory qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Could not open 'foo': No such file or directory
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -528,7 +528,7 @@ Format specific information:
qemu-img: Could not open 'TEST_DIR/t.IMGFMT': 'data-file' is required for this image qemu-img: Could not open 'TEST_DIR/t.IMGFMT': 'data-file' is required for this image
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -542,7 +542,7 @@ Format specific information:
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 data_file=TEST_DIR/t.IMGFMT.data data_file_raw=on Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 data_file=TEST_DIR/t.IMGFMT.data data_file_raw=on
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -554,7 +554,7 @@ Format specific information:
No errors were found on the image. No errors were found on the image.
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -567,7 +567,7 @@ No errors were found on the image.
qemu-img: data-file-raw cannot be set on existing images qemu-img: data-file-raw cannot be set on existing images
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1

2
tests/qemu-iotests/069.out
View File

@ -4,5 +4,5 @@ QA output created by 069
Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=131072 Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=131072
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=131072 backing_file=TEST_DIR/t.IMGFMT.base Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=131072 backing_file=TEST_DIR/t.IMGFMT.base
can't open device TEST_DIR/t.IMGFMT: Could not open backing file: Could not open 'TEST_DIR/t.IMGFMT.base': No such file or directory qemu-io: can't open device TEST_DIR/t.IMGFMT: Could not open backing file: Could not open 'TEST_DIR/t.IMGFMT.base': No such file or directory
*** done *** done

4
tests/qemu-iotests/070.out
View File

@ -1,7 +1,7 @@
QA output created by 070 QA output created by 070
=== Verify open image read-only fails, due to dirty log === === Verify open image read-only fails, due to dirty log ===
can't open device TEST_DIR/iotest-dirtylog-10G-4M.vhdx: VHDX image file 'TEST_DIR/iotest-dirtylog-10G-4M.vhdx' opened read-only, but contains a log that needs to be replayed qemu-io: can't open device TEST_DIR/iotest-dirtylog-10G-4M.vhdx: VHDX image file 'TEST_DIR/iotest-dirtylog-10G-4M.vhdx' opened read-only, but contains a log that needs to be replayed
To replay the log, run: To replay the log, run:
qemu-img check -r all 'TEST_DIR/iotest-dirtylog-10G-4M.vhdx' qemu-img check -r all 'TEST_DIR/iotest-dirtylog-10G-4M.vhdx'
=== Verify open image replays log === === Verify open image replays log ===
@ -22,6 +22,6 @@ read 18874368/18874368 bytes at offset 0
=== Verify image created by Disk2VHD can be opened === === Verify image created by Disk2VHD can be opened ===
image: TEST_DIR/test-disk2vhd.IMGFMT image: TEST_DIR/test-disk2vhd.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 256M (268435456 bytes) virtual size: 256 MiB (268435456 bytes)
cluster_size: 2097152 cluster_size: 2097152
*** done *** done

14
tests/qemu-iotests/075.out
View File

@ -9,23 +9,23 @@ read 512/512 bytes at offset 1048064
512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
== block_size must be a multiple of 512 == == block_size must be a multiple of 512 ==
can't open device TEST_DIR/simple-pattern.cloop: block_size 513 must be a multiple of 512 qemu-io: can't open device TEST_DIR/simple-pattern.cloop: block_size 513 must be a multiple of 512
== block_size cannot be zero == == block_size cannot be zero ==
can't open device TEST_DIR/simple-pattern.cloop: block_size cannot be zero qemu-io: can't open device TEST_DIR/simple-pattern.cloop: block_size cannot be zero
== huge block_size === == huge block_size ===
can't open device TEST_DIR/simple-pattern.cloop: block_size 4294966784 must be 64 MB or less qemu-io: can't open device TEST_DIR/simple-pattern.cloop: block_size 4294966784 must be 64 MB or less
== offsets_size overflow === == offsets_size overflow ===
can't open device TEST_DIR/simple-pattern.cloop: n_blocks 4294967295 must be 536870911 or less qemu-io: can't open device TEST_DIR/simple-pattern.cloop: n_blocks 4294967295 must be 536870911 or less
== refuse images that require too many offsets === == refuse images that require too many offsets ===
can't open device TEST_DIR/simple-pattern.cloop: image requires too many offsets, try increasing block size qemu-io: can't open device TEST_DIR/simple-pattern.cloop: image requires too many offsets, try increasing block size
== refuse images with non-monotonically increasing offsets == == refuse images with non-monotonically increasing offsets ==
can't open device TEST_DIR/simple-pattern.cloop: offsets not monotonically increasing at index 1, image file is corrupt qemu-io: can't open device TEST_DIR/simple-pattern.cloop: offsets not monotonically increasing at index 1, image file is corrupt
== refuse images with invalid compressed block size == == refuse images with invalid compressed block size ==
can't open device TEST_DIR/simple-pattern.cloop: invalid compressed block size at index 1, image file is corrupt qemu-io: can't open device TEST_DIR/simple-pattern.cloop: invalid compressed block size at index 1, image file is corrupt
*** done *** done

6
tests/qemu-iotests/076.out
View File

@ -5,13 +5,13 @@ read 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
== Negative catalog size == == Negative catalog size ==
can't open device TEST_DIR/parallels-v1: Catalog too large qemu-io: can't open device TEST_DIR/parallels-v1: Catalog too large
== Overflow in catalog allocation == == Overflow in catalog allocation ==
can't open device TEST_DIR/parallels-v1: Catalog too large qemu-io: can't open device TEST_DIR/parallels-v1: Catalog too large
== Zero sectors per track == == Zero sectors per track ==
can't open device TEST_DIR/parallels-v1: Invalid image: Zero sectors per track qemu-io: can't open device TEST_DIR/parallels-v1: Invalid image: Zero sectors per track
== Read from a valid v2 image == == Read from a valid v2 image ==
read 65536/65536 bytes at offset 0 read 65536/65536 bytes at offset 0

12
tests/qemu-iotests/078.out
View File

@ -5,18 +5,18 @@ read 512/512 bytes at offset 0
512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
== Negative catalog size == == Negative catalog size ==
can't open device TEST_DIR/empty.bochs: Catalog size is too large qemu-io: can't open device TEST_DIR/empty.bochs: Catalog size is too large
== Overflow for catalog size * sizeof(uint32_t) == == Overflow for catalog size * sizeof(uint32_t) ==
can't open device TEST_DIR/empty.bochs: Catalog size is too large qemu-io: can't open device TEST_DIR/empty.bochs: Catalog size is too large
== Too small catalog bitmap for image size == == Too small catalog bitmap for image size ==
can't open device TEST_DIR/empty.bochs: Catalog size is too small for this disk size qemu-io: can't open device TEST_DIR/empty.bochs: Catalog size is too small for this disk size
can't open device TEST_DIR/empty.bochs: Catalog size is too small for this disk size qemu-io: can't open device TEST_DIR/empty.bochs: Catalog size is too small for this disk size
== Negative extent size == == Negative extent size ==
can't open device TEST_DIR/empty.bochs: Extent size 2147483648 is too large qemu-io: can't open device TEST_DIR/empty.bochs: Extent size 2147483648 is too large
== Zero extent size == == Zero extent size ==
can't open device TEST_DIR/empty.bochs: Extent size must be at least 512 qemu-io: can't open device TEST_DIR/empty.bochs: Extent size must be at least 512
*** done *** done

40
tests/qemu-iotests/080.out
View File

@ -2,34 +2,34 @@ QA output created by 080
== Huge header size == == Huge header size ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size qemu-io: can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size
can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size qemu-io: can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size
== Huge unknown header extension == == Huge unknown header extension ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: Invalid backing file offset qemu-io: can't open device TEST_DIR/t.qcow2: Invalid backing file offset
can't open device TEST_DIR/t.qcow2: Header extension too large qemu-io: can't open device TEST_DIR/t.qcow2: Header extension too large
can't open device TEST_DIR/t.qcow2: Header extension too large qemu-io: can't open device TEST_DIR/t.qcow2: Header extension too large
== Huge refcount table size == == Huge refcount table size ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: Reference count table too large qemu-io: can't open device TEST_DIR/t.qcow2: Reference count table too large
can't open device TEST_DIR/t.qcow2: Reference count table too large qemu-io: can't open device TEST_DIR/t.qcow2: Reference count table too large
== Misaligned refcount table == == Misaligned refcount table ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: Reference count table offset invalid qemu-io: can't open device TEST_DIR/t.qcow2: Reference count table offset invalid
== Huge refcount offset == == Huge refcount offset ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: Reference count table offset invalid qemu-io: can't open device TEST_DIR/t.qcow2: Reference count table offset invalid
== Invalid snapshot table == == Invalid snapshot table ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: Snapshot table too large qemu-io: can't open device TEST_DIR/t.qcow2: Snapshot table too large
can't open device TEST_DIR/t.qcow2: Snapshot table too large qemu-io: can't open device TEST_DIR/t.qcow2: Snapshot table too large
can't open device TEST_DIR/t.qcow2: Snapshot table offset invalid qemu-io: can't open device TEST_DIR/t.qcow2: Snapshot table offset invalid
can't open device TEST_DIR/t.qcow2: Snapshot table offset invalid qemu-io: can't open device TEST_DIR/t.qcow2: Snapshot table offset invalid
== Hitting snapshot table size limit == == Hitting snapshot table size limit ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
@ -39,10 +39,10 @@ read 512/512 bytes at offset 0
== Invalid L1 table == == Invalid L1 table ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: Active L1 table too large qemu-io: can't open device TEST_DIR/t.qcow2: Active L1 table too large
can't open device TEST_DIR/t.qcow2: Active L1 table too large qemu-io: can't open device TEST_DIR/t.qcow2: Active L1 table too large
can't open device TEST_DIR/t.qcow2: Active L1 table offset invalid qemu-io: can't open device TEST_DIR/t.qcow2: Active L1 table offset invalid
can't open device TEST_DIR/t.qcow2: Active L1 table offset invalid qemu-io: can't open device TEST_DIR/t.qcow2: Active L1 table offset invalid
== Invalid L1 table (with internal snapshot in the image) == == Invalid L1 table (with internal snapshot in the image) ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
@ -50,7 +50,7 @@ qemu-img: Could not open 'TEST_DIR/t.IMGFMT': L1 table is too small
== Invalid backing file size == == Invalid backing file size ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: Backing file name too long qemu-io: can't open device TEST_DIR/t.qcow2: Backing file name too long
== Invalid L2 entry (huge physical offset) == == Invalid L2 entry (huge physical offset) ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
@ -66,7 +66,7 @@ wrote 512/512 bytes at offset 0
qemu-img: Failed to load snapshot: Snapshot L1 table offset invalid qemu-img: Failed to load snapshot: Snapshot L1 table offset invalid
qemu-img: Snapshot L1 table offset invalid qemu-img: Snapshot L1 table offset invalid
qemu-img: Failed to turn zero into data clusters: Invalid argument qemu-img: Failed to turn zero into data clusters: Invalid argument
Failed to flush the refcount block cache: Invalid argument qemu-io: Failed to flush the refcount block cache: Invalid argument
write failed: Invalid argument write failed: Invalid argument
qemu-img: Snapshot L1 table offset invalid qemu-img: Snapshot L1 table offset invalid
qemu-img: Could not apply snapshot 'test': Failed to load snapshot: Invalid argument qemu-img: Could not apply snapshot 'test': Failed to load snapshot: Invalid argument
@ -89,7 +89,7 @@ wrote 512/512 bytes at offset 0
qemu-img: Failed to load snapshot: Snapshot L1 table too large qemu-img: Failed to load snapshot: Snapshot L1 table too large
qemu-img: Snapshot L1 table too large qemu-img: Snapshot L1 table too large
qemu-img: Failed to turn zero into data clusters: File too large qemu-img: Failed to turn zero into data clusters: File too large
Failed to flush the refcount block cache: File too large qemu-io: Failed to flush the refcount block cache: File too large
write failed: File too large write failed: File too large
qemu-img: Snapshot L1 table too large qemu-img: Snapshot L1 table too large
qemu-img: Could not apply snapshot 'test': Failed to load snapshot: File too large qemu-img: Could not apply snapshot 'test': Failed to load snapshot: File too large

2
tests/qemu-iotests/081.out
View File

@ -70,7 +70,7 @@ read 10485760/10485760 bytes at offset 0
10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
== checking the blkverify mode with invalid settings == == checking the blkverify mode with invalid settings ==
can't open: blkverify=on can only be set if there are exactly two files and vote-threshold is 2 qemu-io: can't open: blkverify=on can only be set if there are exactly two files and vote-threshold is 2
== dynamically adding a child to a quorum == == dynamically adding a child to a quorum ==
Testing: Testing:

5
tests/qemu-iotests/082
View File

@ -212,7 +212,10 @@ run_qemu_img amend -f $IMGFMT -o backing_file="$TEST_IMG" -o ,, -o help "$TEST_I
# Leave out everything that isn't needed # Leave out everything that isn't needed
run_qemu_img amend -f $IMGFMT -o help run_qemu_img amend -f $IMGFMT -o help
run_qemu_img convert -o help
# amend requires specifying either a format explicitly, or a file
# which it can probe
run_qemu_img amend -o help
# Try help option for a format that does not support amendment # Try help option for a format that does not support amendment
run_qemu_img amend -f bochs -o help run_qemu_img amend -f bochs -o help

51
tests/qemu-iotests/082.out
View File

@ -6,14 +6,14 @@ Testing: create -f foo -f qcow2 TEST_DIR/t.qcow2 128M
Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 65536 cluster_size: 65536
Testing: create -f qcow2 -o cluster_size=4k -o lazy_refcounts=on TEST_DIR/t.qcow2 128M Testing: create -f qcow2 -o cluster_size=4k -o lazy_refcounts=on TEST_DIR/t.qcow2 128M
Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=4096 lazy_refcounts=on refcount_bits=16 Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=4096 lazy_refcounts=on refcount_bits=16
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 4096 cluster_size: 4096
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -25,7 +25,7 @@ Testing: create -f qcow2 -o cluster_size=4k -o lazy_refcounts=on -o cluster_size
Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=8192 lazy_refcounts=on refcount_bits=16 Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=8192 lazy_refcounts=on refcount_bits=16
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 8192 cluster_size: 8192
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -37,7 +37,7 @@ Testing: create -f qcow2 -o cluster_size=4k,cluster_size=8k TEST_DIR/t.qcow2 128
Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=8192 lazy_refcounts=off refcount_bits=16 Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=8192 lazy_refcounts=off refcount_bits=16
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 8192 cluster_size: 8192
=== create: help for -o === === create: help for -o ===
@ -242,7 +242,7 @@ Testing: create -f qcow2 -o backing_file=TEST_DIR/t.qcow2 -o ,, -o help TEST_DIR
qemu-img: Invalid option list: ,, qemu-img: Invalid option list: ,,
Testing: create -f qcow2 -o help Testing: create -f qcow2 -o help
Supported options: Supported qcow2 options:
backing_file=<str> - File name of a base image backing_file=<str> - File name of a base image
backing_fmt=<str> - Image format of the base image backing_fmt=<str> - Image format of the base image
cluster_size=<size> - qcow2 cluster size cluster_size=<size> - qcow2 cluster size
@ -263,10 +263,16 @@ Supported options:
refcount_bits=<num> - Width of a reference count entry in bits refcount_bits=<num> - Width of a reference count entry in bits
size=<size> - Virtual disk size size=<size> - Virtual disk size
The protocol level may support further options.
Specify the target filename to include those options.
Testing: create -o help Testing: create -o help
Supported options: Supported raw options:
size=<size> - Virtual disk size size=<size> - Virtual disk size
The protocol level may support further options.
Specify the target filename to include those options.
Testing: create -f bochs -o help Testing: create -f bochs -o help
qemu-img: Format driver 'bochs' does not support image creation qemu-img: Format driver 'bochs' does not support image creation
@ -278,18 +284,18 @@ Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_
Testing: convert -f foo -f qcow2 TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base Testing: convert -f foo -f qcow2 TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
image: TEST_DIR/t.IMGFMT.base image: TEST_DIR/t.IMGFMT.base
file format: raw file format: raw
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
Testing: convert -O foo -O qcow2 TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base Testing: convert -O foo -O qcow2 TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
image: TEST_DIR/t.IMGFMT.base image: TEST_DIR/t.IMGFMT.base
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 65536 cluster_size: 65536
Testing: convert -O qcow2 -o cluster_size=4k -o lazy_refcounts=on TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base Testing: convert -O qcow2 -o cluster_size=4k -o lazy_refcounts=on TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
image: TEST_DIR/t.IMGFMT.base image: TEST_DIR/t.IMGFMT.base
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 4096 cluster_size: 4096
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -300,7 +306,7 @@ Format specific information:
Testing: convert -O qcow2 -o cluster_size=4k -o lazy_refcounts=on -o cluster_size=8k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base Testing: convert -O qcow2 -o cluster_size=4k -o lazy_refcounts=on -o cluster_size=8k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
image: TEST_DIR/t.IMGFMT.base image: TEST_DIR/t.IMGFMT.base
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 8192 cluster_size: 8192
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -311,7 +317,7 @@ Format specific information:
Testing: convert -O qcow2 -o cluster_size=4k,cluster_size=8k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base Testing: convert -O qcow2 -o cluster_size=4k,cluster_size=8k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
image: TEST_DIR/t.IMGFMT.base image: TEST_DIR/t.IMGFMT.base
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 8192 cluster_size: 8192
=== convert: help for -o === === convert: help for -o ===
@ -516,7 +522,7 @@ Testing: convert -O qcow2 -o backing_file=TEST_DIR/t.qcow2 -o ,, -o help TEST_DI
qemu-img: Invalid option list: ,, qemu-img: Invalid option list: ,,
Testing: convert -O qcow2 -o help Testing: convert -O qcow2 -o help
Supported options: Supported qcow2 options:
backing_file=<str> - File name of a base image backing_file=<str> - File name of a base image
backing_fmt=<str> - Image format of the base image backing_fmt=<str> - Image format of the base image
cluster_size=<size> - qcow2 cluster size cluster_size=<size> - qcow2 cluster size
@ -537,10 +543,16 @@ Supported options:
refcount_bits=<num> - Width of a reference count entry in bits refcount_bits=<num> - Width of a reference count entry in bits
size=<size> - Virtual disk size size=<size> - Virtual disk size
The protocol level may support further options.
Specify the target filename to include those options.
Testing: convert -o help Testing: convert -o help
Supported options: Supported raw options:
size=<size> - Virtual disk size size=<size> - Virtual disk size
The protocol level may support further options.
Specify the target filename to include those options.
Testing: convert -O bochs -o help Testing: convert -O bochs -o help
qemu-img: Format driver 'bochs' does not support image creation qemu-img: Format driver 'bochs' does not support image creation
@ -560,7 +572,7 @@ qemu-img: Cannot enable copy offloading when -c is used
Testing: amend -f foo -f qcow2 -o lazy_refcounts=on TEST_DIR/t.qcow2 Testing: amend -f foo -f qcow2 -o lazy_refcounts=on TEST_DIR/t.qcow2
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -571,7 +583,7 @@ Format specific information:
Testing: amend -f qcow2 -o size=130M -o lazy_refcounts=off TEST_DIR/t.qcow2 Testing: amend -f qcow2 -o size=130M -o lazy_refcounts=off TEST_DIR/t.qcow2
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 130M (136314880 bytes) virtual size: 130 MiB (136314880 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -582,7 +594,7 @@ Format specific information:
Testing: amend -f qcow2 -o size=8M -o lazy_refcounts=on -o size=132M TEST_DIR/t.qcow2 Testing: amend -f qcow2 -o size=8M -o lazy_refcounts=on -o size=132M TEST_DIR/t.qcow2
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 132M (138412032 bytes) virtual size: 132 MiB (138412032 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -593,7 +605,7 @@ Format specific information:
Testing: amend -f qcow2 -o size=4M,size=148M TEST_DIR/t.qcow2 Testing: amend -f qcow2 -o size=4M,size=148M TEST_DIR/t.qcow2
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 148M (155189248 bytes) virtual size: 148 MiB (155189248 bytes)
cluster_size: 65536 cluster_size: 65536
=== amend: help for -o === === amend: help for -o ===
@ -831,9 +843,8 @@ Creation options for 'qcow2':
Note that not all of these options may be amendable. Note that not all of these options may be amendable.
Testing: convert -o help Testing: amend -o help
Supported options: qemu-img: Expecting one image file name
size=<size> - Virtual disk size
Testing: amend -f bochs -o help Testing: amend -f bochs -o help
qemu-img: Format driver 'bochs' does not support option amendment qemu-img: Format driver 'bochs' does not support option amendment

8
tests/qemu-iotests/084.out
View File

@ -5,7 +5,7 @@ QA output created by 084
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 1048576 cluster_size: 1048576
disk image file size in bytes: 67109888 disk image file size in bytes: 67109888
@ -14,13 +14,13 @@ disk image file size in bytes: 67109888
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 1048576 cluster_size: 1048576
disk image file size in bytes: 1024 disk image file size in bytes: 1024
Test 1: Maximum size (512 TB - 128 MB): Test 1: Maximum size (512 TB - 128 MB):
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 512T (562949819203584 bytes) virtual size: 512 TiB (562949819203584 bytes)
cluster_size: 1048576 cluster_size: 1048576
Test 2: Size too large (512 TB - 128 MB + 64 kB) Test 2: Size too large (512 TB - 128 MB + 64 kB)
@ -35,7 +35,7 @@ qemu-img: Could not open 'TEST_DIR/t.IMGFMT': unsupported VDI image (too many bl
Test 5: Valid Image: 64MB, Blocks In Image 64, Block Size 1MB Test 5: Valid Image: 64MB, Blocks In Image 64, Block Size 1MB
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 1048576 cluster_size: 1048576
Test 6: Block Size != 1MB; too small test (1MB - 1) Test 6: Block Size != 1MB; too small test (1MB - 1)

12
tests/qemu-iotests/088.out
View File

@ -2,10 +2,10 @@ QA output created by 088
== Invalid block size == == Invalid block size ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.vpc: Invalid block size 0 qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 0
can't open device TEST_DIR/t.vpc: Invalid block size 0 qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 0
can't open device TEST_DIR/t.vpc: Invalid block size 128 qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 128
can't open device TEST_DIR/t.vpc: Invalid block size 128 qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 128
can't open device TEST_DIR/t.vpc: Invalid block size 305419896 qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 305419896
can't open device TEST_DIR/t.vpc: Invalid block size 305419896 qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 305419896
*** done *** done

2
tests/qemu-iotests/089.out
View File

@ -38,7 +38,7 @@ read failed: Input/output error
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
=== Testing option merging === === Testing option merging ===

4
tests/qemu-iotests/095.out
View File

@ -6,7 +6,7 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=104857600 backing_file=TEST_DIR/
=== Base image info before commit and resize === === Base image info before commit and resize ===
image: TEST_DIR/t.IMGFMT.base image: TEST_DIR/t.IMGFMT.base
file format: IMGFMT file format: IMGFMT
virtual size: 5.0M (5242880 bytes) virtual size: 5 MiB (5242880 bytes)
=== Running QEMU Live Commit Test === === Running QEMU Live Commit Test ===
@ -23,5 +23,5 @@ virtual size: 5.0M (5242880 bytes)
=== Base image info after commit and resize === === Base image info after commit and resize ===
image: TEST_DIR/t.IMGFMT.base image: TEST_DIR/t.IMGFMT.base
file format: IMGFMT file format: IMGFMT
virtual size: 100M (104857600 bytes) virtual size: 100 MiB (104857600 bytes)
*** done *** done

14
tests/qemu-iotests/103.out
View File

@ -5,13 +5,13 @@ wrote 65536/65536 bytes at offset 0
=== Testing invalid option combinations === === Testing invalid option combinations ===
can't open device TEST_DIR/t.IMGFMT: cache-size, l2-cache-size and refcount-cache-size may not be set at the same time qemu-io: can't open device TEST_DIR/t.IMGFMT: cache-size, l2-cache-size and refcount-cache-size may not be set at the same time
can't open device TEST_DIR/t.IMGFMT: l2-cache-size may not exceed cache-size qemu-io: can't open device TEST_DIR/t.IMGFMT: l2-cache-size may not exceed cache-size
can't open device TEST_DIR/t.IMGFMT: refcount-cache-size may not exceed cache-size qemu-io: can't open device TEST_DIR/t.IMGFMT: refcount-cache-size may not exceed cache-size
can't open device TEST_DIR/t.IMGFMT: cache-size, l2-cache-size and refcount-cache-size may not be set at the same time qemu-io: can't open device TEST_DIR/t.IMGFMT: cache-size, l2-cache-size and refcount-cache-size may not be set at the same time
can't open device TEST_DIR/t.IMGFMT: L2 cache entry size must be a power of two between 512 and the cluster size (65536) qemu-io: can't open device TEST_DIR/t.IMGFMT: L2 cache entry size must be a power of two between 512 and the cluster size (65536)
can't open device TEST_DIR/t.IMGFMT: L2 cache entry size must be a power of two between 512 and the cluster size (65536) qemu-io: can't open device TEST_DIR/t.IMGFMT: L2 cache entry size must be a power of two between 512 and the cluster size (65536)
can't open device TEST_DIR/t.IMGFMT: L2 cache entry size must be a power of two between 512 and the cluster size (65536) qemu-io: can't open device TEST_DIR/t.IMGFMT: L2 cache entry size must be a power of two between 512 and the cluster size (65536)
=== Testing valid option combinations === === Testing valid option combinations ===

6
tests/qemu-iotests/104.out
View File

@ -4,9 +4,9 @@ QA output created by 104
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1024 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1024
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 1.0K (1024 bytes) virtual size: 1 KiB (1024 bytes)
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1234 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1234
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 1.5K (1536 bytes) virtual size: 1.5 KiB (1536 bytes)
***done *** done

6
tests/qemu-iotests/110.out
View File

@ -6,14 +6,14 @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=t.IMGFMT.base Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=t.IMGFMT.base
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
backing file: t.IMGFMT.base (actual path: TEST_DIR/t.IMGFMT.base) backing file: t.IMGFMT.base (actual path: TEST_DIR/t.IMGFMT.base)
=== Non-reconstructable filename === === Non-reconstructable filename ===
image: json:{"driver": "IMGFMT", "file": {"set-state.0.event": "read_aio", "image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "set-state.0.new_state": 42}} image: json:{"driver": "IMGFMT", "file": {"set-state.0.event": "read_aio", "image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "set-state.0.new_state": 42}}
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
backing file: t.IMGFMT.base (actual path: TEST_DIR/t.IMGFMT.base) backing file: t.IMGFMT.base (actual path: TEST_DIR/t.IMGFMT.base)
=== Backing name is always relative to the backed image === === Backing name is always relative to the backed image ===
@ -24,6 +24,6 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=t.IMGFMT.b
image: json:{"driver": "IMGFMT", "file": {"children": [{"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, {"driver": "file", "filename": "TEST_DIR/t.IMGFMT.copy"}], "driver": "quorum", "vote-threshold": 1}} image: json:{"driver": "IMGFMT", "file": {"children": [{"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, {"driver": "file", "filename": "TEST_DIR/t.IMGFMT.copy"}], "driver": "quorum", "vote-threshold": 1}}
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
backing file: t.IMGFMT.base (cannot determine actual path) backing file: t.IMGFMT.base (cannot determine actual path)
*** done *** done

4
tests/qemu-iotests/114.out
View File

@ -3,11 +3,11 @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.base Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.base
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: TEST_DIR/t.IMGFMT.base backing file: TEST_DIR/t.IMGFMT.base
backing file format: foo backing file format: foo
can't open device TEST_DIR/t.qcow2: Could not open backing file: Unknown driver 'foo' qemu-io: can't open device TEST_DIR/t.qcow2: Could not open backing file: Unknown driver 'foo'
no file open, try 'help open' no file open, try 'help open'
read 4096/4096 bytes at offset 0 read 4096/4096 bytes at offset 0
4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

14
tests/qemu-iotests/116.out
View File

@ -2,29 +2,29 @@ QA output created by 116
== truncated header cluster == == truncated header cluster ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument qemu-io: can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
== invalid header magic == == invalid header magic ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
can't open device TEST_DIR/t.qed: Image not in QED format qemu-io: can't open device TEST_DIR/t.qed: Image not in QED format
== invalid cluster size == == invalid cluster size ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument qemu-io: can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
== invalid table size == == invalid table size ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument qemu-io: can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
== invalid header size == == invalid header size ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument qemu-io: can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
== invalid L1 table offset == == invalid L1 table offset ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument qemu-io: can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
== invalid image size == == invalid image size ==
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument qemu-io: can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
*** done *** done

4
tests/qemu-iotests/126.out
View File

@ -11,13 +11,13 @@ Formatting 'TEST_DIR/image:base.IMGFMT', fmt=IMGFMT size=67108864
Formatting 'TEST_DIR/image:top.IMGFMT', fmt=IMGFMT size=67108864 backing_file=./image:base.IMGFMT Formatting 'TEST_DIR/image:top.IMGFMT', fmt=IMGFMT size=67108864 backing_file=./image:base.IMGFMT
image: TEST_DIR/image:top.IMGFMT image: TEST_DIR/image:top.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
backing file: ./image:base.IMGFMT (actual path: TEST_DIR/./image:base.IMGFMT) backing file: ./image:base.IMGFMT (actual path: TEST_DIR/./image:base.IMGFMT)
Formatting 'base.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'base.IMGFMT', fmt=IMGFMT size=67108864
Formatting 'file:image:top.IMGFMT', fmt=IMGFMT size=67108864 backing_file=base.IMGFMT Formatting 'file:image:top.IMGFMT', fmt=IMGFMT size=67108864 backing_file=base.IMGFMT
image: ./image:top.IMGFMT image: ./image:top.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
backing file: base.IMGFMT (actual path: ./base.IMGFMT) backing file: base.IMGFMT (actual path: ./base.IMGFMT)
*** done *** done

10
tests/qemu-iotests/130.out
View File

@ -4,7 +4,7 @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
=== HMP commit === === HMP commit ===
@ -13,14 +13,14 @@ QEMU X.Y.Z monitor - type 'help' for more information
(qemu) (qemu)
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.orig backing_fmt=raw Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.orig backing_fmt=raw
QEMU X.Y.Z monitor - type 'help' for more information QEMU X.Y.Z monitor - type 'help' for more information
(qemu) commit testdisk (qemu) commit testdisk
(qemu) (qemu)
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
backing file: TEST_DIR/t.IMGFMT.orig backing file: TEST_DIR/t.IMGFMT.orig
backing file format: raw backing file format: raw
@ -31,13 +31,13 @@ wrote 4096/4096 bytes at offset 0
4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.orig backing_fmt=raw Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.orig backing_fmt=raw
wrote 4096/4096 bytes at offset 0 wrote 4096/4096 bytes at offset 0
4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
backing file: TEST_DIR/t.IMGFMT.orig backing file: TEST_DIR/t.IMGFMT.orig
backing file format: raw backing file format: raw
*** done *** done

2
tests/qemu-iotests/131.out
View File

@ -22,7 +22,7 @@ read 32768/32768 bytes at offset 163840
read 32768/32768 bytes at offset 0 read 32768/32768 bytes at offset 0
32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
== Corrupt image == == Corrupt image ==
can't open device TEST_DIR/t.parallels: parallels: Image was not closed correctly; cannot be opened read/write qemu-io: can't open device TEST_DIR/t.parallels: parallels: Image was not closed correctly; cannot be opened read/write
ERROR image was not closed correctly ERROR image was not closed correctly
1 errors were found on the image. 1 errors were found on the image.

30
tests/qemu-iotests/133.out
View File

@ -4,18 +4,18 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t
=== Check that node-name can't be changed === === Check that node-name can't be changed ===
Cannot change the option 'node-name' qemu-io: Cannot change the option 'node-name'
Cannot change the option 'node-name' qemu-io: Cannot change the option 'node-name'
Cannot change the option 'node-name' qemu-io: Cannot change the option 'node-name'
=== Check that unchanged node-name is okay === === Check that unchanged node-name is okay ===
=== Check that driver can't be changed === === Check that driver can't be changed ===
Cannot change the option 'driver' qemu-io: Cannot change the option 'driver'
Cannot change the option 'driver' qemu-io: Cannot change the option 'driver'
Cannot change the option 'driver' qemu-io: Cannot change the option 'driver'
=== Check that unchanged driver is okay === === Check that unchanged driver is okay ===
@ -27,16 +27,16 @@ format name: null-co
=== Check that mixing -c/-r/-w and their corresponding options is forbidden === === Check that mixing -c/-r/-w and their corresponding options is forbidden ===
Cannot set both -r/-w and 'read-only' qemu-io: Cannot set both -r/-w and 'read-only'
Cannot set both -r/-w and 'read-only' qemu-io: Cannot set both -r/-w and 'read-only'
Cannot set both -c and the cache options qemu-io: Cannot set both -c and the cache options
Cannot set both -c and the cache options qemu-io: Cannot set both -c and the cache options
Cannot set both -c and the cache options qemu-io: Cannot set both -c and the cache options
=== Check that invalid options are handled correctly === === Check that invalid options are handled correctly ===
Parameter 'read-only' expects 'on' or 'off' qemu-io: Parameter 'read-only' expects 'on' or 'off'
Parameter 'cache.no-flush' expects 'on' or 'off' qemu-io: Parameter 'cache.no-flush' expects 'on' or 'off'
Parameter 'cache.direct' expects 'on' or 'off' qemu-io: Parameter 'cache.direct' expects 'on' or 'off'
Parameter 'auto-read-only' expects 'on' or 'off' qemu-io: Parameter 'auto-read-only' expects 'on' or 'off'
*** done *** done

28
tests/qemu-iotests/137.out
View File

@ -15,24 +15,24 @@ read 33554432/33554432 bytes at offset 0
=== Try setting some invalid values === === Try setting some invalid values ===
Parameter 'lazy-refcounts' expects 'on' or 'off' qemu-io: Parameter 'lazy-refcounts' expects 'on' or 'off'
cache-size, l2-cache-size and refcount-cache-size may not be set at the same time qemu-io: cache-size, l2-cache-size and refcount-cache-size may not be set at the same time
l2-cache-size may not exceed cache-size qemu-io: l2-cache-size may not exceed cache-size
refcount-cache-size may not exceed cache-size qemu-io: refcount-cache-size may not exceed cache-size
L2 cache entry size must be a power of two between 512 and the cluster size (65536) qemu-io: L2 cache entry size must be a power of two between 512 and the cluster size (65536)
L2 cache entry size must be a power of two between 512 and the cluster size (65536) qemu-io: L2 cache entry size must be a power of two between 512 and the cluster size (65536)
Refcount cache size too big qemu-io: Refcount cache size too big
Conflicting values for qcow2 options 'overlap-check' ('constant') and 'overlap-check.template' ('all') qemu-io: Conflicting values for qcow2 options 'overlap-check' ('constant') and 'overlap-check.template' ('all')
Unsupported value 'blubb' for qcow2 option 'overlap-check'. Allowed are any of the following: none, constant, cached, all qemu-io: Unsupported value 'blubb' for qcow2 option 'overlap-check'. Allowed are any of the following: none, constant, cached, all
Unsupported value 'blubb' for qcow2 option 'overlap-check'. Allowed are any of the following: none, constant, cached, all qemu-io: Unsupported value 'blubb' for qcow2 option 'overlap-check'. Allowed are any of the following: none, constant, cached, all
Cache clean interval too big qemu-io: Cache clean interval too big
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=36028797018963968 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=36028797018963968
L2 cache size too big qemu-io: L2 cache size too big
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
=== Test transaction semantics === === Test transaction semantics ===
Unsupported value 'blubb' for qcow2 option 'overlap-check'. Allowed are any of the following: none, constant, cached, all qemu-io: Unsupported value 'blubb' for qcow2 option 'overlap-check'. Allowed are any of the following: none, constant, cached, all
wrote 512/512 bytes at offset 0 wrote 512/512 bytes at offset 0
512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
./common.rc: Killed ( if [ "${VALGRIND_QEMU}" == "y" ]; then ./common.rc: Killed ( if [ "${VALGRIND_QEMU}" == "y" ]; then
@ -44,7 +44,7 @@ incompatible_features 0x0
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
wrote 65536/65536 bytes at offset 0 wrote 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
Parameter 'lazy-refcounts' expects 'on' or 'off' qemu-io: Parameter 'lazy-refcounts' expects 'on' or 'off'
qcow2: Marking image as corrupt: Preventing invalid write on metadata (overlaps with qcow2_header); further corruption events will be suppressed qcow2: Marking image as corrupt: Preventing invalid write on metadata (overlaps with qcow2_header); further corruption events will be suppressed
write failed: Input/output error write failed: Input/output error
*** done *** done

2
tests/qemu-iotests/140.out
View File

@ -8,7 +8,7 @@ wrote 65536/65536 bytes at offset 0
read 65536/65536 bytes at offset 0 read 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
{"return": {}} {"return": {}}
can't open device nbd+unix:///drv?socket=TEST_DIR/nbd: Requested export not available qemu-io: can't open device nbd+unix:///drv?socket=TEST_DIR/nbd: Requested export not available
server reported: export 'drv' not present server reported: export 'drv' not present
{"return": {}} {"return": {}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false, "reason": "host-qmp-quit"}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false, "reason": "host-qmp-quit"}}

2
tests/qemu-iotests/143.out
View File

@ -1,7 +1,7 @@
QA output created by 143 QA output created by 143
{"return": {}} {"return": {}}
{"return": {}} {"return": {}}
can't open device nbd+unix:///no_such_export?socket=TEST_DIR/nbd: Requested export not available qemu-io: can't open device nbd+unix:///no_such_export?socket=TEST_DIR/nbd: Requested export not available
server reported: export 'no_such_export' not present server reported: export 'no_such_export' not present
{"return": {}} {"return": {}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false, "reason": "host-qmp-quit"}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false, "reason": "host-qmp-quit"}}

32
tests/qemu-iotests/153.out
View File

@ -23,20 +23,20 @@ Is another process using the image [TEST_DIR/t.qcow2]?
== Running utility commands == == Running utility commands ==
_qemu_io_wrapper -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -c read 0 512 TEST_DIR/t.qcow2
can't open device TEST_DIR/t.qcow2: Failed to get "write" lock qemu-io: can't open device TEST_DIR/t.qcow2: Failed to get "write" lock
Is another process using the image [TEST_DIR/t.qcow2]? Is another process using the image [TEST_DIR/t.qcow2]?
_qemu_io_wrapper -r -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -r -c read 0 512 TEST_DIR/t.qcow2
can't open device TEST_DIR/t.qcow2: Failed to get shared "write" lock qemu-io: can't open device TEST_DIR/t.qcow2: Failed to get shared "write" lock
Is another process using the image [TEST_DIR/t.qcow2]? Is another process using the image [TEST_DIR/t.qcow2]?
_qemu_io_wrapper -c open TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open TEST_DIR/t.qcow2 -c read 0 512
can't open device TEST_DIR/t.qcow2: Failed to get "write" lock qemu-io: can't open device TEST_DIR/t.qcow2: Failed to get "write" lock
Is another process using the image [TEST_DIR/t.qcow2]? Is another process using the image [TEST_DIR/t.qcow2]?
no file open, try 'help open' no file open, try 'help open'
_qemu_io_wrapper -c open -r TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open -r TEST_DIR/t.qcow2 -c read 0 512
can't open device TEST_DIR/t.qcow2: Failed to get shared "write" lock qemu-io: can't open device TEST_DIR/t.qcow2: Failed to get shared "write" lock
Is another process using the image [TEST_DIR/t.qcow2]? Is another process using the image [TEST_DIR/t.qcow2]?
no file open, try 'help open' no file open, try 'help open'
@ -100,12 +100,12 @@ file format: IMGFMT
== Running utility commands -U == == Running utility commands -U ==
_qemu_io_wrapper -U -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -U -c read 0 512 TEST_DIR/t.qcow2
can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images qemu-io: can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images
_qemu_io_wrapper -U -r -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -U -r -c read 0 512 TEST_DIR/t.qcow2
_qemu_io_wrapper -c open -U TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open -U TEST_DIR/t.qcow2 -c read 0 512
can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images qemu-io: can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images
no file open, try 'help open' no file open, try 'help open'
_qemu_io_wrapper -c open -r -U TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open -r -U TEST_DIR/t.qcow2 -c read 0 512
@ -166,13 +166,13 @@ Is another process using the image [TEST_DIR/t.qcow2]?
== Running utility commands == == Running utility commands ==
_qemu_io_wrapper -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -c read 0 512 TEST_DIR/t.qcow2
can't open device TEST_DIR/t.qcow2: Failed to get "write" lock qemu-io: can't open device TEST_DIR/t.qcow2: Failed to get "write" lock
Is another process using the image [TEST_DIR/t.qcow2]? Is another process using the image [TEST_DIR/t.qcow2]?
_qemu_io_wrapper -r -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -r -c read 0 512 TEST_DIR/t.qcow2
_qemu_io_wrapper -c open TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open TEST_DIR/t.qcow2 -c read 0 512
can't open device TEST_DIR/t.qcow2: Failed to get "write" lock qemu-io: can't open device TEST_DIR/t.qcow2: Failed to get "write" lock
Is another process using the image [TEST_DIR/t.qcow2]? Is another process using the image [TEST_DIR/t.qcow2]?
no file open, try 'help open' no file open, try 'help open'
@ -222,12 +222,12 @@ file format: IMGFMT
== Running utility commands -U == == Running utility commands -U ==
_qemu_io_wrapper -U -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -U -c read 0 512 TEST_DIR/t.qcow2
can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images qemu-io: can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images
_qemu_io_wrapper -U -r -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -U -r -c read 0 512 TEST_DIR/t.qcow2
_qemu_io_wrapper -c open -U TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open -U TEST_DIR/t.qcow2 -c read 0 512
can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images qemu-io: can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images
no file open, try 'help open' no file open, try 'help open'
_qemu_io_wrapper -c open -r -U TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open -r -U TEST_DIR/t.qcow2 -c read 0 512
@ -325,12 +325,12 @@ file format: IMGFMT
== Running utility commands -U == == Running utility commands -U ==
_qemu_io_wrapper -U -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -U -c read 0 512 TEST_DIR/t.qcow2
can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images qemu-io: can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images
_qemu_io_wrapper -U -r -c read 0 512 TEST_DIR/t.qcow2 _qemu_io_wrapper -U -r -c read 0 512 TEST_DIR/t.qcow2
_qemu_io_wrapper -c open -U TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open -U TEST_DIR/t.qcow2 -c read 0 512
can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images qemu-io: can't open device TEST_DIR/t.qcow2: force-share=on can only be used with read-only images
no file open, try 'help open' no file open, try 'help open'
_qemu_io_wrapper -c open -r -U TEST_DIR/t.qcow2 -c read 0 512 _qemu_io_wrapper -c open -r -U TEST_DIR/t.qcow2 -c read 0 512
@ -420,7 +420,7 @@ Adding drive
{"return": "OKrn"} {"return": "OKrn"}
_qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512 _qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512
can't open device TEST_DIR/t.qcow2: Failed to get "write" lock qemu-io: can't open device TEST_DIR/t.qcow2: Failed to get "write" lock
Is another process using the image [TEST_DIR/t.qcow2]? Is another process using the image [TEST_DIR/t.qcow2]?
Creating overlay with qemu-img when the guest is running should be allowed Creating overlay with qemu-img when the guest is running should be allowed
@ -437,7 +437,7 @@ _qemu_img_wrapper info TEST_DIR/t.qcow2
{"return": ""} {"return": ""}
_qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512 _qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512
can't open device TEST_DIR/t.qcow2: Failed to get "write" lock qemu-io: can't open device TEST_DIR/t.qcow2: Failed to get "write" lock
Is another process using the image [TEST_DIR/t.qcow2]? Is another process using the image [TEST_DIR/t.qcow2]?
Closing the other Closing the other
{"return": ""} {"return": ""}
@ -449,7 +449,7 @@ _qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512
No conflict: No conflict:
image: null-co:// image: null-co://
file format: null-co file format: null-co
virtual size: 1.0G (1073741824 bytes) virtual size: 1 GiB (1073741824 bytes)
disk size: unavailable disk size: unavailable
Conflict: Conflict:
@ -458,5 +458,5 @@ qemu-img: --force-share/-U conflicts with image options
No conflict: No conflict:
Conflict: Conflict:
-U conflicts with image options qemu-io: -U conflicts with image options
*** done *** done

6
tests/qemu-iotests/187.out
View File

@ -3,16 +3,16 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
Start from read-only Start from read-only
Block node is read-only qemu-io: Block node is read-only
wrote 65536/65536 bytes at offset 0 wrote 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
Block node is read-only qemu-io: Block node is read-only
Start from read-write Start from read-write
wrote 65536/65536 bytes at offset 0 wrote 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
Block node is read-only qemu-io: Block node is read-only
wrote 65536/65536 bytes at offset 0 wrote 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
*** done *** done

2
tests/qemu-iotests/188.out
View File

@ -14,5 +14,5 @@ read 16777216/16777216 bytes at offset 0
16 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 16 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
== verify open failure with wrong password == == verify open failure with wrong password ==
can't open: Invalid password, cannot unlock any keyslot qemu-io: can't open: Invalid password, cannot unlock any keyslot
*** done *** done

8
tests/qemu-iotests/191.out
View File

@ -395,13 +395,13 @@ wrote 65536/65536 bytes at offset 1048576
} }
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: TEST_DIR/t.IMGFMT.base backing file: TEST_DIR/t.IMGFMT.base
backing file format: IMGFMT backing file format: IMGFMT
image: TEST_DIR/t.IMGFMT.ovl2 image: TEST_DIR/t.IMGFMT.ovl2
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: TEST_DIR/t.IMGFMT.base backing file: TEST_DIR/t.IMGFMT.base
backing file format: IMGFMT backing file format: IMGFMT
@ -813,13 +813,13 @@ wrote 65536/65536 bytes at offset 1048576
} }
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: TEST_DIR/t.IMGFMT.base backing file: TEST_DIR/t.IMGFMT.base
backing file format: IMGFMT backing file format: IMGFMT
image: TEST_DIR/t.IMGFMT.ovl2 image: TEST_DIR/t.IMGFMT.ovl2
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: TEST_DIR/t.IMGFMT.base backing file: TEST_DIR/t.IMGFMT.base
backing file format: IMGFMT backing file format: IMGFMT

4
tests/qemu-iotests/195.out
View File

@ -35,7 +35,7 @@ Testing: -drive if=none,file=TEST_DIR/t.IMGFMT,backing.node-name=mid
image: TEST_DIR/t.IMGFMT.mid image: TEST_DIR/t.IMGFMT.mid
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: /dev/null backing file: /dev/null
backing file format: IMGFMT backing file format: IMGFMT
@ -73,7 +73,7 @@ Testing: -drive if=none,file=TEST_DIR/t.IMGFMT,node-name=top
image: TEST_DIR/t.IMGFMT image: TEST_DIR/t.IMGFMT
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
backing file: /dev/null backing file: /dev/null
backing file format: IMGFMT backing file format: IMGFMT

2
tests/qemu-iotests/197.out
View File

@ -16,7 +16,7 @@ read 2147483136/2147483136 bytes at offset 1024
2 GiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 2 GiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
read 1024/1024 bytes at offset 3221226496 read 1024/1024 bytes at offset 3221226496
1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
can't open device TEST_DIR/t.wrap.qcow2: Can't use copy-on-read on read-only device qemu-io: can't open device TEST_DIR/t.wrap.qcow2: Can't use copy-on-read on read-only device
2 GiB (0x80010000) bytes allocated at offset 0 bytes (0x0) 2 GiB (0x80010000) bytes allocated at offset 0 bytes (0x0)
1023.938 MiB (0x3fff0000) bytes not allocated at offset 2 GiB (0x80010000) 1023.938 MiB (0x3fff0000) bytes not allocated at offset 2 GiB (0x80010000)
64 KiB (0x10000) bytes allocated at offset 3 GiB (0xc0000000) 64 KiB (0x10000) bytes allocated at offset 3 GiB (0xc0000000)

4
tests/qemu-iotests/198.out
View File

@ -34,7 +34,7 @@ read 16777216/16777216 bytes at offset 0
== checking image base == == checking image base ==
image: json:{"encrypt.key-secret": "sec0", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT.base"}} image: json:{"encrypt.key-secret": "sec0", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT.base"}}
file format: IMGFMT file format: IMGFMT
virtual size: 16M (16777216 bytes) virtual size: 16 MiB (16777216 bytes)
Format specific information: Format specific information:
encrypt: encrypt:
ivgen alg: plain64 ivgen alg: plain64
@ -76,7 +76,7 @@ Format specific information:
== checking image layer == == checking image layer ==
image: json:{"encrypt.key-secret": "sec1", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}} image: json:{"encrypt.key-secret": "sec1", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}}
file format: IMGFMT file format: IMGFMT
virtual size: 16M (16777216 bytes) virtual size: 16 MiB (16777216 bytes)
backing file: TEST_DIR/t.IMGFMT.base backing file: TEST_DIR/t.IMGFMT.base
Format specific information: Format specific information:
encrypt: encrypt:

2
tests/qemu-iotests/205
View File

@ -78,7 +78,7 @@ class TestNbdServerRemove(iotests.QMPTestCase):
def assertConnectFailed(self, qemu_io_output): def assertConnectFailed(self, qemu_io_output):
self.assertEqual(filter_qemu_io(qemu_io_output).strip(), self.assertEqual(filter_qemu_io(qemu_io_output).strip(),
"can't open device " + nbd_uri + "qemu-io: can't open device " + nbd_uri +
": Requested export not available\n" ": Requested export not available\n"
"server reported: export 'exp' not present") "server reported: export 'exp' not present")

10
tests/qemu-iotests/206.out
View File

@ -14,7 +14,7 @@
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -36,7 +36,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -58,7 +58,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
cluster_size: 2097152 cluster_size: 2097152
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -80,7 +80,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
cluster_size: 512 cluster_size: 512
backing file: TEST_IMG.base backing file: TEST_IMG.base
backing file format: IMGFMT backing file format: IMGFMT
@ -97,7 +97,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
encrypted: yes encrypted: yes
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:

12
tests/qemu-iotests/207.out
View File

@ -7,12 +7,12 @@
image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}} image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
file format: IMGFMT file format: IMGFMT
virtual size: 4.0M (4194304 bytes) virtual size: 4 MiB (4194304 bytes)
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 4.0M (4194304 bytes) virtual size: 4 MiB (4194304 bytes)
=== Test host-key-check options === === Test host-key-check options ===
@ -23,7 +23,7 @@ virtual size: 4.0M (4194304 bytes)
image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}} image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
file format: IMGFMT file format: IMGFMT
virtual size: 8.0M (8388608 bytes) virtual size: 8 MiB (8388608 bytes)
{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "ssh", "location": {"host-key-check": {"mode": "known_hosts"}, "path": "TEST_DIR/PID-t.img", "server": {"host": "127.0.0.1", "port": "22"}}, "size": 4194304}}} {"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "ssh", "location": {"host-key-check": {"mode": "known_hosts"}, "path": "TEST_DIR/PID-t.img", "server": {"host": "127.0.0.1", "port": "22"}}, "size": 4194304}}}
{"return": {}} {"return": {}}
@ -32,7 +32,7 @@ virtual size: 8.0M (8388608 bytes)
image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}} image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
file format: IMGFMT file format: IMGFMT
virtual size: 4.0M (4194304 bytes) virtual size: 4 MiB (4194304 bytes)
{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "ssh", "location": {"host-key-check": {"hash": "wrong", "mode": "hash", "type": "md5"}, "path": "TEST_DIR/PID-t.img", "server": {"host": "127.0.0.1", "port": "22"}}, "size": 2097152}}} {"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "ssh", "location": {"host-key-check": {"hash": "wrong", "mode": "hash", "type": "md5"}, "path": "TEST_DIR/PID-t.img", "server": {"host": "127.0.0.1", "port": "22"}}, "size": 2097152}}}
{"return": {}} {"return": {}}
@ -47,7 +47,7 @@ Job failed: remote host key does not match host_key_check 'wrong'
image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}} image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
file format: IMGFMT file format: IMGFMT
virtual size: 8.0M (8388608 bytes) virtual size: 8 MiB (8388608 bytes)
{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "ssh", "location": {"host-key-check": {"hash": "wrong", "mode": "hash", "type": "sha1"}, "path": "TEST_DIR/PID-t.img", "server": {"host": "127.0.0.1", "port": "22"}}, "size": 2097152}}} {"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "ssh", "location": {"host-key-check": {"hash": "wrong", "mode": "hash", "type": "sha1"}, "path": "TEST_DIR/PID-t.img", "server": {"host": "127.0.0.1", "port": "22"}}, "size": 2097152}}}
{"return": {}} {"return": {}}
@ -62,7 +62,7 @@ Job failed: remote host key does not match host_key_check 'wrong'
image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}} image: json:{"driver": "IMGFMT", "file": {"server.host": "127.0.0.1", "server.port": "22", "driver": "ssh", "path": "TEST_IMG"}}
file format: IMGFMT file format: IMGFMT
virtual size: 4.0M (4194304 bytes) virtual size: 4 MiB (4194304 bytes)
=== Invalid path and user === === Invalid path and user ===

8
tests/qemu-iotests/210.out
View File

@ -14,7 +14,7 @@
image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"} image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
encrypted: yes encrypted: yes
Format specific information: Format specific information:
ivgen alg: plain64 ivgen alg: plain64
@ -66,7 +66,7 @@ Format specific information:
image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"} image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
encrypted: yes encrypted: yes
Format specific information: Format specific information:
ivgen alg: plain64 ivgen alg: plain64
@ -121,7 +121,7 @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"} image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
file format: IMGFMT file format: IMGFMT
virtual size: 0 (0 bytes) virtual size: 0 B (0 bytes)
encrypted: yes encrypted: yes
Format specific information: Format specific information:
ivgen alg: plain64 ivgen alg: plain64
@ -191,7 +191,7 @@ Job failed: The requested file size is too large
{"error": {"class": "GenericError", "desc": "Parameter 'size' expects a >0 size"}} {"error": {"class": "GenericError", "desc": "Parameter 'size' expects a >0 size"}}
image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"} image: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_IMG"}, "key-secret": "keysec0"}
file format: IMGFMT file format: IMGFMT
virtual size: 0 (0 bytes) virtual size: 0 B (0 bytes)
encrypted: yes encrypted: yes
Format specific information: Format specific information:
ivgen alg: plain64 ivgen alg: plain64

10
tests/qemu-iotests/211.out
View File

@ -14,7 +14,7 @@
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 1048576 cluster_size: 1048576
[{ "start": 0, "length": 134217728, "depth": 0, "zero": true, "data": false}] [{ "start": 0, "length": 134217728, "depth": 0, "zero": true, "data": false}]
@ -33,7 +33,7 @@ cluster_size: 1048576
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 1048576 cluster_size: 1048576
[{ "start": 0, "length": 67108864, "depth": 0, "zero": true, "data": false}] [{ "start": 0, "length": 67108864, "depth": 0, "zero": true, "data": false}]
@ -52,7 +52,7 @@ cluster_size: 1048576
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
cluster_size: 1048576 cluster_size: 1048576
[{ "start": 0, "length": 3072, "depth": 0, "zero": false, "data": true, "offset": 1024}, [{ "start": 0, "length": 3072, "depth": 0, "zero": false, "data": true, "offset": 1024},
@ -75,7 +75,7 @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 0 (0 bytes) virtual size: 0 B (0 bytes)
cluster_size: 1048576 cluster_size: 1048576
=== Maximum size === === Maximum size ===
@ -87,7 +87,7 @@ cluster_size: 1048576
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 512T (562949819203584 bytes) virtual size: 512 TiB (562949819203584 bytes)
cluster_size: 1048576 cluster_size: 1048576
=== Invalid sizes === === Invalid sizes ===

10
tests/qemu-iotests/212.out
View File

@ -14,7 +14,7 @@
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
=== Successful image creation (explicit defaults) === === Successful image creation (explicit defaults) ===
@ -30,7 +30,7 @@ virtual size: 128M (134217728 bytes)
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
=== Successful image creation (with non-default options) === === Successful image creation (with non-default options) ===
@ -46,7 +46,7 @@ virtual size: 64M (67108864 bytes)
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
=== Invalid BlockdevRef === === Invalid BlockdevRef ===
@ -65,7 +65,7 @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 0 (0 bytes) virtual size: 0 B (0 bytes)
=== Maximum size === === Maximum size ===
@ -76,7 +76,7 @@ virtual size: 0 (0 bytes)
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 4096T (4503599627369984 bytes) virtual size: 4 PiB (4503599627369984 bytes)
=== Invalid sizes === === Invalid sizes ===

10
tests/qemu-iotests/213.out
View File

@ -14,7 +14,7 @@
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 128M (134217728 bytes) virtual size: 128 MiB (134217728 bytes)
cluster_size: 8388608 cluster_size: 8388608
=== Successful image creation (explicit defaults) === === Successful image creation (explicit defaults) ===
@ -31,7 +31,7 @@ cluster_size: 8388608
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 8388608 cluster_size: 8388608
=== Successful image creation (with non-default options) === === Successful image creation (with non-default options) ===
@ -48,7 +48,7 @@ cluster_size: 8388608
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
cluster_size: 268435456 cluster_size: 268435456
=== Invalid BlockdevRef === === Invalid BlockdevRef ===
@ -68,7 +68,7 @@ Job failed: Cannot find device=this doesn't exist nor node_name=this doesn't exi
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 0 (0 bytes) virtual size: 0 B (0 bytes)
cluster_size: 8388608 cluster_size: 8388608
=== Maximum size === === Maximum size ===
@ -80,7 +80,7 @@ cluster_size: 8388608
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 64T (70368744177664 bytes) virtual size: 64 TiB (70368744177664 bytes)
cluster_size: 67108864 cluster_size: 67108864
=== Invalid sizes === === Invalid sizes ===

2
tests/qemu-iotests/215.out
View File

@ -16,7 +16,7 @@ read 2147483136/2147483136 bytes at offset 1024
2 GiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 2 GiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
read 1024/1024 bytes at offset 3221226496 read 1024/1024 bytes at offset 3221226496
1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
can't open device TEST_DIR/t.wrap.qcow2: Block node is read-only qemu-io: can't open device TEST_DIR/t.wrap.qcow2: Block node is read-only
2 GiB (0x80010000) bytes allocated at offset 0 bytes (0x0) 2 GiB (0x80010000) bytes allocated at offset 0 bytes (0x0)
1023.938 MiB (0x3fff0000) bytes not allocated at offset 2 GiB (0x80010000) 1023.938 MiB (0x3fff0000) bytes not allocated at offset 2 GiB (0x80010000)
64 KiB (0x10000) bytes allocated at offset 3 GiB (0xc0000000) 64 KiB (0x10000) bytes allocated at offset 3 GiB (0xc0000000)

16
tests/qemu-iotests/226.out
View File

@ -3,24 +3,24 @@ QA output created by 226
=== Testing with driver:file === === Testing with driver:file ===
== Testing RO == == Testing RO ==
can't open: A regular file was expected by the 'file' driver, but something else was given qemu-io: can't open: A regular file was expected by the 'file' driver, but something else was given
warning: Opening a character device as a file using the 'file' driver is deprecated qemu-io: warning: Opening a character device as a file using the 'file' driver is deprecated
== Testing RW == == Testing RW ==
can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory qemu-io: can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory
warning: Opening a character device as a file using the 'file' driver is deprecated qemu-io: warning: Opening a character device as a file using the 'file' driver is deprecated
=== Testing with driver:host_device === === Testing with driver:host_device ===
== Testing RO == == Testing RO ==
can't open: 'host_device' driver expects either a character or block device qemu-io: can't open: 'host_device' driver expects either a character or block device
== Testing RW == == Testing RW ==
can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory qemu-io: can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory
=== Testing with driver:host_cdrom === === Testing with driver:host_cdrom ===
== Testing RO == == Testing RO ==
can't open: 'host_cdrom' driver expects either a character or block device qemu-io: can't open: 'host_cdrom' driver expects either a character or block device
== Testing RW == == Testing RW ==
can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory qemu-io: can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory
*** done *** done

4
tests/qemu-iotests/233.out
View File

@ -28,11 +28,11 @@ server reported: Option 0x8 not permitted before TLS
== check TLS works == == check TLS works ==
image: nbd://127.0.0.1:PORT image: nbd://127.0.0.1:PORT
file format: nbd file format: nbd
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
disk size: unavailable disk size: unavailable
image: nbd://127.0.0.1:PORT image: nbd://127.0.0.1:PORT
file format: nbd file format: nbd
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
disk size: unavailable disk size: unavailable
exports available: 1 exports available: 1
export: '' export: ''

22
tests/qemu-iotests/237.out
View File

@ -14,7 +14,7 @@
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 5.0G (5368709120 bytes) virtual size: 5 GiB (5368709120 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
@ -41,7 +41,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 64M (67108864 bytes) virtual size: 64 MiB (67108864 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
@ -68,7 +68,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 32M (33554432 bytes) virtual size: 32 MiB (33554432 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
@ -169,7 +169,7 @@ Job failed: List of extents contains unused extents
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 512 (512 bytes) virtual size: 512 B (512 bytes)
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
parent cid: XXXXXXXXXX parent cid: XXXXXXXXXX
@ -189,7 +189,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 512 (512 bytes) virtual size: 512 B (512 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
@ -211,7 +211,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 1.0G (1073741824 bytes) virtual size: 1 GiB (1073741824 bytes)
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
parent cid: XXXXXXXXXX parent cid: XXXXXXXXXX
@ -231,7 +231,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 1.0G (1073741824 bytes) virtual size: 1 GiB (1073741824 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
@ -253,7 +253,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 2.0G (2147483648 bytes) virtual size: 2 GiB (2147483648 bytes)
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
parent cid: XXXXXXXXXX parent cid: XXXXXXXXXX
@ -273,7 +273,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 2.0G (2147483648 bytes) virtual size: 2 GiB (2147483648 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
@ -295,7 +295,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 5.0G (5368709120 bytes) virtual size: 5 GiB (5368709120 bytes)
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX
parent cid: XXXXXXXXXX parent cid: XXXXXXXXXX
@ -323,7 +323,7 @@ Format specific information:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 5.0G (5368709120 bytes) virtual size: 5 GiB (5368709120 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
cid: XXXXXXXXXX cid: XXXXXXXXXX

10
tests/qemu-iotests/242.out
View File

@ -8,7 +8,7 @@ qemu-img info dump:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 1.0M (1048576 bytes) virtual size: 1 MiB (1048576 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -28,7 +28,7 @@ qemu-img info dump:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 1.0M (1048576 bytes) virtual size: 1 MiB (1048576 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -60,7 +60,7 @@ qemu-img info dump:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 1.0M (1048576 bytes) virtual size: 1 MiB (1048576 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -100,7 +100,7 @@ qemu-img info dump:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 1.0M (1048576 bytes) virtual size: 1 MiB (1048576 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1
@ -149,7 +149,7 @@ Unset the unknown bitmap flag '0x4' in the bitmap directory entry:
image: TEST_IMG image: TEST_IMG
file format: IMGFMT file format: IMGFMT
virtual size: 1.0M (1048576 bytes) virtual size: 1 MiB (1048576 bytes)
cluster_size: 65536 cluster_size: 65536
Format specific information: Format specific information:
compat: 1.1 compat: 1.1

10
tests/qemu-iotests/244.out
View File

@ -9,22 +9,22 @@ read 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
read 65536/65536 bytes at offset 0 read 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
can't open device TEST_DIR/t.qcow2: Could not open 'inexistent': No such file or directory qemu-io: can't open device TEST_DIR/t.qcow2: Could not open 'inexistent': No such file or directory
no file open, try 'help open' no file open, try 'help open'
Data file required, but without data file name in the image: Data file required, but without data file name in the image:
can't open device TEST_DIR/t.qcow2: 'data-file' is required for this image qemu-io: can't open device TEST_DIR/t.qcow2: 'data-file' is required for this image
no file open, try 'help open' no file open, try 'help open'
read 65536/65536 bytes at offset 0 read 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
can't open device TEST_DIR/t.qcow2: Could not open 'inexistent': No such file or directory qemu-io: can't open device TEST_DIR/t.qcow2: Could not open 'inexistent': No such file or directory
no file open, try 'help open' no file open, try 'help open'
Setting data-file for an image with internal data: Setting data-file for an image with internal data:
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
can't open device TEST_DIR/t.qcow2: 'data-file' can only be set for images with an external data file qemu-io: can't open device TEST_DIR/t.qcow2: 'data-file' can only be set for images with an external data file
no file open, try 'help open' no file open, try 'help open'
can't open device TEST_DIR/t.qcow2: Could not open 'inexistent': No such file or directory qemu-io: can't open device TEST_DIR/t.qcow2: Could not open 'inexistent': No such file or directory
no file open, try 'help open' no file open, try 'help open'
=== Conflicting features === === Conflicting features ===

115
tests/qemu-iotests/249 Executable file
View File

@ -0,0 +1,115 @@
#!/usr/bin/env bash
#
# Test that a backing image is put back in read-only mode after
# block-commit (both when it fails and when it succeeds).
#
# Copyright (C) 2019 Igalia, S.L.
#
# 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
rm -f "$TEST_IMG.base"
rm -f "$TEST_IMG.int"
}
trap "_cleanup; exit \$status" 0 1 2 3 15
# get standard environment, filters and checks
. ./common.rc
. ./common.filter
. ./common.qemu
# Any format implementing BlockDriver.bdrv_change_backing_file
_supported_fmt qcow2 qed
_supported_proto file
_supported_os Linux
IMG_SIZE=1M
# Create the images: base <- int <- active
TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE | _filter_imgfmt
TEST_IMG="$TEST_IMG.int" _make_test_img -b "$TEST_IMG.base" | _filter_imgfmt
_make_test_img -b "$TEST_IMG.int" | _filter_imgfmt
# Launch QEMU with these two drives:
# none0: base (read-only)
# none1: base <- int <- active
_launch_qemu -drive if=none,file="${TEST_IMG}.base",node-name=base,read-only=on \
-drive if=none,file="${TEST_IMG}",backing.node-name=int,backing.backing=base
_send_qemu_cmd $QEMU_HANDLE \
"{ 'execute': 'qmp_capabilities' }" \
'return'
echo
echo '=== Send a write command to a drive opened in read-only mode (1)'
echo
_send_qemu_cmd $QEMU_HANDLE \
"{ 'execute': 'human-monitor-command',
'arguments': {'command-line': 'qemu-io none0 \"aio_write 0 2k\"'}}" \
'return'
echo
echo '=== Run block-commit on base using an invalid filter node name'
echo
_send_qemu_cmd $QEMU_HANDLE \
"{ 'execute': 'block-commit',
'arguments': {'job-id': 'job0', 'device': 'none1', 'top-node': 'int',
'filter-node-name': '1234'}}" \
'error'
echo
echo '=== Send a write command to a drive opened in read-only mode (2)'
echo
_send_qemu_cmd $QEMU_HANDLE \
"{ 'execute': 'human-monitor-command',
'arguments': {'command-line': 'qemu-io none0 \"aio_write 0 2k\"'}}" \
'return'
echo
echo '=== Run block-commit on base using the default filter node name'
echo
_send_qemu_cmd $QEMU_HANDLE \
"{ 'execute': 'block-commit',
'arguments': {'job-id': 'job0', 'device': 'none1', 'top-node': 'int'}}" \
'return'
# Wait for block-commit to finish
_send_qemu_cmd $QEMU_HANDLE '' \
'"status": "null"'
echo
echo '=== Send a write command to a drive opened in read-only mode (3)'
echo
_send_qemu_cmd $QEMU_HANDLE \
"{ 'execute': 'human-monitor-command',
'arguments': {'command-line': 'qemu-io none0 \"aio_write 0 2k\"'}}" \
'return'
_cleanup_qemu
# success, all done
echo "*** done"
rm -f $seq.full
status=0

35
tests/qemu-iotests/249.out Normal file
View File

@ -0,0 +1,35 @@
QA output created by 249
Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576
Formatting 'TEST_DIR/t.IMGFMT.int', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT.base
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT.int
{"return": {}}
=== Send a write command to a drive opened in read-only mode (1)
{"return": "Block node is read-onlyrn"}
=== Run block-commit on base using an invalid filter node name
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "null", "id": "job0"}}
{"error": {"class": "GenericError", "desc": "Invalid node name"}}
=== Send a write command to a drive opened in read-only mode (2)
{"return": "Block node is read-onlyrn"}
=== Run block-commit on base using the default filter node name
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
{"return": {}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "job0"}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "pending", "id": "job0"}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "job0", "len": 1048576, "offset": 1048576, "speed": 0, "type": "commit"}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "concluded", "id": "job0"}}
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "null", "id": "job0"}}
=== Send a write command to a drive opened in read-only mode (3)
{"return": "Block node is read-onlyrn"}
*** done

1
tests/qemu-iotests/group
View File

@ -248,3 +248,4 @@
246 rw auto quick 246 rw auto quick
247 rw auto quick 247 rw auto quick
248 rw auto quick 248 rw auto quick
249 rw auto quick

2
util/cutils.c
View File

@ -825,7 +825,7 @@ const char *qemu_ether_ntoa(const MACAddr *mac)
char *size_to_str(uint64_t val) char *size_to_str(uint64_t val)
{ {
static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" }; static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
unsigned long div; uint64_t div;
int i; int i;
/* /*