The following changes since commit f90ea7ba7c5ae7010ee0ce062207ae42530f57d6:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20171012' into staging (2017-10-12 17:06:50 +0100)

git://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to b867eaa17b3940760f51134e409cb0580dd3dde3:

block/throttle.c: add bdrv_co_drain_begin/end callbacks (2017-10-13 12:38:41 +0100)

Manos Pitsidianakis (3):

block: add bdrv_co_drain_end callback

block: rename bdrv_co_drain to bdrv_co_drain_begin

block/throttle.c: add bdrv_co_drain_begin/end callbacks

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

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

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

block/throttle.c | 18 ++++++++++++++++++

4 files changed, 65 insertions(+), 20 deletions(-)

2.13.6

From: Manos Pitsidianakis <el13635@mail.ntua.gr>

BlockDriverState has a bdrv_co_drain() callback but no equivalent for

the end of the drain. The throttle driver (block/throttle.c) needs a way

to mark the end of the drain in order to toggle io_limits_disabled

correctly, thus bdrv_co_drain_end is needed.

Signed-off-by: Manos Pitsidianakis <el13635@mail.ntua.gr>

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

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

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

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

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

2 files changed, 43 insertions(+), 16 deletions(-)

diff --git a/include/block/block_int.h b/include/block/block_int.h

--- a/include/block/block_int.h

+++ b/include/block/block_int.h

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

int (*bdrv_probe_geometry)(BlockDriverState *bs, HDGeometry *geo);

/**

- * Drain and stop any internal sources of requests in the driver, and

- * remain so until next I/O callback (e.g. bdrv_co_writev) is called.

+ * bdrv_co_drain is called if implemented in the beginning of a

+ * drain operation to drain and stop any internal sources of requests in

+ * the driver.

+ * bdrv_co_drain_end is called if implemented at the end of the drain.

+ *

+ * They should be used by the driver to e.g. manage scheduled I/O

+ * requests, or toggle an internal state. After the end of the drain new

+ * requests will continue normally.

*/

void coroutine_fn (*bdrv_co_drain)(BlockDriverState *bs);

+ void coroutine_fn (*bdrv_co_drain_end)(BlockDriverState *bs);

void (*bdrv_add_child)(BlockDriverState *parent, BlockDriverState *child,

Error **errp);

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 @@ typedef struct {

Coroutine *co;

bool done;

+ bool begin;

} BdrvCoDrainData;

static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)

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

BdrvCoDrainData *data = opaque;

BlockDriverState *bs = data->bs;

- bs->drv->bdrv_co_drain(bs);

+ if (data->begin) {

+ bs->drv->bdrv_co_drain(bs);

+ } else {

+ bs->drv->bdrv_co_drain_end(bs);

+ }

/* Set data->done before reading bs->wakeup. */

atomic_mb_set(&data->done, true);

bdrv_wakeup(bs);

-static void bdrv_drain_invoke(BlockDriverState *bs)

+static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)

{

- BdrvCoDrainData data = { .bs = bs, .done = false };

+ BdrvCoDrainData data = { .bs = bs, .done = false, .begin = begin};

- if (!bs->drv || !bs->drv->bdrv_co_drain) {

+ if (!bs->drv || (begin && !bs->drv->bdrv_co_drain) ||

+ (!begin && !bs->drv->bdrv_co_drain_end)) {

return;

}

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

BDRV_POLL_WHILE(bs, !data.done);

}

-static bool bdrv_drain_recurse(BlockDriverState *bs)

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

{

BdrvChild *child, *tmp;

bool waited;

- waited = BDRV_POLL_WHILE(bs, atomic_read(&bs->in_flight) > 0);

/* Ensure any pending metadata writes are submitted to bs->file. */

- bdrv_drain_invoke(bs);

+ bdrv_drain_invoke(bs, begin);

+

+ /* Wait for drained requests to finish */

+ waited = BDRV_POLL_WHILE(bs, atomic_read(&bs->in_flight) > 0);

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

BlockDriverState *bs = child->bs;

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

*/

bdrv_ref(bs);

}

- waited |= bdrv_drain_recurse(bs);

+ waited |= bdrv_drain_recurse(bs, begin);

if (in_main_loop) {

bdrv_unref(bs);

}

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

BlockDriverState *bs = data->bs;

bdrv_dec_in_flight(bs);

- bdrv_drained_begin(bs);

+ if (data->begin) {

+ bdrv_drained_begin(bs);

+ } else {

+ bdrv_drained_end(bs);

+ }

+

data->done = true;

aio_co_wake(co);

}

-static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs)

+static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,

+ bool begin)

BdrvCoDrainData data;

@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs)

.co = qemu_coroutine_self(),

.bs = bs,

.done = false,

+ .begin = begin,

};

bdrv_inc_in_flight(bs);

aio_bh_schedule_oneshot(bdrv_get_aio_context(bs),

@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs)

void bdrv_drained_begin(BlockDriverState *bs)

{

if (qemu_in_coroutine()) {

- bdrv_co_yield_to_drain(bs);

+ bdrv_co_yield_to_drain(bs, true);

return;

}

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

bdrv_parent_drained_begin(bs);

}

- bdrv_drain_recurse(bs);

+ bdrv_drain_recurse(bs, true);

void bdrv_drained_end(BlockDriverState *bs)

