Example as code, documentation template for sphinx build
[kvmfornfv.git] / qemu / main-loop.c
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  */
24
25 #include "qemu-common.h"
26 #include "qemu/timer.h"
27 #include "qemu/sockets.h"       // struct in_addr needed for libslirp.h
28 #include "sysemu/qtest.h"
29 #include "slirp/libslirp.h"
30 #include "qemu/main-loop.h"
31 #include "block/aio.h"
32
33 #ifndef _WIN32
34
35 #include "qemu/compatfd.h"
36
37 /* If we have signalfd, we mask out the signals we want to handle and then
38  * use signalfd to listen for them.  We rely on whatever the current signal
39  * handler is to dispatch the signals when we receive them.
40  */
41 static void sigfd_handler(void *opaque)
42 {
43     int fd = (intptr_t)opaque;
44     struct qemu_signalfd_siginfo info;
45     struct sigaction action;
46     ssize_t len;
47
48     while (1) {
49         do {
50             len = read(fd, &info, sizeof(info));
51         } while (len == -1 && errno == EINTR);
52
53         if (len == -1 && errno == EAGAIN) {
54             break;
55         }
56
57         if (len != sizeof(info)) {
58             printf("read from sigfd returned %zd: %m\n", len);
59             return;
60         }
61
62         sigaction(info.ssi_signo, NULL, &action);
63         if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
64             action.sa_sigaction(info.ssi_signo,
65                                 (siginfo_t *)&info, NULL);
66         } else if (action.sa_handler) {
67             action.sa_handler(info.ssi_signo);
68         }
69     }
70 }
71
72 static int qemu_signal_init(void)
73 {
74     int sigfd;
75     sigset_t set;
76
77     /*
78      * SIG_IPI must be blocked in the main thread and must not be caught
79      * by sigwait() in the signal thread. Otherwise, the cpu thread will
80      * not catch it reliably.
81      */
82     sigemptyset(&set);
83     sigaddset(&set, SIG_IPI);
84     sigaddset(&set, SIGIO);
85     sigaddset(&set, SIGALRM);
86     sigaddset(&set, SIGBUS);
87     /* SIGINT cannot be handled via signalfd, so that ^C can be used
88      * to interrupt QEMU when it is being run under gdb.  SIGHUP and
89      * SIGTERM are also handled asynchronously, even though it is not
90      * strictly necessary, because they use the same handler as SIGINT.
91      */
92     pthread_sigmask(SIG_BLOCK, &set, NULL);
93
94     sigdelset(&set, SIG_IPI);
95     sigfd = qemu_signalfd(&set);
96     if (sigfd == -1) {
97         fprintf(stderr, "failed to create signalfd\n");
98         return -errno;
99     }
100
101     fcntl_setfl(sigfd, O_NONBLOCK);
102
103     qemu_set_fd_handler(sigfd, sigfd_handler, NULL, (void *)(intptr_t)sigfd);
104
105     return 0;
106 }
107
108 #else /* _WIN32 */
109
110 static int qemu_signal_init(void)
111 {
112     return 0;
113 }
114 #endif
115
116 static AioContext *qemu_aio_context;
117 static QEMUBH *qemu_notify_bh;
118
119 static void notify_event_cb(void *opaque)
120 {
121     /* No need to do anything; this bottom half is only used to
122      * kick the kernel out of ppoll/poll/WaitForMultipleObjects.
123      */
124 }
125
126 AioContext *qemu_get_aio_context(void)
127 {
128     return qemu_aio_context;
129 }
130
131 void qemu_notify_event(void)
132 {
133     if (!qemu_aio_context) {
134         return;
135     }
136     qemu_bh_schedule(qemu_notify_bh);
137 }
138
139 static GArray *gpollfds;
140
141 int qemu_init_main_loop(Error **errp)
142 {
143     int ret;
144     GSource *src;
145     Error *local_error = NULL;
146
147     init_clocks();
148
149     ret = qemu_signal_init();
150     if (ret) {
151         return ret;
152     }
153
154     qemu_aio_context = aio_context_new(&local_error);
155     qemu_notify_bh = qemu_bh_new(notify_event_cb, NULL);
156     if (!qemu_aio_context) {
157         error_propagate(errp, local_error);
158         return -EMFILE;
159     }
160     gpollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD));
161     src = aio_get_g_source(qemu_aio_context);
162     g_source_attach(src, NULL);
163     g_source_unref(src);
164     return 0;
165 }
166
167 static int max_priority;
168
169 #ifndef _WIN32
170 static int glib_pollfds_idx;
171 static int glib_n_poll_fds;
172
173 static void glib_pollfds_fill(int64_t *cur_timeout)
174 {
175     GMainContext *context = g_main_context_default();
176     int timeout = 0;
177     int64_t timeout_ns;
178     int n;
179
180     g_main_context_prepare(context, &max_priority);
181
182     glib_pollfds_idx = gpollfds->len;
183     n = glib_n_poll_fds;
184     do {
185         GPollFD *pfds;
186         glib_n_poll_fds = n;
187         g_array_set_size(gpollfds, glib_pollfds_idx + glib_n_poll_fds);
188         pfds = &g_array_index(gpollfds, GPollFD, glib_pollfds_idx);
189         n = g_main_context_query(context, max_priority, &timeout, pfds,
190                                  glib_n_poll_fds);
191     } while (n != glib_n_poll_fds);
192
193     if (timeout < 0) {
194         timeout_ns = -1;
195     } else {
196         timeout_ns = (int64_t)timeout * (int64_t)SCALE_MS;
197     }
198
199     *cur_timeout = qemu_soonest_timeout(timeout_ns, *cur_timeout);
200 }
201
202 static void glib_pollfds_poll(void)
203 {
204     GMainContext *context = g_main_context_default();
205     GPollFD *pfds = &g_array_index(gpollfds, GPollFD, glib_pollfds_idx);
206
207     if (g_main_context_check(context, max_priority, pfds, glib_n_poll_fds)) {
208         g_main_context_dispatch(context);
209     }
210 }
211
212 #define MAX_MAIN_LOOP_SPIN (1000)
213
214 static int os_host_main_loop_wait(int64_t timeout)
215 {
216     int ret;
217     static int spin_counter;
218
219     glib_pollfds_fill(&timeout);
220
221     /* If the I/O thread is very busy or we are incorrectly busy waiting in
222      * the I/O thread, this can lead to starvation of the BQL such that the
223      * VCPU threads never run.  To make sure we can detect the later case,
224      * print a message to the screen.  If we run into this condition, create
225      * a fake timeout in order to give the VCPU threads a chance to run.
226      */
227     if (!timeout && (spin_counter > MAX_MAIN_LOOP_SPIN)) {
228         static bool notified;
229
230         if (!notified && !qtest_enabled()) {
231             fprintf(stderr,
232                     "main-loop: WARNING: I/O thread spun for %d iterations\n",
233                     MAX_MAIN_LOOP_SPIN);
234             notified = true;
235         }
236
237         timeout = SCALE_MS;
238     }
239
240     if (timeout) {
241         spin_counter = 0;
242         qemu_mutex_unlock_iothread();
243     } else {
244         spin_counter++;
245     }
246
247     ret = qemu_poll_ns((GPollFD *)gpollfds->data, gpollfds->len, timeout);
248
249     if (timeout) {
250         qemu_mutex_lock_iothread();
251     }
252
253     glib_pollfds_poll();
254     return ret;
255 }
256 #else
257 /***********************************************************/
258 /* Polling handling */
259
260 typedef struct PollingEntry {
261     PollingFunc *func;
262     void *opaque;
263     struct PollingEntry *next;
264 } PollingEntry;
265
266 static PollingEntry *first_polling_entry;
267
268 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
269 {
270     PollingEntry **ppe, *pe;
271     pe = g_malloc0(sizeof(PollingEntry));
272     pe->func = func;
273     pe->opaque = opaque;
274     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
275     *ppe = pe;
276     return 0;
277 }
278
279 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
280 {
281     PollingEntry **ppe, *pe;
282     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
283         pe = *ppe;
284         if (pe->func == func && pe->opaque == opaque) {
285             *ppe = pe->next;
286             g_free(pe);
287             break;
288         }
289     }
290 }
291
292 /***********************************************************/
293 /* Wait objects support */
294 typedef struct WaitObjects {
295     int num;
296     int revents[MAXIMUM_WAIT_OBJECTS + 1];
297     HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
298     WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
299     void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
300 } WaitObjects;
301
302 static WaitObjects wait_objects = {0};
303
304 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
305 {
306     WaitObjects *w = &wait_objects;
307     if (w->num >= MAXIMUM_WAIT_OBJECTS) {
308         return -1;
309     }
310     w->events[w->num] = handle;
311     w->func[w->num] = func;
312     w->opaque[w->num] = opaque;
313     w->revents[w->num] = 0;
314     w->num++;
315     return 0;
316 }
317
318 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
319 {
320     int i, found;
321     WaitObjects *w = &wait_objects;
322
323     found = 0;
324     for (i = 0; i < w->num; i++) {
325         if (w->events[i] == handle) {
326             found = 1;
327         }
328         if (found) {
329             w->events[i] = w->events[i + 1];
330             w->func[i] = w->func[i + 1];
331             w->opaque[i] = w->opaque[i + 1];
332             w->revents[i] = w->revents[i + 1];
333         }
334     }
335     if (found) {
336         w->num--;
337     }
338 }
339
340 void qemu_fd_register(int fd)
341 {
342     WSAEventSelect(fd, event_notifier_get_handle(&qemu_aio_context->notifier),
343                    FD_READ | FD_ACCEPT | FD_CLOSE |
344                    FD_CONNECT | FD_WRITE | FD_OOB);
345 }
346
347 static int pollfds_fill(GArray *pollfds, fd_set *rfds, fd_set *wfds,
348                         fd_set *xfds)
349 {
350     int nfds = -1;
351     int i;
352
353     for (i = 0; i < pollfds->len; i++) {
354         GPollFD *pfd = &g_array_index(pollfds, GPollFD, i);
355         int fd = pfd->fd;
356         int events = pfd->events;
357         if (events & G_IO_IN) {
358             FD_SET(fd, rfds);
359             nfds = MAX(nfds, fd);
360         }
361         if (events & G_IO_OUT) {
362             FD_SET(fd, wfds);
363             nfds = MAX(nfds, fd);
364         }
365         if (events & G_IO_PRI) {
366             FD_SET(fd, xfds);
367             nfds = MAX(nfds, fd);
368         }
369     }
370     return nfds;
371 }
372
373 static void pollfds_poll(GArray *pollfds, int nfds, fd_set *rfds,
374                          fd_set *wfds, fd_set *xfds)
375 {
376     int i;
377
378     for (i = 0; i < pollfds->len; i++) {
379         GPollFD *pfd = &g_array_index(pollfds, GPollFD, i);
380         int fd = pfd->fd;
381         int revents = 0;
382
383         if (FD_ISSET(fd, rfds)) {
384             revents |= G_IO_IN;
385         }
386         if (FD_ISSET(fd, wfds)) {
387             revents |= G_IO_OUT;
388         }
389         if (FD_ISSET(fd, xfds)) {
390             revents |= G_IO_PRI;
391         }
392         pfd->revents = revents & pfd->events;
393     }
394 }
395
396 static int os_host_main_loop_wait(int64_t timeout)
397 {
398     GMainContext *context = g_main_context_default();
399     GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
400     int select_ret = 0;
401     int g_poll_ret, ret, i, n_poll_fds;
402     PollingEntry *pe;
403     WaitObjects *w = &wait_objects;
404     gint poll_timeout;
405     int64_t poll_timeout_ns;
406     static struct timeval tv0;
407     fd_set rfds, wfds, xfds;
408     int nfds;
409
410     /* XXX: need to suppress polling by better using win32 events */
411     ret = 0;
412     for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
413         ret |= pe->func(pe->opaque);
414     }
415     if (ret != 0) {
416         return ret;
417     }
418
419     FD_ZERO(&rfds);
420     FD_ZERO(&wfds);
421     FD_ZERO(&xfds);
422     nfds = pollfds_fill(gpollfds, &rfds, &wfds, &xfds);
423     if (nfds >= 0) {
424         select_ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv0);
425         if (select_ret != 0) {
426             timeout = 0;
427         }
428         if (select_ret > 0) {
429             pollfds_poll(gpollfds, nfds, &rfds, &wfds, &xfds);
430         }
431     }
432
433     g_main_context_prepare(context, &max_priority);
434     n_poll_fds = g_main_context_query(context, max_priority, &poll_timeout,
435                                       poll_fds, ARRAY_SIZE(poll_fds));
436     g_assert(n_poll_fds <= ARRAY_SIZE(poll_fds));
437
438     for (i = 0; i < w->num; i++) {
439         poll_fds[n_poll_fds + i].fd = (DWORD_PTR)w->events[i];
440         poll_fds[n_poll_fds + i].events = G_IO_IN;
441     }
442
443     if (poll_timeout < 0) {
444         poll_timeout_ns = -1;
445     } else {
446         poll_timeout_ns = (int64_t)poll_timeout * (int64_t)SCALE_MS;
447     }
448
449     poll_timeout_ns = qemu_soonest_timeout(poll_timeout_ns, timeout);
450
451     qemu_mutex_unlock_iothread();
452     g_poll_ret = qemu_poll_ns(poll_fds, n_poll_fds + w->num, poll_timeout_ns);
453
454     qemu_mutex_lock_iothread();
455     if (g_poll_ret > 0) {
456         for (i = 0; i < w->num; i++) {
457             w->revents[i] = poll_fds[n_poll_fds + i].revents;
458         }
459         for (i = 0; i < w->num; i++) {
460             if (w->revents[i] && w->func[i]) {
461                 w->func[i](w->opaque[i]);
462             }
463         }
464     }
465
466     if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
467         g_main_context_dispatch(context);
468     }
469
470     return select_ret || g_poll_ret;
471 }
472 #endif
473
474 int main_loop_wait(int nonblocking)
475 {
476     int ret;
477     uint32_t timeout = UINT32_MAX;
478     int64_t timeout_ns;
479
480     if (nonblocking) {
481         timeout = 0;
482     }
483
484     /* poll any events */
485     g_array_set_size(gpollfds, 0); /* reset for new iteration */
486     /* XXX: separate device handlers from system ones */
487 #ifdef CONFIG_SLIRP
488     slirp_pollfds_fill(gpollfds, &timeout);
489 #endif
490     qemu_iohandler_fill(gpollfds);
491
492     if (timeout == UINT32_MAX) {
493         timeout_ns = -1;
494     } else {
495         timeout_ns = (uint64_t)timeout * (int64_t)(SCALE_MS);
496     }
497
498     timeout_ns = qemu_soonest_timeout(timeout_ns,
499                                       timerlistgroup_deadline_ns(
500                                           &main_loop_tlg));
501
502     ret = os_host_main_loop_wait(timeout_ns);
503     qemu_iohandler_poll(gpollfds, ret);
504 #ifdef CONFIG_SLIRP
505     slirp_pollfds_poll(gpollfds, (ret < 0));
506 #endif
507
508     qemu_clock_run_all_timers();
509
510     return ret;
511 }
512
513 /* Functions to operate on the main QEMU AioContext.  */
514
515 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
516 {
517     return aio_bh_new(qemu_aio_context, cb, opaque);
518 }