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

Merge remote-tracking branch 'kwolf/for-anthony' into staging

Browse source 
# By Max Reitz (10) and others
# Via Kevin Wolf
* kwolf/for-anthony: (30 commits)
  qcow2: Remove useless count_contiguous_clusters() parameter
  qcow2: COMPRESSED on count_contiguous_clusters
  qcow2: count_contiguous_clusters and compression
  qcow2: Free only newly allocated clusters on error
  qcow2: Always use error path in l2_allocate
  qcow2: Don't put invalid L2 table into cache
  qemu-iotests: Preallocated zero clusters in 061
  qcow2: Correct bitmap size in zero expansion
  qemu-iotests: Quote $TEST_IMG* and $TEST_DIR usage
  qemu-iotests: Add basic ability to use binary sample images
  qemu-iotests: fix qmp.py search path
  block: use DIV_ROUND_UP in bdrv_co_do_readv
  qcow2: Assert against currently impossible overflow
  block: qed - use QEMU_PACKED for on-disk structures
  block: qcow2 - used QEMU_PACKED for on-disk structures
  block: vpc - use QEMU_PACKED for on-disk structures
  block: vdi - use QEMU_PACKED for on-disk structures
  rbd: avoid qemu_rbd_snap_list() memory leaks
  qdict: Extract qdict_extract_subqdict
  block: Fix compiler warning (-Werror=uninitialized)
  ...

Message-id: 1380296370-14523-1-git-send-email-kwolf@redhat.com
This commit is contained in:
Anthony Liguori 2013-09-30 17:14:49 -05:00
parent 3469a60d9f 61653008ad
commit 4235d77349
75 changed files with 574 additions and 424 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
block.c
View file

