The following changes since commit 0274f45bdef73283f2c213610f11d4e5dcba43b6:

Merge remote-tracking branch 'remotes/vivier2/tags/linux-user-for-4.1-pull-request' into staging (2019-07-19 09:44:43 +0100)

for you to fetch changes up to 49278ec065da3fbf90f7effcde3b39ac606b2e9e:

iotests: Test quitting with job on throttled node (2019-07-19 15:17:55 +0200)

Block layer patches:

- block: Fix forbidden use of polling in drained_end

- block: Don't wait for I/O throttling while exiting QEMU

- iotests: Use read-zeroes for the null driver to be Valgrind-friendly

Andrey Shinkevich (1):

iotests: Set read-zeroes on in null block driver for Valgrind

Max Reitz (12):

block: Introduce BdrvChild.parent_quiesce_counter

tests: Add job commit by drained_end test

block: Add @drained_end_counter

block: Make bdrv_parent_drained_[^_]*() static

tests: Lock AioContexts in test-block-iothread

block: Do not poll in bdrv_do_drained_end()

tests: Extend commit by drained_end test

block: Loop unsafely in bdrv*drained_end()

iotests: Add @has_quit to vm.shutdown()

iotests: Test commit with a filter on the chain

vl: Drain before (block) job cancel when quitting

iotests: Test quitting with job on throttled node

include/block/block.h | 42 ++++++++----

include/block/block_int.h | 15 ++++-

block.c | 52 ++++++++++-----

block/block-backend.c | 6 +-

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

blockjob.c | 2 +-

tests/test-bdrv-drain.c | 147 ++++++++++++++++++++++++++++++++++++++++

tests/test-block-iothread.c | 40 +++++++----

vl.c | 11 +++

python/qemu/machine.py | 5 +-

tests/qemu-iotests/040 | 40 ++++++++++-

tests/qemu-iotests/040.out | 4 +-

tests/qemu-iotests/051 | 10 +--

tests/qemu-iotests/051.pc.out | 10 +--

tests/qemu-iotests/093 | 9 +--

tests/qemu-iotests/136 | 1 +

tests/qemu-iotests/186 | 20 +++---

tests/qemu-iotests/186.out | 152 +++++++++++++++++++++---------------------

tests/qemu-iotests/218 | 55 ++++++++++++++-

tests/qemu-iotests/218.out | 4 ++

tests/qemu-iotests/227 | 4 +-

tests/qemu-iotests/227.out | 4 +-

tests/qemu-iotests/238 | 2 +-

tests/qemu-iotests/240 | 8 +--

tests/qemu-iotests/255 | 2 +-

25 files changed, 576 insertions(+), 203 deletions(-)

From: Max Reitz <mreitz@redhat.com>

These functions are not used outside of block/io.c, there is no reason

why they should be globally available.

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

include/block/block.h | 18 ------------------

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

2 files changed, 4 insertions(+), 22 deletions(-)

@@ -XXX,XX +XXX,XX @@ int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo);

void bdrv_io_plug(BlockDriverState *bs);

void bdrv_io_unplug(BlockDriverState *bs);

-/**

- * bdrv_parent_drained_begin:

- *

- * Begin a quiesced section of all users of @bs. This is part of

- * bdrv_drained_begin.

- */

-void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore,

- bool ignore_bds_parents);

-

/**

* bdrv_parent_drained_begin_single:

*

@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll);

*/

void bdrv_parent_drained_end_single(BdrvChild *c);

-/**

- * bdrv_parent_drained_end:

- *

- * End a quiesced section of all users of @bs. This is part of

- * bdrv_drained_end.

- */

-void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

- bool ignore_bds_parents);

-

