spapr: Forbid nested KVM-HV in pre-power9 compat mode
[qemu/ar7.git] / util / aio-win32.c
blob953c56ab48a2f4bcf2ece21dd070ef0bc44f1265
1 /*
2 * QEMU aio implementation
4 * Copyright IBM Corp., 2008
5 * Copyright Red Hat Inc., 2012
7 * Authors:
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/osdep.h"
19 #include "qemu-common.h"
20 #include "block/block.h"
21 #include "qemu/queue.h"
22 #include "qemu/sockets.h"
23 #include "qapi/error.h"
24 #include "qemu/rcu_queue.h"
26 struct AioHandler {
27 EventNotifier *e;
28 IOHandler *io_read;
29 IOHandler *io_write;
30 EventNotifierHandler *io_notify;
31 GPollFD pfd;
32 int deleted;
33 void *opaque;
34 bool is_external;
35 QLIST_ENTRY(AioHandler) node;
38 static void aio_remove_fd_handler(AioContext *ctx, AioHandler *node)
40 /* If aio_poll is in progress, just mark the node as deleted */
41 if (qemu_lockcnt_count(&ctx->list_lock)) {
42 node->deleted = 1;
43 node->pfd.revents = 0;
44 } else {
45 /* Otherwise, delete it for real. We can't just mark it as
46 * deleted because deleted nodes are only cleaned up after
47 * releasing the list_lock.
49 QLIST_REMOVE(node, node);
50 g_free(node);
54 void aio_set_fd_handler(AioContext *ctx,
55 int fd,
56 bool is_external,
57 IOHandler *io_read,
58 IOHandler *io_write,
59 AioPollFn *io_poll,
60 void *opaque)
62 /* fd is a SOCKET in our case */
63 AioHandler *old_node;
64 AioHandler *node = NULL;
66 qemu_lockcnt_lock(&ctx->list_lock);
67 QLIST_FOREACH(old_node, &ctx->aio_handlers, node) {
68 if (old_node->pfd.fd == fd && !old_node->deleted) {
69 break;
73 if (io_read || io_write) {
74 HANDLE event;
75 long bitmask = 0;
77 /* Alloc and insert if it's not already there */
78 node = g_new0(AioHandler, 1);
79 node->pfd.fd = fd;
81 node->pfd.events = 0;
82 if (node->io_read) {
83 node->pfd.events |= G_IO_IN;
85 if (node->io_write) {
86 node->pfd.events |= G_IO_OUT;
89 node->e = &ctx->notifier;
91 /* Update handler with latest information */
92 node->opaque = opaque;
93 node->io_read = io_read;
94 node->io_write = io_write;
95 node->is_external = is_external;
97 if (io_read) {
98 bitmask |= FD_READ | FD_ACCEPT | FD_CLOSE;
101 if (io_write) {
102 bitmask |= FD_WRITE | FD_CONNECT;
105 QLIST_INSERT_HEAD_RCU(&ctx->aio_handlers, node, node);
106 event = event_notifier_get_handle(&ctx->notifier);
107 WSAEventSelect(node->pfd.fd, event, bitmask);
109 if (old_node) {
110 aio_remove_fd_handler(ctx, old_node);
113 qemu_lockcnt_unlock(&ctx->list_lock);
114 aio_notify(ctx);
117 void aio_set_fd_poll(AioContext *ctx, int fd,
118 IOHandler *io_poll_begin,
119 IOHandler *io_poll_end)
121 /* Not implemented */
124 void aio_set_event_notifier(AioContext *ctx,
125 EventNotifier *e,
126 bool is_external,
127 EventNotifierHandler *io_notify,
128 AioPollFn *io_poll)
130 AioHandler *node;
132 qemu_lockcnt_lock(&ctx->list_lock);
133 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
134 if (node->e == e && !node->deleted) {
135 break;
139 /* Are we deleting the fd handler? */
140 if (!io_notify) {
141 if (node) {
142 g_source_remove_poll(&ctx->source, &node->pfd);
144 aio_remove_fd_handler(ctx, node);
146 } else {
147 if (node == NULL) {
148 /* Alloc and insert if it's not already there */
149 node = g_new0(AioHandler, 1);
150 node->e = e;
151 node->pfd.fd = (uintptr_t)event_notifier_get_handle(e);
152 node->pfd.events = G_IO_IN;
153 node->is_external = is_external;
154 QLIST_INSERT_HEAD_RCU(&ctx->aio_handlers, node, node);
156 g_source_add_poll(&ctx->source, &node->pfd);
158 /* Update handler with latest information */
159 node->io_notify = io_notify;
162 qemu_lockcnt_unlock(&ctx->list_lock);
163 aio_notify(ctx);
166 void aio_set_event_notifier_poll(AioContext *ctx,
167 EventNotifier *notifier,
168 EventNotifierHandler *io_poll_begin,
169 EventNotifierHandler *io_poll_end)
171 /* Not implemented */
174 bool aio_prepare(AioContext *ctx)
176 static struct timeval tv0;
177 AioHandler *node;
178 bool have_select_revents = false;
179 fd_set rfds, wfds;
182 * We have to walk very carefully in case aio_set_fd_handler is
183 * called while we're walking.
185 qemu_lockcnt_inc(&ctx->list_lock);
187 /* fill fd sets */
188 FD_ZERO(&rfds);
189 FD_ZERO(&wfds);
190 QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
191 if (node->io_read) {
192 FD_SET ((SOCKET)node->pfd.fd, &rfds);
194 if (node->io_write) {
195 FD_SET ((SOCKET)node->pfd.fd, &wfds);
199 if (select(0, &rfds, &wfds, NULL, &tv0) > 0) {
200 QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
201 node->pfd.revents = 0;
202 if (FD_ISSET(node->pfd.fd, &rfds)) {
203 node->pfd.revents |= G_IO_IN;
204 have_select_revents = true;
207 if (FD_ISSET(node->pfd.fd, &wfds)) {
208 node->pfd.revents |= G_IO_OUT;
209 have_select_revents = true;
214 qemu_lockcnt_dec(&ctx->list_lock);
215 return have_select_revents;
218 bool aio_pending(AioContext *ctx)
220 AioHandler *node;
221 bool result = false;
224 * We have to walk very carefully in case aio_set_fd_handler is
225 * called while we're walking.
227 qemu_lockcnt_inc(&ctx->list_lock);
228 QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
229 if (node->pfd.revents && node->io_notify) {
230 result = true;
231 break;
234 if ((node->pfd.revents & G_IO_IN) && node->io_read) {
235 result = true;
236 break;
238 if ((node->pfd.revents & G_IO_OUT) && node->io_write) {
239 result = true;
240 break;
244 qemu_lockcnt_dec(&ctx->list_lock);
245 return result;
248 static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
250 AioHandler *node;
251 bool progress = false;
252 AioHandler *tmp;
255 * We have to walk very carefully in case aio_set_fd_handler is
256 * called while we're walking.
258 QLIST_FOREACH_SAFE_RCU(node, &ctx->aio_handlers, node, tmp) {
259 int revents = node->pfd.revents;
261 if (!node->deleted &&
262 (revents || event_notifier_get_handle(node->e) == event) &&
263 node->io_notify) {
264 node->pfd.revents = 0;
265 node->io_notify(node->e);
267 /* aio_notify() does not count as progress */
268 if (node->e != &ctx->notifier) {
269 progress = true;
273 if (!node->deleted &&
274 (node->io_read || node->io_write)) {
275 node->pfd.revents = 0;
276 if ((revents & G_IO_IN) && node->io_read) {
277 node->io_read(node->opaque);
278 progress = true;
280 if ((revents & G_IO_OUT) && node->io_write) {
281 node->io_write(node->opaque);
282 progress = true;
285 /* if the next select() will return an event, we have progressed */
286 if (event == event_notifier_get_handle(&ctx->notifier)) {
287 WSANETWORKEVENTS ev;
288 WSAEnumNetworkEvents(node->pfd.fd, event, &ev);
289 if (ev.lNetworkEvents) {
290 progress = true;
295 if (node->deleted) {
296 if (qemu_lockcnt_dec_if_lock(&ctx->list_lock)) {
297 QLIST_REMOVE(node, node);
298 g_free(node);
299 qemu_lockcnt_inc_and_unlock(&ctx->list_lock);
304 return progress;
307 void aio_dispatch(AioContext *ctx)
309 qemu_lockcnt_inc(&ctx->list_lock);
310 aio_bh_poll(ctx);
311 aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
312 qemu_lockcnt_dec(&ctx->list_lock);
313 timerlistgroup_run_timers(&ctx->tlg);
316 bool aio_poll(AioContext *ctx, bool blocking)
318 AioHandler *node;
319 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
320 bool progress, have_select_revents, first;
321 int count;
322 int timeout;
325 * There cannot be two concurrent aio_poll calls for the same AioContext (or
326 * an aio_poll concurrent with a GSource prepare/check/dispatch callback).
327 * We rely on this below to avoid slow locked accesses to ctx->notify_me.
329 assert(in_aio_context_home_thread(ctx));
330 progress = false;
332 /* aio_notify can avoid the expensive event_notifier_set if
333 * everything (file descriptors, bottom halves, timers) will
334 * be re-evaluated before the next blocking poll(). This is
335 * already true when aio_poll is called with blocking == false;
336 * if blocking == true, it is only true after poll() returns,
337 * so disable the optimization now.
339 if (blocking) {
340 atomic_set(&ctx->notify_me, atomic_read(&ctx->notify_me) + 2);
342 * Write ctx->notify_me before computing the timeout
343 * (reading bottom half flags, etc.). Pairs with
344 * smp_mb in aio_notify().
346 smp_mb();
349 qemu_lockcnt_inc(&ctx->list_lock);
350 have_select_revents = aio_prepare(ctx);
352 /* fill fd sets */
353 count = 0;
354 QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
355 if (!node->deleted && node->io_notify
356 && aio_node_check(ctx, node->is_external)) {
357 events[count++] = event_notifier_get_handle(node->e);
361 first = true;
363 /* ctx->notifier is always registered. */
364 assert(count > 0);
366 /* Multiple iterations, all of them non-blocking except the first,
367 * may be necessary to process all pending events. After the first
368 * WaitForMultipleObjects call ctx->notify_me will be decremented.
370 do {
371 HANDLE event;
372 int ret;
374 timeout = blocking && !have_select_revents
375 ? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx)) : 0;
376 ret = WaitForMultipleObjects(count, events, FALSE, timeout);
377 if (blocking) {
378 assert(first);
379 atomic_store_release(&ctx->notify_me, atomic_read(&ctx->notify_me) - 2);
380 aio_notify_accept(ctx);
383 if (first) {
384 progress |= aio_bh_poll(ctx);
385 first = false;
388 /* if we have any signaled events, dispatch event */
389 event = NULL;
390 if ((DWORD) (ret - WAIT_OBJECT_0) < count) {
391 event = events[ret - WAIT_OBJECT_0];
392 events[ret - WAIT_OBJECT_0] = events[--count];
393 } else if (!have_select_revents) {
394 break;
397 have_select_revents = false;
398 blocking = false;
400 progress |= aio_dispatch_handlers(ctx, event);
401 } while (count > 0);
403 qemu_lockcnt_dec(&ctx->list_lock);
405 progress |= timerlistgroup_run_timers(&ctx->tlg);
406 return progress;
409 void aio_context_setup(AioContext *ctx)
413 void aio_context_destroy(AioContext *ctx)
417 void aio_context_use_g_source(AioContext *ctx)
421 void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
422 int64_t grow, int64_t shrink, Error **errp)
424 if (max_ns) {
425 error_setg(errp, "AioContext polling is not implemented on Windows");