+ if (qemu_in_coroutine()) {

+ bdrv_co_yield_to_drain(bs, false);

+ return;

+ }

assert(bs->quiesce_counter > 0);

if (atomic_fetch_dec(&bs->quiesce_counter) > 1) {

return;

bdrv_parent_drained_end(bs);

+ bdrv_drain_recurse(bs, false);

aio_enable_external(bdrv_get_aio_context(bs));

}

@@ -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)) {

- waited |= bdrv_drain_recurse(bs);

+ waited |= bdrv_drain_recurse(bs, true);

}

}

aio_context_release(aio_context);

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

aio_context_acquire(aio_context);

aio_enable_external(aio_context);

bdrv_parent_drained_end(bs);

+ bdrv_drain_recurse(bs, false);

aio_context_release(aio_context);

2.13.6

From: Manos Pitsidianakis <el13635@mail.ntua.gr>

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

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

Signed-off-by: Manos Pitsidianakis <el13635@mail.ntua.gr>

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

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

---

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

block/io.c | 4 ++--

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

3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/block/block_int.h b/include/block/block_int.h

--- a/include/block/block_int.h

+++ b/include/block/block_int.h

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

int (*bdrv_probe_geometry)(BlockDriverState *bs, HDGeometry *geo);

/**

- * bdrv_co_drain is called if implemented in the beginning of a

+ * bdrv_co_drain_begin is called if implemented in the beginning of a

* drain operation to drain and stop any internal sources of requests in

* the driver.

* bdrv_co_drain_end is called if implemented at the end of the drain.

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

* requests, or toggle an internal state. After the end of the drain new

* requests will continue normally.

*/

- void coroutine_fn (*bdrv_co_drain)(BlockDriverState *bs);

+ void coroutine_fn (*bdrv_co_drain_begin)(BlockDriverState *bs);

void coroutine_fn (*bdrv_co_drain_end)(BlockDriverState *bs);

void (*bdrv_add_child)(BlockDriverState *parent, BlockDriverState *child,

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 coroutine_fn bdrv_drain_invoke_entry(void *opaque)

BlockDriverState *bs = data->bs;

if (data->begin) {

- bs->drv->bdrv_co_drain(bs);

+ bs->drv->bdrv_co_drain_begin(bs);

} else {

bs->drv->bdrv_co_drain_end(bs);

}

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

BdrvCoDrainData data = { .bs = bs, .done = false, .begin = begin};

- if (!bs->drv || (begin && !bs->drv->bdrv_co_drain) ||

+ if (!bs->drv || (begin && !bs->drv->bdrv_co_drain_begin) ||

(!begin && !bs->drv->bdrv_co_drain_end)) {

return;

}

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 @@ static bool qed_plug_allocating_write_reqs(BDRVQEDState *s)

assert(!s->allocating_write_reqs_plugged);

if (s->allocating_acb != NULL) {

/* Another allocating write came concurrently. This cannot happen

- * from bdrv_qed_co_drain, but it can happen when the timer runs.

+ * from bdrv_qed_co_drain_begin, but it can happen when the timer runs.

*/

qemu_co_mutex_unlock(&s->table_lock);

return false;

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

}

-static void coroutine_fn bdrv_qed_co_drain(BlockDriverState *bs)

+static void coroutine_fn bdrv_qed_co_drain_begin(BlockDriverState *bs)

{

BDRVQEDState *s = bs->opaque;

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_qed = {

.bdrv_check = bdrv_qed_check,

.bdrv_detach_aio_context = bdrv_qed_detach_aio_context,

.bdrv_attach_aio_context = bdrv_qed_attach_aio_context,

- .bdrv_co_drain = bdrv_qed_co_drain,

+ .bdrv_co_drain_begin = bdrv_qed_co_drain_begin,

static void bdrv_qed_init(void)

2.13.6

From: Manos Pitsidianakis <el13635@mail.ntua.gr>

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

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

Signed-off-by: Manos Pitsidianakis <el13635@mail.ntua.gr>

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

---

block/throttle.c | 18 ++++++++++++++++++

1 file changed, 18 insertions(+)

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

--- a/block/throttle.c

+++ b/block/throttle.c

@@ -XXX,XX +XXX,XX @@ static bool throttle_recurse_is_first_non_filter(BlockDriverState *bs,

return bdrv_recurse_is_first_non_filter(bs->file->bs, candidate);

+static void coroutine_fn throttle_co_drain_begin(BlockDriverState *bs)

+ ThrottleGroupMember *tgm = bs->opaque;

+ if (atomic_fetch_inc(&tgm->io_limits_disabled) == 0) {

+ throttle_group_restart_tgm(tgm);

+static void coroutine_fn throttle_co_drain_end(BlockDriverState *bs)

+{

+ ThrottleGroupMember *tgm = bs->opaque;

+ assert(tgm->io_limits_disabled);

+ atomic_dec(&tgm->io_limits_disabled);

+}

static BlockDriver bdrv_throttle = {

.format_name = "throttle",

.protocol_name = "throttle",

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_throttle = {

.bdrv_reopen_abort = throttle_reopen_abort,

.bdrv_co_get_block_status = bdrv_co_get_block_status_from_file,

+ .bdrv_co_drain_begin = throttle_co_drain_begin,

+ .bdrv_co_drain_end = throttle_co_drain_end,

.is_filter = true,

};

2.13.6