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 "block/thread-pool.h"
34 #include "qemu/error-report.h"
35 #include "qemu/queue.h"
36 #include "qemu/compiler.h"
37 #include "qom/object.h"
45 /* If we have signalfd, we mask out the signals we want to handle and then
46 * use signalfd to listen for them. We rely on whatever the current signal
47 * handler is to dispatch the signals when we receive them.
51 * We are going to call a signal hander directly. Such handler may or may not
52 * have been defined in our binary, so there's no guarantee that the pointer
53 * used to set the handler is a cfi-valid pointer. Since the handlers are
54 * stored in kernel memory, changing the handler to an attacker-defined
55 * function requires being able to call a sigaction() syscall,
56 * which is not as easy as overwriting a pointer in memory.
59 static void sigfd_handler(void *opaque
)
61 int fd
= (intptr_t)opaque
;
62 struct qemu_signalfd_siginfo info
;
63 struct sigaction action
;
68 len
= read(fd
, &info
, sizeof(info
));
69 } while (len
== -1 && errno
== EINTR
);
71 if (len
== -1 && errno
== EAGAIN
) {
75 if (len
!= sizeof(info
)) {
76 error_report("read from sigfd returned %zd: %s", len
,
81 sigaction(info
.ssi_signo
, NULL
, &action
);
82 if ((action
.sa_flags
& SA_SIGINFO
) && action
.sa_sigaction
) {
83 sigaction_invoke(&action
, &info
);
84 } else if (action
.sa_handler
) {
85 action
.sa_handler(info
.ssi_signo
);
90 static int qemu_signal_init(Error
**errp
)
96 * SIG_IPI must be blocked in the main thread and must not be caught
97 * by sigwait() in the signal thread. Otherwise, the cpu thread will
98 * not catch it reliably.
101 sigaddset(&set
, SIG_IPI
);
102 sigaddset(&set
, SIGIO
);
103 sigaddset(&set
, SIGALRM
);
104 sigaddset(&set
, SIGBUS
);
105 /* SIGINT cannot be handled via signalfd, so that ^C can be used
106 * to interrupt QEMU when it is being run under gdb. SIGHUP and
107 * SIGTERM are also handled asynchronously, even though it is not
108 * strictly necessary, because they use the same handler as SIGINT.
110 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
112 sigdelset(&set
, SIG_IPI
);
113 sigfd
= qemu_signalfd(&set
);
115 error_setg_errno(errp
, errno
, "failed to create signalfd");
119 g_unix_set_fd_nonblocking(sigfd
, true, NULL
);
121 qemu_set_fd_handler(sigfd
, sigfd_handler
, NULL
, (void *)(intptr_t)sigfd
);
128 static int qemu_signal_init(Error
**errp
)
134 static AioContext
*qemu_aio_context
;
135 static QEMUBH
*qemu_notify_bh
;
137 static void notify_event_cb(void *opaque
)
139 /* No need to do anything; this bottom half is only used to
140 * kick the kernel out of ppoll/poll/WaitForMultipleObjects.
144 AioContext
*qemu_get_aio_context(void)
146 return qemu_aio_context
;
149 void qemu_notify_event(void)
151 if (!qemu_aio_context
) {
154 qemu_bh_schedule(qemu_notify_bh
);
157 static GArray
*gpollfds
;
159 int qemu_init_main_loop(Error
**errp
)
164 init_clocks(qemu_timer_notify_cb
);
166 ret
= qemu_signal_init(errp
);
171 qemu_aio_context
= aio_context_new(errp
);
172 if (!qemu_aio_context
) {
175 qemu_set_current_aio_context(qemu_aio_context
);
176 qemu_notify_bh
= qemu_bh_new(notify_event_cb
, NULL
);
177 gpollfds
= g_array_new(FALSE
, FALSE
, sizeof(GPollFD
));
178 src
= aio_get_g_source(qemu_aio_context
);
179 g_source_set_name(src
, "aio-context");
180 g_source_attach(src
, NULL
);
182 src
= iohandler_get_g_source();
183 g_source_set_name(src
, "io-handler");
184 g_source_attach(src
, NULL
);
189 static void main_loop_update_params(EventLoopBase
*base
, Error
**errp
)
193 if (!qemu_aio_context
) {
194 error_setg(errp
, "qemu aio context not ready");
198 aio_context_set_aio_params(qemu_aio_context
, base
->aio_max_batch
, errp
);
203 aio_context_set_thread_pool_params(qemu_aio_context
, base
->thread_pool_min
,
204 base
->thread_pool_max
, errp
);
209 static void main_loop_init(EventLoopBase
*base
, Error
**errp
)
211 MainLoop
*m
= MAIN_LOOP(base
);
214 error_setg(errp
, "only one main-loop instance allowed");
218 main_loop_update_params(base
, errp
);
224 static bool main_loop_can_be_deleted(EventLoopBase
*base
)
229 static void main_loop_class_init(ObjectClass
*oc
, void *class_data
)
231 EventLoopBaseClass
*bc
= EVENT_LOOP_BASE_CLASS(oc
);
233 bc
->init
= main_loop_init
;
234 bc
->update_params
= main_loop_update_params
;
235 bc
->can_be_deleted
= main_loop_can_be_deleted
;
238 static const TypeInfo main_loop_info
= {
239 .name
= TYPE_MAIN_LOOP
,
240 .parent
= TYPE_EVENT_LOOP_BASE
,
241 .class_init
= main_loop_class_init
,
242 .instance_size
= sizeof(MainLoop
),
245 static void main_loop_register_types(void)
247 type_register_static(&main_loop_info
);
250 type_init(main_loop_register_types
)
252 static int max_priority
;
255 static int glib_pollfds_idx
;
256 static int glib_n_poll_fds
;
258 void qemu_fd_register(int fd
)
262 static void glib_pollfds_fill(int64_t *cur_timeout
)
264 GMainContext
*context
= g_main_context_default();
269 g_main_context_prepare(context
, &max_priority
);
271 glib_pollfds_idx
= gpollfds
->len
;
276 g_array_set_size(gpollfds
, glib_pollfds_idx
+ glib_n_poll_fds
);
277 pfds
= &g_array_index(gpollfds
, GPollFD
, glib_pollfds_idx
);
278 n
= g_main_context_query(context
, max_priority
, &timeout
, pfds
,
280 } while (n
!= glib_n_poll_fds
);
285 timeout_ns
= (int64_t)timeout
* (int64_t)SCALE_MS
;
288 *cur_timeout
= qemu_soonest_timeout(timeout_ns
, *cur_timeout
);
291 static void glib_pollfds_poll(void)
293 GMainContext
*context
= g_main_context_default();
294 GPollFD
*pfds
= &g_array_index(gpollfds
, GPollFD
, glib_pollfds_idx
);
296 if (g_main_context_check(context
, max_priority
, pfds
, glib_n_poll_fds
)) {
297 g_main_context_dispatch(context
);
301 #define MAX_MAIN_LOOP_SPIN (1000)
303 static int os_host_main_loop_wait(int64_t timeout
)
305 GMainContext
*context
= g_main_context_default();
308 g_main_context_acquire(context
);
310 glib_pollfds_fill(&timeout
);
312 qemu_mutex_unlock_iothread();
313 replay_mutex_unlock();
315 ret
= qemu_poll_ns((GPollFD
*)gpollfds
->data
, gpollfds
->len
, timeout
);
318 qemu_mutex_lock_iothread();
322 g_main_context_release(context
);
327 /***********************************************************/
328 /* Polling handling */
330 typedef struct PollingEntry
{
333 struct PollingEntry
*next
;
336 static PollingEntry
*first_polling_entry
;
338 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
340 PollingEntry
**ppe
, *pe
;
341 pe
= g_new0(PollingEntry
, 1);
344 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
349 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
351 PollingEntry
**ppe
, *pe
;
352 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
354 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
362 /***********************************************************/
363 /* Wait objects support */
364 typedef struct WaitObjects
{
366 int revents
[MAXIMUM_WAIT_OBJECTS
];
367 HANDLE events
[MAXIMUM_WAIT_OBJECTS
];
368 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
];
369 void *opaque
[MAXIMUM_WAIT_OBJECTS
];
372 static WaitObjects wait_objects
= {0};
374 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
376 WaitObjects
*w
= &wait_objects
;
377 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
) {
380 w
->events
[w
->num
] = handle
;
381 w
->func
[w
->num
] = func
;
382 w
->opaque
[w
->num
] = opaque
;
383 w
->revents
[w
->num
] = 0;
388 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
391 WaitObjects
*w
= &wait_objects
;
394 for (i
= 0; i
< w
->num
; i
++) {
395 if (w
->events
[i
] == handle
) {
398 if (found
&& i
< (MAXIMUM_WAIT_OBJECTS
- 1)) {
399 w
->events
[i
] = w
->events
[i
+ 1];
400 w
->func
[i
] = w
->func
[i
+ 1];
401 w
->opaque
[i
] = w
->opaque
[i
+ 1];
402 w
->revents
[i
] = w
->revents
[i
+ 1];
410 void qemu_fd_register(int fd
)
412 WSAEventSelect(fd
, event_notifier_get_handle(&qemu_aio_context
->notifier
),
413 FD_READ
| FD_ACCEPT
| FD_CLOSE
|
414 FD_CONNECT
| FD_WRITE
| FD_OOB
);
417 static int pollfds_fill(GArray
*pollfds
, fd_set
*rfds
, fd_set
*wfds
,
423 for (i
= 0; i
< pollfds
->len
; i
++) {
424 GPollFD
*pfd
= &g_array_index(pollfds
, GPollFD
, i
);
426 int events
= pfd
->events
;
427 if (events
& G_IO_IN
) {
429 nfds
= MAX(nfds
, fd
);
431 if (events
& G_IO_OUT
) {
433 nfds
= MAX(nfds
, fd
);
435 if (events
& G_IO_PRI
) {
437 nfds
= MAX(nfds
, fd
);
443 static void pollfds_poll(GArray
*pollfds
, int nfds
, fd_set
*rfds
,
444 fd_set
*wfds
, fd_set
*xfds
)
448 for (i
= 0; i
< pollfds
->len
; i
++) {
449 GPollFD
*pfd
= &g_array_index(pollfds
, GPollFD
, i
);
453 if (FD_ISSET(fd
, rfds
)) {
456 if (FD_ISSET(fd
, wfds
)) {
459 if (FD_ISSET(fd
, xfds
)) {
462 pfd
->revents
= revents
& pfd
->events
;
466 static int os_host_main_loop_wait(int64_t timeout
)
468 GMainContext
*context
= g_main_context_default();
469 GPollFD poll_fds
[1024 * 2]; /* this is probably overkill */
471 int g_poll_ret
, ret
, i
, n_poll_fds
;
473 WaitObjects
*w
= &wait_objects
;
475 int64_t poll_timeout_ns
;
476 static struct timeval tv0
;
477 fd_set rfds
, wfds
, xfds
;
480 g_main_context_acquire(context
);
482 /* XXX: need to suppress polling by better using win32 events */
484 for (pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
485 ret
|= pe
->func(pe
->opaque
);
488 g_main_context_release(context
);
495 nfds
= pollfds_fill(gpollfds
, &rfds
, &wfds
, &xfds
);
497 select_ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv0
);
498 if (select_ret
!= 0) {
501 if (select_ret
> 0) {
502 pollfds_poll(gpollfds
, nfds
, &rfds
, &wfds
, &xfds
);
506 g_main_context_prepare(context
, &max_priority
);
507 n_poll_fds
= g_main_context_query(context
, max_priority
, &poll_timeout
,
508 poll_fds
, ARRAY_SIZE(poll_fds
));
509 g_assert(n_poll_fds
+ w
->num
<= ARRAY_SIZE(poll_fds
));
511 for (i
= 0; i
< w
->num
; i
++) {
512 poll_fds
[n_poll_fds
+ i
].fd
= (DWORD_PTR
)w
->events
[i
];
513 poll_fds
[n_poll_fds
+ i
].events
= G_IO_IN
;
516 if (poll_timeout
< 0) {
517 poll_timeout_ns
= -1;
519 poll_timeout_ns
= (int64_t)poll_timeout
* (int64_t)SCALE_MS
;
522 poll_timeout_ns
= qemu_soonest_timeout(poll_timeout_ns
, timeout
);
524 qemu_mutex_unlock_iothread();
526 replay_mutex_unlock();
528 g_poll_ret
= qemu_poll_ns(poll_fds
, n_poll_fds
+ w
->num
, poll_timeout_ns
);
532 qemu_mutex_lock_iothread();
533 if (g_poll_ret
> 0) {
534 for (i
= 0; i
< w
->num
; i
++) {
535 w
->revents
[i
] = poll_fds
[n_poll_fds
+ i
].revents
;
537 for (i
= 0; i
< w
->num
; i
++) {
538 if (w
->revents
[i
] && w
->func
[i
]) {
539 w
->func
[i
](w
->opaque
[i
]);
544 if (g_main_context_check(context
, max_priority
, poll_fds
, n_poll_fds
)) {
545 g_main_context_dispatch(context
);
548 g_main_context_release(context
);
550 return select_ret
|| g_poll_ret
;
554 static NotifierList main_loop_poll_notifiers
=
555 NOTIFIER_LIST_INITIALIZER(main_loop_poll_notifiers
);
557 void main_loop_poll_add_notifier(Notifier
*notify
)
559 notifier_list_add(&main_loop_poll_notifiers
, notify
);
562 void main_loop_poll_remove_notifier(Notifier
*notify
)
564 notifier_remove(notify
);
567 void main_loop_wait(int nonblocking
)
569 MainLoopPoll mlpoll
= {
570 .state
= MAIN_LOOP_POLL_FILL
,
571 .timeout
= UINT32_MAX
,
581 /* poll any events */
582 g_array_set_size(gpollfds
, 0); /* reset for new iteration */
583 /* XXX: separate device handlers from system ones */
584 notifier_list_notify(&main_loop_poll_notifiers
, &mlpoll
);
586 if (mlpoll
.timeout
== UINT32_MAX
) {
589 timeout_ns
= (uint64_t)mlpoll
.timeout
* (int64_t)(SCALE_MS
);
592 timeout_ns
= qemu_soonest_timeout(timeout_ns
,
593 timerlistgroup_deadline_ns(
596 ret
= os_host_main_loop_wait(timeout_ns
);
597 mlpoll
.state
= ret
< 0 ? MAIN_LOOP_POLL_ERR
: MAIN_LOOP_POLL_OK
;
598 notifier_list_notify(&main_loop_poll_notifiers
, &mlpoll
);
600 if (icount_enabled()) {
602 * CPU thread can infinitely wait for event after
605 icount_start_warp_timer();
607 qemu_clock_run_all_timers();
610 /* Functions to operate on the main QEMU AioContext. */
612 QEMUBH
*qemu_bh_new_full(QEMUBHFunc
*cb
, void *opaque
, const char *name
)
614 return aio_bh_new_full(qemu_aio_context
, cb
, opaque
, name
);
618 * Functions to operate on the I/O handler AioContext.
619 * This context runs on top of main loop. We can't reuse qemu_aio_context
620 * because iohandlers mustn't be polled by aio_poll(qemu_aio_context).
622 static AioContext
*iohandler_ctx
;
624 static void iohandler_init(void)
626 if (!iohandler_ctx
) {
627 iohandler_ctx
= aio_context_new(&error_abort
);
631 AioContext
*iohandler_get_aio_context(void)
634 return iohandler_ctx
;
637 GSource
*iohandler_get_g_source(void)
640 return aio_get_g_source(iohandler_ctx
);
643 void qemu_set_fd_handler(int fd
,
649 aio_set_fd_handler(iohandler_ctx
, fd
, false,
650 fd_read
, fd_write
, NULL
, NULL
, opaque
);
653 void event_notifier_set_handler(EventNotifier
*e
,
654 EventNotifierHandler
*handler
)
657 aio_set_event_notifier(iohandler_ctx
, e
, false,
658 handler
, NULL
, NULL
);