1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include "qapi/error.h"
27#include "qemu/cutils.h"
28#include "qemu/timer.h"
29#include "sysemu/cpu-timers.h"
30#include "sysemu/replay.h"
31#include "qemu/main-loop.h"
32#include "block/aio.h"
33#include "block/thread-pool.h"
34#include "qemu/error-report.h"
35#include "qemu/queue.h"
36#include "qemu/compiler.h"
37#include "qom/object.h"
38
39#ifndef _WIN32
40#include <sys/wait.h>
41#endif
42
43#ifndef _WIN32
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58QEMU_DISABLE_CFI
59static void sigfd_handler(void *opaque)
60{
61 int fd = (intptr_t)opaque;
62 struct qemu_signalfd_siginfo info;
63 struct sigaction action;
64 ssize_t len;
65
66 while (1) {
67 do {
68 len = read(fd, &info, sizeof(info));
69 } while (len == -1 && errno == EINTR);
70
71 if (len == -1 && errno == EAGAIN) {
72 break;
73 }
74
75 if (len != sizeof(info)) {
76 error_report("read from sigfd returned %zd: %s", len,
77 g_strerror(errno));
78 return;
79 }
80
81 sigaction(info.ssi_signo, NULL, &action);
82 if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
83 sigaction_invoke(&action, &info);
84 } else if (action.sa_handler) {
85 action.sa_handler(info.ssi_signo);
86 }
87 }
88}
89
90static int qemu_signal_init(Error **errp)
91{
92 int sigfd;
93 sigset_t set;
94
95
96
97
98
99
100 sigemptyset(&set);
101 sigaddset(&set, SIG_IPI);
102 sigaddset(&set, SIGIO);
103 sigaddset(&set, SIGALRM);
104 sigaddset(&set, SIGBUS);
105
106
107
108
109
110 pthread_sigmask(SIG_BLOCK, &set, NULL);
111
112 sigdelset(&set, SIG_IPI);
113 sigfd = qemu_signalfd(&set);
114 if (sigfd == -1) {
115 error_setg_errno(errp, errno, "failed to create signalfd");
116 return -errno;
117 }
118
119 g_unix_set_fd_nonblocking(sigfd, true, NULL);
120
121 qemu_set_fd_handler(sigfd, sigfd_handler, NULL, (void *)(intptr_t)sigfd);
122
123 return 0;
124}
125
126#else
127
128static int qemu_signal_init(Error **errp)
129{
130 return 0;
131}
132#endif
133
134static AioContext *qemu_aio_context;
135static QEMUBH *qemu_notify_bh;
136
137static void notify_event_cb(void *opaque)
138{
139
140
141
142}
143
144AioContext *qemu_get_aio_context(void)
145{
146 return qemu_aio_context;
147}
148
149void qemu_notify_event(void)
150{
151 if (!qemu_aio_context) {
152 return;
153 }
154 qemu_bh_schedule(qemu_notify_bh);
155}
156
157static GArray *gpollfds;
158
159int qemu_init_main_loop(Error **errp)
160{
161 int ret;
162 GSource *src;
163
164 init_clocks(qemu_timer_notify_cb);
165
166 ret = qemu_signal_init(errp);
167 if (ret) {
168 return ret;
169 }
170
171 qemu_aio_context = aio_context_new(errp);
172 if (!qemu_aio_context) {
173 return -EMFILE;
174 }
175 qemu_set_current_aio_context(qemu_aio_context);
176 qemu_notify_bh = qemu_bh_new(notify_event_cb, NULL);
177 gpollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD));
178 src = aio_get_g_source(qemu_aio_context);
179 g_source_set_name(src, "aio-context");
180 g_source_attach(src, NULL);
181 g_source_unref(src);
182 src = iohandler_get_g_source();
183 g_source_set_name(src, "io-handler");
184 g_source_attach(src, NULL);
185 g_source_unref(src);
186 return 0;
187}
188
189static void main_loop_update_params(EventLoopBase *base, Error **errp)
190{
191 ERRP_GUARD();
192
193 if (!qemu_aio_context) {
194 error_setg(errp, "qemu aio context not ready");
195 return;
196 }
197
198 aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
199 if (*errp) {
200 return;
201 }
202
203 aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool_min,
204 base->thread_pool_max, errp);
205}
206
207MainLoop *mloop;
208
209static void main_loop_init(EventLoopBase *base, Error **errp)
210{
211 MainLoop *m = MAIN_LOOP(base);
212
213 if (mloop) {
214 error_setg(errp, "only one main-loop instance allowed");
215 return;
216 }
217
218 main_loop_update_params(base, errp);
219
220 mloop = m;
221 return;
222}
223
224static bool main_loop_can_be_deleted(EventLoopBase *base)
225{
226 return false;
227}
228
229static void main_loop_class_init(ObjectClass *oc, void *class_data)
230{
231 EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(oc);
232
233 bc->init = main_loop_init;
234 bc->update_params = main_loop_update_params;
235 bc->can_be_deleted = main_loop_can_be_deleted;
236}
237
238static const TypeInfo main_loop_info = {
239 .name = TYPE_MAIN_LOOP,
240 .parent = TYPE_EVENT_LOOP_BASE,
241 .class_init = main_loop_class_init,
242 .instance_size = sizeof(MainLoop),
243};
244
245static void main_loop_register_types(void)
246{
247 type_register_static(&main_loop_info);
248}
249
250type_init(main_loop_register_types)
251
252static int max_priority;
253
254#ifndef _WIN32
255static int glib_pollfds_idx;
256static int glib_n_poll_fds;
257
258void qemu_fd_register(int fd)
259{
260}
261
262static void glib_pollfds_fill(int64_t *cur_timeout)
263{
264 GMainContext *context = g_main_context_default();
265 int timeout = 0;
266 int64_t timeout_ns;
267 int n;
268
269 g_main_context_prepare(context, &max_priority);
270
271 glib_pollfds_idx = gpollfds->len;
272 n = glib_n_poll_fds;
273 do {
274 GPollFD *pfds;
275 glib_n_poll_fds = n;
276 g_array_set_size(gpollfds, glib_pollfds_idx + glib_n_poll_fds);
277 pfds = &g_array_index(gpollfds, GPollFD, glib_pollfds_idx);
278 n = g_main_context_query(context, max_priority, &timeout, pfds,
279 glib_n_poll_fds);
280 } while (n != glib_n_poll_fds);
281
282 if (timeout < 0) {
283 timeout_ns = -1;
284 } else {
285 timeout_ns = (int64_t)timeout * (int64_t)SCALE_MS;
286 }
287
288 *cur_timeout = qemu_soonest_timeout(timeout_ns, *cur_timeout);
289}
290
291static void glib_pollfds_poll(void)
292{
293 GMainContext *context = g_main_context_default();
294 GPollFD *pfds = &g_array_index(gpollfds, GPollFD, glib_pollfds_idx);
295
296 if (g_main_context_check(context, max_priority, pfds, glib_n_poll_fds)) {
297 g_main_context_dispatch(context);
298 }
299}
300
301#define MAX_MAIN_LOOP_SPIN (1000)
302
303static int os_host_main_loop_wait(int64_t timeout)
304{
305 GMainContext *context = g_main_context_default();
306 int ret;
307
308 g_main_context_acquire(context);
309
310 glib_pollfds_fill(&timeout);
311
312 qemu_mutex_unlock_iothread();
313 replay_mutex_unlock();
314
315 ret = qemu_poll_ns((GPollFD *)gpollfds->data, gpollfds->len, timeout);
316
317 replay_mutex_lock();
318 qemu_mutex_lock_iothread();
319
320 glib_pollfds_poll();
321
322 g_main_context_release(context);
323
324 return ret;
325}
326#else
327
328
329
330typedef struct PollingEntry {
331 PollingFunc *func;
332 void *opaque;
333 struct PollingEntry *next;
334} PollingEntry;
335
336static PollingEntry *first_polling_entry;
337
338int qemu_add_polling_cb(PollingFunc *func, void *opaque)
339{
340 PollingEntry **ppe, *pe;
341 pe = g_new0(PollingEntry, 1);
342 pe->func = func;
343 pe->opaque = opaque;
344 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
345 *ppe = pe;
346 return 0;
347}
348
349void qemu_del_polling_cb(PollingFunc *func, void *opaque)
350{
351 PollingEntry **ppe, *pe;
352 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
353 pe = *ppe;
354 if (pe->func == func && pe->opaque == opaque) {
355 *ppe = pe->next;
356 g_free(pe);
357 break;
358 }
359 }
360}
361
362
363
364typedef struct WaitObjects {
365 int num;
366 int revents[MAXIMUM_WAIT_OBJECTS + 1];
367 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
368 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
369 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
370} WaitObjects;
371
372static WaitObjects wait_objects = {0};
373
374int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
375{
376 WaitObjects *w = &wait_objects;
377 if (w->num >= MAXIMUM_WAIT_OBJECTS) {
378 return -1;
379 }
380 w->events[w->num] = handle;
381 w->func[w->num] = func;
382 w->opaque[w->num] = opaque;
383 w->revents[w->num] = 0;
384 w->num++;
385 return 0;
386}
387
388void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
389{
390 int i, found;
391 WaitObjects *w = &wait_objects;
392
393 found = 0;
394 for (i = 0; i < w->num; i++) {
395 if (w->events[i] == handle) {
396 found = 1;
397 }
398 if (found) {
399 w->events[i] = w->events[i + 1];
400 w->func[i] = w->func[i + 1];
401 w->opaque[i] = w->opaque[i + 1];
402 w->revents[i] = w->revents[i + 1];
403 }
404 }
405 if (found) {
406 w->num--;
407 }
408}
409
410void qemu_fd_register(int fd)
411{
412 WSAEventSelect(fd, event_notifier_get_handle(&qemu_aio_context->notifier),
413 FD_READ | FD_ACCEPT | FD_CLOSE |
414 FD_CONNECT | FD_WRITE | FD_OOB);
415}
416
417static int pollfds_fill(GArray *pollfds, fd_set *rfds, fd_set *wfds,
418 fd_set *xfds)
419{
420 int nfds = -1;
421 int i;
422
423 for (i = 0; i < pollfds->len; i++) {
424 GPollFD *pfd = &g_array_index(pollfds, GPollFD, i);
425 int fd = pfd->fd;
426 int events = pfd->events;
427 if (events & G_IO_IN) {
428 FD_SET(fd, rfds);
429 nfds = MAX(nfds, fd);
430 }
431 if (events & G_IO_OUT) {
432 FD_SET(fd, wfds);
433 nfds = MAX(nfds, fd);
434 }
435 if (events & G_IO_PRI) {
436 FD_SET(fd, xfds);
437 nfds = MAX(nfds, fd);
438 }
439 }
440 return nfds;
441}
442
443static void pollfds_poll(GArray *pollfds, int nfds, fd_set *rfds,
444 fd_set *wfds, fd_set *xfds)
445{
446 int i;
447
448 for (i = 0; i < pollfds->len; i++) {
449 GPollFD *pfd = &g_array_index(pollfds, GPollFD, i);
450 int fd = pfd->fd;
451 int revents = 0;
452
453 if (FD_ISSET(fd, rfds)) {
454 revents |= G_IO_IN;
455 }
456 if (FD_ISSET(fd, wfds)) {
457 revents |= G_IO_OUT;
458 }
459 if (FD_ISSET(fd, xfds)) {
460 revents |= G_IO_PRI;
461 }
462 pfd->revents = revents & pfd->events;
463 }
464}
465
466static int os_host_main_loop_wait(int64_t timeout)
467{
468 GMainContext *context = g_main_context_default();
469 GPollFD poll_fds[1024 * 2];
470 int select_ret = 0;
471 int g_poll_ret, ret, i, n_poll_fds;
472 PollingEntry *pe;
473 WaitObjects *w = &wait_objects;
474 gint poll_timeout;
475 int64_t poll_timeout_ns;
476 static struct timeval tv0;
477 fd_set rfds, wfds, xfds;
478 int nfds;
479
480 g_main_context_acquire(context);
481
482
483 ret = 0;
484 for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
485 ret |= pe->func(pe->opaque);
486 }
487 if (ret != 0) {
488 g_main_context_release(context);
489 return ret;
490 }
491
492 FD_ZERO(&rfds);
493 FD_ZERO(&wfds);
494 FD_ZERO(&xfds);
495 nfds = pollfds_fill(gpollfds, &rfds, &wfds, &xfds);
496 if (nfds >= 0) {
497 select_ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv0);
498 if (select_ret != 0) {
499 timeout = 0;
500 }
501 if (select_ret > 0) {
502 pollfds_poll(gpollfds, nfds, &rfds, &wfds, &xfds);
503 }
504 }
505
506 g_main_context_prepare(context, &max_priority);
507 n_poll_fds = g_main_context_query(context, max_priority, &poll_timeout,
508 poll_fds, ARRAY_SIZE(poll_fds));
509 g_assert(n_poll_fds + w->num <= ARRAY_SIZE(poll_fds));
510
511 for (i = 0; i < w->num; i++) {
512 poll_fds[n_poll_fds + i].fd = (DWORD_PTR)w->events[i];
513 poll_fds[n_poll_fds + i].events = G_IO_IN;
514 }
515
516 if (poll_timeout < 0) {
517 poll_timeout_ns = -1;
518 } else {
519 poll_timeout_ns = (int64_t)poll_timeout * (int64_t)SCALE_MS;
520 }
521
522 poll_timeout_ns = qemu_soonest_timeout(poll_timeout_ns, timeout);
523
524 qemu_mutex_unlock_iothread();
525
526 replay_mutex_unlock();
527
528 g_poll_ret = qemu_poll_ns(poll_fds, n_poll_fds + w->num, poll_timeout_ns);
529
530 replay_mutex_lock();
531
532 qemu_mutex_lock_iothread();
533 if (g_poll_ret > 0) {
534 for (i = 0; i < w->num; i++) {
535 w->revents[i] = poll_fds[n_poll_fds + i].revents;
536 }
537 for (i = 0; i < w->num; i++) {
538 if (w->revents[i] && w->func[i]) {
539 w->func[i](w->opaque[i]);
540 }
541 }
542 }
543
544 if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
545 g_main_context_dispatch(context);
546 }
547
548 g_main_context_release(context);
549
550 return select_ret || g_poll_ret;
551}
552#endif
553
554static NotifierList main_loop_poll_notifiers =
555 NOTIFIER_LIST_INITIALIZER(main_loop_poll_notifiers);
556
557void main_loop_poll_add_notifier(Notifier *notify)
558{
559 notifier_list_add(&main_loop_poll_notifiers, notify);
560}
561
562void main_loop_poll_remove_notifier(Notifier *notify)
563{
564 notifier_remove(notify);
565}
566
567void main_loop_wait(int nonblocking)
568{
569 MainLoopPoll mlpoll = {
570 .state = MAIN_LOOP_POLL_FILL,
571 .timeout = UINT32_MAX,
572 .pollfds = gpollfds,
573 };
574 int ret;
575 int64_t timeout_ns;
576
577 if (nonblocking) {
578 mlpoll.timeout = 0;
579 }
580
581
582 g_array_set_size(gpollfds, 0);
583
584 notifier_list_notify(&main_loop_poll_notifiers, &mlpoll);
585
586 if (mlpoll.timeout == UINT32_MAX) {
587 timeout_ns = -1;
588 } else {
589 timeout_ns = (uint64_t)mlpoll.timeout * (int64_t)(SCALE_MS);
590 }
591
592 timeout_ns = qemu_soonest_timeout(timeout_ns,
593 timerlistgroup_deadline_ns(
594 &main_loop_tlg));
595
596 ret = os_host_main_loop_wait(timeout_ns);
597 mlpoll.state = ret < 0 ? MAIN_LOOP_POLL_ERR : MAIN_LOOP_POLL_OK;
598 notifier_list_notify(&main_loop_poll_notifiers, &mlpoll);
599
600 if (icount_enabled()) {
601
602
603
604
605 icount_start_warp_timer();
606 }
607 qemu_clock_run_all_timers();
608}
609
610
611
612QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
613{
614 return aio_bh_new_full(qemu_aio_context, cb, opaque, name);
615}
616
617
618
619
620
621
622static AioContext *iohandler_ctx;
623
624static void iohandler_init(void)
625{
626 if (!iohandler_ctx) {
627 iohandler_ctx = aio_context_new(&error_abort);
628 }
629}
630
631AioContext *iohandler_get_aio_context(void)
632{
633 iohandler_init();
634 return iohandler_ctx;
635}
636
637GSource *iohandler_get_g_source(void)
638{
639 iohandler_init();
640 return aio_get_g_source(iohandler_ctx);
641}
642
643void qemu_set_fd_handler(int fd,
644 IOHandler *fd_read,
645 IOHandler *fd_write,
646 void *opaque)
647{
648 iohandler_init();
649 aio_set_fd_handler(iohandler_ctx, fd, false,
650 fd_read, fd_write, NULL, NULL, opaque);
651}
652
653void event_notifier_set_handler(EventNotifier *e,
654 EventNotifierHandler *handler)
655{
656 iohandler_init();
657 aio_set_event_notifier(iohandler_ctx, e, false,
658 handler, NULL, NULL);
659}
660