2 * QEMU aio implementation
4 * Copyright IBM Corp., 2008
5 * Copyright Red Hat Inc., 2012
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Paolo Bonzini <pbonzini@redhat.com>
11 * This work is licensed under the terms of the GNU GPL, version 2. See
12 * the COPYING file in the top-level directory.
14 * Contributions after 2012-01-13 are licensed under the terms of the
15 * GNU GPL, version 2 or (at your option) any later version.
18 #include "qemu-common.h"
19 #include "block/block.h"
20 #include "qemu/queue.h"
21 #include "qemu/sockets.h"
25 EventNotifierHandler *io_notify;
28 QLIST_ENTRY(AioHandler) node;
31 void aio_set_event_notifier(AioContext *ctx,
33 EventNotifierHandler *io_notify)
37 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
38 if (node->e == e && !node->deleted) {
43 /* Are we deleting the fd handler? */
46 g_source_remove_poll(&ctx->source, &node->pfd);
48 /* If the lock is held, just mark the node as deleted */
49 if (ctx->walking_handlers) {
51 node->pfd.revents = 0;
53 /* Otherwise, delete it for real. We can't just mark it as
54 * deleted because deleted nodes are only cleaned up after
55 * releasing the walking_handlers lock.
57 QLIST_REMOVE(node, node);
63 /* Alloc and insert if it's not already there */
64 node = g_malloc0(sizeof(AioHandler));
66 node->pfd.fd = (uintptr_t)event_notifier_get_handle(e);
67 node->pfd.events = G_IO_IN;
68 QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
70 g_source_add_poll(&ctx->source, &node->pfd);
72 /* Update handler with latest information */
73 node->io_notify = io_notify;
79 bool aio_pending(AioContext *ctx)
83 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
84 if (node->pfd.revents && node->io_notify) {
92 static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
95 bool progress = false;
98 * We have to walk very carefully in case aio_set_fd_handler is
99 * called while we're walking.
101 node = QLIST_FIRST(&ctx->aio_handlers);
105 ctx->walking_handlers++;
107 if (!node->deleted &&
108 (node->pfd.revents || event_notifier_get_handle(node->e) == event) &&
110 node->pfd.revents = 0;
111 node->io_notify(node->e);
113 /* aio_notify() does not count as progress */
114 if (node->e != &ctx->notifier) {
120 node = QLIST_NEXT(node, node);
122 ctx->walking_handlers--;
124 if (!ctx->walking_handlers && tmp->deleted) {
125 QLIST_REMOVE(tmp, node);
133 static bool aio_dispatch(AioContext *ctx)
137 progress = aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
138 progress |= timerlistgroup_run_timers(&ctx->tlg);
142 bool aio_poll(AioContext *ctx, bool blocking)
145 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
146 bool progress, first;
153 * If there are callbacks left that have been queued, we need to call then.
154 * Do not call select in this case, because it is possible that the caller
155 * does not need a complete flush (as is the case for aio_poll loops).
157 if (aio_bh_poll(ctx)) {
162 /* Dispatch any pending callbacks from the GSource. */
163 progress |= aio_dispatch(ctx);
165 if (progress && !blocking) {
169 ctx->walking_handlers++;
173 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
174 if (!node->deleted && node->io_notify) {
175 events[count++] = event_notifier_get_handle(node->e);
179 ctx->walking_handlers--;
182 /* wait until next event */
187 ? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx)) : 0;
188 ret = WaitForMultipleObjects(count, events, FALSE, timeout);
190 if (first && aio_bh_poll(ctx)) {
195 /* if we have any signaled events, dispatch event */
196 if ((DWORD) (ret - WAIT_OBJECT_0) >= count) {
202 progress |= aio_dispatch_handlers(ctx, events[ret - WAIT_OBJECT_0]);
204 /* Try again, but only call each handler once. */
205 events[ret - WAIT_OBJECT_0] = events[--count];
209 /* Run the timers a second time. We do this because otherwise aio_wait
210 * will not note progress - and will stop a drain early - if we have
211 * a timer that was not ready to run entering g_poll but is ready
212 * after g_poll. This will only do anything if a timer has expired.
214 progress |= timerlistgroup_run_timers(&ctx->tlg);