Merge remote-tracking branch 'kwolf/for-anthony' into staging
# 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:
commit
4235d77349
39
block.c
39
block.c
|
@ -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)) {
|
||||||
|
|
|
@ -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,
|
||||||
|
|
|
@ -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,
|
||||||
|
|
|
@ -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);
|
||||||
|
if (l2_table != NULL) {
|
||||||
qcow2_cache_put(bs, s->l2_table_cache, (void**) table);
|
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) {
|
||||||
|
if (!preallocated) {
|
||||||
qcow2_free_clusters(bs, offset, s->cluster_size,
|
qcow2_free_clusters(bs, offset, s->cluster_size,
|
||||||
QCOW2_DISCARD_ALWAYS);
|
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) {
|
||||||
|
if (!preallocated) {
|
||||||
qcow2_free_clusters(bs, offset, s->cluster_size,
|
qcow2_free_clusters(bs, offset, s->cluster_size,
|
||||||
QCOW2_DISCARD_ALWAYS);
|
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;
|
||||||
}
|
}
|
||||||
|
|
|
@ -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,
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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 */
|
||||||
|
|
|
@ -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,
|
||||||
|
|
|
@ -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,
|
||||||
|
|
|
@ -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,
|
||||||
|
|
|
@ -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,
|
||||||
|
|
|
@ -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) {
|
||||||
|
|
|
@ -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). */
|
||||||
|
|
|
@ -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
28
block/vpc.c
|
@ -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);
|
||||||
|
|
|
@ -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,
|
||||||
|
|
|
@ -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 */
|
||||||
|
|
|
@ -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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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"
|
||||||
|
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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) =="
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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 ===
|
||||||
|
|
|
@ -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) i[K[Din[K[D[Dinf[K[D[D[Dinfo[K[D[D[D[Dinfo [K[D[D[D[D[Dinfo b[K[D[D[D[D[D[Dinfo bl[K[D[D[D[D[D[D[Dinfo blo[K[D[D[D[D[D[D[D[Dinfo bloc[K[D[D[D[D[D[D[D[D[Dinfo block[K
|
||||||
|
ide0-hd0: TEST_DIR/t.qcow2 (qcow2)
|
||||||
|
Backing file: TEST_DIR/t.qcow2.orig (chain depth: 1)
|
||||||
|
[not inserted](qemu) q[K[Dqu[K[D[Dqui[K[D[D[Dquit[K
|
||||||
|
|
||||||
|
|
||||||
=== 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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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" \
|
||||||
|
|
|
@ -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
8
tests/qemu-iotests/sample_images/README
Normal 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.
|
Loading…
Reference in a new issue