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 "main-loop.h"
35 static int io_thread_fd
= -1;
37 void qemu_notify_event(void)
39 /* Write 8 bytes to be compatible with eventfd. */
40 static const uint64_t val
= 1;
43 if (io_thread_fd
== -1) {
47 ret
= write(io_thread_fd
, &val
, sizeof(val
));
48 } while (ret
< 0 && errno
== EINTR
);
50 /* EAGAIN is fine, a read must be pending. */
51 if (ret
< 0 && errno
!= EAGAIN
) {
52 fprintf(stderr
, "qemu_notify_event: write() failed: %s\n",
58 static void qemu_event_read(void *opaque
)
60 int fd
= (intptr_t)opaque
;
64 /* Drain the notify pipe. For eventfd, only 8 bytes will be read. */
66 len
= read(fd
, buffer
, sizeof(buffer
));
67 } while ((len
== -1 && errno
== EINTR
) || len
== sizeof(buffer
));
70 static int qemu_event_init(void)
75 err
= qemu_eventfd(fds
);
79 err
= fcntl_setfl(fds
[0], O_NONBLOCK
);
83 err
= fcntl_setfl(fds
[1], O_NONBLOCK
);
87 qemu_set_fd_handler2(fds
[0], NULL
, qemu_event_read
, NULL
,
88 (void *)(intptr_t)fds
[0]);
90 io_thread_fd
= fds
[1];
99 /* If we have signalfd, we mask out the signals we want to handle and then
100 * use signalfd to listen for them. We rely on whatever the current signal
101 * handler is to dispatch the signals when we receive them.
103 static void sigfd_handler(void *opaque
)
105 int fd
= (intptr_t)opaque
;
106 struct qemu_signalfd_siginfo info
;
107 struct sigaction action
;
112 len
= read(fd
, &info
, sizeof(info
));
113 } while (len
== -1 && errno
== EINTR
);
115 if (len
== -1 && errno
== EAGAIN
) {
119 if (len
!= sizeof(info
)) {
120 printf("read from sigfd returned %zd: %m\n", len
);
124 sigaction(info
.ssi_signo
, NULL
, &action
);
125 if ((action
.sa_flags
& SA_SIGINFO
) && action
.sa_sigaction
) {
126 action
.sa_sigaction(info
.ssi_signo
,
127 (siginfo_t
*)&info
, NULL
);
128 } else if (action
.sa_handler
) {
129 action
.sa_handler(info
.ssi_signo
);
134 static int qemu_signal_init(void)
140 * SIG_IPI must be blocked in the main thread and must not be caught
141 * by sigwait() in the signal thread. Otherwise, the cpu thread will
142 * not catch it reliably.
145 sigaddset(&set
, SIG_IPI
);
146 sigaddset(&set
, SIGIO
);
147 sigaddset(&set
, SIGALRM
);
148 sigaddset(&set
, SIGBUS
);
149 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
151 sigdelset(&set
, SIG_IPI
);
152 sigfd
= qemu_signalfd(&set
);
154 fprintf(stderr
, "failed to create signalfd\n");
158 fcntl_setfl(sigfd
, O_NONBLOCK
);
160 qemu_set_fd_handler2(sigfd
, NULL
, sigfd_handler
, NULL
,
161 (void *)(intptr_t)sigfd
);
168 static HANDLE qemu_event_handle
= NULL
;
170 static void dummy_event_handler(void *opaque
)
174 static int qemu_event_init(void)
176 qemu_event_handle
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
177 if (!qemu_event_handle
) {
178 fprintf(stderr
, "Failed CreateEvent: %ld\n", GetLastError());
181 qemu_add_wait_object(qemu_event_handle
, dummy_event_handler
, NULL
);
185 void qemu_notify_event(void)
187 if (!qemu_event_handle
) {
190 if (!SetEvent(qemu_event_handle
)) {
191 fprintf(stderr
, "qemu_notify_event: SetEvent failed: %ld\n",
197 static int qemu_signal_init(void)
203 static AioContext
*qemu_aio_context
;
205 int qemu_init_main_loop(void)
212 qemu_mutex_lock_iothread();
213 ret
= qemu_signal_init();
218 /* Note eventfd must be drained before signalfd handlers run */
219 ret
= qemu_event_init();
224 qemu_aio_context
= aio_context_new();
228 static fd_set rfds
, wfds
, xfds
;
230 static GPollFD poll_fds
[1024 * 2]; /* this is probably overkill */
231 static int n_poll_fds
;
232 static int max_priority
;
235 static void glib_select_fill(int *max_fd
, fd_set
*rfds
, fd_set
*wfds
,
236 fd_set
*xfds
, uint32_t *cur_timeout
)
238 GMainContext
*context
= g_main_context_default();
242 g_main_context_prepare(context
, &max_priority
);
244 n_poll_fds
= g_main_context_query(context
, max_priority
, &timeout
,
245 poll_fds
, ARRAY_SIZE(poll_fds
));
246 g_assert(n_poll_fds
<= ARRAY_SIZE(poll_fds
));
248 for (i
= 0; i
< n_poll_fds
; i
++) {
249 GPollFD
*p
= &poll_fds
[i
];
251 if ((p
->events
& G_IO_IN
)) {
253 *max_fd
= MAX(*max_fd
, p
->fd
);
255 if ((p
->events
& G_IO_OUT
)) {
257 *max_fd
= MAX(*max_fd
, p
->fd
);
259 if ((p
->events
& G_IO_ERR
)) {
261 *max_fd
= MAX(*max_fd
, p
->fd
);
265 if (timeout
>= 0 && timeout
< *cur_timeout
) {
266 *cur_timeout
= timeout
;
270 static void glib_select_poll(fd_set
*rfds
, fd_set
*wfds
, fd_set
*xfds
,
273 GMainContext
*context
= g_main_context_default();
278 for (i
= 0; i
< n_poll_fds
; i
++) {
279 GPollFD
*p
= &poll_fds
[i
];
281 if ((p
->events
& G_IO_IN
) && FD_ISSET(p
->fd
, rfds
)) {
282 p
->revents
|= G_IO_IN
;
284 if ((p
->events
& G_IO_OUT
) && FD_ISSET(p
->fd
, wfds
)) {
285 p
->revents
|= G_IO_OUT
;
287 if ((p
->events
& G_IO_ERR
) && FD_ISSET(p
->fd
, xfds
)) {
288 p
->revents
|= G_IO_ERR
;
293 if (g_main_context_check(context
, max_priority
, poll_fds
, n_poll_fds
)) {
294 g_main_context_dispatch(context
);
298 static int os_host_main_loop_wait(uint32_t timeout
)
300 struct timeval tv
, *tvarg
= NULL
;
303 glib_select_fill(&nfds
, &rfds
, &wfds
, &xfds
, &timeout
);
305 if (timeout
< UINT32_MAX
) {
307 tv
.tv_sec
= timeout
/ 1000;
308 tv
.tv_usec
= (timeout
% 1000) * 1000;
312 qemu_mutex_unlock_iothread();
315 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, tvarg
);
318 qemu_mutex_lock_iothread();
321 glib_select_poll(&rfds
, &wfds
, &xfds
, (ret
< 0));
325 /***********************************************************/
326 /* Polling handling */
328 typedef struct PollingEntry
{
331 struct PollingEntry
*next
;
334 static PollingEntry
*first_polling_entry
;
336 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
338 PollingEntry
**ppe
, *pe
;
339 pe
= g_malloc0(sizeof(PollingEntry
));
342 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
347 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
349 PollingEntry
**ppe
, *pe
;
350 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
352 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
360 /***********************************************************/
361 /* Wait objects support */
362 typedef struct WaitObjects
{
364 int revents
[MAXIMUM_WAIT_OBJECTS
+ 1];
365 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
366 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
367 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
370 static WaitObjects wait_objects
= {0};
372 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
374 WaitObjects
*w
= &wait_objects
;
375 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
) {
378 w
->events
[w
->num
] = handle
;
379 w
->func
[w
->num
] = func
;
380 w
->opaque
[w
->num
] = opaque
;
381 w
->revents
[w
->num
] = 0;
386 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
389 WaitObjects
*w
= &wait_objects
;
392 for (i
= 0; i
< w
->num
; i
++) {
393 if (w
->events
[i
] == handle
) {
397 w
->events
[i
] = w
->events
[i
+ 1];
398 w
->func
[i
] = w
->func
[i
+ 1];
399 w
->opaque
[i
] = w
->opaque
[i
+ 1];
400 w
->revents
[i
] = w
->revents
[i
+ 1];
408 void qemu_fd_register(int fd
)
410 WSAEventSelect(fd
, qemu_event_handle
, FD_READ
| FD_ACCEPT
| FD_CLOSE
|
411 FD_CONNECT
| FD_WRITE
| FD_OOB
);
414 static int os_host_main_loop_wait(uint32_t timeout
)
416 GMainContext
*context
= g_main_context_default();
419 WaitObjects
*w
= &wait_objects
;
421 static struct timeval tv0
;
423 /* XXX: need to suppress polling by better using win32 events */
425 for (pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
426 ret
|= pe
->func(pe
->opaque
);
433 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv0
);
439 g_main_context_prepare(context
, &max_priority
);
440 n_poll_fds
= g_main_context_query(context
, max_priority
, &poll_timeout
,
441 poll_fds
, ARRAY_SIZE(poll_fds
));
442 g_assert(n_poll_fds
<= ARRAY_SIZE(poll_fds
));
444 for (i
= 0; i
< w
->num
; i
++) {
445 poll_fds
[n_poll_fds
+ i
].fd
= (DWORD_PTR
)w
->events
[i
];
446 poll_fds
[n_poll_fds
+ i
].events
= G_IO_IN
;
449 if (poll_timeout
< 0 || timeout
< poll_timeout
) {
450 poll_timeout
= timeout
;
453 qemu_mutex_unlock_iothread();
454 ret
= g_poll(poll_fds
, n_poll_fds
+ w
->num
, poll_timeout
);
455 qemu_mutex_lock_iothread();
457 for (i
= 0; i
< w
->num
; i
++) {
458 w
->revents
[i
] = poll_fds
[n_poll_fds
+ i
].revents
;
460 for (i
= 0; i
< w
->num
; i
++) {
461 if (w
->revents
[i
] && w
->func
[i
]) {
462 w
->func
[i
](w
->opaque
[i
]);
467 if (g_main_context_check(context
, max_priority
, poll_fds
, n_poll_fds
)) {
468 g_main_context_dispatch(context
);
471 /* If an edge-triggered socket event occurred, select will return a
472 * positive result on the next iteration. We do not need to do anything
480 int main_loop_wait(int nonblocking
)
483 uint32_t timeout
= UINT32_MAX
;
488 aio_bh_update_timeout(qemu_aio_context
, &timeout
);
491 /* poll any events */
492 /* XXX: separate device handlers from system ones */
499 slirp_update_timeout(&timeout
);
500 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
502 qemu_iohandler_fill(&nfds
, &rfds
, &wfds
, &xfds
);
503 ret
= os_host_main_loop_wait(timeout
);
504 qemu_iohandler_poll(&rfds
, &wfds
, &xfds
, ret
);
506 slirp_select_poll(&rfds
, &wfds
, &xfds
, (ret
< 0));
509 qemu_run_all_timers();
511 /* Check bottom-halves last in case any of the earlier events triggered
518 /* Functions to operate on the main QEMU AioContext. */
520 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
522 return aio_bh_new(qemu_aio_context
, cb
, opaque
);
525 int qemu_bh_poll(void)
527 return aio_bh_poll(qemu_aio_context
);
530 void qemu_aio_flush(void)
532 aio_flush(qemu_aio_context
);
535 bool qemu_aio_wait(void)
537 return aio_poll(qemu_aio_context
, true);
540 void qemu_aio_set_fd_handler(int fd
,
543 AioFlushHandler
*io_flush
,
546 aio_set_fd_handler(qemu_aio_context
, fd
, io_read
, io_write
, io_flush
,
549 qemu_set_fd_handler2(fd
, NULL
, io_read
, io_write
, opaque
);
553 void qemu_aio_set_event_notifier(EventNotifier
*notifier
,
554 EventNotifierHandler
*io_read
,
555 AioFlushEventNotifierHandler
*io_flush
)
557 qemu_aio_set_fd_handler(event_notifier_get_fd(notifier
),
558 (IOHandler
*)io_read
, NULL
,
559 (AioFlushHandler
*)io_flush
, notifier
);