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