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 /* 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 int qemu_init_main_loop(void)
128 qemu_mutex_lock_iothread();
129 ret
= qemu_signal_init();
134 qemu_aio_context
= aio_context_new();
135 src
= aio_get_g_source(qemu_aio_context
);
136 g_source_attach(src
, NULL
);
141 static fd_set rfds
, wfds
, xfds
;
143 static GPollFD poll_fds
[1024 * 2]; /* this is probably overkill */
144 static int n_poll_fds
;
145 static int max_priority
;
148 static void glib_select_fill(int *max_fd
, fd_set
*rfds
, fd_set
*wfds
,
149 fd_set
*xfds
, uint32_t *cur_timeout
)
151 GMainContext
*context
= g_main_context_default();
155 g_main_context_prepare(context
, &max_priority
);
157 n_poll_fds
= g_main_context_query(context
, max_priority
, &timeout
,
158 poll_fds
, ARRAY_SIZE(poll_fds
));
159 g_assert(n_poll_fds
<= ARRAY_SIZE(poll_fds
));
161 for (i
= 0; i
< n_poll_fds
; i
++) {
162 GPollFD
*p
= &poll_fds
[i
];
164 if ((p
->events
& G_IO_IN
)) {
166 *max_fd
= MAX(*max_fd
, p
->fd
);
168 if ((p
->events
& G_IO_OUT
)) {
170 *max_fd
= MAX(*max_fd
, p
->fd
);
172 if ((p
->events
& G_IO_ERR
)) {
174 *max_fd
= MAX(*max_fd
, p
->fd
);
178 if (timeout
>= 0 && timeout
< *cur_timeout
) {
179 *cur_timeout
= timeout
;
183 static void glib_select_poll(fd_set
*rfds
, fd_set
*wfds
, fd_set
*xfds
,
186 GMainContext
*context
= g_main_context_default();
191 for (i
= 0; i
< n_poll_fds
; i
++) {
192 GPollFD
*p
= &poll_fds
[i
];
194 if ((p
->events
& G_IO_IN
) && FD_ISSET(p
->fd
, rfds
)) {
195 p
->revents
|= G_IO_IN
;
197 if ((p
->events
& G_IO_OUT
) && FD_ISSET(p
->fd
, wfds
)) {
198 p
->revents
|= G_IO_OUT
;
200 if ((p
->events
& G_IO_ERR
) && FD_ISSET(p
->fd
, xfds
)) {
201 p
->revents
|= G_IO_ERR
;
206 if (g_main_context_check(context
, max_priority
, poll_fds
, n_poll_fds
)) {
207 g_main_context_dispatch(context
);
211 static int os_host_main_loop_wait(uint32_t timeout
)
213 struct timeval tv
, *tvarg
= NULL
;
216 glib_select_fill(&nfds
, &rfds
, &wfds
, &xfds
, &timeout
);
218 if (timeout
< UINT32_MAX
) {
220 tv
.tv_sec
= timeout
/ 1000;
221 tv
.tv_usec
= (timeout
% 1000) * 1000;
225 qemu_mutex_unlock_iothread();
228 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, tvarg
);
231 qemu_mutex_lock_iothread();
234 glib_select_poll(&rfds
, &wfds
, &xfds
, (ret
< 0));
238 /***********************************************************/
239 /* Polling handling */
241 typedef struct PollingEntry
{
244 struct PollingEntry
*next
;
247 static PollingEntry
*first_polling_entry
;
249 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
251 PollingEntry
**ppe
, *pe
;
252 pe
= g_malloc0(sizeof(PollingEntry
));
255 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
260 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
262 PollingEntry
**ppe
, *pe
;
263 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
265 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
273 /***********************************************************/
274 /* Wait objects support */
275 typedef struct WaitObjects
{
277 int revents
[MAXIMUM_WAIT_OBJECTS
+ 1];
278 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
279 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
280 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
283 static WaitObjects wait_objects
= {0};
285 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
287 WaitObjects
*w
= &wait_objects
;
288 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
) {
291 w
->events
[w
->num
] = handle
;
292 w
->func
[w
->num
] = func
;
293 w
->opaque
[w
->num
] = opaque
;
294 w
->revents
[w
->num
] = 0;
299 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
302 WaitObjects
*w
= &wait_objects
;
305 for (i
= 0; i
< w
->num
; i
++) {
306 if (w
->events
[i
] == handle
) {
310 w
->events
[i
] = w
->events
[i
+ 1];
311 w
->func
[i
] = w
->func
[i
+ 1];
312 w
->opaque
[i
] = w
->opaque
[i
+ 1];
313 w
->revents
[i
] = w
->revents
[i
+ 1];
321 void qemu_fd_register(int fd
)
323 WSAEventSelect(fd
, event_notifier_get_handle(&qemu_aio_context
->notifier
),
324 FD_READ
| FD_ACCEPT
| FD_CLOSE
|
325 FD_CONNECT
| FD_WRITE
| FD_OOB
);
328 static int os_host_main_loop_wait(uint32_t timeout
)
330 GMainContext
*context
= g_main_context_default();
333 WaitObjects
*w
= &wait_objects
;
335 static struct timeval tv0
;
337 /* XXX: need to suppress polling by better using win32 events */
339 for (pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
340 ret
|= pe
->func(pe
->opaque
);
347 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv0
);
353 g_main_context_prepare(context
, &max_priority
);
354 n_poll_fds
= g_main_context_query(context
, max_priority
, &poll_timeout
,
355 poll_fds
, ARRAY_SIZE(poll_fds
));
356 g_assert(n_poll_fds
<= ARRAY_SIZE(poll_fds
));
358 for (i
= 0; i
< w
->num
; i
++) {
359 poll_fds
[n_poll_fds
+ i
].fd
= (DWORD_PTR
)w
->events
[i
];
360 poll_fds
[n_poll_fds
+ i
].events
= G_IO_IN
;
363 if (poll_timeout
< 0 || timeout
< poll_timeout
) {
364 poll_timeout
= timeout
;
367 qemu_mutex_unlock_iothread();
368 ret
= g_poll(poll_fds
, n_poll_fds
+ w
->num
, poll_timeout
);
369 qemu_mutex_lock_iothread();
371 for (i
= 0; i
< w
->num
; i
++) {
372 w
->revents
[i
] = poll_fds
[n_poll_fds
+ i
].revents
;
374 for (i
= 0; i
< w
->num
; i
++) {
375 if (w
->revents
[i
] && w
->func
[i
]) {
376 w
->func
[i
](w
->opaque
[i
]);
381 if (g_main_context_check(context
, max_priority
, poll_fds
, n_poll_fds
)) {
382 g_main_context_dispatch(context
);
385 /* If an edge-triggered socket event occurred, select will return a
386 * positive result on the next iteration. We do not need to do anything
394 int main_loop_wait(int nonblocking
)
397 uint32_t timeout
= UINT32_MAX
;
403 /* poll any events */
404 /* XXX: separate device handlers from system ones */
411 slirp_update_timeout(&timeout
);
412 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
414 qemu_iohandler_fill(&nfds
, &rfds
, &wfds
, &xfds
);
415 ret
= os_host_main_loop_wait(timeout
);
416 qemu_iohandler_poll(&rfds
, &wfds
, &xfds
, ret
);
418 slirp_select_poll(&rfds
, &wfds
, &xfds
, (ret
< 0));
421 qemu_run_all_timers();
426 /* Functions to operate on the main QEMU AioContext. */
428 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
430 return aio_bh_new(qemu_aio_context
, cb
, opaque
);
433 void qemu_aio_flush(void)
435 aio_flush(qemu_aio_context
);
438 bool qemu_aio_wait(void)
440 return aio_poll(qemu_aio_context
, true);
444 void qemu_aio_set_fd_handler(int fd
,
447 AioFlushHandler
*io_flush
,
450 aio_set_fd_handler(qemu_aio_context
, fd
, io_read
, io_write
, io_flush
,
455 void qemu_aio_set_event_notifier(EventNotifier
*notifier
,
456 EventNotifierHandler
*io_read
,
457 AioFlushEventNotifierHandler
*io_flush
)
459 aio_set_event_notifier(qemu_aio_context
, notifier
, io_read
, io_flush
);