The following changes since commit d147f7e815f97cb477e223586bcb80c316ae10ea:

Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream' into staging (2017-10-03 16:27:24 +0100)

are available in the git repository at:

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

for you to fetch changes up to f708a5e71cba0d784e307334c07ade5f56f827ab:

aio: fix assert when remove poll during destroy (2017-10-03 14:36:19 -0400)

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

Peter Xu (4):

qom: provide root container for internal objs

iothread: provide helpers for internal use

iothread: export iothread_stop()

iothread: delay the context release to finalize

Stefan Hajnoczi (1):

aio: fix assert when remove poll during destroy

include/qom/object.h | 11 +++++++++++

include/sysemu/iothread.h | 9 +++++++++

iothread.c | 46 ++++++++++++++++++++++++++++++++++++----------

qom/object.c | 11 +++++++++++

util/aio-posix.c | 9 ++++++++-

5 files changed, 75 insertions(+), 11 deletions(-)

2.13.6

From: Peter Xu <peterx@redhat.com>

We have object_get_objects_root() to keep user created objects, however

no place for objects that will be used internally. Create such a

container for internal objects.

CC: Andreas Färber <afaerber@suse.de>

CC: Markus Armbruster <armbru@redhat.com>

CC: Paolo Bonzini <pbonzini@redhat.com>

Suggested-by: Daniel P. Berrange <berrange@redhat.com>

Signed-off-by: Peter Xu <peterx@redhat.com>

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

Message-id: 20170928025958.1420-2-peterx@redhat.com

include/qom/object.h | 11 +++++++++++

qom/object.c | 11 +++++++++++

2 files changed, 22 insertions(+)

diff --git a/include/qom/object.h b/include/qom/object.h

--- a/include/qom/object.h

+++ b/include/qom/object.h

@@ -XXX,XX +XXX,XX @@ Object *object_get_root(void);

Object *object_get_objects_root(void);

+ * object_get_internal_root:

+ * Get the container object that holds internally used object

+ * instances. Any object which is put into this container must not be

+ * user visible, and it will not be exposed in the QOM tree.

+ * Returns: the internal object container

+ */

+Object *object_get_internal_root(void);

* object_get_canonical_path_component:

*

* Returns: The final component in the object's canonical path. The canonical

diff --git a/qom/object.c b/qom/object.c

--- a/qom/object.c

+++ b/qom/object.c

@@ -XXX,XX +XXX,XX @@ Object *object_get_objects_root(void)

return container_get(object_get_root(), "/objects");

+Object *object_get_internal_root(void)

+{

+ static Object *internal_root;

+

+ if (!internal_root) {

+ internal_root = object_new("container");

+ }

+

+ return internal_root;

+}

+

static void object_get_child_property(Object *obj, Visitor *v,

const char *name, void *opaque,

Error **errp)

2.13.6

After iothread is enabled internally inside QEMU with GMainContext, we

may encounter this warning when destroying the iothread:

(qemu-system-x86_64:19925): GLib-CRITICAL **: g_source_remove_poll:

assertion '!SOURCE_DESTROYED (source)' failed

The problem is that g_source_remove_poll() does not allow to remove one

source from array if the source is detached from its owner

context. (peterx: which IMHO does not make much sense)

Fix it on QEMU side by avoid calling g_source_remove_poll() if we know

the object is during destruction, and we won't leak anything after all

since the array will be gone soon cleanly even with that fd.

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

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

Signed-off-by: Peter Xu <peterx@redhat.com>

Message-id: 20170928025958.1420-6-peterx@redhat.com

[peterx: write the commit message]

Signed-off-by: Peter Xu <peterx@redhat.com>

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

---

util/aio-posix.c | 9 ++++++++-

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

From: Peter Xu <peterx@redhat.com>

So that internal iothread users can explicitly stop one iothread without

destroying it.

Since at it, fix iothread_stop() to allow it to be called multiple

times. Before this patch we may call iothread_stop() more than once on

single iothread, while that may not be correct since qemu_thread_join()

is not allowed to run twice. From manual of pthread_join():

Joining with a thread that has previously been joined results in

undefined behavior.

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

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

Signed-off-by: Peter Xu <peterx@redhat.com>

Message-id: 20170928025958.1420-4-peterx@redhat.com

include/sysemu/iothread.h | 1 +

iothread.c | 24 ++++++++++++++++--------

2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h

--- a/include/sysemu/iothread.h

+++ b/include/sysemu/iothread.h

@@ -XXX,XX +XXX,XX @@ GMainContext *iothread_get_g_main_context(IOThread *iothread);

* "query-iothreads".

*/

IOThread *iothread_create(const char *id, Error **errp);

+void iothread_stop(IOThread *iothread);

void iothread_destroy(IOThread *iothread);

