blob: 014c795916229ecac587f4bc94e1c92c5dc6db21 [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
Peter Maydelld38ea872016-01-29 17:50:05 +000025#include "qemu/osdep.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010026#include "qapi/error.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020027#include "qemu/cutils.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010028#include "qemu/timer.h"
Claudio Fontana740b1752020-08-19 13:17:19 +020029#include "sysemu/cpu-timers.h"
Alex Bennéed759c952018-02-27 12:52:48 +030030#include "sysemu/replay.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010031#include "qemu/main-loop.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010032#include "block/aio.h"
Nicolas Saenz Julienne71ad4712022-04-25 09:57:23 +020033#include "block/thread-pool.h"
Alistair Francis8297be82017-09-11 12:52:53 -070034#include "qemu/error-report.h"
Paolo Bonzinie9ed92b2019-07-12 19:34:35 +020035#include "qemu/queue.h"
Nicolas Saenz Julienne70ac26b2022-04-25 09:57:22 +020036#include "qom/object.h"
Paolo Bonzinie9ed92b2019-07-12 19:34:35 +020037
38#ifndef _WIN32
39#include <sys/wait.h>
40#endif
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020041
42#ifndef _WIN32
43
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020044/* If we have signalfd, we mask out the signals we want to handle and then
45 * use signalfd to listen for them. We rely on whatever the current signal
46 * handler is to dispatch the signals when we receive them.
47 */
Daniele Buonoc905a362020-12-04 18:06:12 -050048/*
49 * Disable CFI checks.
50 * We are going to call a signal hander directly. Such handler may or may not
51 * have been defined in our binary, so there's no guarantee that the pointer
52 * used to set the handler is a cfi-valid pointer. Since the handlers are
53 * stored in kernel memory, changing the handler to an attacker-defined
54 * function requires being able to call a sigaction() syscall,
55 * which is not as easy as overwriting a pointer in memory.
56 */
57QEMU_DISABLE_CFI
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020058static 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) {
Nikita Ivanov37b0b242022-10-23 12:04:22 +030066 len = RETRY_ON_EINTR(read(fd, &info, sizeof(info)));
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020067
68 if (len == -1 && errno == EAGAIN) {
69 break;
70 }
71
72 if (len != sizeof(info)) {
Thomas Huth372a87a2019-10-18 15:07:16 +020073 error_report("read from sigfd returned %zd: %s", len,
74 g_strerror(errno));
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020075 return;
76 }
77
78 sigaction(info.ssi_signo, NULL, &action);
79 if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
Paolo Bonzinid98d4072017-02-08 13:22:12 +010080 sigaction_invoke(&action, &info);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020081 } else if (action.sa_handler) {
82 action.sa_handler(info.ssi_signo);
83 }
84 }
85}
86
Fei Li78524332019-01-13 22:08:45 +080087static int qemu_signal_init(Error **errp)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020088{
89 int sigfd;
90 sigset_t set;
91
92 /*
93 * SIG_IPI must be blocked in the main thread and must not be caught
94 * by sigwait() in the signal thread. Otherwise, the cpu thread will
95 * not catch it reliably.
96 */
97 sigemptyset(&set);
98 sigaddset(&set, SIG_IPI);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +020099 sigaddset(&set, SIGIO);
100 sigaddset(&set, SIGALRM);
101 sigaddset(&set, SIGBUS);
Jan Kiszka3e9418e2014-10-27 14:13:02 +0000102 /* SIGINT cannot be handled via signalfd, so that ^C can be used
103 * to interrupt QEMU when it is being run under gdb. SIGHUP and
104 * SIGTERM are also handled asynchronously, even though it is not
105 * strictly necessary, because they use the same handler as SIGINT.
106 */
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200107 pthread_sigmask(SIG_BLOCK, &set, NULL);
108
Lai Jiangshan4aa75342012-01-12 17:05:35 +0800109 sigdelset(&set, SIG_IPI);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200110 sigfd = qemu_signalfd(&set);
111 if (sigfd == -1) {
Fei Li78524332019-01-13 22:08:45 +0800112 error_setg_errno(errp, errno, "failed to create signalfd");
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200113 return -errno;
114 }
115
Marc-André Lureau4d14cb02022-03-29 15:25:05 +0400116 g_unix_set_fd_nonblocking(sigfd, true, NULL);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200117
Fam Zheng82e1cc42015-06-04 14:45:18 +0800118 qemu_set_fd_handler(sigfd, sigfd_handler, NULL, (void *)(intptr_t)sigfd);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200119
120 return 0;
121}
122
123#else /* _WIN32 */
124
Fei Li78524332019-01-13 22:08:45 +0800125static int qemu_signal_init(Error **errp)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200126{
127 return 0;
128}
129#endif
130
Paolo Bonzinif627aab2012-10-29 23:45:23 +0100131static AioContext *qemu_aio_context;
Paolo Bonziniedec47c2015-07-24 13:42:55 +0200132static QEMUBH *qemu_notify_bh;
133
134static void notify_event_cb(void *opaque)
135{
136 /* No need to do anything; this bottom half is only used to
137 * kick the kernel out of ppoll/poll/WaitForMultipleObjects.
138 */
139}
Paolo Bonzinif627aab2012-10-29 23:45:23 +0100140
Stefan Hajnoczi5f3aa1f2013-03-07 13:41:44 +0100141AioContext *qemu_get_aio_context(void)
142{
143 return qemu_aio_context;
144}
145
Paolo Bonzini4c8d0d22010-05-24 17:27:14 +0200146void qemu_notify_event(void)
147{
148 if (!qemu_aio_context) {
149 return;
150 }
Paolo Bonziniedec47c2015-07-24 13:42:55 +0200151 qemu_bh_schedule(qemu_notify_bh);
Paolo Bonzini4c8d0d22010-05-24 17:27:14 +0200152}
153
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100154static GArray *gpollfds;
155
Chrysostomos Nanakos2f78e492014-09-18 14:30:49 +0300156int qemu_init_main_loop(Error **errp)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200157{
158 int ret;
Paolo Bonzini82cbbdc2012-09-24 15:07:08 +0200159 GSource *src;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200160
Paolo Bonzini3f53bc62017-03-03 11:50:29 +0100161 init_clocks(qemu_timer_notify_cb);
Paolo Bonzini172061a2012-10-29 15:28:36 +0100162
Fei Li78524332019-01-13 22:08:45 +0800163 ret = qemu_signal_init(errp);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200164 if (ret) {
165 return ret;
166 }
167
Markus Armbruster668f62e2020-07-07 18:06:02 +0200168 qemu_aio_context = aio_context_new(errp);
Chrysostomos Nanakos2f78e492014-09-18 14:30:49 +0300169 if (!qemu_aio_context) {
Chrysostomos Nanakos2f78e492014-09-18 14:30:49 +0300170 return -EMFILE;
171 }
Paolo Bonzini5f50be92021-06-09 14:22:34 +0200172 qemu_set_current_aio_context(qemu_aio_context);
Cao jin28ba61e2016-07-06 18:08:59 +0800173 qemu_notify_bh = qemu_bh_new(notify_event_cb, NULL);
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100174 gpollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD));
Paolo Bonzini82cbbdc2012-09-24 15:07:08 +0200175 src = aio_get_g_source(qemu_aio_context);
Daniel P. Berrangec3ff7572016-09-30 15:34:24 +0100176 g_source_set_name(src, "aio-context");
Paolo Bonzini82cbbdc2012-09-24 15:07:08 +0200177 g_source_attach(src, NULL);
178 g_source_unref(src);
Fam Zhengf3926942015-09-07 11:28:58 +0800179 src = iohandler_get_g_source();
Daniel P. Berrangec3ff7572016-09-30 15:34:24 +0100180 g_source_set_name(src, "io-handler");
Fam Zhengf3926942015-09-07 11:28:58 +0800181 g_source_attach(src, NULL);
182 g_source_unref(src);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200183 return 0;
184}
185
Nicolas Saenz Julienne70ac26b2022-04-25 09:57:22 +0200186static void main_loop_update_params(EventLoopBase *base, Error **errp)
187{
Nicolas Saenz Julienne71ad4712022-04-25 09:57:23 +0200188 ERRP_GUARD();
189
Nicolas Saenz Julienne70ac26b2022-04-25 09:57:22 +0200190 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);
Nicolas Saenz Julienne71ad4712022-04-25 09:57:23 +0200196 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);
Nicolas Saenz Julienne70ac26b2022-04-25 09:57:22 +0200202}
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
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200249static int max_priority;
250
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100251#ifndef _WIN32
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100252static int glib_pollfds_idx;
253static int glib_n_poll_fds;
254
Alex Bligh7b595f32013-08-21 16:02:54 +0100255static void glib_pollfds_fill(int64_t *cur_timeout)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200256{
257 GMainContext *context = g_main_context_default();
Paolo Bonzini4dae83a2012-03-20 10:49:17 +0100258 int timeout = 0;
Alex Bligh7b595f32013-08-21 16:02:54 +0100259 int64_t timeout_ns;
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100260 int n;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200261
262 g_main_context_prepare(context, &max_priority);
263
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100264 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);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200274
Alex Bligh7b595f32013-08-21 16:02:54 +0100275 if (timeout < 0) {
276 timeout_ns = -1;
277 } else {
278 timeout_ns = (int64_t)timeout * (int64_t)SCALE_MS;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200279 }
Alex Bligh7b595f32013-08-21 16:02:54 +0100280
281 *cur_timeout = qemu_soonest_timeout(timeout_ns, *cur_timeout);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200282}
283
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100284static void glib_pollfds_poll(void)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200285{
286 GMainContext *context = g_main_context_default();
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100287 GPollFD *pfds = &g_array_index(gpollfds, GPollFD, glib_pollfds_idx);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200288
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100289 if (g_main_context_check(context, max_priority, pfds, glib_n_poll_fds)) {
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200290 g_main_context_dispatch(context);
291 }
292}
293
Anthony Liguori893986f2013-04-05 08:46:00 -0500294#define MAX_MAIN_LOOP_SPIN (1000)
295
Alex Bligh7b595f32013-08-21 16:02:54 +0100296static int os_host_main_loop_wait(int64_t timeout)
Paolo Bonzini15455532012-03-20 10:49:18 +0100297{
Richard W.M. Jonesecbddbb2017-03-31 21:51:33 +0100298 GMainContext *context = g_main_context_default();
Paolo Bonzini15455532012-03-20 10:49:18 +0100299 int ret;
300
Richard W.M. Jonesecbddbb2017-03-31 21:51:33 +0100301 g_main_context_acquire(context);
302
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100303 glib_pollfds_fill(&timeout);
Paolo Bonzini15455532012-03-20 10:49:18 +0100304
Alex Bennéed759c952018-02-27 12:52:48 +0300305 qemu_mutex_unlock_iothread();
306 replay_mutex_unlock();
Paolo Bonzini15455532012-03-20 10:49:18 +0100307
Alex Bligh7b595f32013-08-21 16:02:54 +0100308 ret = qemu_poll_ns((GPollFD *)gpollfds->data, gpollfds->len, timeout);
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100309
Alex Bennéed759c952018-02-27 12:52:48 +0300310 replay_mutex_lock();
311 qemu_mutex_lock_iothread();
Paolo Bonzini15455532012-03-20 10:49:18 +0100312
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100313 glib_pollfds_poll();
Richard W.M. Jonesecbddbb2017-03-31 21:51:33 +0100314
315 g_main_context_release(context);
316
Paolo Bonzini15455532012-03-20 10:49:18 +0100317 return ret;
318}
319#else
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200320/***********************************************************/
321/* Polling handling */
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;
Markus Armbrusterb21e2382022-03-15 15:41:56 +0100334 pe = g_new0(PollingEntry, 1);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200335 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/* Wait objects support */
357typedef struct WaitObjects {
358 int num;
Bin Meng4f76b3d2022-10-19 18:20:13 +0800359 int revents[MAXIMUM_WAIT_OBJECTS];
360 HANDLE events[MAXIMUM_WAIT_OBJECTS];
361 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS];
362 void *opaque[MAXIMUM_WAIT_OBJECTS];
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200363} WaitObjects;
364
365static WaitObjects wait_objects = {0};
366
367int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
368{
Bin Mengd393b0a2022-10-19 18:20:14 +0800369 int i;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200370 WaitObjects *w = &wait_objects;
Bin Mengd393b0a2022-10-19 18:20:14 +0800371
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200372 if (w->num >= MAXIMUM_WAIT_OBJECTS) {
373 return -1;
374 }
Bin Mengd393b0a2022-10-19 18:20:14 +0800375
376 for (i = 0; i < w->num; i++) {
377 /* check if the same handle is added twice */
378 if (w->events[i] == handle) {
379 return -1;
380 }
381 }
382
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200383 w->events[w->num] = handle;
384 w->func[w->num] = func;
385 w->opaque[w->num] = opaque;
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100386 w->revents[w->num] = 0;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200387 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 }
Bin Meng4f76b3d2022-10-19 18:20:13 +0800401 if (found && i < (MAXIMUM_WAIT_OBJECTS - 1)) {
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200402 w->events[i] = w->events[i + 1];
403 w->func[i] = w->func[i + 1];
404 w->opaque[i] = w->opaque[i + 1];
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100405 w->revents[i] = w->revents[i + 1];
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200406 }
407 }
408 if (found) {
409 w->num--;
410 }
411}
412
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100413static 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;
Stefan Hajnoczi8db165b2013-05-16 17:36:00 +0200423 if (events & G_IO_IN) {
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100424 FD_SET(fd, rfds);
425 nfds = MAX(nfds, fd);
426 }
Stefan Hajnoczi8db165b2013-05-16 17:36:00 +0200427 if (events & G_IO_OUT) {
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100428 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)) {
Stefan Hajnoczi8db165b2013-05-16 17:36:00 +0200450 revents |= G_IO_IN;
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100451 }
452 if (FD_ISSET(fd, wfds)) {
Stefan Hajnoczi8db165b2013-05-16 17:36:00 +0200453 revents |= G_IO_OUT;
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100454 }
455 if (FD_ISSET(fd, xfds)) {
456 revents |= G_IO_PRI;
457 }
458 pfd->revents = revents & pfd->events;
459 }
460}
461
Alex Bligh7b595f32013-08-21 16:02:54 +0100462static int os_host_main_loop_wait(int64_t timeout)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200463{
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100464 GMainContext *context = g_main_context_default();
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100465 GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
Stefan Hajnoczi134a03e2013-02-20 11:28:24 +0100466 int select_ret = 0;
Stefan Hajnoczi48ce11f2013-02-20 11:28:26 +0100467 int g_poll_ret, ret, i, n_poll_fds;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200468 PollingEntry *pe;
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100469 WaitObjects *w = &wait_objects;
Stefan Weil42fe1c22012-04-27 17:02:08 +0200470 gint poll_timeout;
Alex Bligh7b595f32013-08-21 16:02:54 +0100471 int64_t poll_timeout_ns;
Paolo Bonzini15455532012-03-20 10:49:18 +0100472 static struct timeval tv0;
Stefan Hajnoczi9cbaacf2013-02-20 11:28:30 +0100473 fd_set rfds, wfds, xfds;
474 int nfds;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200475
Richard W.M. Jonesecbddbb2017-03-31 21:51:33 +0100476 g_main_context_acquire(context);
477
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200478 /* XXX: need to suppress polling by better using win32 events */
479 ret = 0;
480 for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
481 ret |= pe->func(pe->opaque);
482 }
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100483 if (ret != 0) {
Richard W.M. Jonesecbddbb2017-03-31 21:51:33 +0100484 g_main_context_release(context);
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100485 return ret;
486 }
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200487
Stefan Hajnoczi3cb8c202013-05-16 17:36:01 +0200488 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
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100502 g_main_context_prepare(context, &max_priority);
Stefan Weil42fe1c22012-04-27 17:02:08 +0200503 n_poll_fds = g_main_context_query(context, max_priority, &poll_timeout,
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100504 poll_fds, ARRAY_SIZE(poll_fds));
Lidong Chen6512e342019-06-19 15:14:47 -0400505 g_assert(n_poll_fds + w->num <= ARRAY_SIZE(poll_fds));
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100506
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100507 for (i = 0; i < w->num; i++) {
Stefan Weil58b96302012-04-12 20:42:34 +0200508 poll_fds[n_poll_fds + i].fd = (DWORD_PTR)w->events[i];
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100509 poll_fds[n_poll_fds + i].events = G_IO_IN;
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100510 }
511
Alex Bligh7b595f32013-08-21 16:02:54 +0100512 if (poll_timeout < 0) {
513 poll_timeout_ns = -1;
514 } else {
515 poll_timeout_ns = (int64_t)poll_timeout * (int64_t)SCALE_MS;
Stefan Weil3239ad02012-04-29 19:15:02 +0200516 }
517
Alex Bligh7b595f32013-08-21 16:02:54 +0100518 poll_timeout_ns = qemu_soonest_timeout(poll_timeout_ns, timeout);
519
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100520 qemu_mutex_unlock_iothread();
Alex Bennéed759c952018-02-27 12:52:48 +0300521
522 replay_mutex_unlock();
523
Alex Bligh7b595f32013-08-21 16:02:54 +0100524 g_poll_ret = qemu_poll_ns(poll_fds, n_poll_fds + w->num, poll_timeout_ns);
525
Alex Bennéed759c952018-02-27 12:52:48 +0300526 replay_mutex_lock();
527
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100528 qemu_mutex_lock_iothread();
Fabien Chouteau5e3bc732013-01-08 16:30:56 +0100529 if (g_poll_ret > 0) {
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100530 for (i = 0; i < w->num; i++) {
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100531 w->revents[i] = poll_fds[n_poll_fds + i].revents;
Paolo Bonzini06ac7d42012-03-20 10:49:20 +0100532 }
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 }
Paolo Bonzinid3385eb2012-03-20 10:49:19 +0100539
Paolo Bonziniea26ce72012-03-20 10:49:21 +0100540 if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
541 g_main_context_dispatch(context);
542 }
543
Richard W.M. Jonesecbddbb2017-03-31 21:51:33 +0100544 g_main_context_release(context);
545
Fabien Chouteau5e3bc732013-01-08 16:30:56 +0100546 return select_ret || g_poll_ret;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200547}
548#endif
549
Marc-André Lureau1ab67b92019-01-17 15:43:55 +0400550static 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
Peter Maydellde5f8522017-06-27 18:32:49 +0100563void main_loop_wait(int nonblocking)
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200564{
Marc-André Lureau1ab67b92019-01-17 15:43:55 +0400565 MainLoopPoll mlpoll = {
566 .state = MAIN_LOOP_POLL_FILL,
567 .timeout = UINT32_MAX,
568 .pollfds = gpollfds,
569 };
Stefano Stabellini7c7db752012-04-13 19:35:04 +0100570 int ret;
Alex Bligh7b595f32013-08-21 16:02:54 +0100571 int64_t timeout_ns;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200572
573 if (nonblocking) {
Marc-André Lureau1ab67b92019-01-17 15:43:55 +0400574 mlpoll.timeout = 0;
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200575 }
576
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200577 /* poll any events */
Stefan Hajnoczicbff4b32013-02-20 11:28:25 +0100578 g_array_set_size(gpollfds, 0); /* reset for new iteration */
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200579 /* XXX: separate device handlers from system ones */
Marc-André Lureau1ab67b92019-01-17 15:43:55 +0400580 notifier_list_notify(&main_loop_poll_notifiers, &mlpoll);
Alex Bligh7b595f32013-08-21 16:02:54 +0100581
Marc-André Lureau1ab67b92019-01-17 15:43:55 +0400582 if (mlpoll.timeout == UINT32_MAX) {
Alex Bligh7b595f32013-08-21 16:02:54 +0100583 timeout_ns = -1;
584 } else {
Marc-André Lureau1ab67b92019-01-17 15:43:55 +0400585 timeout_ns = (uint64_t)mlpoll.timeout * (int64_t)(SCALE_MS);
Alex Bligh7b595f32013-08-21 16:02:54 +0100586 }
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);
Marc-André Lureau1ab67b92019-01-17 15:43:55 +0400593 mlpoll.state = ret < 0 ? MAIN_LOOP_POLL_ERR : MAIN_LOOP_POLL_OK;
594 notifier_list_notify(&main_loop_poll_notifiers, &mlpoll);
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200595
Claudio Fontana740b1752020-08-19 13:17:19 +0200596 if (icount_enabled()) {
597 /*
598 * CPU thread can infinitely wait for event after
599 * missing the warp
600 */
Claudio Fontana8191d362020-08-31 16:18:34 +0200601 icount_start_warp_timer();
Claudio Fontana740b1752020-08-19 13:17:19 +0200602 }
Alex Bligh40daca52013-08-21 16:03:02 +0100603 qemu_clock_run_all_timers();
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200604}
Paolo Bonzinif627aab2012-10-29 23:45:23 +0100605
606/* Functions to operate on the main QEMU AioContext. */
607
Alexander Bulekov9c86c972023-04-27 17:10:07 -0400608QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name,
609 MemReentrancyGuard *reentrancy_guard)
Paolo Bonzinif627aab2012-10-29 23:45:23 +0100610{
Alexander Bulekov9c86c972023-04-27 17:10:07 -0400611 return aio_bh_new_full(qemu_aio_context, cb, opaque, name,
612 reentrancy_guard);
Paolo Bonzinif627aab2012-10-29 23:45:23 +0100613}
Paolo Bonzinie9ed92b2019-07-12 19:34:35 +0200614
615/*
616 * Functions to operate on the I/O handler AioContext.
617 * This context runs on top of main loop. We can't reuse qemu_aio_context
618 * because iohandlers mustn't be polled by aio_poll(qemu_aio_context).
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();
Stefan Hajnoczi60f782b2023-05-16 15:02:38 -0400647 aio_set_fd_handler(iohandler_ctx, fd, fd_read, fd_write, NULL, NULL,
648 opaque);
Paolo Bonzinie9ed92b2019-07-12 19:34:35 +0200649}
650
651void event_notifier_set_handler(EventNotifier *e,
652 EventNotifierHandler *handler)
653{
654 iohandler_init();
Stefan Hajnoczi60f782b2023-05-16 15:02:38 -0400655 aio_set_event_notifier(iohandler_ctx, e, handler, NULL, NULL);
Paolo Bonzinie9ed92b2019-07-12 19:34:35 +0200656}