11de7afc9SPaolo Bonzini /*
21de7afc9SPaolo Bonzini * QEMU System Emulator
31de7afc9SPaolo Bonzini *
41de7afc9SPaolo Bonzini * Copyright (c) 2003-2008 Fabrice Bellard
51de7afc9SPaolo Bonzini *
61de7afc9SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy
71de7afc9SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal
81de7afc9SPaolo Bonzini * in the Software without restriction, including without limitation the rights
91de7afc9SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
101de7afc9SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is
111de7afc9SPaolo Bonzini * furnished to do so, subject to the following conditions:
121de7afc9SPaolo Bonzini *
131de7afc9SPaolo Bonzini * The above copyright notice and this permission notice shall be included in
141de7afc9SPaolo Bonzini * all copies or substantial portions of the Software.
151de7afc9SPaolo Bonzini *
161de7afc9SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
171de7afc9SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
181de7afc9SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
191de7afc9SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
201de7afc9SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
211de7afc9SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
221de7afc9SPaolo Bonzini * THE SOFTWARE.
231de7afc9SPaolo Bonzini */
241de7afc9SPaolo Bonzini
251de7afc9SPaolo Bonzini #ifndef QEMU_MAIN_LOOP_H
26175de524SMarkus Armbruster #define QEMU_MAIN_LOOP_H
271de7afc9SPaolo Bonzini
281de7afc9SPaolo Bonzini #include "block/aio.h"
2970ac26b9SNicolas Saenz Julienne #include "qom/object.h"
3070ac26b9SNicolas Saenz Julienne #include "sysemu/event-loop-base.h"
311de7afc9SPaolo Bonzini
321de7afc9SPaolo Bonzini #define SIG_IPI SIGUSR1
331de7afc9SPaolo Bonzini
3470ac26b9SNicolas Saenz Julienne #define TYPE_MAIN_LOOP "main-loop"
3570ac26b9SNicolas Saenz Julienne OBJECT_DECLARE_TYPE(MainLoop, MainLoopClass, MAIN_LOOP)
3670ac26b9SNicolas Saenz Julienne
3770ac26b9SNicolas Saenz Julienne struct MainLoop {
3870ac26b9SNicolas Saenz Julienne EventLoopBase parent_obj;
3970ac26b9SNicolas Saenz Julienne };
4070ac26b9SNicolas Saenz Julienne typedef struct MainLoop MainLoop;
4170ac26b9SNicolas Saenz Julienne
421de7afc9SPaolo Bonzini /**
431de7afc9SPaolo Bonzini * qemu_init_main_loop: Set up the process so that it can run the main loop.
441de7afc9SPaolo Bonzini *
451de7afc9SPaolo Bonzini * This includes setting up signal handlers. It should be called before
461de7afc9SPaolo Bonzini * any other threads are created. In addition, threads other than the
471de7afc9SPaolo Bonzini * main one should block signals that are trapped by the main loop.
481de7afc9SPaolo Bonzini * For simplicity, you can consider these signals to be safe: SIGUSR1,
491de7afc9SPaolo Bonzini * SIGUSR2, thread signals (SIGFPE, SIGILL, SIGSEGV, SIGBUS) and real-time
501de7afc9SPaolo Bonzini * signals if available. Remember that Windows in practice does not have
511de7afc9SPaolo Bonzini * signals, though.
521de7afc9SPaolo Bonzini *
531de7afc9SPaolo Bonzini * In the case of QEMU tools, this will also start/initialize timers.
541de7afc9SPaolo Bonzini */
552f78e491SChrysostomos Nanakos int qemu_init_main_loop(Error **errp);
561de7afc9SPaolo Bonzini
571de7afc9SPaolo Bonzini /**
581de7afc9SPaolo Bonzini * main_loop_wait: Run one iteration of the main loop.
591de7afc9SPaolo Bonzini *
601de7afc9SPaolo Bonzini * If @nonblocking is true, poll for events, otherwise suspend until
611de7afc9SPaolo Bonzini * one actually occurs. The main loop usually consists of a loop that
621de7afc9SPaolo Bonzini * repeatedly calls main_loop_wait(false).
631de7afc9SPaolo Bonzini *
641de7afc9SPaolo Bonzini * Main loop services include file descriptor callbacks, bottom halves
65a275e934SStefan Weil * and timers (defined in qemu/timer.h). Bottom halves are similar to timers
661de7afc9SPaolo Bonzini * that execute immediately, but have a lower overhead and scheduling them
671de7afc9SPaolo Bonzini * is wait-free, thread-safe and signal-safe.
681de7afc9SPaolo Bonzini *
691de7afc9SPaolo Bonzini * It is sometimes useful to put a whole program in a coroutine. In this
701de7afc9SPaolo Bonzini * case, the coroutine actually should be started from within the main loop,
711de7afc9SPaolo Bonzini * so that the main loop can run whenever the coroutine yields. To do this,
721de7afc9SPaolo Bonzini * you can use a bottom half to enter the coroutine as soon as the main loop
731de7afc9SPaolo Bonzini * starts:
741de7afc9SPaolo Bonzini *
751de7afc9SPaolo Bonzini * void enter_co_bh(void *opaque) {
761de7afc9SPaolo Bonzini * QEMUCoroutine *co = opaque;
770b8b8753SPaolo Bonzini * qemu_coroutine_enter(co);
781de7afc9SPaolo Bonzini * }
791de7afc9SPaolo Bonzini *
801de7afc9SPaolo Bonzini * ...
810b8b8753SPaolo Bonzini * QEMUCoroutine *co = qemu_coroutine_create(coroutine_entry, NULL);
821de7afc9SPaolo Bonzini * QEMUBH *start_bh = qemu_bh_new(enter_co_bh, co);
831de7afc9SPaolo Bonzini * qemu_bh_schedule(start_bh);
841de7afc9SPaolo Bonzini * while (...) {
851de7afc9SPaolo Bonzini * main_loop_wait(false);
861de7afc9SPaolo Bonzini * }
871de7afc9SPaolo Bonzini *
881de7afc9SPaolo Bonzini * (In the future we may provide a wrapper for this).
891de7afc9SPaolo Bonzini *
901de7afc9SPaolo Bonzini * @nonblocking: Whether the caller should block until an event occurs.
911de7afc9SPaolo Bonzini */
92de5f852fSPeter Maydell void main_loop_wait(int nonblocking);
931de7afc9SPaolo Bonzini
941de7afc9SPaolo Bonzini /**
955f3aa1ffSStefan Hajnoczi * qemu_get_aio_context: Return the main loop's AioContext
965f3aa1ffSStefan Hajnoczi */
975f3aa1ffSStefan Hajnoczi AioContext *qemu_get_aio_context(void);
985f3aa1ffSStefan Hajnoczi
995f3aa1ffSStefan Hajnoczi /**
1001de7afc9SPaolo Bonzini * qemu_notify_event: Force processing of pending events.
1011de7afc9SPaolo Bonzini *
1021de7afc9SPaolo Bonzini * Similar to signaling a condition variable, qemu_notify_event forces
1031de7afc9SPaolo Bonzini * main_loop_wait to look at pending events and exit. The caller of
1041de7afc9SPaolo Bonzini * main_loop_wait will usually call it again very soon, so qemu_notify_event
1051de7afc9SPaolo Bonzini * also has the side effect of recalculating the sets of file descriptors
1061de7afc9SPaolo Bonzini * that the main loop waits for.
1071de7afc9SPaolo Bonzini *
1081de7afc9SPaolo Bonzini * Calling qemu_notify_event is rarely necessary, because main loop
1096484e422SFam Zheng * services (bottom halves and timers) call it themselves.
1101de7afc9SPaolo Bonzini */
1111de7afc9SPaolo Bonzini void qemu_notify_event(void);
1121de7afc9SPaolo Bonzini
1131de7afc9SPaolo Bonzini #ifdef _WIN32
1141de7afc9SPaolo Bonzini /* return TRUE if no sleep should be done afterwards */
1151de7afc9SPaolo Bonzini typedef int PollingFunc(void *opaque);
1161de7afc9SPaolo Bonzini
1171de7afc9SPaolo Bonzini /**
1181de7afc9SPaolo Bonzini * qemu_add_polling_cb: Register a Windows-specific polling callback
1191de7afc9SPaolo Bonzini *
1201de7afc9SPaolo Bonzini * Currently, under Windows some events are polled rather than waited for.
1211de7afc9SPaolo Bonzini * Polling callbacks do not ensure that @func is called timely, because
1221de7afc9SPaolo Bonzini * the main loop might wait for an arbitrarily long time. If possible,
1231de7afc9SPaolo Bonzini * you should instead create a separate thread that does a blocking poll
1241de7afc9SPaolo Bonzini * and set a Win32 event object. The event can then be passed to
1251de7afc9SPaolo Bonzini * qemu_add_wait_object.
1261de7afc9SPaolo Bonzini *
1271de7afc9SPaolo Bonzini * Polling callbacks really have nothing Windows specific in them, but
1281de7afc9SPaolo Bonzini * as they are a hack and are currently not necessary under POSIX systems,
1291de7afc9SPaolo Bonzini * they are only available when QEMU is running under Windows.
1301de7afc9SPaolo Bonzini *
1311de7afc9SPaolo Bonzini * @func: The function that does the polling, and returns 1 to force
1321de7afc9SPaolo Bonzini * immediate completion of main_loop_wait.
1331de7afc9SPaolo Bonzini * @opaque: A pointer-size value that is passed to @func.
1341de7afc9SPaolo Bonzini */
1351de7afc9SPaolo Bonzini int qemu_add_polling_cb(PollingFunc *func, void *opaque);
1361de7afc9SPaolo Bonzini
1371de7afc9SPaolo Bonzini /**
1381de7afc9SPaolo Bonzini * qemu_del_polling_cb: Unregister a Windows-specific polling callback
1391de7afc9SPaolo Bonzini *
1401de7afc9SPaolo Bonzini * This function removes a callback that was registered with
1411de7afc9SPaolo Bonzini * qemu_add_polling_cb.
1421de7afc9SPaolo Bonzini *
1431de7afc9SPaolo Bonzini * @func: The function that was passed to qemu_add_polling_cb.
1441de7afc9SPaolo Bonzini * @opaque: A pointer-size value that was passed to qemu_add_polling_cb.
1451de7afc9SPaolo Bonzini */
1461de7afc9SPaolo Bonzini void qemu_del_polling_cb(PollingFunc *func, void *opaque);
1471de7afc9SPaolo Bonzini
1481de7afc9SPaolo Bonzini /* Wait objects handling */
1491de7afc9SPaolo Bonzini typedef void WaitObjectFunc(void *opaque);
1501de7afc9SPaolo Bonzini
1511de7afc9SPaolo Bonzini /**
1521de7afc9SPaolo Bonzini * qemu_add_wait_object: Register a callback for a Windows handle
1531de7afc9SPaolo Bonzini *
1541de7afc9SPaolo Bonzini * Under Windows, the iohandler mechanism can only be used with sockets.
1551de7afc9SPaolo Bonzini * QEMU must use the WaitForMultipleObjects API to wait on other handles.
1561de7afc9SPaolo Bonzini * This function registers a #HANDLE with QEMU, so that it will be included
1571de7afc9SPaolo Bonzini * in the main loop's calls to WaitForMultipleObjects. When the handle
1581de7afc9SPaolo Bonzini * is in a signaled state, QEMU will call @func.
1591de7afc9SPaolo Bonzini *
160d393b0a1SBin Meng * If the same HANDLE is added twice, this function returns -1.
161d393b0a1SBin Meng *
1621de7afc9SPaolo Bonzini * @handle: The Windows handle to be observed.
1631de7afc9SPaolo Bonzini * @func: A function to be called when @handle is in a signaled state.
1641de7afc9SPaolo Bonzini * @opaque: A pointer-size value that is passed to @func.
1651de7afc9SPaolo Bonzini */
1661de7afc9SPaolo Bonzini int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque);
1671de7afc9SPaolo Bonzini
1681de7afc9SPaolo Bonzini /**
1691de7afc9SPaolo Bonzini * qemu_del_wait_object: Unregister a callback for a Windows handle
1701de7afc9SPaolo Bonzini *
1711de7afc9SPaolo Bonzini * This function removes a callback that was registered with
1721de7afc9SPaolo Bonzini * qemu_add_wait_object.
1731de7afc9SPaolo Bonzini *
1741de7afc9SPaolo Bonzini * @func: The function that was passed to qemu_add_wait_object.
1751de7afc9SPaolo Bonzini * @opaque: A pointer-size value that was passed to qemu_add_wait_object.
1761de7afc9SPaolo Bonzini */
1771de7afc9SPaolo Bonzini void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque);
1781de7afc9SPaolo Bonzini #endif
1791de7afc9SPaolo Bonzini
1801de7afc9SPaolo Bonzini /* async I/O support */
1811de7afc9SPaolo Bonzini
1821de7afc9SPaolo Bonzini typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
183d29a8a1bSStefan Hajnoczi
184d29a8a1bSStefan Hajnoczi /**
185d29a8a1bSStefan Hajnoczi * IOCanReadHandler: Return the number of bytes that #IOReadHandler can accept
186d29a8a1bSStefan Hajnoczi *
187d29a8a1bSStefan Hajnoczi * This function reports how many bytes #IOReadHandler is prepared to accept.
188d29a8a1bSStefan Hajnoczi * #IOReadHandler may be invoked with up to this number of bytes. If this
189d29a8a1bSStefan Hajnoczi * function returns 0 then #IOReadHandler is not invoked.
190d29a8a1bSStefan Hajnoczi *
191d29a8a1bSStefan Hajnoczi * This function is typically called from an event loop. If the number of
192d29a8a1bSStefan Hajnoczi * bytes changes outside the event loop (e.g. because a vcpu thread drained the
193d29a8a1bSStefan Hajnoczi * buffer), then it is necessary to kick the event loop so that this function
194d29a8a1bSStefan Hajnoczi * is called again. aio_notify() or qemu_notify_event() can be used to kick
195d29a8a1bSStefan Hajnoczi * the event loop.
196d29a8a1bSStefan Hajnoczi */
1971de7afc9SPaolo Bonzini typedef int IOCanReadHandler(void *opaque);
1981de7afc9SPaolo Bonzini
1991de7afc9SPaolo Bonzini /**
2001de7afc9SPaolo Bonzini * qemu_set_fd_handler: Register a file descriptor with the main loop
2011de7afc9SPaolo Bonzini *
2021de7afc9SPaolo Bonzini * This function tells the main loop to wake up whenever one of the
2031de7afc9SPaolo Bonzini * following conditions is true:
2041de7afc9SPaolo Bonzini *
2051de7afc9SPaolo Bonzini * 1) if @fd_write is not %NULL, when the file descriptor is writable;
2061de7afc9SPaolo Bonzini *
2071de7afc9SPaolo Bonzini * 2) if @fd_read is not %NULL, when the file descriptor is readable.
2081de7afc9SPaolo Bonzini *
2091de7afc9SPaolo Bonzini * The callbacks that are set up by qemu_set_fd_handler are level-triggered.
2101de7afc9SPaolo Bonzini * If @fd_read does not read from @fd, or @fd_write does not write to @fd
2111de7afc9SPaolo Bonzini * until its buffers are full, they will be called again on the next
2121de7afc9SPaolo Bonzini * iteration.
2131de7afc9SPaolo Bonzini *
2141de7afc9SPaolo Bonzini * @fd: The file descriptor to be observed. Under Windows it must be
2151de7afc9SPaolo Bonzini * a #SOCKET.
2161de7afc9SPaolo Bonzini *
2171de7afc9SPaolo Bonzini * @fd_read: A level-triggered callback that is fired if @fd is readable
2181de7afc9SPaolo Bonzini * at the beginning of a main loop iteration, or if it becomes readable
2191de7afc9SPaolo Bonzini * during one.
2201de7afc9SPaolo Bonzini *
2211de7afc9SPaolo Bonzini * @fd_write: A level-triggered callback that is fired when @fd is writable
2221de7afc9SPaolo Bonzini * at the beginning of a main loop iteration, or if it becomes writable
2231de7afc9SPaolo Bonzini * during one.
2241de7afc9SPaolo Bonzini *
2251de7afc9SPaolo Bonzini * @opaque: A pointer-sized value that is passed to @fd_read and @fd_write.
2261de7afc9SPaolo Bonzini */
227f4d248bdSFam Zheng void qemu_set_fd_handler(int fd,
2281de7afc9SPaolo Bonzini IOHandler *fd_read,
2291de7afc9SPaolo Bonzini IOHandler *fd_write,
2301de7afc9SPaolo Bonzini void *opaque);
2311de7afc9SPaolo Bonzini
232d6da1e9eSPaolo Bonzini
233d6da1e9eSPaolo Bonzini /**
234d6da1e9eSPaolo Bonzini * event_notifier_set_handler: Register an EventNotifier with the main loop
235d6da1e9eSPaolo Bonzini *
236d6da1e9eSPaolo Bonzini * This function tells the main loop to wake up whenever the
237d6da1e9eSPaolo Bonzini * #EventNotifier was set.
238d6da1e9eSPaolo Bonzini *
239d6da1e9eSPaolo Bonzini * @e: The #EventNotifier to be observed.
240d6da1e9eSPaolo Bonzini *
241d6da1e9eSPaolo Bonzini * @handler: A level-triggered callback that is fired when @e
242d6da1e9eSPaolo Bonzini * has been set. @e is passed to it as a parameter.
243d6da1e9eSPaolo Bonzini */
244d6da1e9eSPaolo Bonzini void event_notifier_set_handler(EventNotifier *e,
245d6da1e9eSPaolo Bonzini EventNotifierHandler *handler);
246d6da1e9eSPaolo Bonzini
247f3926945SFam Zheng GSource *iohandler_get_g_source(void);
248bcd82a96SFam Zheng AioContext *iohandler_get_aio_context(void);
2491de7afc9SPaolo Bonzini
2501de7afc9SPaolo Bonzini /**
251afbe7053SPaolo Bonzini * qemu_mutex_iothread_locked: Return lock status of the main loop mutex.
252afbe7053SPaolo Bonzini *
253afbe7053SPaolo Bonzini * The main loop mutex is the coarsest lock in QEMU, and as such it
254afbe7053SPaolo Bonzini * must always be taken outside other locks. This function helps
255afbe7053SPaolo Bonzini * functions take different paths depending on whether the current
256afbe7053SPaolo Bonzini * thread is running within the main loop mutex.
2576538692eSEmanuele Giuseppe Esposito *
2586538692eSEmanuele Giuseppe Esposito * This function should never be used in the block layer, because
2596538692eSEmanuele Giuseppe Esposito * unit tests, block layer tools and qemu-storage-daemon do not
2606538692eSEmanuele Giuseppe Esposito * have a BQL.
2616538692eSEmanuele Giuseppe Esposito * Please instead refer to qemu_in_main_thread().
262afbe7053SPaolo Bonzini */
263afbe7053SPaolo Bonzini bool qemu_mutex_iothread_locked(void);
264afbe7053SPaolo Bonzini
265afbe7053SPaolo Bonzini /**
2666538692eSEmanuele Giuseppe Esposito * qemu_in_main_thread: return whether it's possible to safely access
2676538692eSEmanuele Giuseppe Esposito * the global state of the block layer.
2686538692eSEmanuele Giuseppe Esposito *
2696538692eSEmanuele Giuseppe Esposito * Global state of the block layer is not accessible from I/O threads
2706538692eSEmanuele Giuseppe Esposito * or worker threads; only from threads that "own" the default
2716538692eSEmanuele Giuseppe Esposito * AioContext that qemu_get_aio_context() returns. For tests, block
2726538692eSEmanuele Giuseppe Esposito * layer tools and qemu-storage-daemon there is a designated thread that
2736538692eSEmanuele Giuseppe Esposito * runs the event loop for qemu_get_aio_context(), and that is the
2746538692eSEmanuele Giuseppe Esposito * main thread.
2756538692eSEmanuele Giuseppe Esposito *
2766538692eSEmanuele Giuseppe Esposito * For emulators, however, any thread that holds the BQL can act
2776538692eSEmanuele Giuseppe Esposito * as the block layer main thread; this will be any of the actual
2786538692eSEmanuele Giuseppe Esposito * main thread, the vCPU threads or the RCU thread.
2796538692eSEmanuele Giuseppe Esposito *
2806538692eSEmanuele Giuseppe Esposito * For clarity, do not use this function outside the block layer.
2816538692eSEmanuele Giuseppe Esposito */
2826538692eSEmanuele Giuseppe Esposito bool qemu_in_main_thread(void);
2836538692eSEmanuele Giuseppe Esposito
28421b1d974SEmanuele Giuseppe Esposito /*
28521b1d974SEmanuele Giuseppe Esposito * Mark and check that the function is part of the Global State API.
28621b1d974SEmanuele Giuseppe Esposito * Please refer to include/block/block-global-state.h for more
28721b1d974SEmanuele Giuseppe Esposito * information about GS API.
28821b1d974SEmanuele Giuseppe Esposito */
289ac7798f2SEmanuele Giuseppe Esposito #define GLOBAL_STATE_CODE() \
290ac7798f2SEmanuele Giuseppe Esposito do { \
291ccfaf783SHanna Reitz assert(qemu_in_main_thread()); \
292ac7798f2SEmanuele Giuseppe Esposito } while (0)
293ac7798f2SEmanuele Giuseppe Esposito
29421b1d974SEmanuele Giuseppe Esposito /*
29521b1d974SEmanuele Giuseppe Esposito * Mark and check that the function is part of the I/O API.
29621b1d974SEmanuele Giuseppe Esposito * Please refer to include/block/block-io.h for more
29721b1d974SEmanuele Giuseppe Esposito * information about IO API.
29821b1d974SEmanuele Giuseppe Esposito */
299ac7798f2SEmanuele Giuseppe Esposito #define IO_CODE() \
300ac7798f2SEmanuele Giuseppe Esposito do { \
301ac7798f2SEmanuele Giuseppe Esposito /* nop */ \
302ac7798f2SEmanuele Giuseppe Esposito } while (0)
303ac7798f2SEmanuele Giuseppe Esposito
30421b1d974SEmanuele Giuseppe Esposito /*
30521b1d974SEmanuele Giuseppe Esposito * Mark and check that the function is part of the "I/O OR GS" API.
30621b1d974SEmanuele Giuseppe Esposito * Please refer to include/block/block-io.h for more
30721b1d974SEmanuele Giuseppe Esposito * information about "IO or GS" API.
30821b1d974SEmanuele Giuseppe Esposito */
309ac7798f2SEmanuele Giuseppe Esposito #define IO_OR_GS_CODE() \
310ac7798f2SEmanuele Giuseppe Esposito do { \
311ac7798f2SEmanuele Giuseppe Esposito /* nop */ \
312ac7798f2SEmanuele Giuseppe Esposito } while (0)
313ac7798f2SEmanuele Giuseppe Esposito
3146538692eSEmanuele Giuseppe Esposito /**
3151de7afc9SPaolo Bonzini * qemu_mutex_lock_iothread: Lock the main loop mutex.
3161de7afc9SPaolo Bonzini *
3171de7afc9SPaolo Bonzini * This function locks the main loop mutex. The mutex is taken by
31811717bc9SYaowei Bai * main() in vl.c and always taken except while waiting on
3191de7afc9SPaolo Bonzini * external events (such as with select). The mutex should be taken
3201de7afc9SPaolo Bonzini * by threads other than the main loop thread when calling
3211de7afc9SPaolo Bonzini * qemu_bh_new(), qemu_set_fd_handler() and basically all other
3221de7afc9SPaolo Bonzini * functions documented in this file.
3231de7afc9SPaolo Bonzini *
3241de7afc9SPaolo Bonzini * NOTE: tools currently are single-threaded and qemu_mutex_lock_iothread
3251de7afc9SPaolo Bonzini * is a no-op there.
3261de7afc9SPaolo Bonzini */
327cb764d06SEmilio G. Cota #define qemu_mutex_lock_iothread() \
328cb764d06SEmilio G. Cota qemu_mutex_lock_iothread_impl(__FILE__, __LINE__)
329cb764d06SEmilio G. Cota void qemu_mutex_lock_iothread_impl(const char *file, int line);
3301de7afc9SPaolo Bonzini
3311de7afc9SPaolo Bonzini /**
3321de7afc9SPaolo Bonzini * qemu_mutex_unlock_iothread: Unlock the main loop mutex.
3331de7afc9SPaolo Bonzini *
3341de7afc9SPaolo Bonzini * This function unlocks the main loop mutex. The mutex is taken by
33511717bc9SYaowei Bai * main() in vl.c and always taken except while waiting on
3361de7afc9SPaolo Bonzini * external events (such as with select). The mutex should be unlocked
3371de7afc9SPaolo Bonzini * as soon as possible by threads other than the main loop thread,
3381de7afc9SPaolo Bonzini * because it prevents the main loop from processing callbacks,
3391de7afc9SPaolo Bonzini * including timers and bottom halves.
3401de7afc9SPaolo Bonzini *
3411de7afc9SPaolo Bonzini * NOTE: tools currently are single-threaded and qemu_mutex_unlock_iothread
3421de7afc9SPaolo Bonzini * is a no-op there.
3431de7afc9SPaolo Bonzini */
3441de7afc9SPaolo Bonzini void qemu_mutex_unlock_iothread(void);
3451de7afc9SPaolo Bonzini
3460aa5d47aSRichard Henderson /**
3470aa5d47aSRichard Henderson * QEMU_IOTHREAD_LOCK_GUARD
3480aa5d47aSRichard Henderson *
3490aa5d47aSRichard Henderson * Wrap a block of code in a conditional qemu_mutex_{lock,unlock}_iothread.
3500aa5d47aSRichard Henderson */
3510aa5d47aSRichard Henderson typedef struct IOThreadLockAuto IOThreadLockAuto;
3520aa5d47aSRichard Henderson
qemu_iothread_auto_lock(const char * file,int line)3530aa5d47aSRichard Henderson static inline IOThreadLockAuto *qemu_iothread_auto_lock(const char *file,
3540aa5d47aSRichard Henderson int line)
3550aa5d47aSRichard Henderson {
3560aa5d47aSRichard Henderson if (qemu_mutex_iothread_locked()) {
3570aa5d47aSRichard Henderson return NULL;
3580aa5d47aSRichard Henderson }
3590aa5d47aSRichard Henderson qemu_mutex_lock_iothread_impl(file, line);
3600aa5d47aSRichard Henderson /* Anything non-NULL causes the cleanup function to be called */
3610aa5d47aSRichard Henderson return (IOThreadLockAuto *)(uintptr_t)1;
3620aa5d47aSRichard Henderson }
3630aa5d47aSRichard Henderson
qemu_iothread_auto_unlock(IOThreadLockAuto * l)3640aa5d47aSRichard Henderson static inline void qemu_iothread_auto_unlock(IOThreadLockAuto *l)
3650aa5d47aSRichard Henderson {
3660aa5d47aSRichard Henderson qemu_mutex_unlock_iothread();
3670aa5d47aSRichard Henderson }
3680aa5d47aSRichard Henderson
3690aa5d47aSRichard Henderson G_DEFINE_AUTOPTR_CLEANUP_FUNC(IOThreadLockAuto, qemu_iothread_auto_unlock)
3700aa5d47aSRichard Henderson
3710aa5d47aSRichard Henderson #define QEMU_IOTHREAD_LOCK_GUARD() \
3720aa5d47aSRichard Henderson g_autoptr(IOThreadLockAuto) _iothread_lock_auto __attribute__((unused)) \
3730aa5d47aSRichard Henderson = qemu_iothread_auto_lock(__FILE__, __LINE__)
3740aa5d47aSRichard Henderson
37519e067e0SAravinda Prasad /*
37619e067e0SAravinda Prasad * qemu_cond_wait_iothread: Wait on condition for the main loop mutex
37719e067e0SAravinda Prasad *
37819e067e0SAravinda Prasad * This function atomically releases the main loop mutex and causes
37919e067e0SAravinda Prasad * the calling thread to block on the condition.
38019e067e0SAravinda Prasad */
38119e067e0SAravinda Prasad void qemu_cond_wait_iothread(QemuCond *cond);
38219e067e0SAravinda Prasad
383b0c3cf94SClaudio Fontana /*
384b0c3cf94SClaudio Fontana * qemu_cond_timedwait_iothread: like the previous, but with timeout
385b0c3cf94SClaudio Fontana */
386b0c3cf94SClaudio Fontana void qemu_cond_timedwait_iothread(QemuCond *cond, int ms);
387b0c3cf94SClaudio Fontana
3881de7afc9SPaolo Bonzini /* internal interfaces */
3891de7afc9SPaolo Bonzini
390*9c86c97fSAlexander Bulekov #define qemu_bh_new_guarded(cb, opaque, guard) \
391*9c86c97fSAlexander Bulekov qemu_bh_new_full((cb), (opaque), (stringify(cb)), guard)
3920f08586cSStefan Hajnoczi #define qemu_bh_new(cb, opaque) \
393*9c86c97fSAlexander Bulekov qemu_bh_new_full((cb), (opaque), (stringify(cb)), NULL)
394*9c86c97fSAlexander Bulekov QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name,
395*9c86c97fSAlexander Bulekov MemReentrancyGuard *reentrancy_guard);
3961de7afc9SPaolo Bonzini void qemu_bh_schedule_idle(QEMUBH *bh);
3971de7afc9SPaolo Bonzini
3981ab67b98SMarc-André Lureau enum {
3991ab67b98SMarc-André Lureau MAIN_LOOP_POLL_FILL,
4001ab67b98SMarc-André Lureau MAIN_LOOP_POLL_ERR,
4011ab67b98SMarc-André Lureau MAIN_LOOP_POLL_OK,
4021ab67b98SMarc-André Lureau };
4031ab67b98SMarc-André Lureau
4041ab67b98SMarc-André Lureau typedef struct MainLoopPoll {
4051ab67b98SMarc-André Lureau int state;
4061ab67b98SMarc-André Lureau uint32_t timeout;
4071ab67b98SMarc-André Lureau GArray *pollfds;
4081ab67b98SMarc-André Lureau } MainLoopPoll;
4091ab67b98SMarc-André Lureau
4101ab67b98SMarc-André Lureau void main_loop_poll_add_notifier(Notifier *notify);
4111ab67b98SMarc-André Lureau void main_loop_poll_remove_notifier(Notifier *notify);
4121ab67b98SMarc-André Lureau
4131de7afc9SPaolo Bonzini #endif
414