The following changes since commit 98b2faeaee96ab084d0b1669918688d8895c155f:

Merge remote-tracking branch 'remotes/jnsnow/tags/ide-pull-request' into staging (2017-02-10 18:07:02 +0000)

git://github.com/XanClic/qemu.git tags/pull-block-2017-02-12

for you to fetch changes up to 10d6eda1926804a09aa0710ca62933087813de0b:

qemu-img: Avoid setting ret to unused value in img_convert() (2017-02-12 00:56:32 +0100)

Daniel P. Berrange (1):

iotests: record separate timings per format,protocol pair

Dou Liyang (2):

block/qapi: reduce the coupling between the bdrv_query_stats and bdrv_query_bds_stats

block/qapi: reduce the execution time of qmp_query_blockstats

Fam Zheng (2):

qapi: Tweak error message of bdrv_query_image_info

iotests: Fix reference output for 059

Jeff Cody (3):

block: check full backing filename when searching protocol filenames

qemu-iotests: Don't create fifos / pidfiles with protocol paths

qemu-iotest: test to lookup protocol-based image with relative backing

Max Reitz (1):

qemu-img: Improve commit invalid base message

Nir Soffer (3):

qemu-io: Return non-zero exit code on failure

qemu-iotests: Add _unsupported_fmt helper

qemu-io: Add failure regression tests

Peter Lieven (2):

block/nfs: fix NULL pointer dereference in URI parsing

block/nfs: fix naming of runtime opts

From: Fam Zheng <famz@redhat.com>

@bs doesn't always have a device name, such as when it comes from

"qemu-img info". Report file name instead.

Signed-off-by: Fam Zheng <famz@redhat.com>

Message-id: 20170119130759.28319-2-famz@redhat.com

Reviewed-by: Eric Blake <eblake@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

block/qapi.c | 4 ++--

diff --git a/block/qapi.c b/block/qapi.c

--- a/block/qapi.c

+++ b/block/qapi.c