#endif /* IOTHREAD_H */

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

index XXXXXXX..XXXXXXX 100644

--- a/iothread.c

+++ b/iothread.c

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

return NULL;

-static int iothread_stop(Object *object, void *opaque)

+void iothread_stop(IOThread *iothread)

- IOThread *iothread;

-

- iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);

- if (!iothread || !iothread->ctx || iothread->stopping) {

- return 0;

+ if (!iothread->ctx || iothread->stopping) {

+ return;

iothread->stopping = true;

aio_notify(iothread->ctx);

@@ -XXX,XX +XXX,XX @@ static int iothread_stop(Object *object, void *opaque)

g_main_loop_quit(iothread->main_loop);

qemu_thread_join(&iothread->thread);

+}

+

+static int iothread_stop_iter(Object *object, void *opaque)

+{

+ IOThread *iothread;

+

+ iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);

+ if (!iothread) {

+ return 0;

+ }

+ iothread_stop(iothread);

return 0;

}

@@ -XXX,XX +XXX,XX @@ static void iothread_instance_finalize(Object *obj)

{

IOThread *iothread = IOTHREAD(obj);

- iothread_stop(obj, NULL);

+ iothread_stop(iothread);

qemu_cond_destroy(&iothread->init_done_cond);

qemu_mutex_destroy(&iothread->init_done_lock);

if (!iothread->ctx) {

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

aio_context_release(ctx);

2.13.6

From: Peter Xu <peterx@redhat.com>

When gcontext is used with iothread, the context will be destroyed

during iothread_stop(). That's not good since sometimes we would like

to keep the resources until iothread is destroyed, but we may want to

stop the thread before that point.

Delay the destruction of gcontext to iothread finalize. Then we can do:

iothread_stop(thread);

some_cleanup_on_resources();

iothread_destroy(thread);

We may need this patch if we want to run chardev IOs in iothreads and

hopefully clean them up correctly. For more specific information,

please see 2b316774f6 ("qemu-char: do not operate on sources from

finalize callbacks").

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

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

Signed-off-by: Peter Xu <peterx@redhat.com>

Message-id: 20170928025958.1420-5-peterx@redhat.com

iothread.c | 6 ++++--

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

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

--- a/iothread.c

+++ b/iothread.c

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

g_main_loop_unref(loop);

g_main_context_pop_thread_default(iothread->worker_context);

- g_main_context_unref(iothread->worker_context);

- iothread->worker_context = NULL;

@@ -XXX,XX +XXX,XX @@ static void iothread_instance_finalize(Object *obj)

IOThread *iothread = IOTHREAD(obj);

iothread_stop(iothread);

+ if (iothread->worker_context) {

+ g_main_context_unref(iothread->worker_context);

+ iothread->worker_context = NULL;

qemu_cond_destroy(&iothread->init_done_cond);

qemu_mutex_destroy(&iothread->init_done_lock);

if (!iothread->ctx) {

2.13.6

From: Peter Xu <peterx@redhat.com>

IOThread is a general framework that contains IO loop environment and a

real thread behind. It's also good to be used internally inside qemu.

Provide some helpers for it to create iothreads to be used internally.

Put all the internal used iothreads into the internal object container.

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

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

Signed-off-by: Peter Xu <peterx@redhat.com>

Message-id: 20170928025958.1420-3-peterx@redhat.com

include/sysemu/iothread.h | 8 ++++++++

iothread.c | 16 ++++++++++++++++

2 files changed, 24 insertions(+)

diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h

--- a/include/sysemu/iothread.h

+++ b/include/sysemu/iothread.h

@@ -XXX,XX +XXX,XX @@ AioContext *iothread_get_aio_context(IOThread *iothread);

void iothread_stop_all(void);

GMainContext *iothread_get_g_main_context(IOThread *iothread);

+/*

+ * Helpers used to allocate iothreads for internal use. These

+ * iothreads will not be seen by monitor clients when query using

+ * "query-iothreads".

+ */

+IOThread *iothread_create(const char *id, Error **errp);

+void iothread_destroy(IOThread *iothread);

+

#endif /* IOTHREAD_H */

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

index XXXXXXX..XXXXXXX 100644

--- a/iothread.c

+++ b/iothread.c

@@ -XXX,XX +XXX,XX @@ GMainContext *iothread_get_g_main_context(IOThread *iothread)

return iothread->worker_context;

}

+

+IOThread *iothread_create(const char *id, Error **errp)

+{

+ Object *obj;

+

+ obj = object_new_with_props(TYPE_IOTHREAD,

+ object_get_internal_root(),

+ id, errp, NULL);

+

+ return IOTHREAD(obj);

+}

+

+void iothread_destroy(IOThread *iothread)

+{

+ object_unparent(OBJECT(iothread));

+}

2.13.6