The following changes since commit f58d9620aa4a514b1227074ff56eefd1334a6225:

Merge remote-tracking branch 'remotes/rth/tags/pull-dt-20180326' into staging (2018-03-27 10:27:34 +0100)

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

for you to fetch changes up to f5a53faad4bfbf1b86012a13055d2a1a774a42b6:

MAINTAINERS: add include/block/aio-wait.h (2018-03-27 13:05:48 +0100)

----------------------------------------------------------------

Stefan Hajnoczi (4):

queue: add QSIMPLEQ_PREPEND()

coroutine: avoid co_queue_wakeup recursion

coroutine: add test-aio coroutine queue chaining test case

MAINTAINERS: add include/block/aio-wait.h

MAINTAINERS | 1 +

include/qemu/coroutine_int.h | 1 -

include/qemu/queue.h | 8 ++++

block/io.c | 3 +-

tests/test-aio.c | 65 ++++++++++++++++++++-----

util/qemu-coroutine-lock.c | 34 -------------

util/qemu-coroutine.c | 110 +++++++++++++++++++++++--------------------

7 files changed, 121 insertions(+), 101 deletions(-)

2.14.3

The include/block/aio-wait.h header file was added by commit

7719f3c968c59e1bcda7e177679dc765b59e578f ("block: extract

AIO_WAIT_WHILE() from BlockDriverState") without updating MAINTAINERS.

MAINTAINERS | 1 +

1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS

--- a/MAINTAINERS

+++ b/MAINTAINERS

@@ -XXX,XX +XXX,XX @@ F: util/aio-*.c

F: block/io.c

F: migration/block*

F: include/block/aio.h

+F: include/block/aio-wait.h

F: scripts/qemugdb/aio.py

T: git git://github.com/stefanha/qemu.git block

2.14.3

Check that two coroutines can queue each other repeatedly without

hitting stack exhaustion.

Switch to qemu_init_main_loop() in main() because coroutines use

qemu_get_aio_context() - they don't know about test-aio's ctx variable.

Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>

Message-id: 20180322152834.12656-4-stefanha@redhat.com

tests/test-aio.c | 65 ++++++++++++++++++++++++++++++++++++++++++++------------

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

diff --git a/tests/test-aio.c b/tests/test-aio.c

--- a/tests/test-aio.c

+++ b/tests/test-aio.c

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

#include "qemu/timer.h"

#include "qemu/sockets.h"

#include "qemu/error-report.h"

+#include "qemu/coroutine.h"

+#include "qemu/main-loop.h"

static AioContext *ctx;

@@ -XXX,XX +XXX,XX @@ static void test_source_timer_schedule(void)

timer_del(&data.timer);

}

+/*

+ * Check that aio_co_enter() can chain many times

+ *

+ * Two coroutines should be able to invoke each other via aio_co_enter() many

+ * times without hitting a limit like stack exhaustion. In other words, the

+ * calls should be chained instead of nested.

+ */

+

+typedef struct {

+ Coroutine *other;

+ unsigned i;

+ unsigned max;

+} ChainData;

+

+static void coroutine_fn chain(void *opaque)

+{

+ ChainData *data = opaque;

+

+ for (data->i = 0; data->i < data->max; data->i++) {

+ /* Queue up the other coroutine... */

+ aio_co_enter(ctx, data->other);

+

+ /* ...and give control to it */

+ qemu_coroutine_yield();

+ }

+}

+

+static void test_queue_chaining(void)

+{

+ /* This number of iterations hit stack exhaustion in the past: */

+ ChainData data_a = { .max = 25000 };

+ ChainData data_b = { .max = 25000 };

+

+ data_b.other = qemu_coroutine_create(chain, &data_a);

+ data_a.other = qemu_coroutine_create(chain, &data_b);

+

+ qemu_coroutine_enter(data_b.other);

+

+ g_assert_cmpint(data_a.i, ==, data_a.max);

+ g_assert_cmpint(data_b.i, ==, data_b.max - 1);

+

+ /* Allow the second coroutine to terminate */

+ qemu_coroutine_enter(data_a.other);

+

+ g_assert_cmpint(data_b.i, ==, data_b.max);

+}

/* End of tests. */

2.14.3

qemu_aio_coroutine_enter() is (indirectly) called recursively when

processing co_queue_wakeup. This can lead to stack exhaustion.

This patch rewrites co_queue_wakeup in an iterative fashion (instead of

recursive) with bounded memory usage to prevent stack exhaustion.

qemu_co_queue_run_restart() is inlined into qemu_aio_coroutine_enter()

and the qemu_coroutine_enter() call is turned into a loop to avoid

recursion.

There is one change that is worth mentioning: Previously, when

coroutine A queued coroutine B, qemu_co_queue_run_restart() entered

coroutine B from coroutine A. If A was terminating then it would still

stay alive until B yielded. After this patch B is entered by A's parent

so that a A can be deleted immediately if it is terminating.

It is safe to make this change since B could never interact with A if it

was terminating anyway.

include/qemu/coroutine_int.h | 1 -

block/io.c | 3 +-

util/qemu-coroutine-lock.c | 34 -------------

util/qemu-coroutine.c | 110 +++++++++++++++++++++++--------------------

4 files changed, 60 insertions(+), 88 deletions(-)

diff --git a/include/qemu/coroutine_int.h b/include/qemu/coroutine_int.h

--- a/include/qemu/coroutine_int.h

+++ b/include/qemu/coroutine_int.h

@@ -XXX,XX +XXX,XX @@ Coroutine *qemu_coroutine_new(void);

void qemu_coroutine_delete(Coroutine *co);

CoroutineAction qemu_coroutine_switch(Coroutine *from, Coroutine *to,

CoroutineAction action);

-void coroutine_fn qemu_co_queue_run_restart(Coroutine *co);

#endif

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

--- a/block/io.c

+++ b/block/io.c

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

BdrvCoDrainData data;

/* Calling bdrv_drain() from a BH ensures the current coroutine yields and

- * other coroutines run if they were queued from

- * qemu_co_queue_run_restart(). */

+ * other coroutines run if they were queued by aio_co_enter(). */

assert(qemu_in_coroutine());

data = (BdrvCoDrainData) {

diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c

index XXXXXXX..XXXXXXX 100644

--- a/util/qemu-coroutine-lock.c

+++ b/util/qemu-coroutine-lock.c

@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_queue_wait_impl(CoQueue *queue, QemuLockable *lock)

}

2.14.3