The following changes since commit 4c8c1cc544dbd5e2564868e61c5037258e393832:

Merge remote-tracking branch 'remotes/vivier/tags/m68k-for-2.10-pull-request' into staging (2017-06-22 19:01:58 +0100)

for you to fetch changes up to 1512008812410ca4054506a7c44343088abdd977:

Merge remote-tracking branch 'mreitz/tags/pull-block-2017-06-23' into queue-block (2017-06-23 14:09:12 +0200)

Alberto Garcia (9):

throttle: Update throttle-groups.c documentation

qcow2: Remove unused Error variable in do_perform_cow()

qcow2: Use unsigned int for both members of Qcow2COWRegion

qcow2: Make perform_cow() call do_perform_cow() twice

qcow2: Split do_perform_cow() into _read(), _encrypt() and _write()

qcow2: Allow reading both COW regions with only one request

qcow2: Pass a QEMUIOVector to do_perform_cow_{read,write}()

qcow2: Merge the writing of the COW regions with the guest data

qcow2: Use offset_into_cluster() and offset_to_l2_index()

Kevin Wolf (37):

commit: Fix completion with extra reference

qemu-iotests: Allow starting new qemu after cleanup

qemu-iotests: Test exiting qemu with running job

doc: Document generic -blockdev options

doc: Document driver-specific -blockdev options

qed: Use bottom half to resume waiting requests

qed: Make qed_read_table() synchronous

qed: Remove callback from qed_read_table()

qed: Remove callback from qed_read_l2_table()

qed: Remove callback from qed_find_cluster()

qed: Make qed_read_backing_file() synchronous

qed: Make qed_copy_from_backing_file() synchronous

qed: Remove callback from qed_copy_from_backing_file()

qed: Make qed_write_header() synchronous

qed: Remove callback from qed_write_header()

qed: Make qed_write_table() synchronous

qed: Remove GenericCB

qed: Remove callback from qed_write_table()

qed: Make qed_aio_read_data() synchronous

qed: Make qed_aio_write_main() synchronous

qed: Inline qed_commit_l2_update()

qed: Add return value to qed_aio_write_l1_update()

qed: Add return value to qed_aio_write_l2_update()

qed: Add return value to qed_aio_write_main()

qed: Add return value to qed_aio_write_cow()

qed: Add return value to qed_aio_write_inplace/alloc()

qed: Add return value to qed_aio_read/write_data()

qed: Remove ret argument from qed_aio_next_io()

qed: Remove recursion in qed_aio_next_io()

qed: Implement .bdrv_co_readv/writev

qed: Use CoQueue for serialising allocations

qed: Simplify request handling

qed: Use a coroutine for need_check_timer

qed: Add coroutine_fn to I/O path functions

qed: Use bdrv_co_* for coroutine_fns

block: Remove bdrv_aio_readv/writev/flush()

Merge remote-tracking branch 'mreitz/tags/pull-block-2017-06-23' into queue-block

Manos Pitsidianakis (1):

block: change variable names in BlockDriverState

Max Reitz (3):

blkdebug: Catch bs->exact_filename overflow

blkverify: Catch bs->exact_filename overflow

block: Do not strcmp() with NULL uri->scheme

Stefan Hajnoczi (10):

block: count bdrv_co_rw_vmstate() requests

block: use BDRV_POLL_WHILE() in bdrv_rw_vmstate()

migration: avoid recursive AioContext locking in save_vmstate()

migration: use bdrv_drain_all_begin/end() instead bdrv_drain_all()

virtio-pci: use ioeventfd even when KVM is disabled

migration: hold AioContext lock for loadvm qemu_fclose()

qemu-iotests: 068: extract _qemu() function

qemu-iotests: 068: use -drive/-device instead of -hda

qemu-iotests: 068: test iothread mode

qemu-img: don't shadow opts variable in img_dd()

Stephen Bates (1):

nvme: Add support for Read Data and Write Data in CMBs.

sochin.jiang (1):

fix: avoid an infinite loop or a dangling pointer problem in img_commit

All functions that are marked coroutine_fn can directly call the

