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"
34 static int io_thread_fd = -1;
36 void qemu_notify_event(void)
38 /* Write 8 bytes to be compatible with eventfd. */
39 static const uint64_t val = 1;
42 if (io_thread_fd == -1) {
46 ret = write(io_thread_fd, &val, sizeof(val));
47 } while (ret < 0 && errno == EINTR);
49 /* EAGAIN is fine, a read must be pending. */
50 if (ret < 0 && errno != EAGAIN) {
51 fprintf(stderr, "qemu_notify_event: write() failed: %s\n",
57 static void qemu_event_read(void *opaque)
59 int fd = (intptr_t)opaque;
63 /* Drain the notify pipe. For eventfd, only 8 bytes will be read. */
65 len = read(fd, buffer, sizeof(buffer));
66 } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
69 static int qemu_event_init(void)
74 err = qemu_eventfd(fds);
78 err = fcntl_setfl(fds[0], O_NONBLOCK);
82 err = fcntl_setfl(fds[1], O_NONBLOCK);
86 qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
87 (void *)(intptr_t)fds[0]);
89 io_thread_fd = fds[1];
98 /* If we have signalfd, we mask out the signals we want to handle and then
99 * use signalfd to listen for them. We rely on whatever the current signal
100 * handler is to dispatch the signals when we receive them.
102 static void sigfd_handler(void *opaque)
104 int fd = (intptr_t)opaque;
105 struct qemu_signalfd_siginfo info;
106 struct sigaction action;
111 len = read(fd, &info, sizeof(info));
112 } while (len == -1 && errno == EINTR);
114 if (len == -1 && errno == EAGAIN) {
118 if (len != sizeof(info)) {
119 printf("read from sigfd returned %zd: %m\n", len);
123 sigaction(info.ssi_signo, NULL, &action);
124 if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
125 action.sa_sigaction(info.ssi_signo,
126 (siginfo_t *)&info, NULL);
127 } else if (action.sa_handler) {
128 action.sa_handler(info.ssi_signo);
133 static int qemu_signal_init(void)
139 * SIG_IPI must be blocked in the main thread and must not be caught
140 * by sigwait() in the signal thread. Otherwise, the cpu thread will
141 * not catch it reliably.
144 sigaddset(&set, SIG_IPI);
145 sigaddset(&set, SIGIO);
146 sigaddset(&set, SIGALRM);
147 sigaddset(&set, SIGBUS);
148 pthread_sigmask(SIG_BLOCK, &set, NULL);
150 sigdelset(&set, SIG_IPI);
151 sigfd = qemu_signalfd(&set);
153 fprintf(stderr, "failed to create signalfd\n");
157 fcntl_setfl(sigfd, O_NONBLOCK);
159 qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
160 (void *)(intptr_t)sigfd);
167 static HANDLE qemu_event_handle = NULL;
169 static void dummy_event_handler(void *opaque)
173 static int qemu_event_init(void)
175 qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
176 if (!qemu_event_handle) {
177 fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
180 qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
184 void qemu_notify_event(void)
186 if (!qemu_event_handle) {
189 if (!SetEvent(qemu_event_handle)) {
190 fprintf(stderr, "qemu_notify_event: SetEvent failed: %ld\n",
196 static int qemu_signal_init(void)
202 int main_loop_init(void)
206 qemu_mutex_lock_iothread();
207 ret = qemu_signal_init();
212 /* Note eventfd must be drained before signalfd handlers run */
213 ret = qemu_event_init();
221 static fd_set rfds, wfds, xfds;
223 static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
224 static int n_poll_fds;
225 static int max_priority;
228 static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds,
229 fd_set *xfds, int *cur_timeout)
231 GMainContext *context = g_main_context_default();
235 g_main_context_prepare(context, &max_priority);
237 n_poll_fds = g_main_context_query(context, max_priority, &timeout,
238 poll_fds, ARRAY_SIZE(poll_fds));
239 g_assert(n_poll_fds <= ARRAY_SIZE(poll_fds));
241 for (i = 0; i < n_poll_fds; i++) {
242 GPollFD *p = &poll_fds[i];
244 if ((p->events & G_IO_IN)) {
246 *max_fd = MAX(*max_fd, p->fd);
248 if ((p->events & G_IO_OUT)) {
250 *max_fd = MAX(*max_fd, p->fd);
252 if ((p->events & G_IO_ERR)) {
254 *max_fd = MAX(*max_fd, p->fd);
258 if (timeout >= 0 && timeout < *cur_timeout) {
259 *cur_timeout = timeout;
263 static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds,
266 GMainContext *context = g_main_context_default();
271 for (i = 0; i < n_poll_fds; i++) {
272 GPollFD *p = &poll_fds[i];
274 if ((p->events & G_IO_IN) && FD_ISSET(p->fd, rfds)) {
275 p->revents |= G_IO_IN;
277 if ((p->events & G_IO_OUT) && FD_ISSET(p->fd, wfds)) {
278 p->revents |= G_IO_OUT;
280 if ((p->events & G_IO_ERR) && FD_ISSET(p->fd, xfds)) {
281 p->revents |= G_IO_ERR;
286 if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
287 g_main_context_dispatch(context);
291 static int os_host_main_loop_wait(int timeout)
296 glib_select_fill(&nfds, &rfds, &wfds, &xfds, &timeout);
299 qemu_mutex_unlock_iothread();
302 tv.tv_sec = timeout / 1000;
303 tv.tv_usec = (timeout % 1000) * 1000;
304 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
307 qemu_mutex_lock_iothread();
310 glib_select_poll(&rfds, &wfds, &xfds, (ret < 0));
314 /***********************************************************/
315 /* Polling handling */
317 typedef struct PollingEntry {
320 struct PollingEntry *next;
323 static PollingEntry *first_polling_entry;
325 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
327 PollingEntry **ppe, *pe;
328 pe = g_malloc0(sizeof(PollingEntry));
331 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
336 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
338 PollingEntry **ppe, *pe;
339 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
341 if (pe->func == func && pe->opaque == opaque) {
349 /***********************************************************/
350 /* Wait objects support */
351 typedef struct WaitObjects {
353 int revents[MAXIMUM_WAIT_OBJECTS + 1];
354 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
355 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
356 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
359 static WaitObjects wait_objects = {0};
361 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
363 WaitObjects *w = &wait_objects;
364 if (w->num >= MAXIMUM_WAIT_OBJECTS) {
367 w->events[w->num] = handle;
368 w->func[w->num] = func;
369 w->opaque[w->num] = opaque;
370 w->revents[w->num] = 0;
375 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
378 WaitObjects *w = &wait_objects;
381 for (i = 0; i < w->num; i++) {
382 if (w->events[i] == handle) {
386 w->events[i] = w->events[i + 1];
387 w->func[i] = w->func[i + 1];
388 w->opaque[i] = w->opaque[i + 1];
389 w->revents[i] = w->revents[i + 1];
397 void qemu_fd_register(int fd)
399 WSAEventSelect(fd, qemu_event_handle, FD_READ | FD_ACCEPT | FD_CLOSE |
400 FD_CONNECT | FD_WRITE | FD_OOB);
403 static int os_host_main_loop_wait(int timeout)
405 GMainContext *context = g_main_context_default();
408 WaitObjects *w = &wait_objects;
409 static struct timeval tv0;
411 /* XXX: need to suppress polling by better using win32 events */
413 for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
414 ret |= pe->func(pe->opaque);
421 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv0);
427 g_main_context_prepare(context, &max_priority);
428 n_poll_fds = g_main_context_query(context, max_priority, &timeout,
429 poll_fds, ARRAY_SIZE(poll_fds));
430 g_assert(n_poll_fds <= ARRAY_SIZE(poll_fds));
432 for (i = 0; i < w->num; i++) {
433 poll_fds[n_poll_fds + i].fd = (DWORD) w->events[i];
434 poll_fds[n_poll_fds + i].events = G_IO_IN;
437 qemu_mutex_unlock_iothread();
438 ret = g_poll(poll_fds, n_poll_fds + w->num, timeout);
439 qemu_mutex_lock_iothread();
441 for (i = 0; i < w->num; i++) {
442 w->revents[i] = poll_fds[n_poll_fds + i].revents;
444 for (i = 0; i < w->num; i++) {
445 if (w->revents[i] && w->func[i]) {
446 w->func[i](w->opaque[i]);
451 if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
452 g_main_context_dispatch(context);
455 /* If an edge-triggered socket event occurred, select will return a
456 * positive result on the next iteration. We do not need to do anything
464 int main_loop_wait(int nonblocking)
471 timeout = qemu_calculate_timeout();
472 qemu_bh_update_timeout(&timeout);
475 /* poll any events */
476 /* XXX: separate device handlers from system ones */
483 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
485 qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds);
486 ret = os_host_main_loop_wait(timeout);
487 qemu_iohandler_poll(&rfds, &wfds, &xfds, ret);
489 slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
492 qemu_run_all_timers();
494 /* Check bottom-halves last in case any of the earlier events triggered