/**

* bdrv_drain_poll:

*

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_parent_cb_resize(BlockDriverState *bs);

static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,

int64_t offset, int bytes, BdrvRequestFlags flags);

-void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore,

- bool ignore_bds_parents)

+static void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore,

+ bool ignore_bds_parents)

BdrvChild *c, *next;

@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_end_single(BdrvChild *c)

}

}

-void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

- bool ignore_bds_parents)

+static void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

+ bool ignore_bds_parents)

{

BdrvChild *c, *next;

2.20.1

From: Max Reitz <mreitz@redhat.com>

The graph must not change in these loops (or a QLIST_FOREACH_SAFE would

not even be enough). We now ensure this by only polling once in the

root bdrv_drained_end() call, so we can drop the _SAFE suffix. Doing so

makes it clear that the graph must not change.

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

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

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

@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

bool ignore_bds_parents,

int *drained_end_counter)

{

- BdrvChild *c, *next;

+ BdrvChild *c;

- QLIST_FOREACH_SAFE(c, &bs->parents, next_parent, next) {

+ QLIST_FOREACH(c, &bs->parents, next_parent) {

if (c == ignore || (ignore_bds_parents && c->role->parent_is_bds)) {

continue;

}

@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,

BdrvChild *parent, bool ignore_bds_parents,

int *drained_end_counter)

{

- BdrvChild *child, *next;

+ BdrvChild *child;

int old_quiesce_counter;

assert(drained_end_counter != NULL);

@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,

if (recursive) {

assert(!ignore_bds_parents);

bs->recursive_quiesce_counter--;

- QLIST_FOREACH_SAFE(child, &bs->children, next, next) {

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

bdrv_do_drained_end(child->bs, true, child, ignore_bds_parents,

drained_end_counter);

}

2.20.1

From: Max Reitz <mreitz@redhat.com>

Commit 5cb2737e925042e6c7cd3fb0b01313950b03cddf laid out why

bdrv_do_drained_end() must decrement the quiesce_counter after

bdrv_drain_invoke(). It did not give a very good reason why it has to

happen after bdrv_parent_drained_end(), instead only claiming symmetry

to bdrv_do_drained_begin().

It turns out that delaying it for so long is wrong.

Situation: We have an active commit job (i.e. a mirror job) from top to

base for the following graph:

filter

|

[file]

|

v

top --[backing]--> base

Now the VM is closed, which results in the job being cancelled and a

bdrv_drain_all() happening pretty much simultaneously.

Beginning the drain means the job is paused once whenever one of its

nodes is quiesced. This is reversed when the drain ends.

With how the code currently is, after base's drain ends (which means

that it will have unpaused the job once), its quiesce_counter remains at

1 while it goes to undrain its parents (bdrv_parent_drained_end()). For

some reason or another, undraining filter causes the job to be kicked

and enter mirror_exit_common(), where it proceeds to invoke

block_job_remove_all_bdrv().

Now base will be detached from the job. Because its quiesce_counter is

still 1, it will unpause the job once more. So in total, undraining

base will unpause the job twice. Eventually, this will lead to the

job's pause_count going negative -- well, it would, were there not an

assertion against this, which crashes qemu.

The general problem is that if in bdrv_parent_drained_end() we undrain

parent A, and then undrain parent B, which then leads to A detaching the

child, bdrv_replace_child_noperm() will undrain A as if we had not done

so yet; that is, one time too many.

It follows that we cannot decrement the quiesce_counter after invoking

bdrv_parent_drained_end().

Unfortunately, decrementing it before bdrv_parent_drained_end() would be

wrong, too. Imagine the above situation in reverse: Undraining A leads

to B detaching the child. If we had already decremented the

quiesce_counter by that point, bdrv_replace_child_noperm() would undrain

B one time too little; because it expects bdrv_parent_drained_end() to

issue this undrain. But bdrv_parent_drained_end() won't do that,

because B is no longer a parent.

Therefore, we have to do something else. This patch opts for

introducing a second quiesce_counter that counts how many times a

child's parent has been quiesced (though c->role->drained_*). With

that, bdrv_replace_child_noperm() just has to undrain the parent exactly

that many times when removing a child, and it will always be right.

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

include/block/block.h | 7 +++++++

include/block/block_int.h | 9 +++++++++

block.c | 15 +++++----------

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

4 files changed, 32 insertions(+), 13 deletions(-)

@@ -XXX,XX +XXX,XX @@ struct BdrvChild {

bool frozen;

+ /*

+ * How many times the parent of this child has been drained

+ * (through role->drained_*).

+ * Usually, this is equal to bs->quiesce_counter (potentially

+ * reduced by bdrv_drain_all_count). It may differ while the

+ * child is entering or leaving a drained section.

+ */

+ int parent_quiesce_counter;

+

QLIST_ENTRY(BdrvChild) next;

