blob: e43c7c8e8d4355794540063da0f6be92c73e8bdc [file] [log] [blame]
Paolo Bonzinid3b12f52011-09-13 10:30:52 +02001/*
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 Bonzinid3b12f52011-09-13 10:30:52 +020024
Stefan Weil0ec024f2011-10-25 22:23:17 +020025#include "qemu-common.h"
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020026#include "qemu-timer.h"
Stefan Weil0ec024f2011-10-25 22:23:17 +020027#include "slirp/slirp.h"
28#include "main-loop.h"
Paolo Bonzinif627aab2012-10-29 23:45:23 +010029#include "qemu-aio.h"
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020030
31#ifndef _WIN32
32
Stefan Weil0ec024f2011-10-25 22:23:17 +020033#include "compatfd.h"
34
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020035/* 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 */
39static 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
70static 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 Bonzinid3b12f52011-09-13 10:30:52 +020082 sigaddset(&set, SIGIO);
83 sigaddset(&set, SIGALRM);
84 sigaddset(&set, SIGBUS);
85 pthread_sigmask(SIG_BLOCK, &set, NULL);
86
Lai Jiangshan4aa75342012-01-12 17:05:35 +080087 sigdelset(&set, SIG_IPI);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020088 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 Bonzinid3b12f52011-09-13 10:30:52 +0200104static int qemu_signal_init(void)
105{
106 return 0;
107}
108#endif
109
Paolo Bonzinif627aab2012-10-29 23:45:23 +0100110static AioContext *qemu_aio_context;
111
Paolo Bonzini4c8d0d22010-05-24 17:27:14 +0200112void qemu_notify_event(void)
113{
114 if (!qemu_aio_context) {
115 return;
116 }
117 aio_notify(qemu_aio_context);
118}
119
Paolo Bonzini172061a2012-10-29 15:28:36 +0100120int qemu_init_main_loop(void)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200121{
122 int ret;
Paolo Bonzini82cbbdc2012-09-24 15:07:08 +0200123 GSource *src;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200124
Paolo Bonzini172061a2012-10-29 15:28:36 +0100125 init_clocks();
126 init_timer_alarm();
127
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200128 qemu_mutex_lock_iothread();
129 ret = qemu_signal_init();
130 if (ret) {
131 return ret;
132 }
133
Paolo Bonzinif627aab2012-10-29 23:45:23 +0100134 qemu_aio_context = aio_context_new();
Paolo Bonzini82cbbdc2012-09-24 15:07:08 +0200135 src = aio_get_g_source(qemu_aio_context);
136 g_source_attach(src, NULL);
137 g_source_unref(src);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200138 return 0;
139}
140
Paolo Bonzini15455532012-03-20 10:49:18 +0100141static fd_set rfds, wfds, xfds;
142static int nfds;
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100143static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200144static int n_poll_fds;
145static int max_priority;
146
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100147#ifndef _WIN32
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200148static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds,
Stefano Stabellini7c7db752012-04-13 19:35:04 +0100149 fd_set *xfds, uint32_t *cur_timeout)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200150{
151 GMainContext *context = g_main_context_default();
152 int i;
Paolo Bonzini4dae83a2012-03-20 10:49:17 +0100153 int timeout = 0;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200154
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 Bonzini4dae83a2012-03-20 10:49:17 +0100178 if (timeout >= 0 && timeout < *cur_timeout) {
179 *cur_timeout = timeout;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200180 }
181}
182
183static 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 Stabellini7c7db752012-04-13 19:35:04 +0100211static int os_host_main_loop_wait(uint32_t timeout)
Paolo Bonzini15455532012-03-20 10:49:18 +0100212{
Stefano Stabellini7c7db752012-04-13 19:35:04 +0100213 struct timeval tv, *tvarg = NULL;
Paolo Bonzini15455532012-03-20 10:49:18 +0100214 int ret;
215
216 glib_select_fill(&nfds, &rfds, &wfds, &xfds, &timeout);
217
Stefano Stabellini7c7db752012-04-13 19:35:04 +0100218 if (timeout < UINT32_MAX) {
219 tvarg = &tv;
220 tv.tv_sec = timeout / 1000;
221 tv.tv_usec = (timeout % 1000) * 1000;
222 }
223
Paolo Bonzini15455532012-03-20 10:49:18 +0100224 if (timeout > 0) {
225 qemu_mutex_unlock_iothread();
226 }
227
Stefano Stabellini7c7db752012-04-13 19:35:04 +0100228 ret = select(nfds + 1, &rfds, &wfds, &xfds, tvarg);
Paolo Bonzini15455532012-03-20 10:49:18 +0100229
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 Bonzinid3b12f52011-09-13 10:30:52 +0200238/***********************************************************/
239/* Polling handling */
240
241typedef struct PollingEntry {
242 PollingFunc *func;
243 void *opaque;
244 struct PollingEntry *next;
245} PollingEntry;
246
247static PollingEntry *first_polling_entry;
248
249int 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
260void 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 */
275typedef struct WaitObjects {
276 int num;
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100277 int revents[MAXIMUM_WAIT_OBJECTS + 1];
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200278 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
279 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
280 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
281} WaitObjects;
282
283static WaitObjects wait_objects = {0};
284
285int 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 Bonzini06ac7d42012-03-20 10:49:20 +0100294 w->revents[w->num] = 0;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200295 w->num++;
296 return 0;
297}
298
299void 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 Bonzini06ac7d42012-03-20 10:49:20 +0100313 w->revents[i] = w->revents[i + 1];
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200314 }
315 }
316 if (found) {
317 w->num--;
318 }
319}
320
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100321void qemu_fd_register(int fd)
322{
Paolo Bonzini4c8d0d22010-05-24 17:27:14 +0200323 WSAEventSelect(fd, event_notifier_get_handle(&qemu_aio_context->notifier),
324 FD_READ | FD_ACCEPT | FD_CLOSE |
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100325 FD_CONNECT | FD_WRITE | FD_OOB);
326}
327
Stefano Stabellini7c7db752012-04-13 19:35:04 +0100328static int os_host_main_loop_wait(uint32_t timeout)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200329{
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100330 GMainContext *context = g_main_context_default();
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100331 int ret, i;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200332 PollingEntry *pe;
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100333 WaitObjects *w = &wait_objects;
Stefan Weil42fe1c22012-04-27 17:02:08 +0200334 gint poll_timeout;
Paolo Bonzini15455532012-03-20 10:49:18 +0100335 static struct timeval tv0;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200336
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 Bonzinid3385eb2012-03-20 10:49:19 +0100342 if (ret != 0) {
343 return ret;
344 }
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200345
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100346 if (nfds >= 0) {
347 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv0);
348 if (ret != 0) {
Stefan Weil3239ad02012-04-29 19:15:02 +0200349 timeout = 0;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200350 }
351 }
352
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100353 g_main_context_prepare(context, &max_priority);
Stefan Weil42fe1c22012-04-27 17:02:08 +0200354 n_poll_fds = g_main_context_query(context, max_priority, &poll_timeout,
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100355 poll_fds, ARRAY_SIZE(poll_fds));
356 g_assert(n_poll_fds <= ARRAY_SIZE(poll_fds));
357
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100358 for (i = 0; i < w->num; i++) {
Stefan Weil58b96302012-04-12 20:42:34 +0200359 poll_fds[n_poll_fds + i].fd = (DWORD_PTR)w->events[i];
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100360 poll_fds[n_poll_fds + i].events = G_IO_IN;
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100361 }
362
Stefan Weil3239ad02012-04-29 19:15:02 +0200363 if (poll_timeout < 0 || timeout < poll_timeout) {
364 poll_timeout = timeout;
365 }
366
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100367 qemu_mutex_unlock_iothread();
Stefan Weil42fe1c22012-04-27 17:02:08 +0200368 ret = g_poll(poll_fds, n_poll_fds + w->num, poll_timeout);
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100369 qemu_mutex_lock_iothread();
370 if (ret > 0) {
371 for (i = 0; i < w->num; i++) {
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100372 w->revents[i] = poll_fds[n_poll_fds + i].revents;
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100373 }
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 Bonzinid3385eb2012-03-20 10:49:19 +0100380
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100381 if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
382 g_main_context_dispatch(context);
383 }
384
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100385 /* 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 Bonzini15455532012-03-20 10:49:18 +0100390 return ret;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200391}
392#endif
393
394int main_loop_wait(int nonblocking)
395{
Stefano Stabellini7c7db752012-04-13 19:35:04 +0100396 int ret;
397 uint32_t timeout = UINT32_MAX;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200398
399 if (nonblocking) {
400 timeout = 0;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200401 }
402
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200403 /* 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 Stabellini7c7db752012-04-13 19:35:04 +0100411 slirp_update_timeout(&timeout);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200412 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
413#endif
414 qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds);
Paolo Bonzini15455532012-03-20 10:49:18 +0100415 ret = os_host_main_loop_wait(timeout);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200416 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 Bonzinid3b12f52011-09-13 10:30:52 +0200423 return ret;
424}
Paolo Bonzinif627aab2012-10-29 23:45:23 +0100425
426/* Functions to operate on the main QEMU AioContext. */
427
428QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
429{
430 return aio_bh_new(qemu_aio_context, cb, opaque);
431}
432
Paolo Bonzinia915f4b2012-09-13 12:28:51 +0200433void qemu_aio_flush(void)
434{
435 aio_flush(qemu_aio_context);
436}
437
438bool qemu_aio_wait(void)
439{
Paolo Bonzini7c0628b2012-09-24 14:37:53 +0200440 return aio_poll(qemu_aio_context, true);
Paolo Bonzinia915f4b2012-09-13 12:28:51 +0200441}
442
Paolo Bonzinif42b2202012-06-09 04:01:51 +0200443#ifdef CONFIG_POSIX
Paolo Bonzinia915f4b2012-09-13 12:28:51 +0200444void 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 Bonzinia915f4b2012-09-13 12:28:51 +0200452}
Paolo Bonzini82cbbdc2012-09-24 15:07:08 +0200453#endif
Paolo Bonzinia915f4b2012-09-13 12:28:51 +0200454
Paolo Bonzinia915f4b2012-09-13 12:28:51 +0200455void qemu_aio_set_event_notifier(EventNotifier *notifier,
456 EventNotifierHandler *io_read,
457 AioFlushEventNotifierHandler *io_flush)
458{
Paolo Bonzini82cbbdc2012-09-24 15:07:08 +0200459 aio_set_event_notifier(qemu_aio_context, notifier, io_read, io_flush);
Paolo Bonzinia915f4b2012-09-13 12:28:51 +0200460}