Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 1 | /* |
| 2 | * QEMU System Emulator |
| 3 | * |
| 4 | * Copyright (c) 2003-2008 Fabrice Bellard |
| 5 | * |
| 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: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in |
| 14 | * all copies or substantial portions of the Software. |
| 15 | * |
| 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 |
| 22 | * THE SOFTWARE. |
| 23 | */ |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 24 | |
Stefan Weil | 0ec024f | 2011-10-25 22:23:17 +0200 | [diff] [blame] | 25 | #include "qemu-common.h" |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 26 | #include "qemu-timer.h" |
Stefan Weil | 0ec024f | 2011-10-25 22:23:17 +0200 | [diff] [blame] | 27 | #include "slirp/slirp.h" |
| 28 | #include "main-loop.h" |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 29 | #include "qemu-aio.h" |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 30 | |
| 31 | #ifndef _WIN32 |
| 32 | |
Stefan Weil | 0ec024f | 2011-10-25 22:23:17 +0200 | [diff] [blame] | 33 | #include "compatfd.h" |
| 34 | |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 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. |
| 38 | */ |
| 39 | static void sigfd_handler(void *opaque) |
| 40 | { |
| 41 | int fd = (intptr_t)opaque; |
| 42 | struct qemu_signalfd_siginfo info; |
| 43 | struct sigaction action; |
| 44 | ssize_t len; |
| 45 | |
| 46 | while (1) { |
| 47 | do { |
| 48 | len = read(fd, &info, sizeof(info)); |
| 49 | } while (len == -1 && errno == EINTR); |
| 50 | |
| 51 | if (len == -1 && errno == EAGAIN) { |
| 52 | break; |
| 53 | } |
| 54 | |
| 55 | if (len != sizeof(info)) { |
| 56 | printf("read from sigfd returned %zd: %m\n", len); |
| 57 | return; |
| 58 | } |
| 59 | |
| 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); |
| 66 | } |
| 67 | } |
| 68 | } |
| 69 | |
| 70 | static int qemu_signal_init(void) |
| 71 | { |
| 72 | int sigfd; |
| 73 | sigset_t set; |
| 74 | |
| 75 | /* |
| 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. |
| 79 | */ |
| 80 | sigemptyset(&set); |
| 81 | sigaddset(&set, SIG_IPI); |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 82 | sigaddset(&set, SIGIO); |
| 83 | sigaddset(&set, SIGALRM); |
| 84 | sigaddset(&set, SIGBUS); |
| 85 | pthread_sigmask(SIG_BLOCK, &set, NULL); |
| 86 | |
Lai Jiangshan | 4aa7534 | 2012-01-12 17:05:35 +0800 | [diff] [blame] | 87 | sigdelset(&set, SIG_IPI); |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 88 | sigfd = qemu_signalfd(&set); |
| 89 | if (sigfd == -1) { |
| 90 | fprintf(stderr, "failed to create signalfd\n"); |
| 91 | return -errno; |
| 92 | } |
| 93 | |
| 94 | fcntl_setfl(sigfd, O_NONBLOCK); |
| 95 | |
| 96 | qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL, |
| 97 | (void *)(intptr_t)sigfd); |
| 98 | |
| 99 | return 0; |
| 100 | } |
| 101 | |
| 102 | #else /* _WIN32 */ |
| 103 | |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 104 | static int qemu_signal_init(void) |
| 105 | { |
| 106 | return 0; |
| 107 | } |
| 108 | #endif |
| 109 | |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 110 | static AioContext *qemu_aio_context; |
| 111 | |
Paolo Bonzini | 4c8d0d2 | 2010-05-24 17:27:14 +0200 | [diff] [blame^] | 112 | void qemu_notify_event(void) |
| 113 | { |
| 114 | if (!qemu_aio_context) { |
| 115 | return; |
| 116 | } |
| 117 | aio_notify(qemu_aio_context); |
| 118 | } |
| 119 | |
Paolo Bonzini | 172061a | 2012-10-29 15:28:36 +0100 | [diff] [blame] | 120 | int qemu_init_main_loop(void) |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 121 | { |
| 122 | int ret; |
Paolo Bonzini | 82cbbdc | 2012-09-24 15:07:08 +0200 | [diff] [blame] | 123 | GSource *src; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 124 | |
Paolo Bonzini | 172061a | 2012-10-29 15:28:36 +0100 | [diff] [blame] | 125 | init_clocks(); |
| 126 | init_timer_alarm(); |
| 127 | |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 128 | qemu_mutex_lock_iothread(); |
| 129 | ret = qemu_signal_init(); |
| 130 | if (ret) { |
| 131 | return ret; |
| 132 | } |
| 133 | |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 134 | qemu_aio_context = aio_context_new(); |
Paolo Bonzini | 82cbbdc | 2012-09-24 15:07:08 +0200 | [diff] [blame] | 135 | src = aio_get_g_source(qemu_aio_context); |
| 136 | g_source_attach(src, NULL); |
| 137 | g_source_unref(src); |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 138 | return 0; |
| 139 | } |
| 140 | |
Paolo Bonzini | 1545553 | 2012-03-20 10:49:18 +0100 | [diff] [blame] | 141 | static fd_set rfds, wfds, xfds; |
| 142 | static int nfds; |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 143 | static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */ |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 144 | static int n_poll_fds; |
| 145 | static int max_priority; |
| 146 | |
Paolo Bonzini | ea26ce7 | 2012-03-20 10:49:21 +0100 | [diff] [blame] | 147 | #ifndef _WIN32 |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 148 | static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds, |
Stefano Stabellini | 7c7db75 | 2012-04-13 19:35:04 +0100 | [diff] [blame] | 149 | fd_set *xfds, uint32_t *cur_timeout) |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 150 | { |
| 151 | GMainContext *context = g_main_context_default(); |
| 152 | int i; |
Paolo Bonzini | 4dae83a | 2012-03-20 10:49:17 +0100 | [diff] [blame] | 153 | int timeout = 0; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 154 | |
| 155 | g_main_context_prepare(context, &max_priority); |
| 156 | |
| 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)); |
| 160 | |
| 161 | for (i = 0; i < n_poll_fds; i++) { |
| 162 | GPollFD *p = &poll_fds[i]; |
| 163 | |
| 164 | if ((p->events & G_IO_IN)) { |
| 165 | FD_SET(p->fd, rfds); |
| 166 | *max_fd = MAX(*max_fd, p->fd); |
| 167 | } |
| 168 | if ((p->events & G_IO_OUT)) { |
| 169 | FD_SET(p->fd, wfds); |
| 170 | *max_fd = MAX(*max_fd, p->fd); |
| 171 | } |
| 172 | if ((p->events & G_IO_ERR)) { |
| 173 | FD_SET(p->fd, xfds); |
| 174 | *max_fd = MAX(*max_fd, p->fd); |
| 175 | } |
| 176 | } |
| 177 | |
Paolo Bonzini | 4dae83a | 2012-03-20 10:49:17 +0100 | [diff] [blame] | 178 | if (timeout >= 0 && timeout < *cur_timeout) { |
| 179 | *cur_timeout = timeout; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 180 | } |
| 181 | } |
| 182 | |
| 183 | static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds, |
| 184 | bool err) |
| 185 | { |
| 186 | GMainContext *context = g_main_context_default(); |
| 187 | |
| 188 | if (!err) { |
| 189 | int i; |
| 190 | |
| 191 | for (i = 0; i < n_poll_fds; i++) { |
| 192 | GPollFD *p = &poll_fds[i]; |
| 193 | |
| 194 | if ((p->events & G_IO_IN) && FD_ISSET(p->fd, rfds)) { |
| 195 | p->revents |= G_IO_IN; |
| 196 | } |
| 197 | if ((p->events & G_IO_OUT) && FD_ISSET(p->fd, wfds)) { |
| 198 | p->revents |= G_IO_OUT; |
| 199 | } |
| 200 | if ((p->events & G_IO_ERR) && FD_ISSET(p->fd, xfds)) { |
| 201 | p->revents |= G_IO_ERR; |
| 202 | } |
| 203 | } |
| 204 | } |
| 205 | |
| 206 | if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) { |
| 207 | g_main_context_dispatch(context); |
| 208 | } |
| 209 | } |
| 210 | |
Stefano Stabellini | 7c7db75 | 2012-04-13 19:35:04 +0100 | [diff] [blame] | 211 | static int os_host_main_loop_wait(uint32_t timeout) |
Paolo Bonzini | 1545553 | 2012-03-20 10:49:18 +0100 | [diff] [blame] | 212 | { |
Stefano Stabellini | 7c7db75 | 2012-04-13 19:35:04 +0100 | [diff] [blame] | 213 | struct timeval tv, *tvarg = NULL; |
Paolo Bonzini | 1545553 | 2012-03-20 10:49:18 +0100 | [diff] [blame] | 214 | int ret; |
| 215 | |
| 216 | glib_select_fill(&nfds, &rfds, &wfds, &xfds, &timeout); |
| 217 | |
Stefano Stabellini | 7c7db75 | 2012-04-13 19:35:04 +0100 | [diff] [blame] | 218 | if (timeout < UINT32_MAX) { |
| 219 | tvarg = &tv; |
| 220 | tv.tv_sec = timeout / 1000; |
| 221 | tv.tv_usec = (timeout % 1000) * 1000; |
| 222 | } |
| 223 | |
Paolo Bonzini | 1545553 | 2012-03-20 10:49:18 +0100 | [diff] [blame] | 224 | if (timeout > 0) { |
| 225 | qemu_mutex_unlock_iothread(); |
| 226 | } |
| 227 | |
Stefano Stabellini | 7c7db75 | 2012-04-13 19:35:04 +0100 | [diff] [blame] | 228 | ret = select(nfds + 1, &rfds, &wfds, &xfds, tvarg); |
Paolo Bonzini | 1545553 | 2012-03-20 10:49:18 +0100 | [diff] [blame] | 229 | |
| 230 | if (timeout > 0) { |
| 231 | qemu_mutex_lock_iothread(); |
| 232 | } |
| 233 | |
| 234 | glib_select_poll(&rfds, &wfds, &xfds, (ret < 0)); |
| 235 | return ret; |
| 236 | } |
| 237 | #else |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 238 | /***********************************************************/ |
| 239 | /* Polling handling */ |
| 240 | |
| 241 | typedef struct PollingEntry { |
| 242 | PollingFunc *func; |
| 243 | void *opaque; |
| 244 | struct PollingEntry *next; |
| 245 | } PollingEntry; |
| 246 | |
| 247 | static PollingEntry *first_polling_entry; |
| 248 | |
| 249 | int qemu_add_polling_cb(PollingFunc *func, void *opaque) |
| 250 | { |
| 251 | PollingEntry **ppe, *pe; |
| 252 | pe = g_malloc0(sizeof(PollingEntry)); |
| 253 | pe->func = func; |
| 254 | pe->opaque = opaque; |
| 255 | for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next); |
| 256 | *ppe = pe; |
| 257 | return 0; |
| 258 | } |
| 259 | |
| 260 | void qemu_del_polling_cb(PollingFunc *func, void *opaque) |
| 261 | { |
| 262 | PollingEntry **ppe, *pe; |
| 263 | for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) { |
| 264 | pe = *ppe; |
| 265 | if (pe->func == func && pe->opaque == opaque) { |
| 266 | *ppe = pe->next; |
| 267 | g_free(pe); |
| 268 | break; |
| 269 | } |
| 270 | } |
| 271 | } |
| 272 | |
| 273 | /***********************************************************/ |
| 274 | /* Wait objects support */ |
| 275 | typedef struct WaitObjects { |
| 276 | int num; |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 277 | int revents[MAXIMUM_WAIT_OBJECTS + 1]; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 278 | HANDLE events[MAXIMUM_WAIT_OBJECTS + 1]; |
| 279 | WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1]; |
| 280 | void *opaque[MAXIMUM_WAIT_OBJECTS + 1]; |
| 281 | } WaitObjects; |
| 282 | |
| 283 | static WaitObjects wait_objects = {0}; |
| 284 | |
| 285 | int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque) |
| 286 | { |
| 287 | WaitObjects *w = &wait_objects; |
| 288 | if (w->num >= MAXIMUM_WAIT_OBJECTS) { |
| 289 | return -1; |
| 290 | } |
| 291 | w->events[w->num] = handle; |
| 292 | w->func[w->num] = func; |
| 293 | w->opaque[w->num] = opaque; |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 294 | w->revents[w->num] = 0; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 295 | w->num++; |
| 296 | return 0; |
| 297 | } |
| 298 | |
| 299 | void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque) |
| 300 | { |
| 301 | int i, found; |
| 302 | WaitObjects *w = &wait_objects; |
| 303 | |
| 304 | found = 0; |
| 305 | for (i = 0; i < w->num; i++) { |
| 306 | if (w->events[i] == handle) { |
| 307 | found = 1; |
| 308 | } |
| 309 | if (found) { |
| 310 | w->events[i] = w->events[i + 1]; |
| 311 | w->func[i] = w->func[i + 1]; |
| 312 | w->opaque[i] = w->opaque[i + 1]; |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 313 | w->revents[i] = w->revents[i + 1]; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 314 | } |
| 315 | } |
| 316 | if (found) { |
| 317 | w->num--; |
| 318 | } |
| 319 | } |
| 320 | |
Paolo Bonzini | d3385eb | 2012-03-20 10:49:19 +0100 | [diff] [blame] | 321 | void qemu_fd_register(int fd) |
| 322 | { |
Paolo Bonzini | 4c8d0d2 | 2010-05-24 17:27:14 +0200 | [diff] [blame^] | 323 | WSAEventSelect(fd, event_notifier_get_handle(&qemu_aio_context->notifier), |
| 324 | FD_READ | FD_ACCEPT | FD_CLOSE | |
Paolo Bonzini | d3385eb | 2012-03-20 10:49:19 +0100 | [diff] [blame] | 325 | FD_CONNECT | FD_WRITE | FD_OOB); |
| 326 | } |
| 327 | |
Stefano Stabellini | 7c7db75 | 2012-04-13 19:35:04 +0100 | [diff] [blame] | 328 | static int os_host_main_loop_wait(uint32_t timeout) |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 329 | { |
Paolo Bonzini | ea26ce7 | 2012-03-20 10:49:21 +0100 | [diff] [blame] | 330 | GMainContext *context = g_main_context_default(); |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 331 | int ret, i; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 332 | PollingEntry *pe; |
Paolo Bonzini | d3385eb | 2012-03-20 10:49:19 +0100 | [diff] [blame] | 333 | WaitObjects *w = &wait_objects; |
Stefan Weil | 42fe1c2 | 2012-04-27 17:02:08 +0200 | [diff] [blame] | 334 | gint poll_timeout; |
Paolo Bonzini | 1545553 | 2012-03-20 10:49:18 +0100 | [diff] [blame] | 335 | static struct timeval tv0; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 336 | |
| 337 | /* XXX: need to suppress polling by better using win32 events */ |
| 338 | ret = 0; |
| 339 | for (pe = first_polling_entry; pe != NULL; pe = pe->next) { |
| 340 | ret |= pe->func(pe->opaque); |
| 341 | } |
Paolo Bonzini | d3385eb | 2012-03-20 10:49:19 +0100 | [diff] [blame] | 342 | if (ret != 0) { |
| 343 | return ret; |
| 344 | } |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 345 | |
Paolo Bonzini | d3385eb | 2012-03-20 10:49:19 +0100 | [diff] [blame] | 346 | if (nfds >= 0) { |
| 347 | ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv0); |
| 348 | if (ret != 0) { |
Stefan Weil | 3239ad0 | 2012-04-29 19:15:02 +0200 | [diff] [blame] | 349 | timeout = 0; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 350 | } |
| 351 | } |
| 352 | |
Paolo Bonzini | ea26ce7 | 2012-03-20 10:49:21 +0100 | [diff] [blame] | 353 | g_main_context_prepare(context, &max_priority); |
Stefan Weil | 42fe1c2 | 2012-04-27 17:02:08 +0200 | [diff] [blame] | 354 | n_poll_fds = g_main_context_query(context, max_priority, &poll_timeout, |
Paolo Bonzini | ea26ce7 | 2012-03-20 10:49:21 +0100 | [diff] [blame] | 355 | poll_fds, ARRAY_SIZE(poll_fds)); |
| 356 | g_assert(n_poll_fds <= ARRAY_SIZE(poll_fds)); |
| 357 | |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 358 | for (i = 0; i < w->num; i++) { |
Stefan Weil | 58b9630 | 2012-04-12 20:42:34 +0200 | [diff] [blame] | 359 | poll_fds[n_poll_fds + i].fd = (DWORD_PTR)w->events[i]; |
Paolo Bonzini | ea26ce7 | 2012-03-20 10:49:21 +0100 | [diff] [blame] | 360 | poll_fds[n_poll_fds + i].events = G_IO_IN; |
Paolo Bonzini | d3385eb | 2012-03-20 10:49:19 +0100 | [diff] [blame] | 361 | } |
| 362 | |
Stefan Weil | 3239ad0 | 2012-04-29 19:15:02 +0200 | [diff] [blame] | 363 | if (poll_timeout < 0 || timeout < poll_timeout) { |
| 364 | poll_timeout = timeout; |
| 365 | } |
| 366 | |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 367 | qemu_mutex_unlock_iothread(); |
Stefan Weil | 42fe1c2 | 2012-04-27 17:02:08 +0200 | [diff] [blame] | 368 | ret = g_poll(poll_fds, n_poll_fds + w->num, poll_timeout); |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 369 | qemu_mutex_lock_iothread(); |
| 370 | if (ret > 0) { |
| 371 | for (i = 0; i < w->num; i++) { |
Paolo Bonzini | ea26ce7 | 2012-03-20 10:49:21 +0100 | [diff] [blame] | 372 | w->revents[i] = poll_fds[n_poll_fds + i].revents; |
Paolo Bonzini | 06ac7d4 | 2012-03-20 10:49:20 +0100 | [diff] [blame] | 373 | } |
| 374 | for (i = 0; i < w->num; i++) { |
| 375 | if (w->revents[i] && w->func[i]) { |
| 376 | w->func[i](w->opaque[i]); |
| 377 | } |
| 378 | } |
| 379 | } |
Paolo Bonzini | d3385eb | 2012-03-20 10:49:19 +0100 | [diff] [blame] | 380 | |
Paolo Bonzini | ea26ce7 | 2012-03-20 10:49:21 +0100 | [diff] [blame] | 381 | if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) { |
| 382 | g_main_context_dispatch(context); |
| 383 | } |
| 384 | |
Paolo Bonzini | d3385eb | 2012-03-20 10:49:19 +0100 | [diff] [blame] | 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 |
| 387 | * here. |
| 388 | */ |
| 389 | |
Paolo Bonzini | 1545553 | 2012-03-20 10:49:18 +0100 | [diff] [blame] | 390 | return ret; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 391 | } |
| 392 | #endif |
| 393 | |
| 394 | int main_loop_wait(int nonblocking) |
| 395 | { |
Stefano Stabellini | 7c7db75 | 2012-04-13 19:35:04 +0100 | [diff] [blame] | 396 | int ret; |
| 397 | uint32_t timeout = UINT32_MAX; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 398 | |
| 399 | if (nonblocking) { |
| 400 | timeout = 0; |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 401 | } |
| 402 | |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 403 | /* poll any events */ |
| 404 | /* XXX: separate device handlers from system ones */ |
| 405 | nfds = -1; |
| 406 | FD_ZERO(&rfds); |
| 407 | FD_ZERO(&wfds); |
| 408 | FD_ZERO(&xfds); |
| 409 | |
| 410 | #ifdef CONFIG_SLIRP |
Stefano Stabellini | 7c7db75 | 2012-04-13 19:35:04 +0100 | [diff] [blame] | 411 | slirp_update_timeout(&timeout); |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 412 | slirp_select_fill(&nfds, &rfds, &wfds, &xfds); |
| 413 | #endif |
| 414 | qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds); |
Paolo Bonzini | 1545553 | 2012-03-20 10:49:18 +0100 | [diff] [blame] | 415 | ret = os_host_main_loop_wait(timeout); |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 416 | qemu_iohandler_poll(&rfds, &wfds, &xfds, ret); |
| 417 | #ifdef CONFIG_SLIRP |
| 418 | slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0)); |
| 419 | #endif |
| 420 | |
| 421 | qemu_run_all_timers(); |
| 422 | |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 423 | return ret; |
| 424 | } |
Paolo Bonzini | f627aab | 2012-10-29 23:45:23 +0100 | [diff] [blame] | 425 | |
| 426 | /* Functions to operate on the main QEMU AioContext. */ |
| 427 | |
| 428 | QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque) |
| 429 | { |
| 430 | return aio_bh_new(qemu_aio_context, cb, opaque); |
| 431 | } |
| 432 | |
Paolo Bonzini | a915f4b | 2012-09-13 12:28:51 +0200 | [diff] [blame] | 433 | void qemu_aio_flush(void) |
| 434 | { |
| 435 | aio_flush(qemu_aio_context); |
| 436 | } |
| 437 | |
| 438 | bool qemu_aio_wait(void) |
| 439 | { |
Paolo Bonzini | 7c0628b | 2012-09-24 14:37:53 +0200 | [diff] [blame] | 440 | return aio_poll(qemu_aio_context, true); |
Paolo Bonzini | a915f4b | 2012-09-13 12:28:51 +0200 | [diff] [blame] | 441 | } |
| 442 | |
Paolo Bonzini | f42b220 | 2012-06-09 04:01:51 +0200 | [diff] [blame] | 443 | #ifdef CONFIG_POSIX |
Paolo Bonzini | a915f4b | 2012-09-13 12:28:51 +0200 | [diff] [blame] | 444 | void qemu_aio_set_fd_handler(int fd, |
| 445 | IOHandler *io_read, |
| 446 | IOHandler *io_write, |
| 447 | AioFlushHandler *io_flush, |
| 448 | void *opaque) |
| 449 | { |
| 450 | aio_set_fd_handler(qemu_aio_context, fd, io_read, io_write, io_flush, |
| 451 | opaque); |
Paolo Bonzini | a915f4b | 2012-09-13 12:28:51 +0200 | [diff] [blame] | 452 | } |
Paolo Bonzini | 82cbbdc | 2012-09-24 15:07:08 +0200 | [diff] [blame] | 453 | #endif |
Paolo Bonzini | a915f4b | 2012-09-13 12:28:51 +0200 | [diff] [blame] | 454 | |
Paolo Bonzini | a915f4b | 2012-09-13 12:28:51 +0200 | [diff] [blame] | 455 | void qemu_aio_set_event_notifier(EventNotifier *notifier, |
| 456 | EventNotifierHandler *io_read, |
| 457 | AioFlushEventNotifierHandler *io_flush) |
| 458 | { |
Paolo Bonzini | 82cbbdc | 2012-09-24 15:07:08 +0200 | [diff] [blame] | 459 | aio_set_event_notifier(qemu_aio_context, notifier, io_read, io_flush); |
Paolo Bonzini | a915f4b | 2012-09-13 12:28:51 +0200 | [diff] [blame] | 460 | } |