QLIST_ENTRY(BdrvChild) next_parent;

};

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,

if (child->role->detach) {

child->role->detach(child);

}

- if (old_bs->quiesce_counter && child->role->drained_end) {

- int num = old_bs->quiesce_counter;

- if (child->role->parent_is_bds) {

- num -= bdrv_drain_all_count;

- }

- assert(num >= 0);

- for (i = 0; i < num; i++) {

- child->role->drained_end(child);

- }

+ while (child->parent_quiesce_counter) {

+ bdrv_parent_drained_end_single(child);

}

QLIST_REMOVE(child, next_parent);

+ } else {

+ assert(child->parent_quiesce_counter == 0);

child->bs = new_bs;

if (new_bs) {

QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);

- if (new_bs->quiesce_counter && child->role->drained_begin) {

+ if (new_bs->quiesce_counter) {

int num = new_bs->quiesce_counter;

if (child->role->parent_is_bds) {

num -= bdrv_drain_all_count;

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

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore,

}

+void bdrv_parent_drained_end_single(BdrvChild *c)

+{

+ assert(c->parent_quiesce_counter > 0);

+ c->parent_quiesce_counter--;

+ if (c->role->drained_end) {

+ c->role->drained_end(c);

+ }

+}

+

void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

bool ignore_bds_parents)

{

@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

if (c == ignore || (ignore_bds_parents && c->role->parent_is_bds)) {

continue;

}

- if (c->role->drained_end) {

- c->role->drained_end(c);

- }

+ bdrv_parent_drained_end_single(c);

}

@@ -XXX,XX +XXX,XX @@ static bool bdrv_parent_drained_poll(BlockDriverState *bs, BdrvChild *ignore,

void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll)

{

+ c->parent_quiesce_counter++;

if (c->role->drained_begin) {

c->role->drained_begin(c);

}

2.20.1

From: Max Reitz <mreitz@redhat.com>

We should never poll anywhere in bdrv_do_drained_end() (including its

recursive callees like bdrv_drain_invoke()), because it does not cope

well with graph changes. In fact, it has been written based on the

postulation that no graph changes will happen in it.

Instead, the callers that want to poll must poll, i.e. all currently

globally available wrappers: bdrv_drained_end(),

bdrv_subtree_drained_end(), bdrv_unapply_subtree_drain(), and

bdrv_drain_all_end(). Graph changes there do not matter.

They can poll simply by passing a pointer to a drained_end_counter and

wait until it reaches 0.

This patch also adds a non-polling global wrapper for

bdrv_do_drained_end() that takes a drained_end_counter pointer. We need

such a variant because now no function called anywhere from

bdrv_do_drained_end() must poll. This includes

BdrvChildRole.drained_end(), which already must not poll according to

its interface documentation, but bdrv_child_cb_drained_end() just

violates that by invoking bdrv_drained_end() (which does poll).

Therefore, BdrvChildRole.drained_end() must take a *drained_end_counter

parameter, which bdrv_child_cb_drained_end() can pass on to the new

bdrv_drained_end_no_poll() function.

Note that we now have a pattern of all drained_end-related functions

either polling or receiving a *drained_end_counter to let the caller

poll based on that.

A problem with a single poll loop is that when the drained section in

bdrv_set_aio_context_ignore() ends, some nodes in the subgraph may be in

the old contexts, while others are in the new context already. To let

the collective poll in bdrv_drained_end() work correctly, we must not

hold a lock to the old context, so that the old context can make

progress in case it is different from the current context.

(In the process, remove the comment saying that the current context is

always the old context, because it is wrong.)

In all other places, all nodes in a subtree must be in the same context,

so we can just poll that. The exception of course is

bdrv_drain_all_end(), but that always runs in the main context, so we

can just poll NULL (like bdrv_drain_all_begin() does).

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

include/block/block.h | 25 ++++++++++++

include/block/block_int.h | 6 ++-

block.c | 37 ++++++++++++++----

block/block-backend.c | 6 +--

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

blockjob.c | 2 +-

6 files changed, 120 insertions(+), 36 deletions(-)

@@ -XXX,XX +XXX,XX @@ struct BdrvChildRole {

* These functions must not change the graph (and therefore also must not

* call aio_poll(), which could change the graph indirectly).

*

+ * If drained_end() schedules background operations, it must atomically

+ * increment *drained_end_counter for each such operation and atomically

+ * decrement it once the operation has settled.

+ *

* Note that this can be nested. If drained_begin() was called twice, new

* I/O is allowed only after drained_end() was called twice, too.

*/

void (*drained_begin)(BdrvChild *child);

- void (*drained_end)(BdrvChild *child);

+ void (*drained_end)(BdrvChild *child, int *drained_end_counter);

/*

* Returns whether the parent has pending requests for the child. This

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

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ static bool bdrv_child_cb_drained_poll(BdrvChild *child)

return bdrv_drain_poll(bs, false, NULL, false);

}

-static void bdrv_child_cb_drained_end(BdrvChild *child)

+static void bdrv_child_cb_drained_end(BdrvChild *child,

+ int *drained_end_counter)

{

BlockDriverState *bs = child->opaque;

- bdrv_drained_end(bs);

+ bdrv_drained_end_no_poll(bs, drained_end_counter);

}

static void bdrv_child_cb_attach(BdrvChild *child)

@@ -XXX,XX +XXX,XX @@ static void bdrv_attach_aio_context(BlockDriverState *bs,

void bdrv_set_aio_context_ignore(BlockDriverState *bs,

AioContext *new_context, GSList **ignore)

{

+ AioContext *old_context = bdrv_get_aio_context(bs);

+ AioContext *current_context = qemu_get_current_aio_context();

BdrvChild *child;

- if (bdrv_get_aio_context(bs) == new_context) {

+ if (old_context == new_context) {

return;

}

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

bdrv_detach_aio_context(bs);

- /* This function executes in the old AioContext so acquire the new one in

- * case it runs in a different thread.

- */

- aio_context_acquire(new_context);

+ /* Acquire the new context, if necessary */

+ if (current_context != new_context) {

+ aio_context_acquire(new_context);

+ }

+

bdrv_attach_aio_context(bs, new_context);

+

+ /*

+ * If this function was recursively called from

+ * bdrv_set_aio_context_ignore(), there may be nodes in the

+ * subtree that have not yet been moved to the new AioContext.

+ * Release the old one so bdrv_drained_end() can poll them.

+ */

+ if (current_context != old_context) {

+ aio_context_release(old_context);

+ }

+

bdrv_drained_end(bs);

- aio_context_release(new_context);

+

+ if (current_context != old_context) {

+ aio_context_acquire(old_context);

+ }

+ if (current_context != new_context) {

+ aio_context_release(new_context);

+ }

}

static bool bdrv_parent_can_set_aio_context(BdrvChild *c, AioContext *ctx,

@@ -XXX,XX +XXX,XX @@ static void blk_root_inherit_options(int *child_flags, QDict *child_options,

}

static void blk_root_drained_begin(BdrvChild *child);

static bool blk_root_drained_poll(BdrvChild *child);

-static void blk_root_drained_end(BdrvChild *child);

+static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter);

static void blk_root_change_media(BdrvChild *child, bool load);

static void blk_root_resize(BdrvChild *child);

@@ -XXX,XX +XXX,XX @@ int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf,

blk_root_drained_begin(blk->root);

ret = blk_pread(blk, offset, buf, count);

- blk_root_drained_end(blk->root);

+ blk_root_drained_end(blk->root, NULL);

return ret;

}

@@ -XXX,XX +XXX,XX @@ static bool blk_root_drained_poll(BdrvChild *child)

return !!blk->in_flight;

}

-static void blk_root_drained_end(BdrvChild *child)

+static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)

