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-common.h"
26 #include "qemu/timer.h"
27 #include "slirp/slirp.h"
28 #include "qemu/main-loop.h"
29 #include "block/aio.h"
33 #include "qemu/compatfd.h"
35 /* If we have signalfd, we mask out the signals we want to handle and then
36 * use signalfd to listen for them. We rely on whatever the current signal
37 * handler is to dispatch the signals when we receive them.
39 static void sigfd_handler(void *opaque
)
41 int fd
= (intptr_t)opaque
;
42 struct qemu_signalfd_siginfo info
;
43 struct sigaction action
;
48 len
= read(fd
, &info
, sizeof(info
));
49 } while (len
== -1 && errno
== EINTR
);
51 if (len
== -1 && errno
== EAGAIN
) {
55 if (len
!= sizeof(info
)) {
56 printf("read from sigfd returned %zd: %m\n", len
);
60 sigaction(info
.ssi_signo
, NULL
, &action
);
61 if ((action
.sa_flags
& SA_SIGINFO
) && action
.sa_sigaction
) {
62 action
.sa_sigaction(info
.ssi_signo
,
63 (siginfo_t
*)&info
, NULL
);
64 } else if (action
.sa_handler
) {
65 action
.sa_handler(info
.ssi_signo
);
70 static int qemu_signal_init(void)
76 * SIG_IPI must be blocked in the main thread and must not be caught
77 * by sigwait() in the signal thread. Otherwise, the cpu thread will
78 * not catch it reliably.
81 sigaddset(&set
, SIG_IPI
);
82 sigaddset(&set
, SIGIO
);
83 sigaddset(&set
, SIGALRM
);
84 sigaddset(&set
, SIGBUS
);
85 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
87 sigdelset(&set
, SIG_IPI
);
88 sigfd
= qemu_signalfd(&set
);
90 fprintf(stderr
, "failed to create signalfd\n");
94 fcntl_setfl(sigfd
, O_NONBLOCK
);
96 qemu_set_fd_handler2(sigfd
, NULL
, sigfd_handler
, NULL
,
97 (void *)(intptr_t)sigfd
);
104 static int qemu_signal_init(void)
110 static AioContext
*qemu_aio_context
;
112 void qemu_notify_event(void)
114 if (!qemu_aio_context
) {
117 aio_notify(qemu_aio_context
);
120 static GArray
*gpollfds
;
122 int qemu_init_main_loop(void)
128 if (init_timer_alarm() < 0) {
129 fprintf(stderr
, "could not initialize alarm timer\n");
133 ret
= qemu_signal_init();
138 gpollfds
= g_array_new(FALSE
, FALSE
, sizeof(GPollFD
));
139 qemu_aio_context
= aio_context_new();
140 src
= aio_get_g_source(qemu_aio_context
);
141 g_source_attach(src
, NULL
);
146 static fd_set rfds
, wfds
, xfds
;
148 static int max_priority
;
150 /* Load rfds/wfds/xfds into gpollfds. Will be removed a few commits later. */
151 static void gpollfds_from_select(void)
154 for (fd
= 0; fd
<= nfds
; fd
++) {
156 if (FD_ISSET(fd
, &rfds
)) {
157 events
|= G_IO_IN
| G_IO_HUP
| G_IO_ERR
;
159 if (FD_ISSET(fd
, &wfds
)) {
160 events
|= G_IO_OUT
| G_IO_ERR
;
162 if (FD_ISSET(fd
, &xfds
)) {
170 g_array_append_val(gpollfds
, pfd
);
175 /* Store gpollfds revents into rfds/wfds/xfds. Will be removed a few commits
178 static void gpollfds_to_select(int ret
)
190 for (i
= 0; i
< gpollfds
->len
; i
++) {
191 int fd
= g_array_index(gpollfds
, GPollFD
, i
).fd
;
192 int revents
= g_array_index(gpollfds
, GPollFD
, i
).revents
;
194 if (revents
& (G_IO_IN
| G_IO_HUP
| G_IO_ERR
)) {
197 if (revents
& (G_IO_OUT
| G_IO_ERR
)) {
200 if (revents
& G_IO_PRI
) {
207 static int glib_pollfds_idx
;
208 static int glib_n_poll_fds
;
210 static void glib_pollfds_fill(uint32_t *cur_timeout
)
212 GMainContext
*context
= g_main_context_default();
216 g_main_context_prepare(context
, &max_priority
);
218 glib_pollfds_idx
= gpollfds
->len
;
223 g_array_set_size(gpollfds
, glib_pollfds_idx
+ glib_n_poll_fds
);
224 pfds
= &g_array_index(gpollfds
, GPollFD
, glib_pollfds_idx
);
225 n
= g_main_context_query(context
, max_priority
, &timeout
, pfds
,
227 } while (n
!= glib_n_poll_fds
);
229 if (timeout
>= 0 && timeout
< *cur_timeout
) {
230 *cur_timeout
= timeout
;
234 static void glib_pollfds_poll(void)
236 GMainContext
*context
= g_main_context_default();
237 GPollFD
*pfds
= &g_array_index(gpollfds
, GPollFD
, glib_pollfds_idx
);
239 if (g_main_context_check(context
, max_priority
, pfds
, glib_n_poll_fds
)) {
240 g_main_context_dispatch(context
);
244 static int os_host_main_loop_wait(uint32_t timeout
)
248 glib_pollfds_fill(&timeout
);
251 qemu_mutex_unlock_iothread();
254 /* We'll eventually drop fd_set completely. But for now we still have
255 * *_fill() and *_poll() functions that use rfds/wfds/xfds.
257 gpollfds_from_select();
259 ret
= g_poll((GPollFD
*)gpollfds
->data
, gpollfds
->len
, timeout
);
261 gpollfds_to_select(ret
);
264 qemu_mutex_lock_iothread();
271 /***********************************************************/
272 /* Polling handling */
274 typedef struct PollingEntry
{
277 struct PollingEntry
*next
;
280 static PollingEntry
*first_polling_entry
;
282 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
284 PollingEntry
**ppe
, *pe
;
285 pe
= g_malloc0(sizeof(PollingEntry
));
288 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
293 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
295 PollingEntry
**ppe
, *pe
;
296 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
298 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
306 /***********************************************************/
307 /* Wait objects support */
308 typedef struct WaitObjects
{
310 int revents
[MAXIMUM_WAIT_OBJECTS
+ 1];
311 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
312 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
313 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
316 static WaitObjects wait_objects
= {0};
318 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
320 WaitObjects
*w
= &wait_objects
;
321 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
) {
324 w
->events
[w
->num
] = handle
;
325 w
->func
[w
->num
] = func
;
326 w
->opaque
[w
->num
] = opaque
;
327 w
->revents
[w
->num
] = 0;
332 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
335 WaitObjects
*w
= &wait_objects
;
338 for (i
= 0; i
< w
->num
; i
++) {
339 if (w
->events
[i
] == handle
) {
343 w
->events
[i
] = w
->events
[i
+ 1];
344 w
->func
[i
] = w
->func
[i
+ 1];
345 w
->opaque
[i
] = w
->opaque
[i
+ 1];
346 w
->revents
[i
] = w
->revents
[i
+ 1];
354 void qemu_fd_register(int fd
)
356 WSAEventSelect(fd
, event_notifier_get_handle(&qemu_aio_context
->notifier
),
357 FD_READ
| FD_ACCEPT
| FD_CLOSE
|
358 FD_CONNECT
| FD_WRITE
| FD_OOB
);
361 static int pollfds_fill(GArray
*pollfds
, fd_set
*rfds
, fd_set
*wfds
,
367 for (i
= 0; i
< pollfds
->len
; i
++) {
368 GPollFD
*pfd
= &g_array_index(pollfds
, GPollFD
, i
);
370 int events
= pfd
->events
;
371 if (events
& (G_IO_IN
| G_IO_HUP
| G_IO_ERR
)) {
373 nfds
= MAX(nfds
, fd
);
375 if (events
& (G_IO_OUT
| G_IO_ERR
)) {
377 nfds
= MAX(nfds
, fd
);
379 if (events
& G_IO_PRI
) {
381 nfds
= MAX(nfds
, fd
);
387 static void pollfds_poll(GArray
*pollfds
, int nfds
, fd_set
*rfds
,
388 fd_set
*wfds
, fd_set
*xfds
)
392 for (i
= 0; i
< pollfds
->len
; i
++) {
393 GPollFD
*pfd
= &g_array_index(pollfds
, GPollFD
, i
);
397 if (FD_ISSET(fd
, rfds
)) {
398 revents
|= G_IO_IN
| G_IO_HUP
| G_IO_ERR
;
400 if (FD_ISSET(fd
, wfds
)) {
401 revents
|= G_IO_OUT
| G_IO_ERR
;
403 if (FD_ISSET(fd
, xfds
)) {
406 pfd
->revents
= revents
& pfd
->events
;
410 static int os_host_main_loop_wait(uint32_t timeout
)
412 GMainContext
*context
= g_main_context_default();
413 GPollFD poll_fds
[1024 * 2]; /* this is probably overkill */
415 int g_poll_ret
, ret
, i
, n_poll_fds
;
417 WaitObjects
*w
= &wait_objects
;
419 static struct timeval tv0
;
421 /* XXX: need to suppress polling by better using win32 events */
423 for (pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
424 ret
|= pe
->func(pe
->opaque
);
430 g_main_context_prepare(context
, &max_priority
);
431 n_poll_fds
= g_main_context_query(context
, max_priority
, &poll_timeout
,
432 poll_fds
, ARRAY_SIZE(poll_fds
));
433 g_assert(n_poll_fds
<= ARRAY_SIZE(poll_fds
));
435 for (i
= 0; i
< w
->num
; i
++) {
436 poll_fds
[n_poll_fds
+ i
].fd
= (DWORD_PTR
)w
->events
[i
];
437 poll_fds
[n_poll_fds
+ i
].events
= G_IO_IN
;
440 if (poll_timeout
< 0 || timeout
< poll_timeout
) {
441 poll_timeout
= timeout
;
444 qemu_mutex_unlock_iothread();
445 g_poll_ret
= g_poll(poll_fds
, n_poll_fds
+ w
->num
, poll_timeout
);
446 qemu_mutex_lock_iothread();
447 if (g_poll_ret
> 0) {
448 for (i
= 0; i
< w
->num
; i
++) {
449 w
->revents
[i
] = poll_fds
[n_poll_fds
+ i
].revents
;
451 for (i
= 0; i
< w
->num
; i
++) {
452 if (w
->revents
[i
] && w
->func
[i
]) {
453 w
->func
[i
](w
->opaque
[i
]);
458 if (g_main_context_check(context
, max_priority
, poll_fds
, n_poll_fds
)) {
459 g_main_context_dispatch(context
);
462 /* Call select after g_poll to avoid a useless iteration and therefore
463 * improve socket latency.
466 /* This back-and-forth between GPollFDs and select(2) is temporary. We'll
467 * drop it in a couple of patches, I promise :).
469 gpollfds_from_select();
473 nfds
= pollfds_fill(gpollfds
, &rfds
, &wfds
, &xfds
);
475 select_ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv0
);
476 if (select_ret
!= 0) {
479 if (select_ret
> 0) {
480 pollfds_poll(gpollfds
, nfds
, &rfds
, &wfds
, &xfds
);
483 gpollfds_to_select(select_ret
);
485 return select_ret
|| g_poll_ret
;
489 int main_loop_wait(int nonblocking
)
492 uint32_t timeout
= UINT32_MAX
;
498 /* poll any events */
499 g_array_set_size(gpollfds
, 0); /* reset for new iteration */
500 /* XXX: separate device handlers from system ones */
507 slirp_update_timeout(&timeout
);
508 slirp_pollfds_fill(gpollfds
);
510 qemu_iohandler_fill(&nfds
, &rfds
, &wfds
, &xfds
);
511 ret
= os_host_main_loop_wait(timeout
);
512 qemu_iohandler_poll(&rfds
, &wfds
, &xfds
, ret
);
514 slirp_pollfds_poll(gpollfds
, (ret
< 0));
517 qemu_run_all_timers();
522 /* Functions to operate on the main QEMU AioContext. */
524 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
526 return aio_bh_new(qemu_aio_context
, cb
, opaque
);
529 bool qemu_aio_wait(void)
531 return aio_poll(qemu_aio_context
, true);
535 void qemu_aio_set_fd_handler(int fd
,
538 AioFlushHandler
*io_flush
,
541 aio_set_fd_handler(qemu_aio_context
, fd
, io_read
, io_write
, io_flush
,
546 void qemu_aio_set_event_notifier(EventNotifier
*notifier
,
547 EventNotifierHandler
*io_read
,
548 AioFlushEventNotifierHandler
*io_flush
)
550 aio_set_event_notifier(qemu_aio_context
, notifier
, io_read
, io_flush
);