4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu/cutils.h"
28 #include "qemu/timer.h"
29 #include "sysemu/cpu-timers.h"
30 #include "sysemu/replay.h"
31 #include "qemu/main-loop.h"
32 #include "block/aio.h"
33 #include "qemu/error-report.h"
34 #include "qemu/queue.h"
35 #include "qemu/compiler.h"
36 #include "qom/object.h"
44 /* If we have signalfd, we mask out the signals we want to handle and then
45 * use signalfd to listen for them. We rely on whatever the current signal
46 * handler is to dispatch the signals when we receive them.
50 * We are going to call a signal hander directly. Such handler may or may not
51 * have been defined in our binary, so there's no guarantee that the pointer
52 * used to set the handler is a cfi-valid pointer. Since the handlers are
53 * stored in kernel memory, changing the handler to an attacker-defined
54 * function requires being able to call a sigaction() syscall,
55 * which is not as easy as overwriting a pointer in memory.
58 static void sigfd_handler(void *opaque
)
60 int fd
= (intptr_t)opaque
;
61 struct qemu_signalfd_siginfo info
;
62 struct sigaction action
;
67 len
= read(fd
, &info
, sizeof(info
));
68 } while (len
== -1 && errno
== EINTR
);
70 if (len
== -1 && errno
== EAGAIN
) {
74 if (len
!= sizeof(info
)) {
75 error_report("read from sigfd returned %zd: %s", len
,
80 sigaction(info
.ssi_signo
, NULL
, &action
);
81 if ((action
.sa_flags
& SA_SIGINFO
) && action
.sa_sigaction
) {
82 sigaction_invoke(&action
, &info
);
83 } else if (action
.sa_handler
) {
84 action
.sa_handler(info
.ssi_signo
);
89 static int qemu_signal_init(Error
**errp
)
95 * SIG_IPI must be blocked in the main thread and must not be caught
96 * by sigwait() in the signal thread. Otherwise, the cpu thread will
97 * not catch it reliably.
100 sigaddset(&set
, SIG_IPI
);
101 sigaddset(&set
, SIGIO
);
102 sigaddset(&set
, SIGALRM
);
103 sigaddset(&set
, SIGBUS
);
104 /* SIGINT cannot be handled via signalfd, so that ^C can be used
105 * to interrupt QEMU when it is being run under gdb. SIGHUP and
106 * SIGTERM are also handled asynchronously, even though it is not
107 * strictly necessary, because they use the same handler as SIGINT.
109 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
111 sigdelset(&set
, SIG_IPI
);
112 sigfd
= qemu_signalfd(&set
);
114 error_setg_errno(errp
, errno
, "failed to create signalfd");
118 g_unix_set_fd_nonblocking(sigfd
, true, NULL
);
120 qemu_set_fd_handler(sigfd
, sigfd_handler
, NULL
, (void *)(intptr_t)sigfd
);
127 static int qemu_signal_init(Error
**errp
)
133 static AioContext
*qemu_aio_context
;
134 static QEMUBH
*qemu_notify_bh
;
136 static void notify_event_cb(void *opaque
)
138 /* No need to do anything; this bottom half is only used to
139 * kick the kernel out of ppoll/poll/WaitForMultipleObjects.
143 AioContext
*qemu_get_aio_context(void)
145 return qemu_aio_context
;
148 void qemu_notify_event(void)
150 if (!qemu_aio_context
) {
153 qemu_bh_schedule(qemu_notify_bh
);
156 static GArray
*gpollfds
;
158 int qemu_init_main_loop(Error
**errp
)
163 init_clocks(qemu_timer_notify_cb
);
165 ret
= qemu_signal_init(errp
);
170 qemu_aio_context
= aio_context_new(errp
);
171 if (!qemu_aio_context
) {
174 qemu_set_current_aio_context(qemu_aio_context
);
175 qemu_notify_bh
= qemu_bh_new(notify_event_cb
, NULL
);
176 gpollfds
= g_array_new(FALSE
, FALSE
, sizeof(GPollFD
));
177 src
= aio_get_g_source(qemu_aio_context
);
178 g_source_set_name(src
, "aio-context");
179 g_source_attach(src
, NULL
);
181 src
= iohandler_get_g_source();
182 g_source_set_name(src
, "io-handler");
183 g_source_attach(src
, NULL
);
188 static void main_loop_update_params(EventLoopBase
*base
, Error
**errp
)
190 if (!qemu_aio_context
) {
191 error_setg(errp
, "qemu aio context not ready");
195 aio_context_set_aio_params(qemu_aio_context
, base
->aio_max_batch
, errp
);
200 static void main_loop_init(EventLoopBase
*base
, Error
**errp
)
202 MainLoop
*m
= MAIN_LOOP(base
);
205 error_setg(errp
, "only one main-loop instance allowed");
209 main_loop_update_params(base
, errp
);
215 static bool main_loop_can_be_deleted(EventLoopBase
*base
)
220 static void main_loop_class_init(ObjectClass
*oc
, void *class_data
)
222 EventLoopBaseClass
*bc
= EVENT_LOOP_BASE_CLASS(oc
);
224 bc
->init
= main_loop_init
;
225 bc
->update_params
= main_loop_update_params
;
226 bc
->can_be_deleted
= main_loop_can_be_deleted
;
229 static const TypeInfo main_loop_info
= {
230 .name
= TYPE_MAIN_LOOP
,
231 .parent
= TYPE_EVENT_LOOP_BASE
,
232 .class_init
= main_loop_class_init
,
233 .instance_size
= sizeof(MainLoop
),
236 static void main_loop_register_types(void)
238 type_register_static(&main_loop_info
);
241 type_init(main_loop_register_types
)
243 static int max_priority
;
246 static int glib_pollfds_idx
;
247 static int glib_n_poll_fds
;
249 void qemu_fd_register(int fd
)
253 static void glib_pollfds_fill(int64_t *cur_timeout
)
255 GMainContext
*context
= g_main_context_default();
260 g_main_context_prepare(context
, &max_priority
);
262 glib_pollfds_idx
= gpollfds
->len
;
267 g_array_set_size(gpollfds
, glib_pollfds_idx
+ glib_n_poll_fds
);
268 pfds
= &g_array_index(gpollfds
, GPollFD
, glib_pollfds_idx
);
269 n
= g_main_context_query(context
, max_priority
, &timeout
, pfds
,
271 } while (n
!= glib_n_poll_fds
);
276 timeout_ns
= (int64_t)timeout
* (int64_t)SCALE_MS
;
279 *cur_timeout
= qemu_soonest_timeout(timeout_ns
, *cur_timeout
);
282 static void glib_pollfds_poll(void)
284 GMainContext
*context
= g_main_context_default();
285 GPollFD
*pfds
= &g_array_index(gpollfds
, GPollFD
, glib_pollfds_idx
);
287 if (g_main_context_check(context
, max_priority
, pfds
, glib_n_poll_fds
)) {
288 g_main_context_dispatch(context
);
292 #define MAX_MAIN_LOOP_SPIN (1000)
294 static int os_host_main_loop_wait(int64_t timeout
)
296 GMainContext
*context
= g_main_context_default();
299 g_main_context_acquire(context
);
301 glib_pollfds_fill(&timeout
);
303 qemu_mutex_unlock_iothread();
304 replay_mutex_unlock();
306 ret
= qemu_poll_ns((GPollFD
*)gpollfds
->data
, gpollfds
->len
, timeout
);
309 qemu_mutex_lock_iothread();
313 g_main_context_release(context
);
318 /***********************************************************/
319 /* Polling handling */
321 typedef struct PollingEntry
{
324 struct PollingEntry
*next
;
327 static PollingEntry
*first_polling_entry
;
329 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
331 PollingEntry
**ppe
, *pe
;
332 pe
= g_new0(PollingEntry
, 1);
335 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
340 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
342 PollingEntry
**ppe
, *pe
;
343 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
345 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
353 /***********************************************************/
354 /* Wait objects support */
355 typedef struct WaitObjects
{
357 int revents
[MAXIMUM_WAIT_OBJECTS
+ 1];
358 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
359 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
360 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
363 static WaitObjects wait_objects
= {0};
365 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
367 WaitObjects
*w
= &wait_objects
;
368 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
) {
371 w
->events
[w
->num
] = handle
;
372 w
->func
[w
->num
] = func
;
373 w
->opaque
[w
->num
] = opaque
;
374 w
->revents
[w
->num
] = 0;
379 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
382 WaitObjects
*w
= &wait_objects
;
385 for (i
= 0; i
< w
->num
; i
++) {
386 if (w
->events
[i
] == handle
) {
390 w
->events
[i
] = w
->events
[i
+ 1];
391 w
->func
[i
] = w
->func
[i
+ 1];
392 w
->opaque
[i
] = w
->opaque
[i
+ 1];
393 w
->revents
[i
] = w
->revents
[i
+ 1];
401 void qemu_fd_register(int fd
)
403 WSAEventSelect(fd
, event_notifier_get_handle(&qemu_aio_context
->notifier
),
404 FD_READ
| FD_ACCEPT
| FD_CLOSE
|
405 FD_CONNECT
| FD_WRITE
| FD_OOB
);
408 static int pollfds_fill(GArray
*pollfds
, fd_set
*rfds
, fd_set
*wfds
,
414 for (i
= 0; i
< pollfds
->len
; i
++) {
415 GPollFD
*pfd
= &g_array_index(pollfds
, GPollFD
, i
);
417 int events
= pfd
->events
;
418 if (events
& G_IO_IN
) {
420 nfds
= MAX(nfds
, fd
);
422 if (events
& G_IO_OUT
) {
424 nfds
= MAX(nfds
, fd
);
426 if (events
& G_IO_PRI
) {
428 nfds
= MAX(nfds
, fd
);
434 static void pollfds_poll(GArray
*pollfds
, int nfds
, fd_set
*rfds
,
435 fd_set
*wfds
, fd_set
*xfds
)
439 for (i
= 0; i
< pollfds
->len
; i
++) {
440 GPollFD
*pfd
= &g_array_index(pollfds
, GPollFD
, i
);
444 if (FD_ISSET(fd
, rfds
)) {
447 if (FD_ISSET(fd
, wfds
)) {
450 if (FD_ISSET(fd
, xfds
)) {
453 pfd
->revents
= revents
& pfd
->events
;
457 static int os_host_main_loop_wait(int64_t timeout
)
459 GMainContext
*context
= g_main_context_default();
460 GPollFD poll_fds
[1024 * 2]; /* this is probably overkill */
462 int g_poll_ret
, ret
, i
, n_poll_fds
;
464 WaitObjects
*w
= &wait_objects
;
466 int64_t poll_timeout_ns
;
467 static struct timeval tv0
;
468 fd_set rfds
, wfds
, xfds
;
471 g_main_context_acquire(context
);
473 /* XXX: need to suppress polling by better using win32 events */
475 for (pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
476 ret
|= pe
->func(pe
->opaque
);
479 g_main_context_release(context
);
486 nfds
= pollfds_fill(gpollfds
, &rfds
, &wfds
, &xfds
);
488 select_ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv0
);
489 if (select_ret
!= 0) {
492 if (select_ret
> 0) {
493 pollfds_poll(gpollfds
, nfds
, &rfds
, &wfds
, &xfds
);
497 g_main_context_prepare(context
, &max_priority
);
498 n_poll_fds
= g_main_context_query(context
, max_priority
, &poll_timeout
,
499 poll_fds
, ARRAY_SIZE(poll_fds
));
500 g_assert(n_poll_fds
+ w
->num
<= ARRAY_SIZE(poll_fds
));
502 for (i
= 0; i
< w
->num
; i
++) {
503 poll_fds
[n_poll_fds
+ i
].fd
= (DWORD_PTR
)w
->events
[i
];
504 poll_fds
[n_poll_fds
+ i
].events
= G_IO_IN
;
507 if (poll_timeout
< 0) {
508 poll_timeout_ns
= -1;
510 poll_timeout_ns
= (int64_t)poll_timeout
* (int64_t)SCALE_MS
;
513 poll_timeout_ns
= qemu_soonest_timeout(poll_timeout_ns
, timeout
);
515 qemu_mutex_unlock_iothread();
517 replay_mutex_unlock();
519 g_poll_ret
= qemu_poll_ns(poll_fds
, n_poll_fds
+ w
->num
, poll_timeout_ns
);
523 qemu_mutex_lock_iothread();
524 if (g_poll_ret
> 0) {
525 for (i
= 0; i
< w
->num
; i
++) {
526 w
->revents
[i
] = poll_fds
[n_poll_fds
+ i
].revents
;
528 for (i
= 0; i
< w
->num
; i
++) {
529 if (w
->revents
[i
] && w
->func
[i
]) {
530 w
->func
[i
](w
->opaque
[i
]);
535 if (g_main_context_check(context
, max_priority
, poll_fds
, n_poll_fds
)) {
536 g_main_context_dispatch(context
);
539 g_main_context_release(context
);
541 return select_ret
|| g_poll_ret
;
545 static NotifierList main_loop_poll_notifiers
=
546 NOTIFIER_LIST_INITIALIZER(main_loop_poll_notifiers
);
548 void main_loop_poll_add_notifier(Notifier
*notify
)
550 notifier_list_add(&main_loop_poll_notifiers
, notify
);
553 void main_loop_poll_remove_notifier(Notifier
*notify
)
555 notifier_remove(notify
);
558 void main_loop_wait(int nonblocking
)
560 MainLoopPoll mlpoll
= {
561 .state
= MAIN_LOOP_POLL_FILL
,
562 .timeout
= UINT32_MAX
,
572 /* poll any events */
573 g_array_set_size(gpollfds
, 0); /* reset for new iteration */
574 /* XXX: separate device handlers from system ones */
575 notifier_list_notify(&main_loop_poll_notifiers
, &mlpoll
);
577 if (mlpoll
.timeout
== UINT32_MAX
) {
580 timeout_ns
= (uint64_t)mlpoll
.timeout
* (int64_t)(SCALE_MS
);
583 timeout_ns
= qemu_soonest_timeout(timeout_ns
,
584 timerlistgroup_deadline_ns(
587 ret
= os_host_main_loop_wait(timeout_ns
);
588 mlpoll
.state
= ret
< 0 ? MAIN_LOOP_POLL_ERR
: MAIN_LOOP_POLL_OK
;
589 notifier_list_notify(&main_loop_poll_notifiers
, &mlpoll
);
591 if (icount_enabled()) {
593 * CPU thread can infinitely wait for event after
596 icount_start_warp_timer();
598 qemu_clock_run_all_timers();
601 /* Functions to operate on the main QEMU AioContext. */
603 QEMUBH
*qemu_bh_new_full(QEMUBHFunc
*cb
, void *opaque
, const char *name
)
605 return aio_bh_new_full(qemu_aio_context
, cb
, opaque
, name
);
609 * Functions to operate on the I/O handler AioContext.
610 * This context runs on top of main loop. We can't reuse qemu_aio_context
611 * because iohandlers mustn't be polled by aio_poll(qemu_aio_context).
613 static AioContext
*iohandler_ctx
;
615 static void iohandler_init(void)
617 if (!iohandler_ctx
) {
618 iohandler_ctx
= aio_context_new(&error_abort
);
622 AioContext
*iohandler_get_aio_context(void)
625 return iohandler_ctx
;
628 GSource
*iohandler_get_g_source(void)
631 return aio_get_g_source(iohandler_ctx
);
634 void qemu_set_fd_handler(int fd
,
640 aio_set_fd_handler(iohandler_ctx
, fd
, false,
641 fd_read
, fd_write
, NULL
, NULL
, opaque
);
644 void event_notifier_set_handler(EventNotifier
*e
,
645 EventNotifierHandler
*handler
)
648 aio_set_event_notifier(iohandler_ctx
, e
, false,
649 handler
, NULL
, NULL
);