@@ -XXX,XX +XXX,XX @@ void bdrv_query_image_info(BlockDriverState *bs,

size = bdrv_getlength(bs);

if (size < 0) {

- error_setg_errno(errp, -size, "Can't get size of device '%s'",

- bdrv_get_device_name(bs));

+ error_setg_errno(errp, -size, "Can't get image size '%s'",

+ bs->exact_filename);

goto out;

}

2.11.0

From: QingFeng Hao <haoqf@linux.vnet.ibm.com>

If TEST_DIR is set to /tmp, test case 144 will fail. The reason is that

TEST_DIR resembles 144's test image name tmp.qcow2.

When 144 is testing $TEST_DIR/tmp.qcow2, it wants to replace

$TEST_DIR/tmp.qcow2 to TEST_DIR/tmp.qcow2, but actually it will fail

and get TEST_DIRTEST_DIR.qcow2 in this case.

The fix is just to modify the code to replace $TEST_DIR/ with TEST_DIR/.

Signed-off-by: QingFeng Hao <haoqf@linux.vnet.ibm.com>

Message-id: 20161216054723.96055-2-haoqf@linux.vnet.ibm.com

Reviewed-by: Eric Blake <eblake@redhat.com>

[mreitz: Fixed commit message and dropped superfluous escaping]

Signed-off-by: Max Reitz <mreitz@redhat.com>

tests/qemu-iotests/common.filter | 2 +-

diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter

--- a/tests/qemu-iotests/common.filter

+++ b/tests/qemu-iotests/common.filter

@@ -XXX,XX +XXX,XX @@ _filter_generated_node_ids()

# replace occurrences of the actual TEST_DIR value with TEST_DIR

_filter_testdir()

{

- sed -e "s#$TEST_DIR#TEST_DIR#g"

+ sed -e "s#$TEST_DIR/#TEST_DIR/#g"

}

# replace occurrences of the actual IMGFMT value with IMGFMT

2.11.0

From: Peter Maydell <peter.maydell@linaro.org>

Some of the argument parsing in qemu-img uses strtoul() to parse

integer arguments. This is tricky to get correct and in fact the

code does not get it right, because it assigns the result of

strtoul() to an 'int' variable and then tries to check for > INT_MAX.

Coverity correctly complains that the comparison is always false.

Rewrite to use qemu_strtoul(), which has a saner convention for

reporting conversion failures.

(Fixes CID 1356421, CID 1356422, CID 1356423.)

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

Message-id: 1486744104-15590-2-git-send-email-peter.maydell@linaro.org

Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

Signed-off-by: Max Reitz <mreitz@redhat.com>

qemu-img.c | 32 ++++++++++++++++----------------

1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/qemu-img.c b/qemu-img.c

--- a/qemu-img.c

+++ b/qemu-img.c

@@ -XXX,XX +XXX,XX @@ static int img_bench(int argc, char **argv)

break;

case 'c':

{

- char *end;

- errno = 0;

- count = strtoul(optarg, &end, 0);

- if (errno || *end || count > INT_MAX) {

+ unsigned long res;

+

+ if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

error_report("Invalid request count specified");

return 1;

}

+ count = res;

break;

}

case 'd':

{

- char *end;

- errno = 0;

- depth = strtoul(optarg, &end, 0);

- if (errno || *end || depth > INT_MAX) {

+ unsigned long res;

+

+ if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

error_report("Invalid queue depth specified");

return 1;

}

+ depth = res;

break;

}

case 'f':

@@ -XXX,XX +XXX,XX @@ static int img_bench(int argc, char **argv)

break;

case OPTION_PATTERN:

{

- char *end;

- errno = 0;

- pattern = strtoul(optarg, &end, 0);

- if (errno || *end || pattern > 0xff) {

+ unsigned long res;

+

+ if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {

error_report("Invalid pattern byte specified");

return 1;

}

+ pattern = res;

break;

}

case OPTION_FLUSH_INTERVAL:

{

- char *end;

- errno = 0;

- flush_interval = strtoul(optarg, &end, 0);

- if (errno || *end || flush_interval > INT_MAX) {

+ unsigned long res;

+

+ if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

error_report("Invalid flush interval specified");

return 1;

}

+ flush_interval = res;

break;

}

case OPTION_NO_DRAIN:

2.11.0

From: Peter Maydell <peter.maydell@linaro.org>

Coverity points out that we assign the return value from

bdrv_snapshot_load_tmp() to 'ret' in img_convert(), but then

never use that variable. (We check for failure by looking

at local_err instead.) Drop the unused assignment, bringing

the call into line with the following call to

bdrv_snapshot_laod_tmp_by_id_or_name().

(Fixes CID 1247240.)

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

Message-id: 1486744104-15590-3-git-send-email-peter.maydell@linaro.org

Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

Signed-off-by: Max Reitz <mreitz@redhat.com>

---

qemu-img.c | 8 ++++----

1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/qemu-img.c b/qemu-img.c

--- a/qemu-img.c

+++ b/qemu-img.c

@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)

if (sn_opts) {

- ret = bdrv_snapshot_load_tmp(bs[0],

- qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),

- qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),

- &local_err);

+ bdrv_snapshot_load_tmp(bs[0],

+ qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),

+ qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),

