The following changes since commit af352675efb7e92a1f5f6461a042a12015ab3d12:

Merge remote-tracking branch 'remotes/aurel/tags/pull-target-sh4-20171218' into staging (2017-12-19 19:11:11 +0000)

are available in the git repository at:

for you to fetch changes up to b4d526c87b26aff6d8b353951aa175a1236ad887:

nvme: Add tracing (2017-12-20 11:05:49 +0100)

Block layer patches

Doug Gale (1):

nvme: Add tracing

Edgar Kaziakhmedov (1):

qcow2: get rid of qcow2_backing_read1 routine

Fam Zheng (1):

qemu-img: Document --force-share / -U

John Snow (1):

iotests: fix 197 for vpc

Kevin Wolf (9):

block: Formats don't need CONSISTENT_READ with NO_IO

block: Make bdrv_drain_invoke() recursive

block: Call .drain_begin only once in bdrv_drain_all_begin()

test-bdrv-drain: Test BlockDriver callbacks for drain

block: bdrv_drain_recurse(): Remove unused begin parameter

block: Don't wait for requests in bdrv_drain*_end()

block: Unify order in drain functions

block: Don't acquire AioContext in hmp_qemu_io()

block: Document that x-blockdev-change breaks quorum children list

From: Fam Zheng <famz@redhat.com>

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

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

Reviewed-by: Kashyap Chamarthy <kchamart@redhat.com>

qemu-img.texi | 9 +++++++++

1 file changed, 9 insertions(+)

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

--- a/qemu-img.texi

+++ b/qemu-img.texi

@@ -XXX,XX +XXX,XX @@ exclusive with the @var{-O} parameters. It is currently required to also use

the @var{-n} parameter to skip image creation. This restriction may be relaxed

in a future release.

+@item --force-share (-U)

+

+If specified, @code{qemu-img} will open the image with shared permissions,

+which makes it less likely to conflict with a running guest's permissions due

+to image locking. For example, this can be used to get the image information

+(with 'info' subcommand) when the image is used by a running guest. Note that

+this could produce inconsistent results because of concurrent metadata changes,

+etc. This option is only allowed when opening images in read-only mode.

+

@item fmt

is the disk image format. It is guessed automatically in most cases. See below

for a description of the supported disk formats.

2.13.6

Drain requests are propagated to child nodes, parent nodes and directly

to the AioContext. The order in which this happened was different

between all combinations of drain/drain_all and begin/end.

The correct order is to keep children only drained when their parents

are also drained. This means that at the start of a drained section, the

AioContext needs to be drained first, the parents second and only then

the children. The correct order for the end of a drained section is the

opposite.

This patch changes the three other functions to follow the example of

bdrv_drained_begin(), which is the only one that got it right.

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

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

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

@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)

return;

+ /* Stop things in parent-to-child order */

if (atomic_fetch_inc(&bs->quiesce_counter) == 0) {

aio_disable_external(bdrv_get_aio_context(bs));

bdrv_parent_drained_begin(bs);

@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)

return;

}

- bdrv_parent_drained_end(bs);

+ /* Re-enable things in child-to-parent order */

bdrv_drain_invoke(bs, false);

+ bdrv_parent_drained_end(bs);

aio_enable_external(bdrv_get_aio_context(bs));

2.13.6

bdrv_drain_all_begin() used to call the .bdrv_co_drain_begin() driver

callback inside its polling loop. This means that how many times it got

called for each node depended on long it had to poll the event loop.

This is obviously not right and results in nodes that stay drained even

after bdrv_drain_all_end(), which calls .bdrv_co_drain_begin() once per

node.

Fix bdrv_drain_all_begin() to call the callback only once, too.

Cc: qemu-stable@nongnu.org

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

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

---

block/io.c | 3 +--

1 file changed, 1 insertion(+), 2 deletions(-)

@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)

aio_context_acquire(aio_context);

bdrv_parent_drained_begin(bs);

aio_disable_external(aio_context);

+ bdrv_drain_invoke(bs, true);

aio_context_release(aio_context);

if (!g_slist_find(aio_ctxs, aio_context)) {

@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)

aio_context_acquire(aio_context);

for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {

if (aio_context == bdrv_get_aio_context(bs)) {

- /* FIXME Calling this multiple times is wrong */

- bdrv_drain_invoke(bs, true);

waited |= bdrv_drain_recurse(bs, true);

}

2.13.6

Commit 1f4ad7d fixed 'qemu-img info' for raw images that are currently

in use as a mirror target. It is not enough for image formats, though,

as these still unconditionally request BLK_PERM_CONSISTENT_READ.

As this permission is geared towards whether the guest-visible data is

consistent, and has no impact on whether the metadata is sane, and

'qemu-img info' does not read guest-visible data (except for the raw

format), it makes sense to not require BLK_PERM_CONSISTENT_READ if there

is not going to be any guest I/O performed, regardless of image format.

block.c | 6 +++++-

1 file changed, 5 insertions(+), 1 deletion(-)

@@ -XXX,XX +XXX,XX @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,

assert(role == &child_backing || role == &child_file);

if (!backing) {

+ int flags = bdrv_reopen_get_flags(reopen_queue, bs);

+

/* Apart from the modifications below, the same permissions are

* forwarded and left alone as for filters */

bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,

@@ -XXX,XX +XXX,XX @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,

/* bs->file always needs to be consistent because of the metadata. We

* can never allow other users to resize or write to it. */

- perm |= BLK_PERM_CONSISTENT_READ;

+ if (!(flags & BDRV_O_NO_IO)) {

+ perm |= BLK_PERM_CONSISTENT_READ;

+ }

shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);

/* We want consistent read from backing files if the parent needs it.

2.13.6

Commit 15afd94a047 added code to acquire and release the AioContext in

qemuio_command(). This means that the lock is taken twice now in the

call path from hmp_qemu_io(). This causes BDRV_POLL_WHILE() to hang for

any requests issued to nodes in a non-mainloop AioContext.

Dropping the first locking from hmp_qemu_io() fixes the problem.

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

hmp.c | 6 ------

1 file changed, 6 deletions(-)

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

--- a/hmp.c

+++ b/hmp.c

@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)

{

BlockBackend *blk;

BlockBackend *local_blk = NULL;

- AioContext *aio_context;

const char* device = qdict_get_str(qdict, "device");

const char* command = qdict_get_str(qdict, "command");

Error *err = NULL;

@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)

}

- aio_context = blk_get_aio_context(blk);

- aio_context_acquire(aio_context);

-

/*

* Notably absent: Proper permission management. This is sad, but it seems

* almost impossible to achieve without changing the semantics and thereby

@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)

*/

qemuio_command(blk, command);

- aio_context_release(aio_context);

-

fail:

blk_unref(local_blk);

hmp_handle_error(mon, &err);

2.13.6

Now that the bdrv_drain_invoke() calls are pulled up to the callers of

bdrv_drain_recurse(), the 'begin' parameter isn't needed any more.

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

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

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

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

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)

}

-static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)

+static bool bdrv_drain_recurse(BlockDriverState *bs)

{

BdrvChild *child, *tmp;

bool waited;

@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)

*/

bdrv_ref(bs);