{

BlockBackend *blk = child->opaque;

assert(blk->quiesce_counter);

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

index XXXXXXX..XXXXXXX 100644

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore,

-void bdrv_parent_drained_end_single(BdrvChild *c)

+static void bdrv_parent_drained_end_single_no_poll(BdrvChild *c,

+ int *drained_end_counter)

assert(c->parent_quiesce_counter > 0);

c->parent_quiesce_counter--;

if (c->role->drained_end) {

- c->role->drained_end(c);

+ c->role->drained_end(c, drained_end_counter);

}

+void bdrv_parent_drained_end_single(BdrvChild *c)

+{

+ int drained_end_counter = 0;

+ bdrv_parent_drained_end_single_no_poll(c, &drained_end_counter);

+ BDRV_POLL_WHILE(c->bs, atomic_read(&drained_end_counter) > 0);

+}

+

static void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

- bool ignore_bds_parents)

+ bool ignore_bds_parents,

+ int *drained_end_counter)

{

BdrvChild *c, *next;

@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,

if (c == ignore || (ignore_bds_parents && c->role->parent_is_bds)) {

continue;

}

- bdrv_parent_drained_end_single(c);

+ bdrv_parent_drained_end_single_no_poll(c, drained_end_counter);

}

}

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

atomic_mb_set(&data->done, true);

