mirror of
https://gitlab.com/qemu-project/qemu
synced 2024-09-06 01:43:39 +00:00
![Peter Xu](/assets/img/avatar_default.png)
Free the AIO context earlier than the GMainContext (if we have) to workaround a glib2 bug that GSource context pointer is not cleared even if the context has already been destroyed (while it should). The patch itself only changed the order to destroy the objects, no functional change at all. Without this workaround, we can encounter qmp-test hang with oob (and possibly any other use case when iothread is used with GMainContexts): #0 0x00007f35ffe45334 in __lll_lock_wait () from /lib64/libpthread.so.0 #1 0x00007f35ffe405d8 in _L_lock_854 () from /lib64/libpthread.so.0 #2 0x00007f35ffe404a7 in pthread_mutex_lock () from /lib64/libpthread.so.0 #3 0x00007f35fc5b9c9d in g_source_unref_internal (source=0x24f0600, context=0x7f35f0000960, have_lock=0) at gmain.c:1685 #4 0x0000000000aa6672 in aio_context_unref (ctx=0x24f0600) at /root/qemu/util/async.c:497 #5 0x000000000065851c in iothread_instance_finalize (obj=0x24f0380) at /root/qemu/iothread.c:129 #6 0x0000000000962d79 in object_deinit (obj=0x24f0380, type=0x242e960) at /root/qemu/qom/object.c:462 #7 0x0000000000962e0d in object_finalize (data=0x24f0380) at /root/qemu/qom/object.c:476 #8 0x0000000000964146 in object_unref (obj=0x24f0380) at /root/qemu/qom/object.c:924 #9 0x0000000000965880 in object_finalize_child_property (obj=0x24ec640, name=0x24efca0 "mon_iothread", opaque=0x24f0380) at /root/qemu/qom/object.c:1436 #10 0x0000000000962c33 in object_property_del_child (obj=0x24ec640, child=0x24f0380, errp=0x0) at /root/qemu/qom/object.c:436 #11 0x0000000000962d26 in object_unparent (obj=0x24f0380) at /root/qemu/qom/object.c:455 #12 0x0000000000658f00 in iothread_destroy (iothread=0x24f0380) at /root/qemu/iothread.c:365 #13 0x00000000004c67a8 in monitor_cleanup () at /root/qemu/monitor.c:4663 #14 0x0000000000669e27 in main (argc=16, argv=0x7ffc8b1ae2f8, envp=0x7ffc8b1ae380) at /root/qemu/vl.c:4749 The glib2 bug is fixed in commit 26056558b ("gmain: allow g_source_get_context() on destroyed sources", 2012-07-30), so the first good version is glib2 2.33.10. But we still support building with glib as old as 2.28, so we need the workaround. Let's make sure we destroy the GSources first before its owner context until we drop support for glib older than 2.33.10. Signed-off-by: Peter Xu <peterx@redhat.com> Message-Id: <20180409083956.1780-1-peterx@redhat.com> Reviewed-by: Eric Blake <eblake@redhat.com> Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com> Signed-off-by: Eric Blake <eblake@redhat.com>
384 lines
10 KiB
C
384 lines
10 KiB
C
/*
|
|
* Event loop thread
|
|
*
|
|
* Copyright Red Hat Inc., 2013
|
|
*
|
|
* Authors:
|
|
* Stefan Hajnoczi <stefanha@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "qom/object.h"
|
|
#include "qom/object_interfaces.h"
|
|
#include "qemu/module.h"
|
|
#include "block/aio.h"
|
|
#include "block/block.h"
|
|
#include "sysemu/iothread.h"
|
|
#include "qapi/error.h"
|
|
#include "qapi/qapi-commands-misc.h"
|
|
#include "qemu/error-report.h"
|
|
#include "qemu/rcu.h"
|
|
#include "qemu/main-loop.h"
|
|
|
|
typedef ObjectClass IOThreadClass;
|
|
|
|
#define IOTHREAD_GET_CLASS(obj) \
|
|
OBJECT_GET_CLASS(IOThreadClass, obj, TYPE_IOTHREAD)
|
|
#define IOTHREAD_CLASS(klass) \
|
|
OBJECT_CLASS_CHECK(IOThreadClass, klass, TYPE_IOTHREAD)
|
|
|
|
#ifdef CONFIG_POSIX
|
|
/* Benchmark results from 2016 on NVMe SSD drives show max polling times around
|
|
* 16-32 microseconds yield IOPS improvements for both iodepth=1 and iodepth=32
|
|
* workloads.
|
|
*/
|
|
#define IOTHREAD_POLL_MAX_NS_DEFAULT 32768ULL
|
|
#else
|
|
#define IOTHREAD_POLL_MAX_NS_DEFAULT 0ULL
|
|
#endif
|
|
|
|
static __thread IOThread *my_iothread;
|
|
|
|
AioContext *qemu_get_current_aio_context(void)
|
|
{
|
|
return my_iothread ? my_iothread->ctx : qemu_get_aio_context();
|
|
}
|
|
|
|
static void *iothread_run(void *opaque)
|
|
{
|
|
IOThread *iothread = opaque;
|
|
|
|
rcu_register_thread();
|
|
|
|
my_iothread = iothread;
|
|
qemu_mutex_lock(&iothread->init_done_lock);
|
|
iothread->thread_id = qemu_get_thread_id();
|
|
qemu_cond_signal(&iothread->init_done_cond);
|
|
qemu_mutex_unlock(&iothread->init_done_lock);
|
|
|
|
while (iothread->running) {
|
|
aio_poll(iothread->ctx, true);
|
|
|
|
if (atomic_read(&iothread->worker_context)) {
|
|
GMainLoop *loop;
|
|
|
|
g_main_context_push_thread_default(iothread->worker_context);
|
|
iothread->main_loop =
|
|
g_main_loop_new(iothread->worker_context, TRUE);
|
|
loop = iothread->main_loop;
|
|
|
|
g_main_loop_run(iothread->main_loop);
|
|
iothread->main_loop = NULL;
|
|
g_main_loop_unref(loop);
|
|
|
|
g_main_context_pop_thread_default(iothread->worker_context);
|
|
}
|
|
}
|
|
|
|
rcu_unregister_thread();
|
|
return NULL;
|
|
}
|
|
|
|
/* Runs in iothread_run() thread */
|
|
static void iothread_stop_bh(void *opaque)
|
|
{
|
|
IOThread *iothread = opaque;
|
|
|
|
iothread->running = false; /* stop iothread_run() */
|
|
|
|
if (iothread->main_loop) {
|
|
g_main_loop_quit(iothread->main_loop);
|
|
}
|
|
}
|
|
|
|
void iothread_stop(IOThread *iothread)
|
|
{
|
|
if (!iothread->ctx || iothread->stopping) {
|
|
return;
|
|
}
|
|
iothread->stopping = true;
|
|
aio_bh_schedule_oneshot(iothread->ctx, iothread_stop_bh, iothread);
|
|
qemu_thread_join(&iothread->thread);
|
|
}
|
|
|
|
static void iothread_instance_init(Object *obj)
|
|
{
|
|
IOThread *iothread = IOTHREAD(obj);
|
|
|
|
iothread->poll_max_ns = IOTHREAD_POLL_MAX_NS_DEFAULT;
|
|
}
|
|
|
|
static void iothread_instance_finalize(Object *obj)
|
|
{
|
|
IOThread *iothread = IOTHREAD(obj);
|
|
|
|
iothread_stop(iothread);
|
|
/*
|
|
* Before glib2 2.33.10, there is a glib2 bug that GSource context
|
|
* pointer may not be cleared even if the context has already been
|
|
* destroyed (while it should). Here let's free the AIO context
|
|
* earlier to bypass that glib bug.
|
|
*
|
|
* We can remove this comment after the minimum supported glib2
|
|
* version boosts to 2.33.10. Before that, let's free the
|
|
* GSources first before destroying any GMainContext.
|
|
*/
|
|
if (iothread->ctx) {
|
|
aio_context_unref(iothread->ctx);
|
|
iothread->ctx = NULL;
|
|
}
|
|
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);
|
|
}
|
|
|
|
static void iothread_complete(UserCreatable *obj, Error **errp)
|
|
{
|
|
Error *local_error = NULL;
|
|
IOThread *iothread = IOTHREAD(obj);
|
|
char *name, *thread_name;
|
|
|
|
iothread->stopping = false;
|
|
iothread->running = true;
|
|
iothread->thread_id = -1;
|
|
iothread->ctx = aio_context_new(&local_error);
|
|
if (!iothread->ctx) {
|
|
error_propagate(errp, local_error);
|
|
return;
|
|
}
|
|
|
|
aio_context_set_poll_params(iothread->ctx,
|
|
iothread->poll_max_ns,
|
|
iothread->poll_grow,
|
|
iothread->poll_shrink,
|
|
&local_error);
|
|
if (local_error) {
|
|
error_propagate(errp, local_error);
|
|
aio_context_unref(iothread->ctx);
|
|
iothread->ctx = NULL;
|
|
return;
|
|
}
|
|
|
|
qemu_mutex_init(&iothread->init_done_lock);
|
|
qemu_cond_init(&iothread->init_done_cond);
|
|
iothread->once = (GOnce) G_ONCE_INIT;
|
|
|
|
/* This assumes we are called from a thread with useful CPU affinity for us
|
|
* to inherit.
|
|
*/
|
|
name = object_get_canonical_path_component(OBJECT(obj));
|
|
thread_name = g_strdup_printf("IO %s", name);
|
|
qemu_thread_create(&iothread->thread, thread_name, iothread_run,
|
|
iothread, QEMU_THREAD_JOINABLE);
|
|
g_free(thread_name);
|
|
g_free(name);
|
|
|
|
/* Wait for initialization to complete */
|
|
qemu_mutex_lock(&iothread->init_done_lock);
|
|
while (iothread->thread_id == -1) {
|
|
qemu_cond_wait(&iothread->init_done_cond,
|
|
&iothread->init_done_lock);
|
|
}
|
|
qemu_mutex_unlock(&iothread->init_done_lock);
|
|
}
|
|
|
|
typedef struct {
|
|
const char *name;
|
|
ptrdiff_t offset; /* field's byte offset in IOThread struct */
|
|
} PollParamInfo;
|
|
|
|
static PollParamInfo poll_max_ns_info = {
|
|
"poll-max-ns", offsetof(IOThread, poll_max_ns),
|
|
};
|
|
static PollParamInfo poll_grow_info = {
|
|
"poll-grow", offsetof(IOThread, poll_grow),
|
|
};
|
|
static PollParamInfo poll_shrink_info = {
|
|
"poll-shrink", offsetof(IOThread, poll_shrink),
|
|
};
|
|
|
|
static void iothread_get_poll_param(Object *obj, Visitor *v,
|
|
const char *name, void *opaque, Error **errp)
|
|
{
|
|
IOThread *iothread = IOTHREAD(obj);
|
|
PollParamInfo *info = opaque;
|
|
int64_t *field = (void *)iothread + info->offset;
|
|
|
|
visit_type_int64(v, name, field, errp);
|
|
}
|
|
|
|
static void iothread_set_poll_param(Object *obj, Visitor *v,
|
|
const char *name, void *opaque, Error **errp)
|
|
{
|
|
IOThread *iothread = IOTHREAD(obj);
|
|
PollParamInfo *info = opaque;
|
|
int64_t *field = (void *)iothread + info->offset;
|
|
Error *local_err = NULL;
|
|
int64_t value;
|
|
|
|
visit_type_int64(v, name, &value, &local_err);
|
|
if (local_err) {
|
|
goto out;
|
|
}
|
|
|
|
if (value < 0) {
|
|
error_setg(&local_err, "%s value must be in range [0, %"PRId64"]",
|
|
info->name, INT64_MAX);
|
|
goto out;
|
|
}
|
|
|
|
*field = value;
|
|
|
|
if (iothread->ctx) {
|
|
aio_context_set_poll_params(iothread->ctx,
|
|
iothread->poll_max_ns,
|
|
iothread->poll_grow,
|
|
iothread->poll_shrink,
|
|
&local_err);
|
|
}
|
|
|
|
out:
|
|
error_propagate(errp, local_err);
|
|
}
|
|
|
|
static void iothread_class_init(ObjectClass *klass, void *class_data)
|
|
{
|
|
UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
|
|
ucc->complete = iothread_complete;
|
|
|
|
object_class_property_add(klass, "poll-max-ns", "int",
|
|
iothread_get_poll_param,
|
|
iothread_set_poll_param,
|
|
NULL, &poll_max_ns_info, &error_abort);
|
|
object_class_property_add(klass, "poll-grow", "int",
|
|
iothread_get_poll_param,
|
|
iothread_set_poll_param,
|
|
NULL, &poll_grow_info, &error_abort);
|
|
object_class_property_add(klass, "poll-shrink", "int",
|
|
iothread_get_poll_param,
|
|
iothread_set_poll_param,
|
|
NULL, &poll_shrink_info, &error_abort);
|
|
}
|
|
|
|
static const TypeInfo iothread_info = {
|
|
.name = TYPE_IOTHREAD,
|
|
.parent = TYPE_OBJECT,
|
|
.class_init = iothread_class_init,
|
|
.instance_size = sizeof(IOThread),
|
|
.instance_init = iothread_instance_init,
|
|
.instance_finalize = iothread_instance_finalize,
|
|
.interfaces = (InterfaceInfo[]) {
|
|
{TYPE_USER_CREATABLE},
|
|
{}
|
|
},
|
|
};
|
|
|
|
static void iothread_register_types(void)
|
|
{
|
|
type_register_static(&iothread_info);
|
|
}
|
|
|
|
type_init(iothread_register_types)
|
|
|
|
char *iothread_get_id(IOThread *iothread)
|
|
{
|
|
return object_get_canonical_path_component(OBJECT(iothread));
|
|
}
|
|
|
|
AioContext *iothread_get_aio_context(IOThread *iothread)
|
|
{
|
|
return iothread->ctx;
|
|
}
|
|
|
|
static int query_one_iothread(Object *object, void *opaque)
|
|
{
|
|
IOThreadInfoList ***prev = opaque;
|
|
IOThreadInfoList *elem;
|
|
IOThreadInfo *info;
|
|
IOThread *iothread;
|
|
|
|
iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);
|
|
if (!iothread) {
|
|
return 0;
|
|
}
|
|
|
|
info = g_new0(IOThreadInfo, 1);
|
|
info->id = iothread_get_id(iothread);
|
|
info->thread_id = iothread->thread_id;
|
|
info->poll_max_ns = iothread->poll_max_ns;
|
|
info->poll_grow = iothread->poll_grow;
|
|
info->poll_shrink = iothread->poll_shrink;
|
|
|
|
elem = g_new0(IOThreadInfoList, 1);
|
|
elem->value = info;
|
|
elem->next = NULL;
|
|
|
|
**prev = elem;
|
|
*prev = &elem->next;
|
|
return 0;
|
|
}
|
|
|
|
IOThreadInfoList *qmp_query_iothreads(Error **errp)
|
|
{
|
|
IOThreadInfoList *head = NULL;
|
|
IOThreadInfoList **prev = &head;
|
|
Object *container = object_get_objects_root();
|
|
|
|
object_child_foreach(container, query_one_iothread, &prev);
|
|
return head;
|
|
}
|
|
|
|
static gpointer iothread_g_main_context_init(gpointer opaque)
|
|
{
|
|
AioContext *ctx;
|
|
IOThread *iothread = opaque;
|
|
GSource *source;
|
|
|
|
iothread->worker_context = g_main_context_new();
|
|
|
|
ctx = iothread_get_aio_context(iothread);
|
|
source = aio_get_g_source(ctx);
|
|
g_source_attach(source, iothread->worker_context);
|
|
g_source_unref(source);
|
|
|
|
aio_notify(iothread->ctx);
|
|
return NULL;
|
|
}
|
|
|
|
GMainContext *iothread_get_g_main_context(IOThread *iothread)
|
|
{
|
|
g_once(&iothread->once, iothread_g_main_context_init, 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));
|
|
}
|
|
|
|
/* Lookup IOThread by its id. Only finds user-created objects, not internal
|
|
* iothread_create() objects. */
|
|
IOThread *iothread_by_id(const char *id)
|
|
{
|
|
return IOTHREAD(object_resolve_path_type(id, TYPE_IOTHREAD, NULL));
|
|
}
|