bdrv_co_* version of functions instead of going through the wrapper.

block/qed.c | 16 +++++++++-------

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

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

--- a/block/qed.c

+++ b/block/qed.c

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_write_header(BDRVQEDState *s)

};

qemu_iovec_init_external(&qiov, &iov, 1);

- ret = bdrv_preadv(s->bs->file, 0, &qiov);

+ ret = bdrv_co_preadv(s->bs->file, 0, qiov.size, &qiov, 0);

if (ret < 0) {

goto out;

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_write_header(BDRVQEDState *s)

/* Update header */

qed_header_cpu_to_le(&s->header, (QEDHeader *) buf);

- ret = bdrv_pwritev(s->bs->file, 0, &qiov);

+ ret = bdrv_co_pwritev(s->bs->file, 0, qiov.size, &qiov, 0);

if (ret < 0) {

goto out;

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_read_backing_file(BDRVQEDState *s, uint64_t pos,

qemu_iovec_concat(*backing_qiov, qiov, 0, size);

BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO);

- ret = bdrv_preadv(s->bs->backing, pos, *backing_qiov);

+ ret = bdrv_co_preadv(s->bs->backing, pos, size, *backing_qiov, 0);

if (ret < 0) {

return ret;

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,

}

BLKDBG_EVENT(s->bs->file, BLKDBG_COW_WRITE);

- ret = bdrv_pwritev(s->bs->file, offset, &qiov);

+ ret = bdrv_co_pwritev(s->bs->file, offset, qiov.size, &qiov, 0);

if (ret < 0) {

goto out;

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_aio_write_main(QEDAIOCB *acb)

trace_qed_aio_write_main(s, acb, 0, offset, acb->cur_qiov.size);

BLKDBG_EVENT(s->bs->file, BLKDBG_WRITE_AIO);

- ret = bdrv_pwritev(s->bs->file, offset, &acb->cur_qiov);

+ ret = bdrv_co_pwritev(s->bs->file, offset, acb->cur_qiov.size,

+ &acb->cur_qiov, 0);

if (ret < 0) {

return ret;

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_aio_write_main(QEDAIOCB *acb)

* region. The solution is to flush after writing a new data

* cluster and before updating the L2 table.

*/

- ret = bdrv_flush(s->bs->file->bs);

+ ret = bdrv_co_flush(s->bs->file->bs);

if (ret < 0) {

return ret;

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_aio_read_data(void *opaque, int ret,

}

BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);

- ret = bdrv_preadv(bs->file, offset, &acb->cur_qiov);

+ ret = bdrv_co_preadv(bs->file, offset, acb->cur_qiov.size,

+ &acb->cur_qiov, 0);

if (ret < 0) {

return ret;

}

1.8.3.1

From: Max Reitz <mreitz@redhat.com>

The bs->exact_filename field may not be sufficient to store the full

blkverify node filename. In this case, we should not generate a filename

at all instead of an unusable one.

Cc: qemu-stable@nongnu.org

Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>

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

Message-id: 20170613172006.19685-3-mreitz@redhat.com

Reviewed-by: Alberto Garcia <berto@igalia.com>

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

block/blkverify.c | 12 ++++++++----

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

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

--- a/block/blkverify.c

+++ b/block/blkverify.c

@@ -XXX,XX +XXX,XX @@ static void blkverify_refresh_filename(BlockDriverState *bs, QDict *options)

if (bs->file->bs->exact_filename[0]

&& s->test_file->bs->exact_filename[0])

{

- snprintf(bs->exact_filename, sizeof(bs->exact_filename),

- "blkverify:%s:%s",

- bs->file->bs->exact_filename,

- s->test_file->bs->exact_filename);

+ int ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),

+ "blkverify:%s:%s",

+ bs->file->bs->exact_filename,

+ s->test_file->bs->exact_filename);

+ if (ret >= sizeof(bs->exact_filename)) {

+ /* An overflow makes the filename unusable, so do not report any */

+ bs->exact_filename[0] = 0;

+ }

}

1.8.3.1

block/qed.c | 32 ++++++++++++--------------------

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

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

--- a/block/qed.c

+++ b/block/qed.c

@@ -XXX,XX +XXX,XX @@ int qed_write_header_sync(BDRVQEDState *s)

* This function only updates known header fields in-place and does not affect

* extra data after the QED header.

*/

-static void qed_write_header(BDRVQEDState *s, BlockCompletionFunc cb,

- void *opaque)

+static int qed_write_header(BDRVQEDState *s)

/* We must write full sectors for O_DIRECT but cannot necessarily generate

* the data following the header if an unrecognized compat feature is

@@ -XXX,XX +XXX,XX @@ static void qed_write_header(BDRVQEDState *s, BlockCompletionFunc cb,

ret = 0;

out:

qemu_vfree(buf);

- cb(opaque, ret);

+ return ret;

static uint64_t qed_max_image_size(uint32_t cluster_size, uint32_t table_size)

@@ -XXX,XX +XXX,XX @@ static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)

-static void qed_finish_clear_need_check(void *opaque, int ret)

-{

- /* Do nothing */

-}

-

-static void qed_flush_after_clear_need_check(void *opaque, int ret)

-{

- BDRVQEDState *s = opaque;

-

- bdrv_aio_flush(s->bs, qed_finish_clear_need_check, s);

-

- /* No need to wait until flush completes */

- qed_unplug_allocating_write_reqs(s);

-}

-

static void qed_clear_need_check(void *opaque, int ret)

{

BDRVQEDState *s = opaque;

@@ -XXX,XX +XXX,XX @@ static void qed_clear_need_check(void *opaque, int ret)

s->header.features &= ~QED_F_NEED_CHECK;

- qed_write_header(s, qed_flush_after_clear_need_check, s);

+ ret = qed_write_header(s);

+ (void) ret;

+

+ qed_unplug_allocating_write_reqs(s);

+

+ ret = bdrv_flush(s->bs);

+ (void) ret;

static void qed_need_check_timer_cb(void *opaque)

@@ -XXX,XX +XXX,XX @@ static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len)

{

BDRVQEDState *s = acb_to_s(acb);

BlockCompletionFunc *cb;

+ int ret;

/* Cancel timer when the first allocating request comes in */

if (QSIMPLEQ_EMPTY(&s->allocating_write_reqs)) {

@@ -XXX,XX +XXX,XX @@ static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len)

if (qed_should_set_need_check(s)) {

s->header.features |= QED_F_NEED_CHECK;

- qed_write_header(s, cb, acb);

+ ret = qed_write_header(s);

+ cb(acb, ret);

} else {

cb(acb, 0);

1.8.3.1

Now that we stay in coroutine context for the whole request when doing

reads or writes, we can add coroutine_fn annotations to many functions

that can do I/O or yield directly.

block/qed-cluster.c | 5 +++--

block/qed.c | 44 ++++++++++++++++++++++++--------------------

block/qed.h | 5 +++--

3 files changed, 30 insertions(+), 24 deletions(-)

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

--- a/block/qed-cluster.c

+++ b/block/qed-cluster.c

@@ -XXX,XX +XXX,XX @@ static unsigned int qed_count_contiguous_clusters(BDRVQEDState *s,

* On failure QED_CLUSTER_L2 or QED_CLUSTER_L1 is returned for missing L2 or L1

* table offset, respectively. len is number of contiguous unallocated bytes.

*/

-int qed_find_cluster(BDRVQEDState *s, QEDRequest *request, uint64_t pos,

- size_t *len, uint64_t *img_offset)

+int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,

+ uint64_t pos, size_t *len,

+ uint64_t *img_offset)

{

uint64_t l2_offset;

uint64_t offset = 0;

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qed.c

+++ b/block/qed.c

@@ -XXX,XX +XXX,XX @@ int qed_write_header_sync(BDRVQEDState *s)

* This function only updates known header fields in-place and does not affect

* extra data after the QED header.

*/

-static int qed_write_header(BDRVQEDState *s)

+static int coroutine_fn qed_write_header(BDRVQEDState *s)

{

/* We must write full sectors for O_DIRECT but cannot necessarily generate

* the data following the header if an unrecognized compat feature is

@@ -XXX,XX +XXX,XX @@ static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)

qemu_co_enter_next(&s->allocating_write_reqs);

}

-static void qed_need_check_timer_entry(void *opaque)

+static void coroutine_fn qed_need_check_timer_entry(void *opaque)

{

BDRVQEDState *s = opaque;

int ret;

@@ -XXX,XX +XXX,XX @@ static BDRVQEDState *acb_to_s(QEDAIOCB *acb)

* This function reads qiov->size bytes starting at pos from the backing file.

* If there is no backing file then zeroes are read.

*/

-static int qed_read_backing_file(BDRVQEDState *s, uint64_t pos,

- QEMUIOVector *qiov,

- QEMUIOVector **backing_qiov)

+static int coroutine_fn qed_read_backing_file(BDRVQEDState *s, uint64_t pos,

+ QEMUIOVector *qiov,

+ QEMUIOVector **backing_qiov)

{

uint64_t backing_length = 0;

size_t size;

@@ -XXX,XX +XXX,XX @@ static int qed_read_backing_file(BDRVQEDState *s, uint64_t pos,

* @len: Number of bytes

* @offset: Byte offset in image file

*/

-static int qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos,

- uint64_t len, uint64_t offset)

+static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,

+ uint64_t pos, uint64_t len,

+ uint64_t offset)

{

QEMUIOVector qiov;

QEMUIOVector *backing_qiov = NULL;

@@ -XXX,XX +XXX,XX @@ out:

* The cluster offset may be an allocated byte offset in the image file, the

* zero cluster marker, or the unallocated cluster marker.

*/

-static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index,

- unsigned int n, uint64_t cluster)

+static void coroutine_fn qed_update_l2_table(BDRVQEDState *s, QEDTable *table,

+ int index, unsigned int n,

+ uint64_t cluster)

{

int i;

for (i = index; i < index + n; i++) {

@@ -XXX,XX +XXX,XX @@ static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index,

}

}

-static void qed_aio_complete(QEDAIOCB *acb)

+static void coroutine_fn qed_aio_complete(QEDAIOCB *acb)

{

BDRVQEDState *s = acb_to_s(acb);

@@ -XXX,XX +XXX,XX @@ static void qed_aio_complete(QEDAIOCB *acb)

/**

* Update L1 table with new L2 table offset and write it out

*/

-static int qed_aio_write_l1_update(QEDAIOCB *acb)

+static int coroutine_fn qed_aio_write_l1_update(QEDAIOCB *acb)

{

BDRVQEDState *s = acb_to_s(acb);

CachedL2Table *l2_table = acb->request.l2_table;

@@ -XXX,XX +XXX,XX @@ static int qed_aio_write_l1_update(QEDAIOCB *acb)

/**

* Update L2 table with new cluster offsets and write them out

*/

-static int qed_aio_write_l2_update(QEDAIOCB *acb, uint64_t offset)

+static int coroutine_fn qed_aio_write_l2_update(QEDAIOCB *acb, uint64_t offset)

{

BDRVQEDState *s = acb_to_s(acb);

bool need_alloc = acb->find_cluster_ret == QED_CLUSTER_L1;

@@ -XXX,XX +XXX,XX @@ static int qed_aio_write_l2_update(QEDAIOCB *acb, uint64_t offset)

/**

* Write data to the image file

*/

-static int qed_aio_write_main(QEDAIOCB *acb)

+static int coroutine_fn qed_aio_write_main(QEDAIOCB *acb)

{

BDRVQEDState *s = acb_to_s(acb);

uint64_t offset = acb->cur_cluster +

@@ -XXX,XX +XXX,XX @@ static int qed_aio_write_main(QEDAIOCB *acb)

/**

* Populate untouched regions of new data cluster

*/

-static int qed_aio_write_cow(QEDAIOCB *acb)

+static int coroutine_fn qed_aio_write_cow(QEDAIOCB *acb)

{

BDRVQEDState *s = acb_to_s(acb);

uint64_t start, len, offset;

@@ -XXX,XX +XXX,XX @@ static bool qed_should_set_need_check(BDRVQEDState *s)

*

* This path is taken when writing to previously unallocated clusters.

*/

-static int qed_aio_write_alloc(QEDAIOCB *acb, size_t len)

+static int coroutine_fn qed_aio_write_alloc(QEDAIOCB *acb, size_t len)

{

BDRVQEDState *s = acb_to_s(acb);

int ret;

@@ -XXX,XX +XXX,XX @@ static int qed_aio_write_alloc(QEDAIOCB *acb, size_t len)

*

* This path is taken when writing to already allocated clusters.

*/

-static int qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len)

+static int coroutine_fn qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset,

+ size_t len)

{

/* Allocate buffer for zero writes */

if (acb->flags & QED_AIOCB_ZERO) {

@@ -XXX,XX +XXX,XX @@ static int qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len)

* @offset: Cluster offset in bytes

* @len: Length in bytes

*/

-static int qed_aio_write_data(void *opaque, int ret,

- uint64_t offset, size_t len)

+static int coroutine_fn qed_aio_write_data(void *opaque, int ret,

+ uint64_t offset, size_t len)

{

QEDAIOCB *acb = opaque;

@@ -XXX,XX +XXX,XX @@ static int qed_aio_write_data(void *opaque, int ret,

* @offset: Cluster offset in bytes

* @len: Length in bytes

*/

-static int qed_aio_read_data(void *opaque, int ret, uint64_t offset, size_t len)

+static int coroutine_fn qed_aio_read_data(void *opaque, int ret,

+ uint64_t offset, size_t len)

{

QEDAIOCB *acb = opaque;

BDRVQEDState *s = acb_to_s(acb);

@@ -XXX,XX +XXX,XX @@ static int qed_aio_read_data(void *opaque, int ret, uint64_t offset, size_t len)

/**

* Begin next I/O or complete the request

*/

-static int qed_aio_next_io(QEDAIOCB *acb)

+static int coroutine_fn qed_aio_next_io(QEDAIOCB *acb)

{

BDRVQEDState *s = acb_to_s(acb);

uint64_t offset;

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qed.h

+++ b/block/qed.h

@@ -XXX,XX +XXX,XX @@ int qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,

/**

* Cluster functions

*/

-int qed_find_cluster(BDRVQEDState *s, QEDRequest *request, uint64_t pos,

- size_t *len, uint64_t *img_offset);

+int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,

+ uint64_t pos, size_t *len,

+ uint64_t *img_offset);

/**

* Consistency check

1.8.3.1

When qemu is exited, all running jobs should be cancelled successfully.

This adds a test for this for all types of block jobs that currently

exist in qemu.

tests/qemu-iotests/185 | 206 +++++++++++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/185.out | 59 +++++++++++++

tests/qemu-iotests/group | 1 +

3 files changed, 266 insertions(+)

create mode 100755 tests/qemu-iotests/185

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

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

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/185

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

+#!/bin/bash

+#

+# Test exiting qemu while jobs are still running

+#

+# Copyright (C) 2017 Red Hat, Inc.

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program. If not, see <http://www.gnu.org/licenses/>.

+#

+

+# creator

+owner=kwolf@redhat.com

+

+seq=`basename $0`

+echo "QA output created by $seq"

+

+here=`pwd`

+status=1 # failure is the default!

+

+MIG_SOCKET="${TEST_DIR}/migrate"

+

+_cleanup()

+{

+ rm -f "${TEST_IMG}.mid"

+ rm -f "${TEST_IMG}.copy"

+ _cleanup_test_img

+ _cleanup_qemu

+}

+trap "_cleanup; exit \$status" 0 1 2 3 15

+

+# get standard environment, filters and checks

+. ./common.rc

+. ./common.filter

+. ./common.qemu

+

+_supported_fmt qcow2

+_supported_proto file

+_supported_os Linux

+

+size=64M

+TEST_IMG="${TEST_IMG}.base" _make_test_img $size

+

+echo

+echo === Starting VM ===

+echo

+

+qemu_comm_method="qmp"

+

+_launch_qemu \

+ -drive file="${TEST_IMG}.base",cache=$CACHEMODE,driver=$IMGFMT,id=disk

+h=$QEMU_HANDLE

+_send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'

+

+echo

+echo === Creating backing chain ===

+echo

+

+_send_qemu_cmd $h \

+ "{ 'execute': 'blockdev-snapshot-sync',

+ 'arguments': { 'device': 'disk',

+ 'snapshot-file': '$TEST_IMG.mid',

+ 'format': '$IMGFMT',

+ 'mode': 'absolute-paths' } }" \

+ "return"

+

+_send_qemu_cmd $h \

+ "{ 'execute': 'human-monitor-command',

+ 'arguments': { 'command-line':

+ 'qemu-io disk \"write 0 4M\"' } }" \

+ "return"

+

+_send_qemu_cmd $h \

+ "{ 'execute': 'blockdev-snapshot-sync',

+ 'arguments': { 'device': 'disk',

+ 'snapshot-file': '$TEST_IMG',

+ 'format': '$IMGFMT',

+ 'mode': 'absolute-paths' } }" \

+ "return"

+

+echo

+echo === Start commit job and exit qemu ===

+echo

+

+# Note that the reference output intentionally includes the 'offset' field in

+# BLOCK_JOB_CANCELLED events for all of the following block jobs. They are

+# predictable and any change in the offsets would hint at a bug in the job

+# throttling code.

+#

+# In order to achieve these predictable offsets, all of the following tests

+# use speed=65536. Each job will perform exactly one iteration before it has

+# to sleep at least for a second, which is plenty of time for the 'quit' QMP

+# command to be received (after receiving the command, the rest runs

+# synchronously, so jobs can arbitrarily continue or complete).

+#

+# The buffer size for commit and streaming is 512k (waiting for 8 seconds after

+# the first request), for active commit and mirror it's large enough to cover

+# the full 4M, and for backup it's the qcow2 cluster size, which we know is

+# 64k. As all of these are at least as large as the speed, we are sure that the

+# offset doesn't advance after the first iteration before qemu exits.

+

+_send_qemu_cmd $h \

+ "{ 'execute': 'block-commit',

+ 'arguments': { 'device': 'disk',

+ 'base':'$TEST_IMG.base',

+ 'top': '$TEST_IMG.mid',

+ 'speed': 65536 } }" \

+ "return"

+

+_send_qemu_cmd $h "{ 'execute': 'quit' }" "return"

+wait=1 _cleanup_qemu

+

+echo

+echo === Start active commit job and exit qemu ===

+echo

+

+_launch_qemu \

+ -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk

+h=$QEMU_HANDLE

+_send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'

+

+_send_qemu_cmd $h \

+ "{ 'execute': 'block-commit',

+ 'arguments': { 'device': 'disk',

+ 'base':'$TEST_IMG.base',

+ 'speed': 65536 } }" \

+ "return"

+

+_send_qemu_cmd $h "{ 'execute': 'quit' }" "return"

+wait=1 _cleanup_qemu

+

+echo

+echo === Start mirror job and exit qemu ===

+echo

+

+_launch_qemu \

+ -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk

+h=$QEMU_HANDLE

+_send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'

+

+_send_qemu_cmd $h \

+ "{ 'execute': 'drive-mirror',

+ 'arguments': { 'device': 'disk',

+ 'target': '$TEST_IMG.copy',

+ 'format': '$IMGFMT',

+ 'sync': 'full',

+ 'speed': 65536 } }" \

+ "return"

+

+_send_qemu_cmd $h "{ 'execute': 'quit' }" "return"

+wait=1 _cleanup_qemu

+

+echo

+echo === Start backup job and exit qemu ===

+echo

+

+_launch_qemu \

+ -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk

+h=$QEMU_HANDLE

+_send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'

+

+_send_qemu_cmd $h \

+ "{ 'execute': 'drive-backup',

+ 'arguments': { 'device': 'disk',

+ 'target': '$TEST_IMG.copy',

+ 'format': '$IMGFMT',

+ 'sync': 'full',

+ 'speed': 65536 } }" \

+ "return"

+

+_send_qemu_cmd $h "{ 'execute': 'quit' }" "return"

+wait=1 _cleanup_qemu

+

+echo

+echo === Start streaming job and exit qemu ===

+echo

+

+_launch_qemu \

+ -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk

+h=$QEMU_HANDLE

+_send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'

+

+_send_qemu_cmd $h \

+ "{ 'execute': 'block-stream',

+ 'arguments': { 'device': 'disk',

+ 'speed': 65536 } }" \

+ "return"

+

+_send_qemu_cmd $h "{ 'execute': 'quit' }" "return"

+wait=1 _cleanup_qemu

+

+_check_test_img

+

+# success, all done

+echo "*** done"

+rm -f $seq.full

+status=0

diff --git a/tests/qemu-iotests/185.out b/tests/qemu-iotests/185.out

+++ b/tests/qemu-iotests/185.out

+QA output created by 185

+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864

+=== Starting VM ===

+{"return": {}}

+=== Creating backing chain ===

+Formatting 'TEST_DIR/t.qcow2.mid', fmt=qcow2 size=67108864 backing_file=TEST_DIR/t.qcow2.base backing_fmt=qcow2 encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16

+{"return": {}}

+wrote 4194304/4194304 bytes at offset 0

+4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+{"return": ""}

+Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=67108864 backing_file=TEST_DIR/t.qcow2.mid backing_fmt=qcow2 encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16

+{"return": {}}

+=== Start commit job and exit qemu ===

+{"return": {}}

+{"return": {}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_CANCELLED", "data": {"device": "disk", "len": 67108864, "offset": 524288, "speed": 65536, "type": "commit"}}

+=== Start active commit job and exit qemu ===

+{"return": {}}

+{"return": {}}

+{"return": {}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_CANCELLED", "data": {"device": "disk", "len": 4194304, "offset": 4194304, "speed": 65536, "type": "commit"}}

+=== Start mirror job and exit qemu ===

+{"return": {}}

+Formatting 'TEST_DIR/t.qcow2.copy', fmt=qcow2 size=67108864 encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16

+{"return": {}}

+{"return": {}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_CANCELLED", "data": {"device": "disk", "len": 4194304, "offset": 4194304, "speed": 65536, "type": "mirror"}}

+=== Start backup job and exit qemu ===

+{"return": {}}

+Formatting 'TEST_DIR/t.qcow2.copy', fmt=qcow2 size=67108864 encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16

+{"return": {}}

+{"return": {}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_CANCELLED", "data": {"device": "disk", "len": 67108864, "offset": 65536, "speed": 65536, "type": "backup"}}

+=== Start streaming job and exit qemu ===

+{"return": {}}

+{"return": {}}

+{"return": {}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_CANCELLED", "data": {"device": "disk", "len": 67108864, "offset": 524288, "speed": 65536, "type": "stream"}}

+No errors were found on the image.

+*** done

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

--- a/tests/qemu-iotests/group

+++ b/tests/qemu-iotests/group

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

181 rw auto migration

182 rw auto quick

183 rw auto migration

+185 rw auto

1.8.3.1

This fixes the last place where we degraded from AIO to actual blocking

synchronous I/O requests. Putting it into a coroutine means that instead

of blocking, the coroutine simply yields while doing I/O.

block/qed.c | 33 +++++++++++++++++----------------

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

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

--- a/block/qed.c

+++ b/block/qed.c

@@ -XXX,XX +XXX,XX @@ static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)

qemu_co_enter_next(&s->allocating_write_reqs);

-static void qed_clear_need_check(void *opaque, int ret)

+static void qed_need_check_timer_entry(void *opaque)

BDRVQEDState *s = opaque;

+ int ret;

- if (ret) {

+ /* The timer should only fire when allocating writes have drained */

+ assert(!s->allocating_acb);

+

+ trace_qed_need_check_timer_cb(s);

+

+ qed_acquire(s);

+ qed_plug_allocating_write_reqs(s);

+

+ /* Ensure writes are on disk before clearing flag */

+ ret = bdrv_co_flush(s->bs->file->bs);

+ qed_release(s);

+ if (ret < 0) {

qed_unplug_allocating_write_reqs(s);

return;

@@ -XXX,XX +XXX,XX @@ static void qed_clear_need_check(void *opaque, int ret)

qed_unplug_allocating_write_reqs(s);

- ret = bdrv_flush(s->bs);

+ ret = bdrv_co_flush(s->bs);

(void) ret;

static void qed_need_check_timer_cb(void *opaque)

{

- BDRVQEDState *s = opaque;

-

- /* The timer should only fire when allocating writes have drained */

- assert(!s->allocating_acb);

-

- trace_qed_need_check_timer_cb(s);

-

- qed_acquire(s);

- qed_plug_allocating_write_reqs(s);

-

- /* Ensure writes are on disk before clearing flag */

- bdrv_aio_flush(s->bs->file->bs, qed_clear_need_check, s);

- qed_release(s);

+ Coroutine *co = qemu_coroutine_create(qed_need_check_timer_entry, opaque);

+ qemu_coroutine_enter(co);

void qed_acquire(BDRVQEDState *s)

1.8.3.1

Now that we're running in coroutine context, the ad-hoc serialisation

code (which drops a request that has to wait out of coroutine context)

can be replaced by a CoQueue.

This means that when we resume a serialised request, it is running in

coroutine context again and its I/O isn't blocking any more.

block/qed.c | 49 +++++++++++++++++--------------------------------

block/qed.h | 3 ++-

2 files changed, 19 insertions(+), 33 deletions(-)

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

--- a/block/qed.c

+++ b/block/qed.c

@@ -XXX,XX +XXX,XX @@ static void qed_plug_allocating_write_reqs(BDRVQEDState *s)

static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)

{

- QEDAIOCB *acb;

-

assert(s->allocating_write_reqs_plugged);

s->allocating_write_reqs_plugged = false;

-

- acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);

- if (acb) {

- qed_aio_start_io(acb);

- }

+ qemu_co_enter_next(&s->allocating_write_reqs);

static void qed_clear_need_check(void *opaque, int ret)

@@ -XXX,XX +XXX,XX @@ static void qed_need_check_timer_cb(void *opaque)

BDRVQEDState *s = opaque;

/* The timer should only fire when allocating writes have drained */

- assert(!QSIMPLEQ_FIRST(&s->allocating_write_reqs));

+ assert(!s->allocating_acb);

trace_qed_need_check_timer_cb(s);

@@ -XXX,XX +XXX,XX @@ static int bdrv_qed_do_open(BlockDriverState *bs, QDict *options, int flags,

int ret;

s->bs = bs;

- QSIMPLEQ_INIT(&s->allocating_write_reqs);

+ qemu_co_queue_init(&s->allocating_write_reqs);

ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header));

if (ret < 0) {

@@ -XXX,XX +XXX,XX @@ static void qed_aio_complete_bh(void *opaque)

qed_release(s);

}

-static void qed_resume_alloc_bh(void *opaque)

-{

- qed_aio_start_io(opaque);

-}

-

static void qed_aio_complete(QEDAIOCB *acb, int ret)

{

BDRVQEDState *s = acb_to_s(acb);

@@ -XXX,XX +XXX,XX @@ static void qed_aio_complete(QEDAIOCB *acb, int ret)

* next request in the queue. This ensures that we don't cycle through

* requests multiple times but rather finish one at a time completely.

*/

- if (acb == QSIMPLEQ_FIRST(&s->allocating_write_reqs)) {

- QEDAIOCB *next_acb;

- QSIMPLEQ_REMOVE_HEAD(&s->allocating_write_reqs, next);

- next_acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);

- if (next_acb) {

- aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),

- qed_resume_alloc_bh, next_acb);

+ if (acb == s->allocating_acb) {

+ s->allocating_acb = NULL;

+ if (!qemu_co_queue_empty(&s->allocating_write_reqs)) {

+ qemu_co_enter_next(&s->allocating_write_reqs);

} else if (s->header.features & QED_F_NEED_CHECK) {

qed_start_need_check_timer(s);

}