bdrv_dec_in_flight(bs);

- if (data->drained_end_counter) {

+ if (!data->begin) {

atomic_dec(data->drained_end_counter);

}

- if (data->begin || data->drained_end_counter) {

- g_free(data);

- }

+ g_free(data);

}

/* Recursively call BlockDriver.bdrv_co_drain_begin/end callbacks */

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

.drained_end_counter = drained_end_counter,

};

- if (!begin && drained_end_counter) {

+ if (!begin) {

atomic_inc(drained_end_counter);

}

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

bdrv_inc_in_flight(bs);

data->co = qemu_coroutine_create(bdrv_drain_invoke_entry, data);

aio_co_schedule(bdrv_get_aio_context(bs), data->co);

-

- /*

- * TODO: Drop this and make callers pass @drained_end_counter and poll

- * themselves

- */

- if (!begin && !drained_end_counter) {

- BDRV_POLL_WHILE(bs, !data->done);

- g_free(data);

- }

}

/* Returns true if BDRV_POLL_WHILE() should go into a blocking aio_poll() */

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

}

bdrv_dec_in_flight(bs);

if (data->begin) {

+ assert(!data->drained_end_counter);

bdrv_do_drained_begin(bs, data->recursive, data->parent,

data->ignore_bds_parents, data->poll);

} else {

+ assert(!data->poll);

bdrv_do_drained_end(bs, data->recursive, data->parent,

data->ignore_bds_parents,

data->drained_end_counter);

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

bdrv_do_drained_begin(bs, true, NULL, false, true);

}

+/**

+ * This function does not poll, nor must any of its recursively called

+ * functions. The *drained_end_counter pointee will be incremented

+ * once for every background operation scheduled, and decremented once

+ * the operation settles. Therefore, the pointer must remain valid

+ * until the pointee reaches 0. That implies that whoever sets up the

+ * pointee has to poll until it is 0.

+ *

+ * We use atomic operations to access *drained_end_counter, because

+ * (1) when called from bdrv_set_aio_context_ignore(), the subgraph of

+ * @bs may contain nodes in different AioContexts,

+ * (2) bdrv_drain_all_end() uses the same counter for all nodes,

+ * regardless of which AioContext they are in.

+ */

static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,

BdrvChild *parent, bool ignore_bds_parents,

int *drained_end_counter)

@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,

BdrvChild *child, *next;

int old_quiesce_counter;

+ assert(drained_end_counter != NULL);

+

if (qemu_in_coroutine()) {

bdrv_co_yield_to_drain(bs, false, recursive, parent, ignore_bds_parents,

false, drained_end_counter);

@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,

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

bdrv_drain_invoke(bs, false, drained_end_counter);

- bdrv_parent_drained_end(bs, parent, ignore_bds_parents);

+ bdrv_parent_drained_end(bs, parent, ignore_bds_parents,

+ drained_end_counter);

old_quiesce_counter = atomic_fetch_dec(&bs->quiesce_counter);

if (old_quiesce_counter == 1) {

@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,

void bdrv_drained_end(BlockDriverState *bs)

{

- bdrv_do_drained_end(bs, false, NULL, false, NULL);

+ int drained_end_counter = 0;

+ bdrv_do_drained_end(bs, false, NULL, false, &drained_end_counter);

+ BDRV_POLL_WHILE(bs, atomic_read(&drained_end_counter) > 0);

+}

+

+void bdrv_drained_end_no_poll(BlockDriverState *bs, int *drained_end_counter)

+{

+ bdrv_do_drained_end(bs, false, NULL, false, drained_end_counter);