+ &local_err);

} else if (snapshot_name != NULL) {

if (bs_n > 1) {

error_report("No support for concatenating multiple snapshot");

2.11.0

From: Dou Liyang <douly.fnst@cn.fujitsu.com>

In order to reduce the execution time, this patch optimize

the qmp_query_blockstats():

Remove the next_query_bds function.

Remove the bdrv_query_stats function.

Remove some judgement sentence.

The original qmp_query_blockstats calls next_query_bds to get

the next objects in each loops. In the next_query_bds, it checks

the query_nodes and blk. It also call bdrv_query_stats to get

the stats, In the bdrv_query_stats, it checks blk and bs each

times. This waste more times, which may stall the main loop a

bit. And if the disk is too many and donot use the dataplane

feature, this may affect the performance in main loop thread.

This patch removes that two functions, and makes the structure

clearly.

Signed-off-by: Dou Liyang <douly.fnst@cn.fujitsu.com>

Message-id: 1484467275-27919-3-git-send-email-douly.fnst@cn.fujitsu.com

Reviewed-by: Markus Armbruster <armbru@redhat.com>

[mreitz: Removed duplicate info->value assignment]

Signed-off-by: Max Reitz <mreitz@redhat.com>

---

block/qapi.c | 73 ++++++++++++++++++++++++------------------------------------

1 file changed, 29 insertions(+), 44 deletions(-)

diff --git a/block/qapi.c b/block/qapi.c

--- a/block/qapi.c

+++ b/block/qapi.c

@@ -XXX,XX +XXX,XX @@ static BlockStats *bdrv_query_bds_stats(const BlockDriverState *bs,

return s;

-static BlockStats *bdrv_query_stats(BlockBackend *blk,

- const BlockDriverState *bs,

- bool query_backing)

- BlockStats *s;

- s = bdrv_query_bds_stats(bs, query_backing);

- if (blk) {

- s->has_device = true;

- s->device = g_strdup(blk_name(blk));

- bdrv_query_blk_stats(s->stats, blk);

BlockInfoList *qmp_query_block(Error **errp)

{

BlockInfoList *head = NULL, **p_next = &head;

@@ -XXX,XX +XXX,XX @@ BlockInfoList *qmp_query_block(Error **errp)

return head;

}

-static bool next_query_bds(BlockBackend **blk, BlockDriverState **bs,

- bool query_nodes)

- if (query_nodes) {

- *bs = bdrv_next_node(*bs);

- return !!*bs;

BlockStatsList *qmp_query_blockstats(bool has_query_nodes,

bool query_nodes,

Error **errp)

BlockStatsList *head = NULL, **p_next = &head;

- BlockBackend *blk = NULL;

- BlockDriverState *bs = NULL;

+ BlockBackend *blk;

+ BlockDriverState *bs;

/* Just to be safe if query_nodes is not always initialized */

- query_nodes = has_query_nodes && query_nodes;

- while (next_query_bds(&blk, &bs, query_nodes)) {

- BlockStatsList *info = g_malloc0(sizeof(*info));

- AioContext *ctx = blk ? blk_get_aio_context(blk)

- : bdrv_get_aio_context(bs);

+ if (has_query_nodes && query_nodes) {

+ for (bs = bdrv_next_node(NULL); bs; bs = bdrv_next_node(bs)) {

+ BlockStatsList *info = g_malloc0(sizeof(*info));

+ AioContext *ctx = bdrv_get_aio_context(bs);

- aio_context_acquire(ctx);

- info->value = bdrv_query_stats(blk, bs, !query_nodes);

- aio_context_release(ctx);

+ aio_context_acquire(ctx);

+ info->value = bdrv_query_bds_stats(bs, false);

+ aio_context_release(ctx);

- *p_next = info;

- p_next = &info->next;

+ *p_next = info;

+ p_next = &info->next;

+ }

+ } else {

+ for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {

+ BlockStatsList *info = g_malloc0(sizeof(*info));

+ AioContext *ctx = blk_get_aio_context(blk);

+ BlockStats *s;

+

+ aio_context_acquire(ctx);

+ s = bdrv_query_bds_stats(blk_bs(blk), true);

+ s->has_device = true;

+ s->device = g_strdup(blk_name(blk));

+ bdrv_query_blk_stats(s->stats, blk);

+ aio_context_release(ctx);

+

+ info->value = s;

+ *p_next = info;

+ p_next = &info->next;

+ }

}

return head;

2.11.0

From: Dou Liyang <douly.fnst@cn.fujitsu.com>

The bdrv_query_stats and bdrv_query_bds_stats functions need to call

each other, that increases the coupling. it also makes the program

complicated and makes some unnecessary tests.

Remove the call from bdrv_query_bds_stats to bdrv_query_stats, just

take some recursion to make it clearly.

Avoid testing whether the blk is NULL during querying the bds stats.

It is unnecessary.

Signed-off-by: Dou Liyang <douly.fnst@cn.fujitsu.com>

Message-id: 1484467275-27919-2-git-send-email-douly.fnst@cn.fujitsu.com

Reviewed-by: Markus Armbruster <armbru@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

block/qapi.c | 26 ++++++++++++++------------

1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/block/qapi.c b/block/qapi.c

--- a/block/qapi.c

+++ b/block/qapi.c

@@ -XXX,XX +XXX,XX @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,

qapi_free_BlockInfo(info);

}

-static BlockStats *bdrv_query_stats(BlockBackend *blk,

- const BlockDriverState *bs,

- bool query_backing);

-

static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)

{

BlockAcctStats *stats = blk_get_stats(blk);

@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)

-static void bdrv_query_bds_stats(BlockStats *s, const BlockDriverState *bs,

+static BlockStats *bdrv_query_bds_stats(const BlockDriverState *bs,

bool query_backing)

{

+ BlockStats *s = NULL;

+

+ s = g_malloc0(sizeof(*s));

+ s->stats = g_malloc0(sizeof(*s->stats));

+

+ if (!bs) {

+ return s;

+ }

+

if (bdrv_get_node_name(bs)[0]) {

s->has_node_name = true;

s->node_name = g_strdup(bdrv_get_node_name(bs));

@@ -XXX,XX +XXX,XX @@ static void bdrv_query_bds_stats(BlockStats *s, const BlockDriverState *bs,

if (bs->file) {

s->has_parent = true;

- s->parent = bdrv_query_stats(NULL, bs->file->bs, query_backing);

+ s->parent = bdrv_query_bds_stats(bs->file->bs, query_backing);

if (query_backing && bs->backing) {

s->has_backing = true;

- s->backing = bdrv_query_stats(NULL, bs->backing->bs, query_backing);

+ s->backing = bdrv_query_bds_stats(bs->backing->bs, query_backing);

}

+ return s;

}

static BlockStats *bdrv_query_stats(BlockBackend *blk,

@@ -XXX,XX +XXX,XX @@ static BlockStats *bdrv_query_stats(BlockBackend *blk,

{

BlockStats *s;

- s = g_malloc0(sizeof(*s));

- s->stats = g_malloc0(sizeof(*s->stats));

+ s = bdrv_query_bds_stats(bs, query_backing);

if (blk) {

s->has_device = true;

s->device = g_strdup(blk_name(blk));

bdrv_query_blk_stats(s->stats, blk);

}

- if (bs) {

- bdrv_query_bds_stats(s, bs, query_backing);

- }

return s;

}

2.11.0

Passing a request size larger than BDRV_REQUEST_MAX_BYTES to any of the

I/O commands results in an error. While 'read' and 'write' handle the

error correctly, 'aio_read' and 'aio_write' hit an assertion:

blk_aio_read_entry: Assertion `rwco->qiov->size == acb->bytes' failed.

The reason is that the QEMU I/O code cannot handle request sizes

larger than BDRV_REQUEST_MAX_BYTES, so this patch makes qemu-io check

that all values are within range.

Message-id: 79f66648c685929a144396bda24d13a207131dcf.1485878688.git.berto@igalia.com

[mreitz: Use BDRV_REQUEST_MAX_BYTES instead of INT_MAX]

Signed-off-by: Max Reitz <mreitz@redhat.com>

qemu-io-cmds.c | 20 +++++++++++++-------

1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c

--- a/qemu-io-cmds.c

+++ b/qemu-io-cmds.c

@@ -XXX,XX +XXX,XX @@ create_iovec(BlockBackend *blk, QEMUIOVector *qiov, char **argv, int nr_iov,

goto fail;

- if (len > SIZE_MAX) {

- printf("Argument '%s' exceeds maximum size %llu\n", arg,

- (unsigned long long)SIZE_MAX);

+ if (len > BDRV_REQUEST_MAX_BYTES) {

+ printf("Argument '%s' exceeds maximum size %" PRIu64 "\n", arg,

+ (uint64_t)BDRV_REQUEST_MAX_BYTES);

+ goto fail;

+ if (count > BDRV_REQUEST_MAX_BYTES - len) {

+ printf("The total number of bytes exceed the maximum size %" PRIu64

+ "\n", (uint64_t)BDRV_REQUEST_MAX_BYTES);

goto fail;

}

@@ -XXX,XX +XXX,XX @@ static int read_f(BlockBackend *blk, int argc, char **argv)

if (count < 0) {

print_cvtnum_err(count, argv[optind]);

return 0;

- } else if (count > SIZE_MAX) {

+ } else if (count > BDRV_REQUEST_MAX_BYTES) {

printf("length cannot exceed %" PRIu64 ", given %s\n",

- (uint64_t) SIZE_MAX, argv[optind]);

+ (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]);

return 0;

}

@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)

if (count < 0) {

print_cvtnum_err(count, argv[optind]);

return 0;

- } else if (count > SIZE_MAX) {

+ } else if (count > BDRV_REQUEST_MAX_BYTES) {

printf("length cannot exceed %" PRIu64 ", given %s\n",

- (uint64_t) SIZE_MAX, argv[optind]);

+ (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]);

return 0;

}

2.11.0

From: Nir Soffer <nirsof@gmail.com>

This helper allows adding tests supporting any format expect the

specified formats. This may be useful to test that many formats behave

in a common way.

Signed-off-by: Nir Soffer <nirsof@gmail.com>

Message-id: 20170201003120.23378-3-nirsof@gmail.com

Reviewed-by: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

---

tests/qemu-iotests/common.rc | 11 +++++++++++

1 file changed, 11 insertions(+)

diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc

--- a/tests/qemu-iotests/common.rc

+++ b/tests/qemu-iotests/common.rc

@@ -XXX,XX +XXX,XX @@ _supported_fmt()

_notrun "not suitable for this image format: $IMGFMT"

+# tests whether $IMGFMT is one of the unsupported image format for a test

+#

+_unsupported_fmt()

+ for f; do

+ if [ "$f" = "$IMGFMT" ]; then

+ _notrun "not suitable for this image format: $IMGFMT"

+ fi

+ done

# tests whether $IMGPROTO is one of the supported image protocols for a test

#

_supported_proto()

2.11.0

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Current implementation invalidates firstly parent bds and then its

children. This leads to the following bug:

after incoming migration, in bdrv_invalidate_cache_all:

1. invalidate parent bds - reopen it with BDRV_O_INACTIVE cleared

2. child is not yet invalidated

3. parent check that its BDRV_O_INACTIVE is cleared

4. parent writes to child

5. assert in bdrv_co_pwritev, as BDRV_O_INACTIVE is set for child

This patch fixes it by just changing invalidate sequence: invalidate

children first.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Message-id: 20170131112308.54189-1-vsementsov@virtuozzo.com

Reviewed-by: Max Reitz <mreitz@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

---

block.c | 11 +++++------

1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/block.c b/block.c

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)

if (!(bs->open_flags & BDRV_O_INACTIVE)) {

return;

- bs->open_flags &= ~BDRV_O_INACTIVE;

- if (bs->drv->bdrv_invalidate_cache) {

- bs->drv->bdrv_invalidate_cache(bs, &local_err);

+ QLIST_FOREACH(child, &bs->children, next) {

+ bdrv_invalidate_cache(child->bs, &local_err);

if (local_err) {

- bs->open_flags |= BDRV_O_INACTIVE;

error_propagate(errp, local_err);

return;

}

2.11.0

The metadata overlap checks introduced in a40f1c2add help detect

corruption in the qcow2 image by verifying that data writes don't

overlap with existing metadata sections.

The 'refcount-block' check in particular iterates over the refcount

table in order to get the addresses of all refcount blocks and check

that none of them overlap with the region where we want to write.

The problem with the refcount table is that since it always occupies

complete clusters its size is usually very big. With the default

values of cluster_size=64KB and refcount_bits=16 this table holds 8192

entries, each one of them enough to map 2GB worth of host clusters.

So unless we're using images with several TB of allocated data this

table is going to be mostly empty, and iterating over it is a waste of

CPU. If the storage backend is fast enough this can have an effect on

I/O performance.

This patch keeps the index of the last used (i.e. non-zero) entry in

the refcount table and updates it every time the table changes. The

refcount-block overlap check then uses that index instead of reading

the whole table.

In my tests with a 4GB qcow2 file stored in RAM this doubles the

amount of write IOPS.

Message-id: 20170201123828.4815-1-berto@igalia.com

Reviewed-by: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

block/qcow2.h | 1 +

block/qcow2-refcount.c | 24 +++++++++++++++++++++++-

block/qcow2.c | 1 +

3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/block/qcow2.h b/block/qcow2.h

--- a/block/qcow2.h

+++ b/block/qcow2.h

@@ -XXX,XX +XXX,XX @@ typedef struct BDRVQcow2State {

uint64_t *refcount_table;

uint64_t refcount_table_offset;

uint32_t refcount_table_size;

+ uint32_t max_refcount_table_index; /* Last used entry in refcount_table */

uint64_t free_cluster_index;

uint64_t free_byte_offset;

diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2-refcount.c

+++ b/block/qcow2-refcount.c

@@ -XXX,XX +XXX,XX @@ static Qcow2SetRefcountFunc *const set_refcount_funcs[] = {

/*********************************************************/

/* refcount handling */

+static void update_max_refcount_table_index(BDRVQcow2State *s)

+{

+ unsigned i = s->refcount_table_size - 1;

+ while (i > 0 && (s->refcount_table[i] & REFT_OFFSET_MASK) == 0) {

+ i--;

+ }

+ /* Set s->max_refcount_table_index to the index of the last used entry */

+ s->max_refcount_table_index = i;

+}

+

int qcow2_refcount_init(BlockDriverState *bs)

{

BDRVQcow2State *s = bs->opaque;

@@ -XXX,XX +XXX,XX @@ int qcow2_refcount_init(BlockDriverState *bs)

for(i = 0; i < s->refcount_table_size; i++)

be64_to_cpus(&s->refcount_table[i]);

+ update_max_refcount_table_index(s);

}

return 0;

fail:

@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,

}

s->refcount_table[refcount_table_index] = new_block;

+ /* If there's a hole in s->refcount_table then it can happen

+ * that refcount_table_index < s->max_refcount_table_index */

+ s->max_refcount_table_index =

+ MAX(s->max_refcount_table_index, refcount_table_index);

/* The new refcount block may be where the caller intended to put its

* data, so let it restart the search. */

@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,

s->refcount_table = new_table;

s->refcount_table_size = table_size;

s->refcount_table_offset = table_offset;

+ update_max_refcount_table_index(s);

/* Free old table. */

qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t),

@@ -XXX,XX +XXX,XX @@ write_refblocks:

s->refcount_table = on_disk_reftable;

s->refcount_table_offset = reftable_offset;

s->refcount_table_size = reftable_size;

+ update_max_refcount_table_index(s);

return 0;

@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,

}

if ((chk & QCOW2_OL_REFCOUNT_BLOCK) && s->refcount_table) {

- for (i = 0; i < s->refcount_table_size; i++) {

+ unsigned last_entry = s->max_refcount_table_index;

+ assert(last_entry < s->refcount_table_size);

+ assert(last_entry + 1 == s->refcount_table_size ||

+ (s->refcount_table[last_entry + 1] & REFT_OFFSET_MASK) == 0);

+ for (i = 0; i <= last_entry; i++) {

if ((s->refcount_table[i] & REFT_OFFSET_MASK) &&

overlaps_with(s->refcount_table[i] & REFT_OFFSET_MASK,

s->cluster_size)) {

@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,

/* Now update the rest of the in-memory information */

old_reftable = s->refcount_table;

s->refcount_table = new_reftable;

+ update_max_refcount_table_index(s);

s->refcount_bits = 1 << refcount_order;

s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);

@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)

s->refcount_table_offset = s->cluster_size;

s->refcount_table_size = s->cluster_size / sizeof(uint64_t);

+ s->max_refcount_table_index = 0;

g_free(s->refcount_table);

s->refcount_table = new_reftable;

2.11.0

From: Nir Soffer <nirsof@gmail.com>

Add regression tests checking that qemu-io fails with non-zero exit code

when reading non-existing file or using the wrong image format.

Signed-off-by: Nir Soffer <nirsof@gmail.com>

Message-id: 20170201003120.23378-4-nirsof@gmail.com

Reviewed-by: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

tests/qemu-iotests/174 | 59 ++++++++++++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/174.out | 7 ++++++

tests/qemu-iotests/group | 1 +

3 files changed, 67 insertions(+)

create mode 100755 tests/qemu-iotests/174

create mode 100644 tests/qemu-iotests/174.out

diff --git a/tests/qemu-iotests/174 b/tests/qemu-iotests/174

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/174

@@ -XXX,XX +XXX,XX @@

+#!/bin/bash

+#

+# Test that qemu-io fail with non-zero exit code

+#