@ -792,7 +792,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
/* Open the image, either directly or using a protocol */ /* Open the image, either directly or using a protocol */
if (drv->bdrv_file_open) { if (drv->bdrv_file_open) {
assert(file == NULL); assert(file == NULL);
assert(drv->bdrv_parse_filename || filename != NULL); assert(!drv->bdrv_needs_filename || filename != NULL);
ret = drv->bdrv_file_open(bs, options, open_flags, &local_err); ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
} else { } else {
if (file == NULL) { if (file == NULL) {
@ -911,7 +911,7 @@ int bdrv_file_open(BlockDriverState **pbs, const char *filename,
goto fail; goto fail;
} }
qdict_del(options, "filename"); qdict_del(options, "filename");
} else if (!drv->bdrv_parse_filename && !filename) { } else if (drv->bdrv_needs_filename && !filename) {
error_setg(errp, "The '%s' block driver requires a file name", error_setg(errp, "The '%s' block driver requires a file name",
drv->format_name); drv->format_name);
ret = -EINVAL; ret = -EINVAL;
@ -978,11 +978,12 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
} else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) { } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
QDECREF(options); QDECREF(options);
return 0; return 0;
} else {
bdrv_get_full_backing_filename(bs, backing_filename,
sizeof(backing_filename));
} }
bs->backing_hd = bdrv_new(""); bs->backing_hd = bdrv_new("");
bdrv_get_full_backing_filename(bs, backing_filename,
sizeof(backing_filename));
if (bs->backing_format[0] != '\0') { if (bs->backing_format[0] != '\0') {
back_drv = bdrv_find_format(bs->backing_format); back_drv = bdrv_find_format(bs->backing_format);
@ -994,6 +995,8 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
ret = bdrv_open(bs->backing_hd, ret = bdrv_open(bs->backing_hd,
*backing_filename ? backing_filename : NULL, options, *backing_filename ? backing_filename : NULL, options,
back_flags, back_drv, &local_err); back_flags, back_drv, &local_err);
pstrcpy(bs->backing_file, sizeof(bs->backing_file),
bs->backing_hd->file->filename);
if (ret < 0) { if (ret < 0) {
bdrv_unref(bs->backing_hd); bdrv_unref(bs->backing_hd);
bs->backing_hd = NULL; bs->backing_hd = NULL;
@ -1004,25 +1007,6 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
return 0; return 0;
} }
static void extract_subqdict(QDict *src, QDict **dst, const char *start)
{
const QDictEntry *entry, *next;
const char *p;
*dst = qdict_new();
entry = qdict_first(src);
while (entry != NULL) {
next = qdict_next(src, entry);
if (strstart(entry->key, start, &p)) {
qobject_incref(entry->value);
qdict_put_obj(*dst, p, entry->value);
qdict_del(src, entry->key);
}
entry = next;
}
}
/* /*
* Opens a disk image (raw, qcow2, vmdk, ...) * Opens a disk image (raw, qcow2, vmdk, ...)
* *
@ -1128,7 +1112,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
flags |= BDRV_O_ALLOW_RDWR; flags |= BDRV_O_ALLOW_RDWR;
} }
extract_subqdict(options, &file_options, "file."); qdict_extract_subqdict(options, &file_options, "file.");
ret = bdrv_file_open(&file, filename, file_options, ret = bdrv_file_open(&file, filename, file_options,
bdrv_open_flags(bs, flags | BDRV_O_UNMAP), &local_err); bdrv_open_flags(bs, flags | BDRV_O_UNMAP), &local_err);
@ -1166,7 +1150,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,
if ((flags & BDRV_O_NO_BACKING) == 0) { if ((flags & BDRV_O_NO_BACKING) == 0) {
QDict *backing_options; QDict *backing_options;
extract_subqdict(options, &backing_options, "backing."); qdict_extract_subqdict(options, &backing_options, "backing.");
ret = bdrv_open_backing_file(bs, backing_options, &local_err); ret = bdrv_open_backing_file(bs, backing_options, &local_err);
if (ret < 0) { if (ret < 0) {
goto close_and_fail; goto close_and_fail;
@ -2669,7 +2653,7 @@ static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
goto out; goto out;
} }
total_sectors = (len + BDRV_SECTOR_SIZE - 1) >> BDRV_SECTOR_BITS; total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
max_nb_sectors = MAX(0, total_sectors - sector_num); max_nb_sectors = MAX(0, total_sectors - sector_num);
if (max_nb_sectors > 0) { if (max_nb_sectors > 0) {
ret = drv->bdrv_co_readv(bs, sector_num, ret = drv->bdrv_co_readv(bs, sector_num,
@ -3159,13 +3143,14 @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum); ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
if (ret < 0) { if (ret < 0) {
*pnum = 0;
return ret; return ret;
} }
if (!(ret & BDRV_BLOCK_DATA)) { if (!(ret & BDRV_BLOCK_DATA)) {
if (bdrv_has_zero_init(bs)) { if (bdrv_has_zero_init(bs)) {
ret |= BDRV_BLOCK_ZERO; ret |= BDRV_BLOCK_ZERO;
} else { } else if (bs->backing_hd) {
BlockDriverState *bs2 = bs->backing_hd; BlockDriverState *bs2 = bs->backing_hd;
int64_t length2 = bdrv_getlength(bs2); int64_t length2 = bdrv_getlength(bs2);
if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) { if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {

4
block/gluster.c
View file

@ -611,6 +611,7 @@ static BlockDriver bdrv_gluster = {
.format_name = "gluster", .format_name = "gluster",
.protocol_name = "gluster", .protocol_name = "gluster",
.instance_size = sizeof(BDRVGlusterState), .instance_size = sizeof(BDRVGlusterState),
.bdrv_needs_filename = true,
.bdrv_file_open = qemu_gluster_open, .bdrv_file_open = qemu_gluster_open,
.bdrv_close = qemu_gluster_close, .bdrv_close = qemu_gluster_close,
.bdrv_create = qemu_gluster_create, .bdrv_create = qemu_gluster_create,
@ -631,6 +632,7 @@ static BlockDriver bdrv_gluster_tcp = {
.format_name = "gluster", .format_name = "gluster",
.protocol_name = "gluster+tcp", .protocol_name = "gluster+tcp",
.instance_size = sizeof(BDRVGlusterState), .instance_size = sizeof(BDRVGlusterState),
.bdrv_needs_filename = true,
.bdrv_file_open = qemu_gluster_open, .bdrv_file_open = qemu_gluster_open,
.bdrv_close = qemu_gluster_close, .bdrv_close = qemu_gluster_close,
.bdrv_create = qemu_gluster_create, .bdrv_create = qemu_gluster_create,
@ -651,6 +653,7 @@ static BlockDriver bdrv_gluster_unix = {
.format_name = "gluster", .format_name = "gluster",
.protocol_name = "gluster+unix", .protocol_name = "gluster+unix",
.instance_size = sizeof(BDRVGlusterState), .instance_size = sizeof(BDRVGlusterState),
.bdrv_needs_filename = true,
.bdrv_file_open = qemu_gluster_open, .bdrv_file_open = qemu_gluster_open,
.bdrv_close = qemu_gluster_close, .bdrv_close = qemu_gluster_close,
.bdrv_create = qemu_gluster_create, .bdrv_create = qemu_gluster_create,
@ -671,6 +674,7 @@ static BlockDriver bdrv_gluster_rdma = {
.format_name = "gluster", .format_name = "gluster",
.protocol_name = "gluster+rdma", .protocol_name = "gluster+rdma",
.instance_size = sizeof(BDRVGlusterState), .instance_size = sizeof(BDRVGlusterState),
.bdrv_needs_filename = true,
.bdrv_file_open = qemu_gluster_open, .bdrv_file_open = qemu_gluster_open,
.bdrv_close = qemu_gluster_close, .bdrv_close = qemu_gluster_close,
.bdrv_create = qemu_gluster_create, .bdrv_create = qemu_gluster_create,

1
block/iscsi.c
View file

@ -1520,6 +1520,7 @@ static BlockDriver bdrv_iscsi = {
.protocol_name = "iscsi", .protocol_name = "iscsi",
.instance_size = sizeof(IscsiLun), .instance_size = sizeof(IscsiLun),
.bdrv_needs_filename = true,
.bdrv_file_open = iscsi_open, .bdrv_file_open = iscsi_open,
.bdrv_close = iscsi_close, .bdrv_close = iscsi_close,
.bdrv_create = iscsi_create, .bdrv_create = iscsi_create,

87
block/qcow2-cluster.c
View file

@ -188,7 +188,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
{ {
BDRVQcowState *s = bs->opaque; BDRVQcowState *s = bs->opaque;
uint64_t old_l2_offset; uint64_t old_l2_offset;
uint64_t *l2_table; uint64_t *l2_table = NULL;
int64_t l2_offset; int64_t l2_offset;
int ret; int ret;
@ -200,7 +200,8 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
l2_offset = qcow2_alloc_clusters(bs, s->l2_size * sizeof(uint64_t)); l2_offset = qcow2_alloc_clusters(bs, s->l2_size * sizeof(uint64_t));
if (l2_offset < 0) { if (l2_offset < 0) {
return l2_offset; ret = l2_offset;
goto fail;
} }
ret = qcow2_cache_flush(bs, s->refcount_block_cache); ret = qcow2_cache_flush(bs, s->refcount_block_cache);
@ -213,7 +214,7 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
trace_qcow2_l2_allocate_get_empty(bs, l1_index); trace_qcow2_l2_allocate_get_empty(bs, l1_index);
ret = qcow2_cache_get_empty(bs, s->l2_table_cache, l2_offset, (void**) table); ret = qcow2_cache_get_empty(bs, s->l2_table_cache, l2_offset, (void**) table);
if (ret < 0) { if (ret < 0) {
return ret; goto fail;
} }
l2_table = *table; l2_table = *table;
@ -265,7 +266,9 @@ static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table)
fail: fail:
trace_qcow2_l2_allocate_done(bs, l1_index, ret); trace_qcow2_l2_allocate_done(bs, l1_index, ret);
qcow2_cache_put(bs, s->l2_table_cache, (void**) table); if (l2_table != NULL) {
qcow2_cache_put(bs, s->l2_table_cache, (void**) table);
}
s->l1_table[l1_index] = old_l2_offset; s->l1_table[l1_index] = old_l2_offset;
return ret; return ret;
} }
@ -278,23 +281,26 @@ fail:
* cluster which may require a different handling) * cluster which may require a different handling)
*/ */
static int count_contiguous_clusters(uint64_t nb_clusters, int cluster_size, static int count_contiguous_clusters(uint64_t nb_clusters, int cluster_size,
uint64_t *l2_table, uint64_t start, uint64_t stop_flags) uint64_t *l2_table, uint64_t stop_flags)
{ {
int i; int i;
uint64_t mask = stop_flags | L2E_OFFSET_MASK; uint64_t mask = stop_flags | L2E_OFFSET_MASK | QCOW2_CLUSTER_COMPRESSED;
uint64_t offset = be64_to_cpu(l2_table[0]) & mask; uint64_t first_entry = be64_to_cpu(l2_table[0]);
uint64_t offset = first_entry & mask;
if (!offset) if (!offset)
return 0; return 0;
for (i = start; i < start + nb_clusters; i++) { assert(qcow2_get_cluster_type(first_entry) != QCOW2_CLUSTER_COMPRESSED);
for (i = 0; i < nb_clusters; i++) {
uint64_t l2_entry = be64_to_cpu(l2_table[i]) & mask; uint64_t l2_entry = be64_to_cpu(l2_table[i]) & mask;
if (offset + (uint64_t) i * cluster_size != l2_entry) { if (offset + (uint64_t) i * cluster_size != l2_entry) {
break; break;
} }
} }
return (i - start); return i;
} }
static int count_contiguous_free_clusters(uint64_t nb_clusters, uint64_t *l2_table) static int count_contiguous_free_clusters(uint64_t nb_clusters, uint64_t *l2_table)
@ -487,8 +493,7 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
return -EIO; return -EIO;
} }
c = count_contiguous_clusters(nb_clusters, s->cluster_size, c = count_contiguous_clusters(nb_clusters, s->cluster_size,
&l2_table[l2_index], 0, &l2_table[l2_index], QCOW_OFLAG_ZERO);
QCOW_OFLAG_COMPRESSED | QCOW_OFLAG_ZERO);
*cluster_offset = 0; *cluster_offset = 0;
break; break;
case QCOW2_CLUSTER_UNALLOCATED: case QCOW2_CLUSTER_UNALLOCATED:
@ -499,8 +504,7 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
case QCOW2_CLUSTER_NORMAL: case QCOW2_CLUSTER_NORMAL:
/* how many allocated clusters ? */ /* how many allocated clusters ? */
c = count_contiguous_clusters(nb_clusters, s->cluster_size, c = count_contiguous_clusters(nb_clusters, s->cluster_size,
&l2_table[l2_index], 0, &l2_table[l2_index], QCOW_OFLAG_ZERO);
QCOW_OFLAG_COMPRESSED | QCOW_OFLAG_ZERO);
*cluster_offset &= L2E_OFFSET_MASK; *cluster_offset &= L2E_OFFSET_MASK;
break; break;
default: default:
@ -716,6 +720,7 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m)
} }
qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table); qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table);
assert(l2_index + m->nb_clusters <= s->l2_size);
for (i = 0; i < m->nb_clusters; i++) { for (i = 0; i < m->nb_clusters; i++) {
/* if two concurrent writes happen to the same unallocated cluster /* if two concurrent writes happen to the same unallocated cluster
* each write allocates separate cluster and writes data concurrently. * each write allocates separate cluster and writes data concurrently.
@ -929,7 +934,7 @@ static int handle_copied(BlockDriverState *bs, uint64_t guest_offset,
/* We keep all QCOW_OFLAG_COPIED clusters */ /* We keep all QCOW_OFLAG_COPIED clusters */
keep_clusters = keep_clusters =
count_contiguous_clusters(nb_clusters, s->cluster_size, count_contiguous_clusters(nb_clusters, s->cluster_size,
&l2_table[l2_index], 0, &l2_table[l2_index],
QCOW_OFLAG_COPIED | QCOW_OFLAG_ZERO); QCOW_OFLAG_COPIED | QCOW_OFLAG_ZERO);
assert(keep_clusters <= nb_clusters); assert(keep_clusters <= nb_clusters);
@ -1509,8 +1514,8 @@ fail:
* i.e., the number of bits in expanded_clusters. * i.e., the number of bits in expanded_clusters.
*/ */
static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
int l1_size, uint8_t *expanded_clusters, int l1_size, uint8_t **expanded_clusters,
uint64_t nb_clusters) uint64_t *nb_clusters)
{ {
BDRVQcowState *s = bs->opaque; BDRVQcowState *s = bs->opaque;
bool is_active_l1 = (l1_table == s->l1_table); bool is_active_l1 = (l1_table == s->l1_table);
@ -1550,11 +1555,12 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
uint64_t l2_entry = be64_to_cpu(l2_table[j]); uint64_t l2_entry = be64_to_cpu(l2_table[j]);
int64_t offset = l2_entry & L2E_OFFSET_MASK, cluster_index; int64_t offset = l2_entry & L2E_OFFSET_MASK, cluster_index;
int cluster_type = qcow2_get_cluster_type(l2_entry); int cluster_type = qcow2_get_cluster_type(l2_entry);
bool preallocated = offset != 0;
if (cluster_type == QCOW2_CLUSTER_NORMAL) { if (cluster_type == QCOW2_CLUSTER_NORMAL) {
cluster_index = offset >> s->cluster_bits; cluster_index = offset >> s->cluster_bits;
assert((cluster_index >= 0) && (cluster_index < nb_clusters)); assert((cluster_index >= 0) && (cluster_index < *nb_clusters));
if (expanded_clusters[cluster_index / 8] & if ((*expanded_clusters)[cluster_index / 8] &
(1 << (cluster_index % 8))) { (1 << (cluster_index % 8))) {
/* Probably a shared L2 table; this cluster was a zero /* Probably a shared L2 table; this cluster was a zero
* cluster which has been expanded, its refcount * cluster which has been expanded, its refcount
@ -1575,8 +1581,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
continue; continue;
} }
if (!offset) { if (!preallocated) {
/* not preallocated */
if (!bs->backing_hd) { if (!bs->backing_hd) {
/* not backed; therefore we can simply deallocate the /* not backed; therefore we can simply deallocate the
* cluster */ * cluster */
@ -1595,16 +1600,20 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_DEFAULT, ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_DEFAULT,
offset, s->cluster_size); offset, s->cluster_size);
if (ret < 0) { if (ret < 0) {
qcow2_free_clusters(bs, offset, s->cluster_size, if (!preallocated) {
QCOW2_DISCARD_ALWAYS); qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_ALWAYS);
}
goto fail; goto fail;
} }
ret = bdrv_write_zeroes(bs->file, offset / BDRV_SECTOR_SIZE, ret = bdrv_write_zeroes(bs->file, offset / BDRV_SECTOR_SIZE,
s->cluster_sectors); s->cluster_sectors);
if (ret < 0) { if (ret < 0) {
qcow2_free_clusters(bs, offset, s->cluster_size, if (!preallocated) {
QCOW2_DISCARD_ALWAYS); qcow2_free_clusters(bs, offset, s->cluster_size,
QCOW2_DISCARD_ALWAYS);
}
goto fail; goto fail;
} }
@ -1612,8 +1621,25 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
l2_dirty = true; l2_dirty = true;
cluster_index = offset >> s->cluster_bits; cluster_index = offset >> s->cluster_bits;
assert((cluster_index >= 0) && (cluster_index < nb_clusters));
expanded_clusters[cluster_index / 8] |= 1 << (cluster_index % 8); if (cluster_index >= *nb_clusters) {
uint64_t old_bitmap_size = (*nb_clusters + 7) / 8;
uint64_t new_bitmap_size;
/* The offset may lie beyond the old end of the underlying image
* file for growable files only */
assert(bs->file->growable);
*nb_clusters = size_to_clusters(s, bs->file->total_sectors *
BDRV_SECTOR_SIZE);
new_bitmap_size = (*nb_clusters + 7) / 8;
*expanded_clusters = g_realloc(*expanded_clusters,
new_bitmap_size);
/* clear the newly allocated space */
memset(&(*expanded_clusters)[old_bitmap_size], 0,
new_bitmap_size - old_bitmap_size);
}
assert((cluster_index >= 0) && (cluster_index < *nb_clusters));
(*expanded_clusters)[cluster_index / 8] |= 1 << (cluster_index % 8);
} }
if (is_active_l1) { if (is_active_l1) {
@ -1672,18 +1698,17 @@ int qcow2_expand_zero_clusters(BlockDriverState *bs)
{ {
BDRVQcowState *s = bs->opaque; BDRVQcowState *s = bs->opaque;
uint64_t *l1_table = NULL; uint64_t *l1_table = NULL;
int cluster_to_sector_bits = s->cluster_bits - BDRV_SECTOR_BITS;
uint64_t nb_clusters; uint64_t nb_clusters;
uint8_t *expanded_clusters; uint8_t *expanded_clusters;
int ret; int ret;
int i, j; int i, j;
nb_clusters = (bs->total_sectors + (1 << cluster_to_sector_bits) - 1) nb_clusters = size_to_clusters(s, bs->file->total_sectors *
>> cluster_to_sector_bits; BDRV_SECTOR_SIZE);
expanded_clusters = g_malloc0((nb_clusters + 7) / 8); expanded_clusters = g_malloc0((nb_clusters + 7) / 8);
ret = expand_zero_clusters_in_l1(bs, s->l1_table, s->l1_size, ret = expand_zero_clusters_in_l1(bs, s->l1_table, s->l1_size,
expanded_clusters, nb_clusters); &expanded_clusters, &nb_clusters);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }
@ -1717,7 +1742,7 @@ int qcow2_expand_zero_clusters(BlockDriverState *bs)
} }
ret = expand_zero_clusters_in_l1(bs, l1_table, s->snapshots[i].l1_size, ret = expand_zero_clusters_in_l1(bs, l1_table, s->snapshots[i].l1_size,
expanded_clusters, nb_clusters); &expanded_clusters, &nb_clusters);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }

1
block/qcow2-refcount.c
View file

@ -874,7 +874,6 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
nb_csectors = ((offset >> s->csize_shift) & nb_csectors = ((offset >> s->csize_shift) &
s->csize_mask) + 1; s->csize_mask) + 1;
if (addend != 0) { if (addend != 0) {
int ret;
ret = update_refcount(bs, ret = update_refcount(bs,
(offset & s->cluster_offset_mask) & ~511, (offset & s->cluster_offset_mask) & ~511,
nb_csectors * 512, addend, nb_csectors * 512, addend,

2
block/qcow2.c
View file

@ -52,7 +52,7 @@
typedef struct { typedef struct {
uint32_t magic; uint32_t magic;
uint32_t len; uint32_t len;
} QCowExtension; } QEMU_PACKED QCowExtension;
#define QCOW2_EXT_MAGIC_END 0 #define QCOW2_EXT_MAGIC_END 0
#define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA

2
block/qcow2.h
View file

@ -86,7 +86,7 @@ typedef struct QCowHeader {
uint32_t refcount_order; uint32_t refcount_order;
uint32_t header_length; uint32_t header_length;
} QCowHeader; } QEMU_PACKED QCowHeader;
typedef struct QCowSnapshot { typedef struct QCowSnapshot {
uint64_t l1_table_offset; uint64_t l1_table_offset;

2
block/qed.h
View file

@ -100,7 +100,7 @@ typedef struct {
/* if (features & QED_F_BACKING_FILE) */ /* if (features & QED_F_BACKING_FILE) */
uint32_t backing_filename_offset; /* in bytes from start of header */ uint32_t backing_filename_offset; /* in bytes from start of header */
uint32_t backing_filename_size; /* in bytes */ uint32_t backing_filename_size; /* in bytes */
} QEDHeader; } QEMU_PACKED QEDHeader;
typedef struct { typedef struct {
uint64_t offsets[0]; /* in bytes */ uint64_t offsets[0]; /* in bytes */

5
block/raw-posix.c
View file

@ -1200,6 +1200,7 @@ static BlockDriver bdrv_file = {
.format_name = "file", .format_name = "file",
.protocol_name = "file", .protocol_name = "file",
.instance_size = sizeof(BDRVRawState), .instance_size = sizeof(BDRVRawState),
.bdrv_needs_filename = true,
.bdrv_probe = NULL, /* no probe for protocols */ .bdrv_probe = NULL, /* no probe for protocols */
.bdrv_file_open = raw_open, .bdrv_file_open = raw_open,
.bdrv_reopen_prepare = raw_reopen_prepare, .bdrv_reopen_prepare = raw_reopen_prepare,
@ -1542,6 +1543,7 @@ static BlockDriver bdrv_host_device = {
.format_name = "host_device", .format_name = "host_device",
.protocol_name = "host_device", .protocol_name = "host_device",
.instance_size = sizeof(BDRVRawState), .instance_size = sizeof(BDRVRawState),
.bdrv_needs_filename = true,
.bdrv_probe_device = hdev_probe_device, .bdrv_probe_device = hdev_probe_device,
.bdrv_file_open = hdev_open, .bdrv_file_open = hdev_open,
.bdrv_close = raw_close, .bdrv_close = raw_close,
@ -1667,6 +1669,7 @@ static BlockDriver bdrv_host_floppy = {
.format_name = "host_floppy", .format_name = "host_floppy",
.protocol_name = "host_floppy", .protocol_name = "host_floppy",
.instance_size = sizeof(BDRVRawState), .instance_size = sizeof(BDRVRawState),
.bdrv_needs_filename = true,
.bdrv_probe_device = floppy_probe_device, .bdrv_probe_device = floppy_probe_device,
.bdrv_file_open = floppy_open, .bdrv_file_open = floppy_open,
.bdrv_close = raw_close, .bdrv_close = raw_close,
@ -1769,6 +1772,7 @@ static BlockDriver bdrv_host_cdrom = {
.format_name = "host_cdrom", .format_name = "host_cdrom",
.protocol_name = "host_cdrom", .protocol_name = "host_cdrom",
.instance_size = sizeof(BDRVRawState), .instance_size = sizeof(BDRVRawState),
.bdrv_needs_filename = true,
.bdrv_probe_device = cdrom_probe_device, .bdrv_probe_device = cdrom_probe_device,
.bdrv_file_open = cdrom_open, .bdrv_file_open = cdrom_open,
.bdrv_close = raw_close, .bdrv_close = raw_close,
@ -1890,6 +1894,7 @@ static BlockDriver bdrv_host_cdrom = {
.format_name = "host_cdrom", .format_name = "host_cdrom",
.protocol_name = "host_cdrom", .protocol_name = "host_cdrom",
.instance_size = sizeof(BDRVRawState), .instance_size = sizeof(BDRVRawState),
.bdrv_needs_filename = true,
.bdrv_probe_device = cdrom_probe_device, .bdrv_probe_device = cdrom_probe_device,
.bdrv_file_open = cdrom_open, .bdrv_file_open = cdrom_open,
.bdrv_close = raw_close, .bdrv_close = raw_close,

2
block/raw-win32.c
View file

@ -459,6 +459,7 @@ static BlockDriver bdrv_file = {
.format_name = "file", .format_name = "file",
.protocol_name = "file", .protocol_name = "file",
.instance_size = sizeof(BDRVRawState), .instance_size = sizeof(BDRVRawState),
.bdrv_needs_filename = true,
.bdrv_file_open = raw_open, .bdrv_file_open = raw_open,
.bdrv_close = raw_close, .bdrv_close = raw_close,
.bdrv_create = raw_create, .bdrv_create = raw_create,
@ -601,6 +602,7 @@ static BlockDriver bdrv_host_device = {
.format_name = "host_device", .format_name = "host_device",
.protocol_name = "host_device", .protocol_name = "host_device",
.instance_size = sizeof(BDRVRawState), .instance_size = sizeof(BDRVRawState),
.bdrv_needs_filename = true,
.bdrv_probe_device = hdev_probe_device, .bdrv_probe_device = hdev_probe_device,
.bdrv_file_open = hdev_open, .bdrv_file_open = hdev_open,
.bdrv_close = raw_close, .bdrv_close = raw_close,

4
block/rbd.c
View file

@ -943,7 +943,7 @@ static int qemu_rbd_snap_list(BlockDriverState *bs,
do { do {
snaps = g_malloc(sizeof(*snaps) * max_snaps); snaps = g_malloc(sizeof(*snaps) * max_snaps);
snap_count = rbd_snap_list(s->image, snaps, &max_snaps); snap_count = rbd_snap_list(s->image, snaps, &max_snaps);
if (snap_count < 0) { if (snap_count <= 0) {
g_free(snaps); g_free(snaps);
} }
} while (snap_count == -ERANGE); } while (snap_count == -ERANGE);
@ -967,6 +967,7 @@ static int qemu_rbd_snap_list(BlockDriverState *bs,
sn_info->vm_clock_nsec = 0; sn_info->vm_clock_nsec = 0;
} }
rbd_snap_list_end(snaps); rbd_snap_list_end(snaps);
g_free(snaps);
done: done:
*psn_tab = sn_tab; *psn_tab = sn_tab;
@ -1002,6 +1003,7 @@ static QEMUOptionParameter qemu_rbd_create_options[] = {
static BlockDriver bdrv_rbd = { static BlockDriver bdrv_rbd = {
.format_name = "rbd", .format_name = "rbd",
.instance_size = sizeof(BDRVRBDState), .instance_size = sizeof(BDRVRBDState),
.bdrv_needs_filename = true,
.bdrv_file_open = qemu_rbd_open, .bdrv_file_open = qemu_rbd_open,
.bdrv_close = qemu_rbd_close, .bdrv_close = qemu_rbd_close,
.bdrv_create = qemu_rbd_create, .bdrv_create = qemu_rbd_create,

3
block/sheepdog.c
View file

@ -2338,6 +2338,7 @@ static BlockDriver bdrv_sheepdog = {
.format_name = "sheepdog", .format_name = "sheepdog",
.protocol_name = "sheepdog", .protocol_name = "sheepdog",
.instance_size = sizeof(BDRVSheepdogState), .instance_size = sizeof(BDRVSheepdogState),
.bdrv_needs_filename = true,
.bdrv_file_open = sd_open, .bdrv_file_open = sd_open,
.bdrv_close = sd_close, .bdrv_close = sd_close,
.bdrv_create = sd_create, .bdrv_create = sd_create,
@ -2366,6 +2367,7 @@ static BlockDriver bdrv_sheepdog_tcp = {
.format_name = "sheepdog", .format_name = "sheepdog",
.protocol_name = "sheepdog+tcp", .protocol_name = "sheepdog+tcp",
.instance_size = sizeof(BDRVSheepdogState), .instance_size = sizeof(BDRVSheepdogState),
.bdrv_needs_filename = true,
.bdrv_file_open = sd_open, .bdrv_file_open = sd_open,
.bdrv_close = sd_close, .bdrv_close = sd_close,
.bdrv_create = sd_create, .bdrv_create = sd_create,
@ -2394,6 +2396,7 @@ static BlockDriver bdrv_sheepdog_unix = {
.format_name = "sheepdog", .format_name = "sheepdog",
.protocol_name = "sheepdog+unix", .protocol_name = "sheepdog+unix",
.instance_size = sizeof(BDRVSheepdogState), .instance_size = sizeof(BDRVSheepdogState),
.bdrv_needs_filename = true,
.bdrv_file_open = sd_open, .bdrv_file_open = sd_open,
.bdrv_close = sd_close, .bdrv_close = sd_close,
.bdrv_create = sd_create, .bdrv_create = sd_create,

5
block/stream.c
View file

@ -119,11 +119,12 @@ wait:
break; break;
} }
copy = false;
ret = bdrv_is_allocated(bs, sector_num, ret = bdrv_is_allocated(bs, sector_num,
STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n);
if (ret == 1) { if (ret == 1) {
/* Allocated in the top, no need to copy. */ /* Allocated in the top, no need to copy. */
copy = false;
} else if (ret >= 0) { } else if (ret >= 0) {
/* Copy if allocated in the intermediate images. Limit to the /* Copy if allocated in the intermediate images. Limit to the
* known-unallocated area [sector_num, sector_num+n). */ * known-unallocated area [sector_num, sector_num+n). */
@ -138,7 +139,7 @@ wait:
copy = (ret == 1); copy = (ret == 1);
} }
trace_stream_one_iteration(s, sector_num, n, ret); trace_stream_one_iteration(s, sector_num, n, ret);
if (ret >= 0 && copy) { if (copy) {
if (s->common.speed) { if (s->common.speed) {
delay_ns = ratelimit_calculate_delay(&s->limit, n); delay_ns = ratelimit_calculate_delay(&s->limit, n);
if (delay_ns > 0) { if (delay_ns > 0) {

2
block/vdi.c
View file

@ -165,7 +165,7 @@ typedef struct {
uuid_t uuid_link; uuid_t uuid_link;
uuid_t uuid_parent; uuid_t uuid_parent;
uint64_t unused2[7]; uint64_t unused2[7];
} VdiHeader; } QEMU_PACKED VdiHeader;
typedef struct { typedef struct {
/* The block map entries are little endian (even in memory). */ /* The block map entries are little endian (even in memory). */

6
block/vmdk.c
View file

@ -105,7 +105,7 @@ typedef struct VmdkExtent {
uint32_t l2_cache_offsets[L2_CACHE_SIZE]; uint32_t l2_cache_offsets[L2_CACHE_SIZE];
uint32_t l2_cache_counts[L2_CACHE_SIZE]; uint32_t l2_cache_counts[L2_CACHE_SIZE];
unsigned int cluster_sectors; int64_t cluster_sectors;
} VmdkExtent; } VmdkExtent;
typedef struct BDRVVmdkState { typedef struct BDRVVmdkState {
@ -424,7 +424,7 @@ static int vmdk_add_extent(BlockDriverState *bs,
extent->l1_size = l1_size; extent->l1_size = l1_size;
extent->l1_entry_sectors = l2_size * cluster_sectors; extent->l1_entry_sectors = l2_size * cluster_sectors;
extent->l2_size = l2_size; extent->l2_size = l2_size;
extent->cluster_sectors = cluster_sectors; extent->cluster_sectors = flat ? sectors : cluster_sectors;
if (s->num_extents > 1) { if (s->num_extents > 1) {
extent->end_sector = (*(extent - 1)).end_sector + extent->sectors; extent->end_sector = (*(extent - 1)).end_sector + extent->sectors;
@ -741,7 +741,7 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
VmdkExtent *extent; VmdkExtent *extent;
ret = vmdk_add_extent(bs, extent_file, true, sectors, ret = vmdk_add_extent(bs, extent_file, true, sectors,
0, 0, 0, 0, sectors, &extent); 0, 0, 0, 0, 0, &extent);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }

28
block/vpc.c
View file

@ -46,7 +46,7 @@ enum vhd_type {
#define VHD_TIMESTAMP_BASE 946684800 #define VHD_TIMESTAMP_BASE 946684800
// always big-endian // always big-endian
struct vhd_footer { typedef struct vhd_footer {
char creator[8]; // "conectix" char creator[8]; // "conectix"
uint32_t features; uint32_t features;
uint32_t version; uint32_t version;
@ -79,9 +79,9 @@ struct vhd_footer {
uint8_t uuid[16]; uint8_t uuid[16];
uint8_t in_saved_state; uint8_t in_saved_state;
}; } QEMU_PACKED VHDFooter;
struct vhd_dyndisk_header { typedef struct vhd_dyndisk_header {
char magic[8]; // "cxsparse" char magic[8]; // "cxsparse"
// Offset of next header structure, 0xFFFFFFFF if none // Offset of next header structure, 0xFFFFFFFF if none
@ -111,7 +111,7 @@ struct vhd_dyndisk_header {
uint32_t reserved; uint32_t reserved;
uint64_t data_offset; uint64_t data_offset;
} parent_locator[8]; } parent_locator[8];
}; } QEMU_PACKED VHDDynDiskHeader;
typedef struct BDRVVPCState { typedef struct BDRVVPCState {
CoMutex lock; CoMutex lock;
@ -160,8 +160,8 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
{ {
BDRVVPCState *s = bs->opaque; BDRVVPCState *s = bs->opaque;
int i; int i;
struct vhd_footer* footer; VHDFooter *footer;
struct vhd_dyndisk_header* dyndisk_header; VHDDynDiskHeader *dyndisk_header;
uint8_t buf[HEADER_SIZE]; uint8_t buf[HEADER_SIZE];
uint32_t checksum; uint32_t checksum;
int disk_type = VHD_DYNAMIC; int disk_type = VHD_DYNAMIC;
@ -172,7 +172,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
goto fail; goto fail;
} }
footer = (struct vhd_footer*) s->footer_buf; footer = (VHDFooter *) s->footer_buf;
if (strncmp(footer->creator, "conectix", 8)) { if (strncmp(footer->creator, "conectix", 8)) {
int64_t offset = bdrv_getlength(bs->file); int64_t offset = bdrv_getlength(bs->file);
if (offset < 0) { if (offset < 0) {
@ -224,7 +224,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
goto fail; goto fail;
} }
dyndisk_header = (struct vhd_dyndisk_header *) buf; dyndisk_header = (VHDDynDiskHeader *) buf;
if (strncmp(dyndisk_header->magic, "cxsparse", 8)) { if (strncmp(dyndisk_header->magic, "cxsparse", 8)) {
ret = -EINVAL; ret = -EINVAL;
@ -446,7 +446,7 @@ static int vpc_read(BlockDriverState *bs, int64_t sector_num,
int ret; int ret;
int64_t offset; int64_t offset;
int64_t sectors, sectors_per_block; int64_t sectors, sectors_per_block;
struct vhd_footer *footer = (struct vhd_footer *) s->footer_buf; VHDFooter *footer = (VHDFooter *) s->footer_buf;
if (cpu_to_be32(footer->type) == VHD_FIXED) { if (cpu_to_be32(footer->type) == VHD_FIXED) {
return bdrv_read(bs->file, sector_num, buf, nb_sectors); return bdrv_read(bs->file, sector_num, buf, nb_sectors);
@ -495,7 +495,7 @@ static int vpc_write(BlockDriverState *bs, int64_t sector_num,
int64_t offset; int64_t offset;
int64_t sectors, sectors_per_block; int64_t sectors, sectors_per_block;
int ret; int ret;
struct vhd_footer *footer = (struct vhd_footer *) s->footer_buf; VHDFooter *footer = (VHDFooter *) s->footer_buf;
if (cpu_to_be32(footer->type) == VHD_FIXED) { if (cpu_to_be32(footer->type) == VHD_FIXED) {
return bdrv_write(bs->file, sector_num, buf, nb_sectors); return bdrv_write(bs->file, sector_num, buf, nb_sectors);
@ -597,8 +597,8 @@ static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
static int create_dynamic_disk(int fd, uint8_t *buf, int64_t total_sectors) static int create_dynamic_disk(int fd, uint8_t *buf, int64_t total_sectors)
{ {
struct vhd_dyndisk_header* dyndisk_header = VHDDynDiskHeader *dyndisk_header =
(struct vhd_dyndisk_header*) buf; (VHDDynDiskHeader *) buf;
size_t block_size, num_bat_entries; size_t block_size, num_bat_entries;
int i; int i;
int ret = -EIO; int ret = -EIO;
@ -688,7 +688,7 @@ static int vpc_create(const char *filename, QEMUOptionParameter *options,
Error **errp) Error **errp)
{ {
uint8_t buf[1024]; uint8_t buf[1024];
struct vhd_footer *footer = (struct vhd_footer *) buf; VHDFooter *footer = (VHDFooter *) buf;
QEMUOptionParameter *disk_type_param; QEMUOptionParameter *disk_type_param;
int fd, i; int fd, i;
uint16_t cyls = 0; uint16_t cyls = 0;
@ -791,7 +791,7 @@ static int vpc_create(const char *filename, QEMUOptionParameter *options,
static int vpc_has_zero_init(BlockDriverState *bs) static int vpc_has_zero_init(BlockDriverState *bs)
{ {
BDRVVPCState *s = bs->opaque; BDRVVPCState *s = bs->opaque;
struct vhd_footer *footer = (struct vhd_footer *) s->footer_buf; VHDFooter *footer = (VHDFooter *) s->footer_buf;
if (cpu_to_be32(footer->type) == VHD_FIXED) { if (cpu_to_be32(footer->type) == VHD_FIXED) {
return bdrv_has_zero_init(bs->file); return bdrv_has_zero_init(bs->file);

6
include/block/block_int.h
View file

@ -73,6 +73,12 @@ struct BlockDriver {
/* Any driver implementing this callback is expected to be able to handle /* Any driver implementing this callback is expected to be able to handle
* NULL file names in its .bdrv_open() implementation */ * NULL file names in its .bdrv_open() implementation */
void (*bdrv_parse_filename)(const char *filename, QDict *options, Error **errp); void (*bdrv_parse_filename)(const char *filename, QDict *options, Error **errp);
/* Drivers not implementing bdrv_parse_filename nor bdrv_open should have
* this field set to true, except ones that are defined only by their
* child's bs.
* An example of the last type will be the quorum block driver.
*/
bool bdrv_needs_filename;
/* For handling image reopen for split or non-split files */ /* For handling image reopen for split or non-split files */
int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state, int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state,

2
include/qapi/qmp/qdict.h
View file

@ -67,4 +67,6 @@ const char *qdict_get_try_str(const QDict *qdict, const char *key);
QDict *qdict_clone_shallow(const QDict *src); QDict *qdict_clone_shallow(const QDict *src);
void qdict_flatten(QDict *qdict); void qdict_flatten(QDict *qdict);
void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start);
#endif /* QDICT_H */ #endif /* QDICT_H */

21
qobject/qdict.c
View file

@ -527,3 +527,24 @@ void qdict_flatten(QDict *qdict)
{ {
qdict_do_flatten(qdict, qdict, NULL); qdict_do_flatten(qdict, qdict, NULL);
} }
/* extract all the src QDict entries starting by start into dst */
void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start)
{
const QDictEntry *entry, *next;
const char *p;
*dst = qdict_new();
entry = qdict_first(src);
while (entry != NULL) {
next = qdict_next(src, entry);
if (strstart(entry->key, start, &p)) {
qobject_incref(entry->value);
qdict_put_obj(*dst, p, entry->value);
qdict_del(src, entry->key);
}
entry = next;
}
}

6
tests/qemu-iotests/001
View file

@ -48,15 +48,15 @@ _make_test_img $size
echo echo
echo "== reading whole image ==" echo "== reading whole image =="
$QEMU_IO -c "read 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== rewriting whole image ==" echo "== rewriting whole image =="
$QEMU_IO -c "write -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verify pattern ==" echo "== verify pattern =="
$QEMU_IO -c "read -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done

36
tests/qemu-iotests/002
View file

@ -48,36 +48,36 @@ _make_test_img $size
echo echo
echo "== reading whole image ==" echo "== reading whole image =="
$QEMU_IO -c "read -p 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -p 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== rewriting whole image ==" echo "== rewriting whole image =="
$QEMU_IO -c "write -pP 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -pP 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verify pattern ==" echo "== verify pattern =="
$QEMU_IO -c "read -pP 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -pP 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "unaligned pwrite" echo "unaligned pwrite"
$QEMU_IO -c 'write -pP 0xab 66 42' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -pP 0xab 66 42' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xac 512 288' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -pP 0xac 512 288' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xad 800 224' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -pP 0xad 800 224' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xae 66000 128k' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -pP 0xae 66000 128k' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xaf 256k 42' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -pP 0xaf 256k 42' "$TEST_IMG" | _filter_qemu_io
echo echo
echo "verify pattern" echo "verify pattern"
$QEMU_IO -c 'read -pP 0xa 0 66' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xa 0 66' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xab 66 42' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xab 66 42' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 108 404' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xa 108 404' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xac 512 288' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xac 512 288' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xad 800 224' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xad 800 224' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 1k 64976' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xa 1k 64976' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xae 66000 128k' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xae 66000 128k' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 197072 65072' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xa 197072 65072' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xaf 256k 42' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xaf 256k 42' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 262186 470' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'read -pP 0xa 262186 470' "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

10
tests/qemu-iotests/003
View file

@ -50,27 +50,27 @@ _make_test_img $size
echo echo
echo "== reading whole image ==" echo "== reading whole image =="
$QEMU_IO -c "readv 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "readv 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== rewriting whole image ==" echo "== rewriting whole image =="
$QEMU_IO -c "writev -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "writev -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verify pattern ==" echo "== verify pattern =="
$QEMU_IO -c "readv -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "readv -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== vectored write ==" echo "== vectored write =="
$QEMU_IO -c "writev -P 0xb $offset $chunksize $chunksize \ $QEMU_IO -c "writev -P 0xb $offset $chunksize $chunksize \
$chunksize $chunksize $chunksize $chunksize $chunksize" \ $chunksize $chunksize $chunksize $chunksize $chunksize" \
$TEST_IMG | _filter_qemu_io "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verify pattern ==" echo "== verify pattern =="
$QEMU_IO -c "readv -P 0xb $offset $chunksize $chunksize \ $QEMU_IO -c "readv -P 0xb $offset $chunksize $chunksize \
$chunksize $chunksize $chunksize $chunksize $chunksize" \ $chunksize $chunksize $chunksize $chunksize $chunksize" \
$TEST_IMG | _filter_qemu_io "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

24
tests/qemu-iotests/004
View file

@ -51,51 +51,51 @@ _make_test_img $size
echo echo
echo "write before image boundary" echo "write before image boundary"
$QEMU_IO -c "write $pre_offset 1M" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write $pre_offset 1M" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "write into image boundary" echo "write into image boundary"
$QEMU_IO -c "write $pre_offset 4M" $TEST_IMG $QEMU_IO -c "write $pre_offset 4M" "$TEST_IMG"
echo echo
echo "write at image boundary" echo "write at image boundary"
$QEMU_IO -c "write $size 4096" $TEST_IMG $QEMU_IO -c "write $size 4096" "$TEST_IMG"
echo echo
echo "write past image boundary" echo "write past image boundary"
$QEMU_IO -c "write $past_offset 4096" $TEST_IMG $QEMU_IO -c "write $past_offset 4096" "$TEST_IMG"
echo echo
echo "pwrite past image boundary" echo "pwrite past image boundary"
$QEMU_IO -c "write -p $past_offset 4096" $TEST_IMG $QEMU_IO -c "write -p $past_offset 4096" "$TEST_IMG"
echo echo
echo "writev past image boundary" echo "writev past image boundary"
$QEMU_IO -c "writev $past_offset 4096" $TEST_IMG $QEMU_IO -c "writev $past_offset 4096" "$TEST_IMG"
echo echo
echo "read before image boundary" echo "read before image boundary"
$QEMU_IO -c "read $pre_offset 1M" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read $pre_offset 1M" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "read into image boundary" echo "read into image boundary"
$QEMU_IO -c "read $pre_offset 4M" $TEST_IMG $QEMU_IO -c "read $pre_offset 4M" "$TEST_IMG"
echo echo
echo "read at image boundary" echo "read at image boundary"
$QEMU_IO -c "read $size 4096" $TEST_IMG $QEMU_IO -c "read $size 4096" "$TEST_IMG"
echo echo
echo "read past image boundary" echo "read past image boundary"
$QEMU_IO -c "read $past_offset 4096" $TEST_IMG $QEMU_IO -c "read $past_offset 4096" "$TEST_IMG"
echo echo
echo "pread past image boundary" echo "pread past image boundary"
$QEMU_IO -c "read -p $past_offset 4096" $TEST_IMG $QEMU_IO -c "read -p $past_offset 4096" "$TEST_IMG"
echo echo
echo "readv past image boundary" echo "readv past image boundary"
$QEMU_IO -c "readv $past_offset 4096" $TEST_IMG $QEMU_IO -c "readv $past_offset 4096" "$TEST_IMG"
# success, all done # success, all done

4
tests/qemu-iotests/005
View file

@ -61,11 +61,11 @@ _make_test_img 5000G
echo echo
echo "small read" echo "small read"
$QEMU_IO -c "read 1024 4096" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read 1024 4096" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "small write" echo "small write"
$QEMU_IO -c "write 8192 4096" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write 8192 4096" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

2
tests/qemu-iotests/007
View file

@ -50,7 +50,7 @@ _make_test_img 1M
for i in `seq 1 10`; do for i in `seq 1 10`; do
echo "savevm $i" echo "savevm $i"
$QEMU -nographic -hda $TEST_IMG -serial none -monitor stdio >/dev/null 2>&1 <<EOF $QEMU -nographic -hda "$TEST_IMG" -serial none -monitor stdio >/dev/null 2>&1 <<EOF
savevm test-$i savevm test-$i
quit quit
EOF EOF

6
tests/qemu-iotests/008
View file

@ -48,15 +48,15 @@ _make_test_img $size
echo echo
echo "== reading whole image ==" echo "== reading whole image =="
$QEMU_IO -c "aio_read 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_read 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== rewriting whole image ==" echo "== rewriting whole image =="
$QEMU_IO -c "aio_write -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_write -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verify pattern ==" echo "== verify pattern =="
$QEMU_IO -c "aio_read -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_read -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done

2
tests/qemu-iotests/009
View file

@ -57,7 +57,7 @@ $QEMU_IO \
-c "write 4k 4k" \ -c "write 4k 4k" \
-c "write 9M 4k" \ -c "write 9M 4k" \
-c "read -P 65 -s 4k -l 4k 2044k 8k" \ -c "read -P 65 -s 4k -l 4k 2044k 8k" \
$TEST_IMG | _filter_qemu_io "$TEST_IMG" | _filter_qemu_io
echo echo
echo "checking image for errors" echo "checking image for errors"

2
tests/qemu-iotests/010
View file

@ -59,7 +59,7 @@ $QEMU_IO \
-c "write -P 165 2044k 4k" \ -c "write -P 165 2044k 4k" \
-c "write -P 99 8M 4k" \ -c "write -P 99 8M 4k" \
-c "read -P 165 2044k 8k" \ -c "read -P 165 2044k 8k" \
$TEST_IMG | _filter_qemu_io "$TEST_IMG" | _filter_qemu_io
echo echo
echo "checking image for errors" echo "checking image for errors"

2
tests/qemu-iotests/011
View file

@ -60,7 +60,7 @@ for i in `seq 1 10`; do
# Note that we filter away the actual offset. That's because qemu # Note that we filter away the actual offset. That's because qemu
# may re-order the two aio requests. We only want to make sure the # may re-order the two aio requests. We only want to make sure the
# filesystem isn't corrupted afterwards anyway. # filesystem isn't corrupted afterwards anyway.
$QEMU_IO -c "aio_write $off1 1M" -c "aio_write $off2 1M" $TEST_IMG | \ $QEMU_IO -c "aio_write $off1 1M" -c "aio_write $off2 1M" "$TEST_IMG" | \
_filter_qemu_io | \ _filter_qemu_io | \
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g' sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
done done

4
tests/qemu-iotests/012
View file

@ -50,11 +50,11 @@ _make_test_img $size
echo echo
echo "== mark image read-only" echo "== mark image read-only"
chmod a-w $TEST_IMG chmod a-w "$TEST_IMG"
echo echo
echo "== read from read-only image" echo "== read from read-only image"
$QEMU_IO -r -c "read 0 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -r -c "read 0 512" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

4
tests/qemu-iotests/013
View file

@ -65,8 +65,8 @@ done
echo "Compressing image" echo "Compressing image"
echo echo
mv $TEST_IMG $TEST_IMG.orig mv "$TEST_IMG" "$TEST_IMG.orig"
$QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c $TEST_IMG.orig $TEST_IMG $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c "$TEST_IMG.orig" "$TEST_IMG"
echo "Testing compressed image" echo "Testing compressed image"
echo echo

2
tests/qemu-iotests/014
View file

@ -61,7 +61,7 @@ done
# With snapshots # With snapshots
for i in `seq 1 3`; do for i in `seq 1 3`; do
$QEMU_IMG snapshot -c test$i $TEST_IMG $QEMU_IMG snapshot -c test$i "$TEST_IMG"
for offset in $TEST_OFFSETS; do for offset in $TEST_OFFSETS; do
echo With snapshot test$i, offset $offset echo With snapshot test$i, offset $offset
for op in $TEST_OPS; do for op in $TEST_OPS; do

16
tests/qemu-iotests/015
View file

@ -61,19 +61,19 @@ _make_test_img $size
# Create two snapshots which fill the image with two different patterns # Create two snapshots which fill the image with two different patterns
echo "creating first snapshot" echo "creating first snapshot"
$QEMU_IO -c "aio_write -P 123 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_write -P 123 0 $size" "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -c snap1 $TEST_IMG $QEMU_IMG snapshot -c snap1 "$TEST_IMG"
echo "creating second snapshot" echo "creating second snapshot"
$QEMU_IO -c "aio_write -P 165 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_write -P 165 0 $size" "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -c snap2 $TEST_IMG $QEMU_IMG snapshot -c snap2 "$TEST_IMG"
# Now check the pattern # Now check the pattern
echo "checking first snapshot" echo "checking first snapshot"
$QEMU_IMG snapshot -a snap1 $TEST_IMG $QEMU_IMG snapshot -a snap1 "$TEST_IMG"
$QEMU_IO -c "aio_read -P 123 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_read -P 123 0 $size" "$TEST_IMG" | _filter_qemu_io
echo "checking second snapshot" echo "checking second snapshot"
$QEMU_IMG snapshot -a snap2 $TEST_IMG $QEMU_IMG snapshot -a snap2 "$TEST_IMG"
$QEMU_IO -c "aio_read -P 165 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_read -P 165 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "checking image for errors" echo "checking image for errors"

12
tests/qemu-iotests/016
View file

@ -48,21 +48,21 @@ _make_test_img $size
echo echo
echo "== reading at EOF ==" echo "== reading at EOF =="
$QEMU_IO -g -c "read -P 0 $size 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -g -c "read -P 0 $size 512" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== reading far past EOF ==" echo "== reading far past EOF =="
$QEMU_IO -g -c "read -P 0 256M 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -g -c "read -P 0 256M 512" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== writing at EOF ==" echo "== writing at EOF =="
$QEMU_IO -g -c "write -P 66 $size 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -g -c "write -P 66 $size 512" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 66 $size 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 66 $size 512" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== writing far past EOF ==" echo "== writing far past EOF =="
$QEMU_IO -g -c "write -P 66 256M 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -g -c "write -P 66 256M 512" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 66 256M 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 66 256M 512" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

6
tests/qemu-iotests/018
View file

@ -66,7 +66,7 @@ echo "Creating test image with backing file"
echo echo
TEST_IMG=$TEST_IMG_SAVE TEST_IMG=$TEST_IMG_SAVE
_make_test_img -b $TEST_IMG.base 6G _make_test_img -b "$TEST_IMG.base" 6G
echo "Filling test image" echo "Filling test image"
echo echo
@ -80,8 +80,8 @@ for offset in $TEST_OFFSETS; do
done done
_check_test_img _check_test_img
mv $TEST_IMG $TEST_IMG.orig mv "$TEST_IMG" "$TEST_IMG.orig"
$QEMU_IMG convert -O $IMGFMT $TEST_IMG.orig $TEST_IMG $QEMU_IMG convert -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
echo "Reading" echo "Reading"
echo echo

12
tests/qemu-iotests/019
View file

@ -33,8 +33,8 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm -f $TEST_IMG.base rm -f "$TEST_IMG.base"
rm -f $TEST_IMG.orig rm -f "$TEST_IMG.orig"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -68,8 +68,8 @@ _check_test_img
echo "Creating test image with backing file" echo "Creating test image with backing file"
echo echo
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G _make_test_img -b "$TEST_IMG.base" 6G
echo "Filling test image" echo "Filling test image"
echo echo
@ -83,7 +83,7 @@ for offset in $TEST_OFFSETS; do
done done
_check_test_img _check_test_img
mv $TEST_IMG $TEST_IMG.orig mv "$TEST_IMG" "$TEST_IMG.orig"
@ -95,7 +95,7 @@ for backing_option in "-B $TEST_IMG.base" "-o backing_file=$TEST_IMG.base"; do
echo echo
echo Testing conversion with $backing_option | _filter_testdir | _filter_imgfmt echo Testing conversion with $backing_option | _filter_testdir | _filter_imgfmt
echo echo
$QEMU_IMG convert -O $IMGFMT $backing_option $TEST_IMG.orig $TEST_IMG $QEMU_IMG convert -O $IMGFMT $backing_option "$TEST_IMG.orig" "$TEST_IMG"
echo "Checking if backing clusters are allocated when they shouldn't" echo "Checking if backing clusters are allocated when they shouldn't"
echo echo

12
tests/qemu-iotests/020
View file

@ -31,8 +31,8 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm -f $TEST_IMG.base rm -f "$TEST_IMG.base"
rm -f $TEST_IMG.orig rm -f "$TEST_IMG.orig"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -65,8 +65,8 @@ _check_test_img
echo "Creating test image with backing file" echo "Creating test image with backing file"
echo echo
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G _make_test_img -b "$TEST_IMG.base" 6G
echo "Filling test image" echo "Filling test image"
echo echo
@ -80,8 +80,8 @@ for offset in $TEST_OFFSETS; do
done done
_check_test_img _check_test_img
$QEMU_IMG commit $TEST_IMG $QEMU_IMG commit "$TEST_IMG"
mv $TEST_IMG.base $TEST_IMG mv "$TEST_IMG.base" "$TEST_IMG"
echo "Reading from the backing file" echo "Reading from the backing file"
echo echo

2
tests/qemu-iotests/021
View file

@ -53,7 +53,7 @@ for pattern in $INVALID_PATTERNS; do
for op in $TEST_OPS; do for op in $TEST_OPS; do
echo echo
echo "== testing $op -P $pattern ==" echo "== testing $op -P $pattern =="
$QEMU_IO -c "$op -P $pattern 0 4096" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "$op -P $pattern 0 4096" "$TEST_IMG" | _filter_qemu_io
done done
done done

4
tests/qemu-iotests/023
View file

@ -71,8 +71,8 @@ for CLUSTER_SIZE in $CLUSTER_SIZES; do
echo "Compressing image" echo "Compressing image"
echo echo
mv $TEST_IMG $TEST_IMG.orig mv "$TEST_IMG" "$TEST_IMG.orig"
$QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c $TEST_IMG.orig $TEST_IMG $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c "$TEST_IMG.orig" "$TEST_IMG"
echo "Testing compressed image" echo "Testing compressed image"
echo echo

12
tests/qemu-iotests/024
View file

@ -31,8 +31,8 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm -f $TEST_DIR/t.$IMGFMT.base_old rm -f "$TEST_DIR/t.$IMGFMT.base_old"
rm -f $TEST_DIR/t.$IMGFMT.base_new rm -f "$TEST_DIR/t.$IMGFMT.base_new"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -62,19 +62,19 @@ echo
_make_test_img 1G _make_test_img 1G
io_pattern writev 0 $CLUSTER_SIZE $((2 * CLUSTER_SIZE)) 8 0x11 io_pattern writev 0 $CLUSTER_SIZE $((2 * CLUSTER_SIZE)) 8 0x11
mv $TEST_IMG $TEST_IMG.base_old mv "$TEST_IMG" "$TEST_IMG.base_old"
echo "Creating new backing file" echo "Creating new backing file"
echo echo
_make_test_img 1G _make_test_img 1G
io_pattern writev 0 $((2 * CLUSTER_SIZE)) $((4 * CLUSTER_SIZE)) 4 0x22 io_pattern writev 0 $((2 * CLUSTER_SIZE)) $((4 * CLUSTER_SIZE)) 4 0x22
mv $TEST_IMG $TEST_IMG.base_new mv "$TEST_IMG" "$TEST_IMG.base_new"
echo "Creating COW image" echo "Creating COW image"
echo echo
_make_test_img -b $TEST_IMG.base_old 1G _make_test_img -b "$TEST_IMG.base_old" 1G
io_pattern writev 0 $((4 * CLUSTER_SIZE)) 0 1 0x33 io_pattern writev 0 $((4 * CLUSTER_SIZE)) 0 1 0x33
io_pattern writev $((8 * CLUSTER_SIZE)) $((4 * CLUSTER_SIZE)) 0 1 0x33 io_pattern writev $((8 * CLUSTER_SIZE)) $((4 * CLUSTER_SIZE)) 0 1 0x33
@ -100,7 +100,7 @@ io_pattern readv $((15 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x00
echo echo
echo Rebase and test again echo Rebase and test again
echo echo
$QEMU_IMG rebase -b $TEST_IMG.base_new $TEST_IMG $QEMU_IMG rebase -b "$TEST_IMG.base_new" "$TEST_IMG"
io_pattern readv $((0 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33 io_pattern readv $((0 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33
io_pattern readv $((1 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33 io_pattern readv $((1 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33
io_pattern readv $((2 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33 io_pattern readv $((2 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33

4
tests/qemu-iotests/025
View file

@ -56,7 +56,7 @@ _check_test_img
echo echo
echo "=== Resizing image" echo "=== Resizing image"
$QEMU_IO $TEST_IMG <<EOF $QEMU_IO "$TEST_IMG" <<EOF
length length
truncate $big_size truncate $big_size
length length
@ -65,7 +65,7 @@ _check_test_img
echo echo
echo "=== Verifying image size after reopen" echo "=== Verifying image size after reopen"
$QEMU_IO -c "length" $TEST_IMG $QEMU_IO -c "length" "$TEST_IMG"
echo echo
echo "=== Verifying resized image" echo "=== Verifying resized image"

20
tests/qemu-iotests/026
View file

@ -31,7 +31,7 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm $TEST_DIR/blkdebug.conf rm "$TEST_DIR/blkdebug.conf"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -75,7 +75,7 @@ for imm in off; do
for once in on off; do for once in on off; do
for vmstate in "" "-b"; do for vmstate in "" "-b"; do
cat > $TEST_DIR/blkdebug.conf <<EOF cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error] [inject-error]
event = "$event" event = "$event"
errno = "$errno" errno = "$errno"
@ -90,16 +90,16 @@ echo "Event: $event; errno: $errno; imm: $imm; once: $once; write $vmstate"
# We want to catch a simple L2 update, not the allocation of the first L2 table # We want to catch a simple L2 update, not the allocation of the first L2 table
if [ "$event" == "l2_update" ]; then if [ "$event" == "l2_update" ]; then
$QEMU_IO -c "write $vmstate 0 512" $TEST_IMG > /dev/null 2>&1 $QEMU_IO -c "write $vmstate 0 512" "$TEST_IMG" > /dev/null 2>&1
fi fi
$QEMU_IO -c "write $vmstate 0 128k " $BLKDBG_TEST_IMG | _filter_qemu_io $QEMU_IO -c "write $vmstate 0 128k " "$BLKDBG_TEST_IMG" | _filter_qemu_io
# l2_load is not called on allocation, so issue a second write # l2_load is not called on allocation, so issue a second write
# Reads are another path to trigger l2_load, so do a read, too # Reads are another path to trigger l2_load, so do a read, too
if [ "$event" == "l2_load" ]; then if [ "$event" == "l2_load" ]; then
$QEMU_IO -c "write $vmstate 0 128k " $BLKDBG_TEST_IMG | _filter_qemu_io $QEMU_IO -c "write $vmstate 0 128k " "$BLKDBG_TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read $vmstate 0 128k " $BLKDBG_TEST_IMG | _filter_qemu_io $QEMU_IO -c "read $vmstate 0 128k " "$BLKDBG_TEST_IMG" | _filter_qemu_io
fi fi
_check_test_img 2>&1 | grep -v "refcount=1 reference=0" _check_test_img 2>&1 | grep -v "refcount=1 reference=0"
@ -133,7 +133,7 @@ for imm in off; do
for once in on off; do for once in on off; do
for vmstate in "" "-b"; do for vmstate in "" "-b"; do
cat > $TEST_DIR/blkdebug.conf <<EOF cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error] [inject-error]
event = "$event" event = "$event"
errno = "$errno" errno = "$errno"
@ -145,7 +145,7 @@ _make_test_img 1G
echo echo
echo "Event: $event; errno: $errno; imm: $imm; once: $once; write $vmstate" echo "Event: $event; errno: $errno; imm: $imm; once: $once; write $vmstate"
$QEMU_IO -c "write $vmstate 0 64M" $BLKDBG_TEST_IMG | _filter_qemu_io $QEMU_IO -c "write $vmstate 0 64M" "$BLKDBG_TEST_IMG" | _filter_qemu_io
_check_test_img 2>&1 | grep -v "refcount=1 reference=0" _check_test_img 2>&1 | grep -v "refcount=1 reference=0"
@ -172,7 +172,7 @@ for errno in 5 28; do
for imm in off; do for imm in off; do
for once in on off; do for once in on off; do
cat > $TEST_DIR/blkdebug.conf <<EOF cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error] [inject-error]
event = "$event" event = "$event"
errno = "$errno" errno = "$errno"
@ -184,7 +184,7 @@ _make_test_img 1G
echo echo
echo "Event: $event; errno: $errno; imm: $imm; once: $once" echo "Event: $event; errno: $errno; imm: $imm; once: $once"
$QEMU_IO -c "write -b 0 64k" $BLKDBG_TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -b 0 64k" "$BLKDBG_TEST_IMG" | _filter_qemu_io
_check_test_img 2>&1 | grep -v "refcount=1 reference=0" _check_test_img 2>&1 | grep -v "refcount=1 reference=0"

10
tests/qemu-iotests/027
View file

@ -54,23 +54,23 @@ _make_test_img $size
# Otherwise an L2 table could get in the way after the data cluster. # Otherwise an L2 table could get in the way after the data cluster.
echo echo
echo "== writing first cluster to populate metadata ==" echo "== writing first cluster to populate metadata =="
$QEMU_IO -c "write -pP 0xde $cluster_size $cluster_size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -pP 0xde $cluster_size $cluster_size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== writing at sub-cluster granularity ==" echo "== writing at sub-cluster granularity =="
$QEMU_IO -c "write -pP 0xa $subcluster_offset $subcluster_size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -pP 0xa $subcluster_offset $subcluster_size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verify pattern ==" echo "== verify pattern =="
$QEMU_IO -c "read -pP 0xa $subcluster_offset $subcluster_size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -pP 0xa $subcluster_offset $subcluster_size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verify zeroes before sub-cluster pattern ==" echo "== verify zeroes before sub-cluster pattern =="
$QEMU_IO -c "read -pP 0 -l $subcluster_offset 0 $subcluster_size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -pP 0 -l $subcluster_offset 0 $subcluster_size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verify zeroes after sub-cluster pattern ==" echo "== verify zeroes after sub-cluster pattern =="
$QEMU_IO -c "read -pP 0 -l 512 -s $subcluster_size $subcluster_offset $(( subcluster_size + 512 ))" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -pP 0 -l 512 -s $subcluster_size $subcluster_offset $(( subcluster_size + 512 ))" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

6
tests/qemu-iotests/028
View file

@ -71,8 +71,8 @@ _check_test_img
echo "Creating test image with backing file" echo "Creating test image with backing file"
echo echo
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base $image_size _make_test_img -b "$TEST_IMG.base" $image_size
echo "Filling test image" echo "Filling test image"
echo echo
@ -97,7 +97,7 @@ io_zero readv $(( offset + 32 * 1024 )) 512 1024 32
_check_test_img _check_test_img
# Rebase it on top of its base image # Rebase it on top of its base image
$QEMU_IMG rebase -b $TEST_IMG.base $TEST_IMG $QEMU_IMG rebase -b "$TEST_IMG.base" "$TEST_IMG"
_check_test_img _check_test_img

12
tests/qemu-iotests/029
View file

@ -47,16 +47,16 @@ _supported_os Linux
CLUSTER_SIZE=65536 CLUSTER_SIZE=65536
_make_test_img 64M _make_test_img 64M
$QEMU_IMG snapshot -c foo $TEST_IMG $QEMU_IMG snapshot -c foo "$TEST_IMG"
$QEMU_IO -c 'write -b 0 4k' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -b 0 4k' "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -a foo $TEST_IMG $QEMU_IMG snapshot -a foo "$TEST_IMG"
_check_test_img _check_test_img
CLUSTER_SIZE=1024 CLUSTER_SIZE=1024
_make_test_img 16M _make_test_img 16M
$QEMU_IMG snapshot -c foo $TEST_IMG $QEMU_IMG snapshot -c foo "$TEST_IMG"
$QEMU_IO -c 'write -b 0 4M' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -b 0 4M' "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -a foo $TEST_IMG $QEMU_IMG snapshot -a foo "$TEST_IMG"
_check_test_img _check_test_img
# success, all done # success, all done

12
tests/qemu-iotests/031
View file

@ -56,22 +56,22 @@ for IMGOPTS in "compat=0.10" "compat=1.1"; do
echo === Create image with unknown header extension === echo === Create image with unknown header extension ===
echo echo
_make_test_img 64M _make_test_img 64M
./qcow2.py $TEST_IMG add-header-ext 0x12345678 "This is a test header extension" ./qcow2.py "$TEST_IMG" add-header-ext 0x12345678 "This is a test header extension"
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
_check_test_img _check_test_img
echo echo
echo === Rewrite header with no backing file === echo === Rewrite header with no backing file ===
echo echo
$QEMU_IMG rebase -u -b "" $TEST_IMG $QEMU_IMG rebase -u -b "" "$TEST_IMG"
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
_check_test_img _check_test_img
echo echo
echo === Add a backing file and format === echo === Add a backing file and format ===
echo echo
$QEMU_IMG rebase -u -b "/some/backing/file/path" -F host_device $TEST_IMG $QEMU_IMG rebase -u -b "/some/backing/file/path" -F host_device "$TEST_IMG"
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
done done
# success, all done # success, all done

4
tests/qemu-iotests/032
View file

@ -55,12 +55,12 @@ _make_test_img 64M
# Allocate every other cluster so that afterwards a big write request will # Allocate every other cluster so that afterwards a big write request will
# actually loop a while and issue many I/O requests for the lower layer # actually loop a while and issue many I/O requests for the lower layer
for i in $(seq 0 128 4096); do echo "write ${i}k 64k"; done | $QEMU_IO $TEST_IMG | _filter_qemu_io for i in $(seq 0 128 4096); do echo "write ${i}k 64k"; done | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
echo echo
echo === AIO request during close === echo === AIO request during close ===
echo echo
$QEMU_IO -c "aio_write 0 4M" -c "close" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_write 0 4M" -c "close" "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img
# success, all done # success, all done

18
tests/qemu-iotests/033
View file

@ -48,24 +48,24 @@ _make_test_img $size
echo echo
echo "== preparing image ==" echo "== preparing image =="
$QEMU_IO -c "write -P 0xa 0x200 0x400" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xa 0x200 0x400" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xa 0x20000 0x600" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xa 0x20000 0x600" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -z 0x400 0x20000" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -z 0x400 0x20000" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verifying patterns (1) ==" echo "== verifying patterns (1) =="
$QEMU_IO -c "read -P 0xa 0x200 0x200" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xa 0x200 0x200" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 0x400 0x20000" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x0 0x400 0x20000" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 0x20400 0x200" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xa 0x20400 0x200" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== rewriting zeroes ==" echo "== rewriting zeroes =="
$QEMU_IO -c "write -P 0xb 0x10000 0x10000" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xb 0x10000 0x10000" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -z 0x10000 0x10000" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -z 0x10000 0x10000" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== verifying patterns (2) ==" echo "== verifying patterns (2) =="
$QEMU_IO -c "read -P 0x0 0x400 0x20000" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x0 0x400 0x20000" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

64
tests/qemu-iotests/034
View file

@ -49,63 +49,63 @@ echo
echo "== creating backing file for COW tests ==" echo "== creating backing file for COW tests =="
_make_test_img $size _make_test_img $size
$QEMU_IO -c "write -P 0x55 0 1M" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x55 0 1M" "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G _make_test_img -b "$TEST_IMG.base" 6G
echo echo
echo "== zero write with backing file ==" echo "== zero write with backing file =="
$QEMU_IO -c "write -z 64k 192k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -z 64k 192k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -z 513k 13k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -z 513k 13k" "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img
echo echo
echo "== verifying patterns (3) ==" echo "== verifying patterns (3) =="
$QEMU_IO -c "read -P 0x55 0 64k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x55 0 64k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 64k 192k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x0 64k 192k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 256k 257k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x55 256k 257k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 513k 13k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x0 513k 13k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 526k 498k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x55 526k 498k" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== overwriting zero cluster ==" echo "== overwriting zero cluster =="
$QEMU_IO -c "write -P 0xa 60k 8k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xa 60k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xb 64k 8k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xb 64k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xc 76k 4k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xc 76k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xd 252k 8k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xd 252k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xe 248k 8k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0xe 248k 8k" "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img
echo echo
echo "== verifying patterns (4) ==" echo "== verifying patterns (4) =="
$QEMU_IO -c "read -P 0x55 0 60k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x55 0 60k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 60k 4k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xa 60k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xb 64k 8k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xb 64k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 72k 4k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x0 72k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xc 76k 4k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xc 76k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 80k 168k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x0 80k 168k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xe 248k 8k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xe 248k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xd 256k 4k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xd 256k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 260k 64k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x55 260k 64k" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== re-zeroing overwritten area ==" echo "== re-zeroing overwritten area =="
$QEMU_IO -c "write -z 64k 192k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -z 64k 192k" "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img
echo echo
echo "== verifying patterns (5) ==" echo "== verifying patterns (5) =="
$QEMU_IO -c "read -P 0x55 0 60k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x55 0 60k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 60k 4k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xa 60k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 64k 192k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x0 64k 192k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xd 256k 4k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0xd 256k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 260k 253k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x55 260k 253k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 513k 13k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x0 513k 13k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 526k 498k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x55 526k 498k" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

2
tests/qemu-iotests/035
View file

@ -59,7 +59,7 @@ function generate_requests() {
done done
} }
generate_requests | $QEMU_IO $TEST_IMG | _filter_qemu_io |\ generate_requests | $QEMU_IO "$TEST_IMG" | _filter_qemu_io |\
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g' sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
echo echo

6
tests/qemu-iotests/036
View file

@ -53,15 +53,15 @@ IMGOPTS="compat=1.1"
echo === Create image with unknown autoclear feature bit === echo === Create image with unknown autoclear feature bit ===
echo echo
_make_test_img 64M _make_test_img 64M
./qcow2.py $TEST_IMG set-feature-bit autoclear 63 ./qcow2.py "$TEST_IMG" set-feature-bit autoclear 63
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
echo echo
echo === Repair image === echo === Repair image ===
echo echo
_check_test_img -r all _check_test_img -r all
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
# success, all done # success, all done
echo "*** done" echo "*** done"

60
tests/qemu-iotests/037
View file

@ -66,50 +66,50 @@ function backing_io()
done done
} }
backing_io 0 256 write | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io 0 256 write | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G _make_test_img -b "$TEST_IMG.base" 6G
echo echo
echo "== COW in a single cluster ==" echo "== COW in a single cluster =="
$QEMU_IO -c "write -P 0x77 0 2k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x77 0 2k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 6k 2k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x88 6k 2k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 9k 2k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x99 9k 2k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 0 2k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x77 0 2k" "$TEST_IMG" | _filter_qemu_io
backing_io $((2 * 1024)) 8 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((2 * 1024)) 8 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 6k 2k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x88 6k 2k" "$TEST_IMG" | _filter_qemu_io
backing_io $((8 * 1024)) 2 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((8 * 1024)) 2 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 9k 2k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x99 9k 2k" "$TEST_IMG" | _filter_qemu_io
backing_io $((11 * 1024)) 2 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((11 * 1024)) 2 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== COW in two-cluster allocations ==" echo "== COW in two-cluster allocations =="
$QEMU_IO -c "write -P 0x77 16k 6k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x77 16k 6k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 26k 6k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x88 26k 6k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 33k 5k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x99 33k 5k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 16k 6k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x77 16k 6k" "$TEST_IMG" | _filter_qemu_io
backing_io $((22 * 1024)) 8 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((22 * 1024)) 8 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 26k 6k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x88 26k 6k" "$TEST_IMG" | _filter_qemu_io
backing_io $((32 * 1024)) 2 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((32 * 1024)) 2 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 33k 5k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x99 33k 5k" "$TEST_IMG" | _filter_qemu_io
backing_io $((38 * 1024)) 4 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((38 * 1024)) 4 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== COW in multi-cluster allocations ==" echo "== COW in multi-cluster allocations =="
$QEMU_IO -c "write -P 0x77 48k 15k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x77 48k 15k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 66k 14k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x88 66k 14k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 83k 15k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x99 83k 15k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 48k 15k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x77 48k 15k" "$TEST_IMG" | _filter_qemu_io
backing_io $((63 * 1024)) 6 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((63 * 1024)) 6 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 66k 14k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x88 66k 14k" "$TEST_IMG" | _filter_qemu_io
backing_io $((80 * 1024)) 6 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((80 * 1024)) 6 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 83k 15k" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x99 83k 15k" "$TEST_IMG" | _filter_qemu_io
backing_io $((98 * 1024)) 4 read | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io $((98 * 1024)) 4 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img

10
tests/qemu-iotests/038
View file

@ -66,11 +66,11 @@ function backing_io()
done done
} }
backing_io 0 256 write | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io 0 256 write | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G _make_test_img -b "$TEST_IMG.base" 6G
echo echo
echo "== Some concurrent requests touching the same cluster ==" echo "== Some concurrent requests touching the same cluster =="
@ -94,7 +94,7 @@ function overlay_io()
echo aio_write -P 0x90 4080k 80k echo aio_write -P 0x90 4080k 80k
} }
overlay_io | $QEMU_IO $TEST_IMG | _filter_qemu_io |\ overlay_io | $QEMU_IO "$TEST_IMG" | _filter_qemu_io |\
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g' \ sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g' \
-e 's/qemu-io> //g' | paste - - | sort | tr '\t' '\n' -e 's/qemu-io> //g' | paste - - | sort | tr '\t' '\n'
@ -124,7 +124,7 @@ function verify_io()
done done
} }
verify_io | $QEMU_IO $TEST_IMG | _filter_qemu_io verify_io | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img

28
tests/qemu-iotests/039
View file

@ -54,10 +54,10 @@ echo "== Checking that image is clean on shutdown =="
IMGOPTS="compat=1.1,lazy_refcounts=on" IMGOPTS="compat=1.1,lazy_refcounts=on"
_make_test_img $size _make_test_img $size
$QEMU_IO -c "write -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x5a 0 512" ""$TEST_IMG"" | _filter_qemu_io
# The dirty bit must not be set # The dirty bit must not be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
_check_test_img _check_test_img
echo echo
@ -68,20 +68,20 @@ _make_test_img $size
old_ulimit=$(ulimit -c) old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3) ulimit -c 0 # do not produce a core dump on abort(3)
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x5a 0 512" -c "abort" "$TEST_IMG" | _filter_qemu_io
ulimit -c "$old_ulimit" ulimit -c "$old_ulimit"
# The dirty bit must be set # The dirty bit must be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
_check_test_img _check_test_img
echo echo
echo "== Read-only access must still work ==" echo "== Read-only access must still work =="
$QEMU_IO -r -c "read -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -r -c "read -P 0x5a 0 512" "$TEST_IMG" | _filter_qemu_io
# The dirty bit must be set # The dirty bit must be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
echo echo
echo "== Repairing the image file must succeed ==" echo "== Repairing the image file must succeed =="
@ -89,12 +89,12 @@ echo "== Repairing the image file must succeed =="
_check_test_img -r all _check_test_img -r all
# The dirty bit must not be set # The dirty bit must not be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
echo echo
echo "== Data should still be accessible after repair ==" echo "== Data should still be accessible after repair =="
$QEMU_IO -c "read -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x5a 0 512" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== Opening a dirty image read/write should repair it ==" echo "== Opening a dirty image read/write should repair it =="
@ -104,16 +104,16 @@ _make_test_img $size
old_ulimit=$(ulimit -c) old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3) ulimit -c 0 # do not produce a core dump on abort(3)
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x5a 0 512" -c "abort" "$TEST_IMG" | _filter_qemu_io
ulimit -c "$old_ulimit" ulimit -c "$old_ulimit"
# The dirty bit must be set # The dirty bit must be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
$QEMU_IO -c "write 0 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write 0 512" "$TEST_IMG" | _filter_qemu_io
# The dirty bit must not be set # The dirty bit must not be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
echo echo
echo "== Creating an image file with lazy_refcounts=off ==" echo "== Creating an image file with lazy_refcounts=off =="
@ -123,11 +123,11 @@ _make_test_img $size
old_ulimit=$(ulimit -c) old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3) ulimit -c 0 # do not produce a core dump on abort(3)
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x5a 0 512" -c "abort" "$TEST_IMG" | _filter_qemu_io
ulimit -c "$old_ulimit" ulimit -c "$old_ulimit"
# The dirty bit must not be set since lazy_refcounts=off # The dirty bit must not be set since lazy_refcounts=off
./qcow2.py $TEST_IMG dump-header | grep incompatible_features ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
_check_test_img _check_test_img
# success, all done # success, all done

10
tests/qemu-iotests/042
View file

@ -48,27 +48,27 @@ echo "== Creating zero size image =="
_make_test_img 0 _make_test_img 0
_check_test_img _check_test_img
mv $TEST_IMG $TEST_IMG.orig mv "$TEST_IMG" "$TEST_IMG.orig"
echo echo
echo "== Converting the image ==" echo "== Converting the image =="
$QEMU_IMG convert -O $IMGFMT $TEST_IMG.orig $TEST_IMG $QEMU_IMG convert -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
_check_test_img _check_test_img
echo echo
echo "== Converting the image, compressed ==" echo "== Converting the image, compressed =="
if [ "$IMGFMT" == "qcow2" ]; then if [ "$IMGFMT" == "qcow2" ]; then
$QEMU_IMG convert -c -O $IMGFMT $TEST_IMG.orig $TEST_IMG $QEMU_IMG convert -c -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
fi fi
_check_test_img _check_test_img
echo echo
echo "== Rebasing the image ==" echo "== Rebasing the image =="
$QEMU_IMG rebase -u -b $TEST_IMG.orig $TEST_IMG $QEMU_IMG rebase -u -b "$TEST_IMG.orig" "$TEST_IMG"
$QEMU_IMG rebase -b $TEST_IMG.orig $TEST_IMG $QEMU_IMG rebase -b "$TEST_IMG.orig" "$TEST_IMG"
_check_test_img _check_test_img
# success, all done # success, all done

32
tests/qemu-iotests/043
View file

@ -31,7 +31,7 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm -f $TEST_IMG.[123].base rm -f "$TEST_IMG".[123].base
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -47,39 +47,39 @@ _supported_os Linux
size=128M size=128M
_make_test_img $size _make_test_img $size
$QEMU_IMG rebase -u -b $TEST_IMG $TEST_IMG $QEMU_IMG rebase -u -b "$TEST_IMG" "$TEST_IMG"
echo echo
echo "== backing file references self ==" echo "== backing file references self =="
_img_info --backing-chain _img_info --backing-chain
_make_test_img $size _make_test_img $size
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base $size _make_test_img -b "$TEST_IMG.base" $size
$QEMU_IMG rebase -u -b $TEST_IMG $TEST_IMG.base $QEMU_IMG rebase -u -b "$TEST_IMG" "$TEST_IMG.base"
echo echo
echo "== parent references self ==" echo "== parent references self =="
_img_info --backing-chain _img_info --backing-chain
_make_test_img $size _make_test_img $size
mv $TEST_IMG $TEST_IMG.1.base mv "$TEST_IMG" "$TEST_IMG.1.base"
_make_test_img -b $TEST_IMG.1.base $size _make_test_img -b "$TEST_IMG.1.base" $size
mv $TEST_IMG $TEST_IMG.2.base mv "$TEST_IMG" "$TEST_IMG.2.base"
_make_test_img -b $TEST_IMG.2.base $size _make_test_img -b "$TEST_IMG.2.base" $size
mv $TEST_IMG $TEST_IMG.3.base mv "$TEST_IMG" "$TEST_IMG.3.base"
_make_test_img -b $TEST_IMG.3.base $size _make_test_img -b "$TEST_IMG.3.base" $size
$QEMU_IMG rebase -u -b $TEST_IMG.2.base $TEST_IMG.1.base $QEMU_IMG rebase -u -b "$TEST_IMG.2.base" "$TEST_IMG.1.base"
echo echo
echo "== ancestor references another ancestor ==" echo "== ancestor references another ancestor =="
_img_info --backing-chain _img_info --backing-chain
_make_test_img $size _make_test_img $size
mv $TEST_IMG $TEST_IMG.1.base mv "$TEST_IMG" "$TEST_IMG.1.base"
_make_test_img -b $TEST_IMG.1.base $size _make_test_img -b "$TEST_IMG.1.base" $size
mv $TEST_IMG $TEST_IMG.2.base mv "$TEST_IMG" "$TEST_IMG.2.base"
_make_test_img -b $TEST_IMG.2.base $size _make_test_img -b "$TEST_IMG.2.base" $size
echo echo
echo "== finite chain of length 3 (human) ==" echo "== finite chain of length 3 (human) =="

10
tests/qemu-iotests/046
View file

@ -66,11 +66,11 @@ function backing_io()
done done
} }
backing_io 0 32 write | $QEMU_IO $TEST_IMG | _filter_qemu_io backing_io 0 32 write | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G _make_test_img -b "$TEST_IMG.base" 6G
echo echo
echo "== Some concurrent requests touching the same cluster ==" echo "== Some concurrent requests touching the same cluster =="
@ -185,7 +185,7 @@ aio_flush
EOF EOF
} }
overlay_io | $QEMU_IO blkdebug::$TEST_IMG | _filter_qemu_io |\ overlay_io | $QEMU_IO blkdebug::"$TEST_IMG" | _filter_qemu_io |\
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g' sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
echo echo
@ -252,7 +252,7 @@ function verify_io()
echo read -P 17 0x11c000 0x4000 echo read -P 17 0x11c000 0x4000
} }
verify_io | $QEMU_IO $TEST_IMG | _filter_qemu_io verify_io | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img

2
tests/qemu-iotests/047
View file

@ -66,7 +66,7 @@ read -P 0x55 1M 128k
EOF EOF
} }
qemu_io_cmds | $QEMU_IO $TEST_IMG | _filter_qemu_io qemu_io_cmds | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img
# success, all done # success, all done

8
tests/qemu-iotests/048
View file

@ -31,13 +31,13 @@ _cleanup()
{ {
echo "Cleanup" echo "Cleanup"
_cleanup_test_img _cleanup_test_img
rm ${TEST_IMG2} rm "${TEST_IMG2}"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
_compare() _compare()
{ {
$QEMU_IMG compare "$@" $TEST_IMG ${TEST_IMG2} $QEMU_IMG compare "$@" "$TEST_IMG" "${TEST_IMG2}"
echo $? echo $?
} }
@ -59,12 +59,12 @@ _make_test_img $size
io_pattern write 524288 $CLUSTER_SIZE $CLUSTER_SIZE 4 45 io_pattern write 524288 $CLUSTER_SIZE $CLUSTER_SIZE 4 45
# Compare identical images # Compare identical images
cp $TEST_IMG ${TEST_IMG2} cp "$TEST_IMG" "${TEST_IMG2}"
_compare _compare
_compare -q _compare -q
# Compare images with different size # Compare images with different size
$QEMU_IMG resize $TEST_IMG +512M $QEMU_IMG resize "$TEST_IMG" +512M
_compare _compare
_compare -s _compare -s

36
tests/qemu-iotests/049
View file

@ -63,13 +63,13 @@ sizes+="1024.0 1024.0b 1.5k 1.5K 1.5M 1.5G 1.5T"
echo "== 1. Traditional size parameter ==" echo "== 1. Traditional size parameter =="
echo echo
for s in $sizes; do for s in $sizes; do
test_qemu_img create -f $IMGFMT $TEST_IMG $s test_qemu_img create -f $IMGFMT "$TEST_IMG" $s
done done
echo "== 2. Specifying size via -o ==" echo "== 2. Specifying size via -o =="
echo echo
for s in $sizes; do for s in $sizes; do
test_qemu_img create -f $IMGFMT -o size=$s $TEST_IMG test_qemu_img create -f $IMGFMT -o size=$s "$TEST_IMG"
done done
echo "== 3. Invalid sizes ==" echo "== 3. Invalid sizes =="
@ -77,8 +77,8 @@ echo
sizes="-1024 -1k 1kilobyte foobar" sizes="-1024 -1k 1kilobyte foobar"
for s in $sizes; do for s in $sizes; do
test_qemu_img create -f $IMGFMT $TEST_IMG -- $s test_qemu_img create -f $IMGFMT "$TEST_IMG" -- $s
test_qemu_img create -f $IMGFMT -o size=$s $TEST_IMG test_qemu_img create -f $IMGFMT -o size=$s "$TEST_IMG"
done done
echo "== Check correct interpretation of suffixes for cluster size ==" echo "== Check correct interpretation of suffixes for cluster size =="
@ -87,35 +87,35 @@ sizes="1024 1024b 1k 1K 1M "
sizes+="1024.0 1024.0b 0.5k 0.5K 0.5M" sizes+="1024.0 1024.0b 0.5k 0.5K 0.5M"
for s in $sizes; do for s in $sizes; do
test_qemu_img create -f $IMGFMT -o cluster_size=$s $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o cluster_size=$s "$TEST_IMG" 64M
done done
echo "== Check compat level option ==" echo "== Check compat level option =="
echo echo
test_qemu_img create -f $IMGFMT -o compat=0.10 $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o compat=0.10 "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=1.1 $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o compat=1.1 "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=0.42 $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o compat=0.42 "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=foobar $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o compat=foobar "$TEST_IMG" 64M
echo "== Check preallocation option ==" echo "== Check preallocation option =="
echo echo
test_qemu_img create -f $IMGFMT -o preallocation=off $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o preallocation=off "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o preallocation=metadata $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o preallocation=metadata "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o preallocation=1234 $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o preallocation=1234 "$TEST_IMG" 64M
echo "== Check encryption option ==" echo "== Check encryption option =="
echo echo
test_qemu_img create -f $IMGFMT -o encryption=off $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o encryption=off "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o encryption=on $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o encryption=on "$TEST_IMG" 64M
echo "== Check lazy_refcounts option (only with v3) ==" echo "== Check lazy_refcounts option (only with v3) =="
echo echo
test_qemu_img create -f $IMGFMT -o compat=1.1,lazy_refcounts=off $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o compat=1.1,lazy_refcounts=off "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=1.1,lazy_refcounts=on $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o compat=1.1,lazy_refcounts=on "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=0.10,lazy_refcounts=off $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o compat=0.10,lazy_refcounts=off "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=0.10,lazy_refcounts=on $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o compat=0.10,lazy_refcounts=on "$TEST_IMG" 64M
# success, all done # success, all done
echo "*** done" echo "*** done"

20
tests/qemu-iotests/050
View file

@ -31,8 +31,8 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm -f $TEST_IMG.old rm -f "$TEST_IMG.old"
rm -f $TEST_IMG.new rm -f "$TEST_IMG.new"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -53,21 +53,21 @@ echo "== Creating images =="
size=10M size=10M
_make_test_img $size _make_test_img $size
$QEMU_IO -c "write -P 0x40 0 1048576" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x40 0 1048576" "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.old mv "$TEST_IMG" "$TEST_IMG.old"
_make_test_img $size _make_test_img $size
$QEMU_IO -c "write -P 0x5a 0 1048576" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x5a 0 1048576" "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.new mv "$TEST_IMG" "$TEST_IMG.new"
_make_test_img -b $TEST_IMG.old $size _make_test_img -b "$TEST_IMG.old" $size
$QEMU_IO -c "write -z 0 1048576" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -z 0 1048576" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== Rebasing the image ==" echo "== Rebasing the image =="
$QEMU_IMG rebase -b $TEST_IMG.new $TEST_IMG $QEMU_IMG rebase -b "$TEST_IMG.new" "$TEST_IMG"
$QEMU_IO -c "read -P 0x00 0 1048576" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0x00 0 1048576" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

67
tests/qemu-iotests/051
View file

@ -45,7 +45,14 @@ _supported_os Linux
function do_run_qemu() function do_run_qemu()
{ {
echo Testing: "$@" echo Testing: "$@"
echo quit | $QEMU -nographic -monitor stdio -serial none "$@" (
if ! test -t 0; then
while read cmd; do
echo $cmd
done
fi
echo quit
) | $QEMU -nographic -monitor stdio -serial none "$@"
echo echo
} }
@ -57,26 +64,34 @@ function run_qemu()
size=128M size=128M
_make_test_img $size _make_test_img $size
cp $TEST_IMG $TEST_IMG.orig
mv $TEST_IMG $TEST_IMG.base
_make_test_img -b $TEST_IMG.base $size
echo echo
echo === Unknown option === echo === Unknown option ===
echo echo
run_qemu -drive file=$TEST_IMG,format=qcow2,unknown_opt= run_qemu -drive file="$TEST_IMG",format=qcow2,unknown_opt=
run_qemu -drive file=$TEST_IMG,format=qcow2,unknown_opt=on run_qemu -drive file="$TEST_IMG",format=qcow2,unknown_opt=on
run_qemu -drive file=$TEST_IMG,format=qcow2,unknown_opt=1234 run_qemu -drive file="$TEST_IMG",format=qcow2,unknown_opt=1234
run_qemu -drive file=$TEST_IMG,format=qcow2,unknown_opt=foo run_qemu -drive file="$TEST_IMG",format=qcow2,unknown_opt=foo
echo
echo === Overriding backing file ===
echo
echo "info block" | run_qemu -drive file=$TEST_IMG,driver=qcow2,backing.file.filename=$TEST_IMG.orig -nodefaults
echo echo
echo === Enable and disable lazy refcounting on the command line, plus some invalid values === echo === Enable and disable lazy refcounting on the command line, plus some invalid values ===
echo echo
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=on run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=on
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=off run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=off
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts= run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=42 run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=42
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=foo run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=foo
echo echo
@ -85,8 +100,8 @@ echo
_make_test_img -ocompat=0.10 $size _make_test_img -ocompat=0.10 $size
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=on run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=on
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=off run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=off
echo echo
echo === No medium === echo === No medium ===
@ -112,21 +127,21 @@ echo
echo === Read-only === echo === Read-only ===
echo echo
run_qemu -drive file=$TEST_IMG,if=floppy,readonly=on run_qemu -drive file="$TEST_IMG",if=floppy,readonly=on
run_qemu -drive file=$TEST_IMG,if=ide,media=cdrom,readonly=on run_qemu -drive file="$TEST_IMG",if=ide,media=cdrom,readonly=on
run_qemu -drive file=$TEST_IMG,if=scsi,media=cdrom,readonly=on run_qemu -drive file="$TEST_IMG",if=scsi,media=cdrom,readonly=on
run_qemu -drive file=$TEST_IMG,if=ide,readonly=on run_qemu -drive file="$TEST_IMG",if=ide,readonly=on
run_qemu -drive file=$TEST_IMG,if=virtio,readonly=on run_qemu -drive file="$TEST_IMG",if=virtio,readonly=on
run_qemu -drive file=$TEST_IMG,if=scsi,readonly=on run_qemu -drive file="$TEST_IMG",if=scsi,readonly=on
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device ide-cd,drive=disk run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-cd,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device lsi53c895a -device scsi-cd,drive=disk run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-cd,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device ide-drive,drive=disk run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-drive,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device ide-hd,drive=disk run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-hd,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device lsi53c895a -device scsi-disk,drive=disk run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-disk,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device lsi53c895a -device scsi-hd,drive=disk run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-hd,drive=disk
echo echo
echo === Cache modes === echo === Cache modes ===
@ -146,8 +161,8 @@ echo
echo === Specifying the protocol layer === echo === Specifying the protocol layer ===
echo echo
run_qemu -drive file=$TEST_IMG,file.driver=file run_qemu -drive file="$TEST_IMG",file.driver=file
run_qemu -drive file=$TEST_IMG,file.driver=qcow2 run_qemu -drive file="$TEST_IMG",file.driver=qcow2
echo echo
echo === Parsing protocol from file name === echo === Parsing protocol from file name ===

11
tests/qemu-iotests/051.out
View file

@ -1,5 +1,6 @@
QA output created by 051 QA output created by 051
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file='TEST_DIR/t.IMGFMT.base'
=== Unknown option === === Unknown option ===
@ -16,6 +17,16 @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,unknown_opt=foo
QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,unknown_opt=foo: could not open disk image TEST_DIR/t.qcow2: Block format 'qcow2' used by device 'ide0-hd0' doesn't support the option 'unknown_opt' QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,unknown_opt=foo: could not open disk image TEST_DIR/t.qcow2: Block format 'qcow2' used by device 'ide0-hd0' doesn't support the option 'unknown_opt'
=== Overriding backing file ===
Testing: -drive file=TEST_DIR/t.qcow2,driver=qcow2,backing.file.filename=TEST_DIR/t.qcow2.orig -nodefaults
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) iininfinfoinfo info binfo blinfo bloinfo blocinfo block
ide0-hd0: TEST_DIR/t.qcow2 (qcow2)
Backing file: TEST_DIR/t.qcow2.orig (chain depth: 1)
[not inserted](qemu) qququiquit
=== Enable and disable lazy refcounting on the command line, plus some invalid values === === Enable and disable lazy refcounting on the command line, plus some invalid values ===
Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=on Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=on

7
tests/qemu-iotests/052
View file

@ -41,6 +41,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
_supported_fmt generic _supported_fmt generic
_supported_proto generic _supported_proto generic
_supported_os Linux _supported_os Linux
_unsupported_qemu_io_options --nocache
size=128M size=128M
@ -48,12 +49,12 @@ _make_test_img $size
echo echo
echo "== reading whole image ==" echo "== reading whole image =="
$QEMU_IO -s -c "read 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -s -c "read 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== writing whole image does not modify image ==" echo "== writing whole image does not modify image =="
$QEMU_IO -s -c "write -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -s -c "write -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P 0 0 $size" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

10
tests/qemu-iotests/053
View file

@ -30,7 +30,7 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
rm -f $TEST_IMG.orig rm -f "$TEST_IMG.orig"
_cleanup_test_img _cleanup_test_img
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -47,13 +47,13 @@ echo
echo "== Creating single sector image ==" echo "== Creating single sector image =="
_make_test_img 512 _make_test_img 512
$QEMU_IO -c "write -P0xa 0 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P0xa 0 512" "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.orig mv "$TEST_IMG" "$TEST_IMG.orig"
echo echo
echo "== Converting the image, compressed ==" echo "== Converting the image, compressed =="
$QEMU_IMG convert -c -O $IMGFMT $TEST_IMG.orig $TEST_IMG $QEMU_IMG convert -c -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
_check_test_img _check_test_img
echo echo
@ -64,7 +64,7 @@ _img_info | grep '^virtual size:'
echo echo
echo "== Verifying the compressed image ==" echo "== Verifying the compressed image =="
$QEMU_IO -c "read -P0xa 0 512" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "read -P0xa 0 512" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

2
tests/qemu-iotests/054
View file

@ -49,7 +49,7 @@ _make_test_img $((1024*1024))T
echo echo
echo "creating too large image (1 EB) using qcow2.py" echo "creating too large image (1 EB) using qcow2.py"
_make_test_img 4G _make_test_img 4G
./qcow2.py $TEST_IMG set-header size $((1024 ** 6)) ./qcow2.py "$TEST_IMG" set-header size $((1024 ** 6))
_check_test_img _check_test_img
# success, all done # success, all done

11
tests/qemu-iotests/059
View file

@ -51,20 +51,25 @@ echo "=== Testing invalid granularity ==="
echo echo
_make_test_img 64M _make_test_img 64M
poke_file "$TEST_IMG" "$granularity_offset" "\xff\xff\xff\xff\xff\xff\xff\xff" poke_file "$TEST_IMG" "$granularity_offset" "\xff\xff\xff\xff\xff\xff\xff\xff"
{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir { $QEMU_IO -c "read 0 512" "$TEST_IMG"; } 2>&1 | _filter_qemu_io | _filter_testdir
echo "=== Testing too big L2 table size ===" echo "=== Testing too big L2 table size ==="
echo echo
_make_test_img 64M _make_test_img 64M
poke_file "$TEST_IMG" "$grain_table_size_offset" "\xff\xff\xff\xff" poke_file "$TEST_IMG" "$grain_table_size_offset" "\xff\xff\xff\xff"
{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir { $QEMU_IO -c "read 0 512" "$TEST_IMG"; } 2>&1 | _filter_qemu_io | _filter_testdir
echo "=== Testing too big L1 table size ===" echo "=== Testing too big L1 table size ==="
echo echo
_make_test_img 64M _make_test_img 64M
poke_file "$TEST_IMG" "$capacity_offset" "\xff\xff\xff\xff" poke_file "$TEST_IMG" "$capacity_offset" "\xff\xff\xff\xff"
poke_file "$TEST_IMG" "$grain_table_size_offset" "\x01\x00\x00\x00" poke_file "$TEST_IMG" "$grain_table_size_offset" "\x01\x00\x00\x00"
{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir { $QEMU_IO -c "read 0 512" "$TEST_IMG"; } 2>&1 | _filter_qemu_io | _filter_testdir
echo "=== Testing monolithicFlat creation and opening ==="
echo
IMGOPTS="subformat=monolithicFlat" _make_test_img 2G
$QEMU_IMG info $TEST_IMG | _filter_testdir
# success, all done # success, all done
echo "*** done" echo "*** done"

13
tests/qemu-iotests/059.out
View file

@ -3,18 +3,25 @@ QA output created by 059
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
invalid granularity, image may be corrupt invalid granularity, image may be corrupt
qemu-io: can't open device TEST_DIR/t.vmdk qemu-io: can't open device TEST_DIR/t.vmdk: Could not open 'TEST_DIR/t.vmdk': Wrong medium type
no file open, try 'help open' no file open, try 'help open'
=== Testing too big L2 table size === === Testing too big L2 table size ===
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
L2 table size too big L2 table size too big
qemu-io: can't open device TEST_DIR/t.vmdk qemu-io: can't open device TEST_DIR/t.vmdk: Could not open 'TEST_DIR/t.vmdk': Wrong medium type
no file open, try 'help open' no file open, try 'help open'
=== Testing too big L1 table size === === Testing too big L1 table size ===
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
L1 size too big L1 size too big
qemu-io: can't open device TEST_DIR/t.vmdk qemu-io: can't open device TEST_DIR/t.vmdk: Could not open 'TEST_DIR/t.vmdk': Wrong medium type
no file open, try 'help open' no file open, try 'help open'
=== Testing monolithicFlat creation and opening ===
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
image: TEST_DIR/t.vmdk
file format: vmdk
virtual size: 2.0G (2147483648 bytes)
disk size: 4.0K
*** done *** done

9
tests/qemu-iotests/061
View file

@ -200,6 +200,15 @@ $QEMU_IMG snapshot -a foo "$TEST_IMG"
_check_test_img _check_test_img
$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io $QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io
echo
echo "=== Testing preallocated zero expansion on full image ==="
echo
IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG" _make_test_img 64M
$QEMU_IO -c "write -P 0x2a 0 64M" "$TEST_IMG" -c "write -z 0 64M" | _filter_qemu_io
$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG"
_check_test_img
$QEMU_IO -c "read -P 0 0 64M" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"
rm -f $seq.full rm -f $seq.full

11
tests/qemu-iotests/061.out
View file

@ -373,4 +373,15 @@ read 131072/131072 bytes at offset 0
No errors were found on the image. No errors were found on the image.
read 131072/131072 bytes at offset 0 read 131072/131072 bytes at offset 0
128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
=== Testing preallocated zero expansion on full image ===
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
wrote 67108864/67108864 bytes at offset 0
64 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
wrote 67108864/67108864 bytes at offset 0
64 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
No errors were found on the image.
read 67108864/67108864 bytes at offset 0
64 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
*** done *** done

28
tests/qemu-iotests/063
View file

@ -32,7 +32,7 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm -f $TEST_IMG.orig $TEST_IMG.raw $TEST_IMG.raw2 rm -f "$TEST_IMG.orig" "$TEST_IMG.raw" "$TEST_IMG.raw2"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -49,47 +49,47 @@ _make_test_img 4M
echo "== Testing conversion with -n fails with no target file ==" echo "== Testing conversion with -n fails with no target file =="
# check .orig file does not exist # check .orig file does not exist
rm -f $TEST_IMG.orig rm -f "$TEST_IMG.orig"
if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n $TEST_IMG $TEST_IMG.orig >/dev/null 2>&1; then if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG.orig" >/dev/null 2>&1; then
exit 1 exit 1
fi fi
echo "== Testing conversion with -n succeeds with a target file ==" echo "== Testing conversion with -n succeeds with a target file =="
rm -f $TEST_IMG.orig rm -f "$TEST_IMG.orig"
cp $TEST_IMG $TEST_IMG.orig cp "$TEST_IMG" "$TEST_IMG.orig"
if ! $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n $TEST_IMG $TEST_IMG.orig ; then if ! $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG.orig" ; then
exit 1 exit 1
fi fi
echo "== Testing conversion to raw is the same after conversion with -n ==" echo "== Testing conversion to raw is the same after conversion with -n =="
# compare the raw files # compare the raw files
if ! $QEMU_IMG convert -f $IMGFMT -O raw $TEST_IMG $TEST_IMG.raw1 ; then if ! $QEMU_IMG convert -f $IMGFMT -O raw "$TEST_IMG" "$TEST_IMG.raw1" ; then
exit 1 exit 1
fi fi
if ! $QEMU_IMG convert -f $IMGFMT -O raw $TEST_IMG.orig $TEST_IMG.raw2 ; then if ! $QEMU_IMG convert -f $IMGFMT -O raw "$TEST_IMG.orig" "$TEST_IMG.raw2" ; then
exit 1 exit 1
fi fi
if ! cmp $TEST_IMG.raw1 $TEST_IMG.raw2 ; then if ! cmp "$TEST_IMG.raw1" "$TEST_IMG.raw2" ; then
exit 1 exit 1
fi fi
echo "== Testing conversion back to original format ==" echo "== Testing conversion back to original format =="
if ! $QEMU_IMG convert -f raw -O $IMGFMT -n $TEST_IMG.raw2 $TEST_IMG ; then if ! $QEMU_IMG convert -f raw -O $IMGFMT -n "$TEST_IMG.raw2" "$TEST_IMG" ; then
exit 1 exit 1
fi fi
_check_test_img _check_test_img
echo "== Testing conversion to a smaller file fails ==" echo "== Testing conversion to a smaller file fails =="
rm -f $TEST_IMG.orig rm -f "$TEST_IMG.orig"
mv $TEST_IMG $TEST_IMG.orig mv "$TEST_IMG" "$TEST_IMG.orig"
_make_test_img 2M _make_test_img 2M
if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n $TEST_IMG.orig $TEST_IMG >/dev/null 2>&1; then if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG.orig" "$TEST_IMG" >/dev/null 2>&1; then
exit 1 exit 1
fi fi
rm -f $TEST_IMG.orig $TEST_IMG.raw $TEST_IMG.raw2 rm -f "$TEST_IMG.orig" "$TEST_IMG.raw" "$TEST_IMG.raw2"
echo "*** done" echo "*** done"
rm -f $seq.full rm -f $seq.full

11
tests/qemu-iotests/common.config
View file

@ -125,6 +125,17 @@ fi
export TEST_DIR export TEST_DIR
if [ -z "$SAMPLE_IMG_DIR" ]; then
SAMPLE_IMG_DIR=`pwd`/sample_images
fi
if [ ! -d "$SAMPLE_IMG_DIR" ]; then
echo "common.config: Error: \$SAMPLE_IMG_DIR ($SAMPLE_IMG_DIR) is not a directory"
exit 1
fi
export SAMPLE_IMG_DIR
_readlink() _readlink()
{ {
if [ $# -ne 1 ]; then if [ $# -ne 1 ]; then

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

@ -91,6 +91,18 @@ _set_default_imgopts()
fi fi
} }
_use_sample_img()
{
SAMPLE_IMG_FILE="${1%\.bz2}"
TEST_IMG="$TEST_DIR/$SAMPLE_IMG_FILE"
bzcat "$SAMPLE_IMG_DIR/$1" > "$TEST_IMG"
if [ $? -ne 0 ]
then
echo "_use_sample_img error, cannot extract '$SAMPLE_IMG_DIR/$1'"
exit 1
fi
}
_make_test_img() _make_test_img()
{ {
# extra qemu-img options can be added by tests # extra qemu-img options can be added by tests
@ -152,20 +164,24 @@ _cleanup_test_img()
nbd) nbd)
kill $QEMU_NBD_PID kill $QEMU_NBD_PID
rm -f $TEST_IMG_FILE rm -f "$TEST_IMG_FILE"
;; ;;
file) file)
rm -f $TEST_DIR/t.$IMGFMT rm -f "$TEST_DIR/t.$IMGFMT"
rm -f $TEST_DIR/t.$IMGFMT.orig rm -f "$TEST_DIR/t.$IMGFMT.orig"
rm -f $TEST_DIR/t.$IMGFMT.base rm -f "$TEST_DIR/t.$IMGFMT.base"
if [ -n "$SAMPLE_IMG_FILE" ]
then
rm -f "$TEST_DIR/$SAMPLE_IMG_FILE"
fi
;; ;;
rbd) rbd)
rbd rm $TEST_DIR/t.$IMGFMT > /dev/null rbd rm "$TEST_DIR/t.$IMGFMT" > /dev/null
;; ;;
sheepdog) sheepdog)
collie vdi delete $TEST_DIR/t.$IMGFMT collie vdi delete "$TEST_DIR/t.$IMGFMT"
;; ;;
esac esac
@ -173,7 +189,7 @@ _cleanup_test_img()
_check_test_img() _check_test_img()
{ {
$QEMU_IMG check "$@" -f $IMGFMT $TEST_IMG 2>&1 | _filter_testdir | \ $QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1 | _filter_testdir | \
sed -e '/allocated.*fragmented.*compressed clusters/d' \ sed -e '/allocated.*fragmented.*compressed clusters/d' \
-e 's/qemu-img: This image format does not support checks/No errors were found on the image./' \ -e 's/qemu-img: This image format does not support checks/No errors were found on the image./' \
-e '/Image end offset: [0-9]\+/d' -e '/Image end offset: [0-9]\+/d'
@ -181,7 +197,7 @@ _check_test_img()
_img_info() _img_info()
{ {
$QEMU_IMG info "$@" $TEST_IMG 2>&1 | \ $QEMU_IMG info "$@" "$TEST_IMG" 2>&1 | \
sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \ sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
-e "s#$TEST_DIR#TEST_DIR#g" \ -e "s#$TEST_DIR#TEST_DIR#g" \
-e "s#$IMGFMT#IMGFMT#g" \ -e "s#$IMGFMT#IMGFMT#g" \

2
tests/qemu-iotests/iotests.py
View file

@ -21,7 +21,7 @@ import re
import subprocess import subprocess
import string import string
import unittest import unittest
import sys; sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'QMP')) import sys; sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'scripts', 'qmp'))
import qmp import qmp
import struct import struct

8
tests/qemu-iotests/sample_images/README Normal file
View file

@ -0,0 +1,8 @@
This is for small sample images to be used with qemu-iotests, intended for
non-native formats that QEMU supports for compatibility. The idea is to use
the native tool to create the sample image.
For instance, a VHDX image in this directory would be an image created not by
QEMU itself, but rather created by Hyper-V.
Sample images added here must be compressed with bzip2.