4 * Copyright Red Hat Inc., 2013
7 * Stefan Hajnoczi <stefanha@redhat.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
14 #include "qemu/osdep.h"
15 #include "qom/object.h"
16 #include "qom/object_interfaces.h"
17 #include "qemu/module.h"
18 #include "block/aio.h"
19 #include "block/block.h"
20 #include "sysemu/iothread.h"
21 #include "qapi/error.h"
22 #include "qapi/qapi-commands-misc.h"
23 #include "qemu/error-report.h"
25 #include "qemu/main-loop.h"
27 typedef ObjectClass IOThreadClass
;
29 #define IOTHREAD_GET_CLASS(obj) \
30 OBJECT_GET_CLASS(IOThreadClass, obj, TYPE_IOTHREAD)
31 #define IOTHREAD_CLASS(klass) \
32 OBJECT_CLASS_CHECK(IOThreadClass, klass, TYPE_IOTHREAD)
35 /* Benchmark results from 2016 on NVMe SSD drives show max polling times around
36 * 16-32 microseconds yield IOPS improvements for both iodepth=1 and iodepth=32
39 #define IOTHREAD_POLL_MAX_NS_DEFAULT 32768ULL
41 #define IOTHREAD_POLL_MAX_NS_DEFAULT 0ULL
44 static __thread IOThread
*my_iothread
;
46 AioContext
*qemu_get_current_aio_context(void)
48 return my_iothread
? my_iothread
->ctx
: qemu_get_aio_context();
51 static void *iothread_run(void *opaque
)
53 IOThread
*iothread
= opaque
;
55 rcu_register_thread();
57 * g_main_context_push_thread_default() must be called before anything
58 * in this new thread uses glib.
60 g_main_context_push_thread_default(iothread
->worker_context
);
61 my_iothread
= iothread
;
62 iothread
->thread_id
= qemu_get_thread_id();
63 qemu_sem_post(&iothread
->init_done_sem
);
65 while (iothread
->running
) {
66 aio_poll(iothread
->ctx
, true);
69 * We must check the running state again in case it was
70 * changed in previous aio_poll()
72 if (iothread
->running
&& atomic_read(&iothread
->run_gcontext
)) {
73 g_main_loop_run(iothread
->main_loop
);
77 g_main_context_pop_thread_default(iothread
->worker_context
);
78 rcu_unregister_thread();
82 /* Runs in iothread_run() thread */
83 static void iothread_stop_bh(void *opaque
)
85 IOThread
*iothread
= opaque
;
87 iothread
->running
= false; /* stop iothread_run() */
89 if (iothread
->main_loop
) {
90 g_main_loop_quit(iothread
->main_loop
);
94 void iothread_stop(IOThread
*iothread
)
96 if (!iothread
->ctx
|| iothread
->stopping
) {
99 iothread
->stopping
= true;
100 aio_bh_schedule_oneshot(iothread
->ctx
, iothread_stop_bh
, iothread
);
101 qemu_thread_join(&iothread
->thread
);
104 static void iothread_instance_init(Object
*obj
)
106 IOThread
*iothread
= IOTHREAD(obj
);
108 iothread
->poll_max_ns
= IOTHREAD_POLL_MAX_NS_DEFAULT
;
109 iothread
->thread_id
= -1;
110 qemu_sem_init(&iothread
->init_done_sem
, 0);
111 /* By default, we don't run gcontext */
112 atomic_set(&iothread
->run_gcontext
, 0);
115 static void iothread_instance_finalize(Object
*obj
)
117 IOThread
*iothread
= IOTHREAD(obj
);
119 iothread_stop(iothread
);
122 * Before glib2 2.33.10, there is a glib2 bug that GSource context
123 * pointer may not be cleared even if the context has already been
124 * destroyed (while it should). Here let's free the AIO context
125 * earlier to bypass that glib bug.
127 * We can remove this comment after the minimum supported glib2
128 * version boosts to 2.33.10. Before that, let's free the
129 * GSources first before destroying any GMainContext.
132 aio_context_unref(iothread
->ctx
);
133 iothread
->ctx
= NULL
;
135 if (iothread
->worker_context
) {
136 g_main_context_unref(iothread
->worker_context
);
137 iothread
->worker_context
= NULL
;
138 g_main_loop_unref(iothread
->main_loop
);
139 iothread
->main_loop
= NULL
;
141 qemu_sem_destroy(&iothread
->init_done_sem
);
144 static void iothread_init_gcontext(IOThread
*iothread
)
148 iothread
->worker_context
= g_main_context_new();
149 source
= aio_get_g_source(iothread_get_aio_context(iothread
));
150 g_source_attach(source
, iothread
->worker_context
);
151 g_source_unref(source
);
152 iothread
->main_loop
= g_main_loop_new(iothread
->worker_context
, TRUE
);
155 static void iothread_complete(UserCreatable
*obj
, Error
**errp
)
157 Error
*local_error
= NULL
;
158 IOThread
*iothread
= IOTHREAD(obj
);
159 char *name
, *thread_name
;
161 iothread
->stopping
= false;
162 iothread
->running
= true;
163 iothread
->ctx
= aio_context_new(&local_error
);
164 if (!iothread
->ctx
) {
165 error_propagate(errp
, local_error
);
170 * Init one GMainContext for the iothread unconditionally, even if
173 iothread_init_gcontext(iothread
);
175 aio_context_set_poll_params(iothread
->ctx
,
176 iothread
->poll_max_ns
,
178 iothread
->poll_shrink
,
181 error_propagate(errp
, local_error
);
182 aio_context_unref(iothread
->ctx
);
183 iothread
->ctx
= NULL
;
187 /* This assumes we are called from a thread with useful CPU affinity for us
190 name
= object_get_canonical_path_component(OBJECT(obj
));
191 thread_name
= g_strdup_printf("IO %s", name
);
192 qemu_thread_create(&iothread
->thread
, thread_name
, iothread_run
,
193 iothread
, QEMU_THREAD_JOINABLE
);
197 /* Wait for initialization to complete */
198 while (iothread
->thread_id
== -1) {
199 qemu_sem_wait(&iothread
->init_done_sem
);
205 ptrdiff_t offset
; /* field's byte offset in IOThread struct */
208 static PollParamInfo poll_max_ns_info
= {
209 "poll-max-ns", offsetof(IOThread
, poll_max_ns
),
211 static PollParamInfo poll_grow_info
= {
212 "poll-grow", offsetof(IOThread
, poll_grow
),
214 static PollParamInfo poll_shrink_info
= {
215 "poll-shrink", offsetof(IOThread
, poll_shrink
),
218 static void iothread_get_poll_param(Object
*obj
, Visitor
*v
,
219 const char *name
, void *opaque
, Error
**errp
)
221 IOThread
*iothread
= IOTHREAD(obj
);
222 PollParamInfo
*info
= opaque
;
223 int64_t *field
= (void *)iothread
+ info
->offset
;
225 visit_type_int64(v
, name
, field
, errp
);
228 static void iothread_set_poll_param(Object
*obj
, Visitor
*v
,
229 const char *name
, void *opaque
, Error
**errp
)
231 IOThread
*iothread
= IOTHREAD(obj
);
232 PollParamInfo
*info
= opaque
;
233 int64_t *field
= (void *)iothread
+ info
->offset
;
234 Error
*local_err
= NULL
;
237 visit_type_int64(v
, name
, &value
, &local_err
);
243 error_setg(&local_err
, "%s value must be in range [0, %"PRId64
"]",
244 info
->name
, INT64_MAX
);
251 aio_context_set_poll_params(iothread
->ctx
,
252 iothread
->poll_max_ns
,
254 iothread
->poll_shrink
,
259 error_propagate(errp
, local_err
);
262 static void iothread_class_init(ObjectClass
*klass
, void *class_data
)
264 UserCreatableClass
*ucc
= USER_CREATABLE_CLASS(klass
);
265 ucc
->complete
= iothread_complete
;
267 object_class_property_add(klass
, "poll-max-ns", "int",
268 iothread_get_poll_param
,
269 iothread_set_poll_param
,
270 NULL
, &poll_max_ns_info
, &error_abort
);
271 object_class_property_add(klass
, "poll-grow", "int",
272 iothread_get_poll_param
,
273 iothread_set_poll_param
,
274 NULL
, &poll_grow_info
, &error_abort
);
275 object_class_property_add(klass
, "poll-shrink", "int",
276 iothread_get_poll_param
,
277 iothread_set_poll_param
,
278 NULL
, &poll_shrink_info
, &error_abort
);
281 static const TypeInfo iothread_info
= {
282 .name
= TYPE_IOTHREAD
,
283 .parent
= TYPE_OBJECT
,
284 .class_init
= iothread_class_init
,
285 .instance_size
= sizeof(IOThread
),
286 .instance_init
= iothread_instance_init
,
287 .instance_finalize
= iothread_instance_finalize
,
288 .interfaces
= (InterfaceInfo
[]) {
289 {TYPE_USER_CREATABLE
},
294 static void iothread_register_types(void)
296 type_register_static(&iothread_info
);
299 type_init(iothread_register_types
)
301 char *iothread_get_id(IOThread
*iothread
)
303 return object_get_canonical_path_component(OBJECT(iothread
));
306 AioContext
*iothread_get_aio_context(IOThread
*iothread
)
308 return iothread
->ctx
;
311 static int query_one_iothread(Object
*object
, void *opaque
)
313 IOThreadInfoList
***prev
= opaque
;
314 IOThreadInfoList
*elem
;
318 iothread
= (IOThread
*)object_dynamic_cast(object
, TYPE_IOTHREAD
);
323 info
= g_new0(IOThreadInfo
, 1);
324 info
->id
= iothread_get_id(iothread
);
325 info
->thread_id
= iothread
->thread_id
;
326 info
->poll_max_ns
= iothread
->poll_max_ns
;
327 info
->poll_grow
= iothread
->poll_grow
;
328 info
->poll_shrink
= iothread
->poll_shrink
;
330 elem
= g_new0(IOThreadInfoList
, 1);
339 IOThreadInfoList
*qmp_query_iothreads(Error
**errp
)
341 IOThreadInfoList
*head
= NULL
;
342 IOThreadInfoList
**prev
= &head
;
343 Object
*container
= object_get_objects_root();
345 object_child_foreach(container
, query_one_iothread
, &prev
);
349 GMainContext
*iothread_get_g_main_context(IOThread
*iothread
)
351 atomic_set(&iothread
->run_gcontext
, 1);
352 aio_notify(iothread
->ctx
);
353 return iothread
->worker_context
;
356 IOThread
*iothread_create(const char *id
, Error
**errp
)
360 obj
= object_new_with_props(TYPE_IOTHREAD
,
361 object_get_internal_root(),
364 return IOTHREAD(obj
);
367 void iothread_destroy(IOThread
*iothread
)
369 object_unparent(OBJECT(iothread
));
372 /* Lookup IOThread by its id. Only finds user-created objects, not internal
373 * iothread_create() objects. */
374 IOThread
*iothread_by_id(const char *id
)
376 return IOTHREAD(object_resolve_path_type(id
, TYPE_IOTHREAD
, NULL
));