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/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"
29 EventNotifierHandler
*io_notify
;
34 QLIST_ENTRY(AioHandler
) node
;
37 void aio_set_fd_handler(AioContext
*ctx
,
45 /* fd is a SOCKET in our case */
48 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
49 if (node
->pfd
.fd
== fd
&& !node
->deleted
) {
54 /* Are we deleting the fd handler? */
55 if (!io_read
&& !io_write
) {
57 /* If the lock is held, just mark the node as deleted */
58 if (ctx
->walking_handlers
) {
60 node
->pfd
.revents
= 0;
62 /* Otherwise, delete it for real. We can't just mark it as
63 * deleted because deleted nodes are only cleaned up after
64 * releasing the walking_handlers lock.
66 QLIST_REMOVE(node
, node
);
74 /* Alloc and insert if it's not already there */
75 node
= g_new0(AioHandler
, 1);
77 QLIST_INSERT_HEAD(&ctx
->aio_handlers
, node
, node
);
82 node
->pfd
.events
|= G_IO_IN
;
85 node
->pfd
.events
|= G_IO_OUT
;
88 node
->e
= &ctx
->notifier
;
90 /* Update handler with latest information */
91 node
->opaque
= opaque
;
92 node
->io_read
= io_read
;
93 node
->io_write
= io_write
;
94 node
->is_external
= is_external
;
96 event
= event_notifier_get_handle(&ctx
->notifier
);
97 WSAEventSelect(node
->pfd
.fd
, event
,
98 FD_READ
| FD_ACCEPT
| FD_CLOSE
|
99 FD_CONNECT
| FD_WRITE
| FD_OOB
);
105 void aio_set_event_notifier(AioContext
*ctx
,
108 EventNotifierHandler
*io_notify
,
113 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
114 if (node
->e
== e
&& !node
->deleted
) {
119 /* Are we deleting the fd handler? */
122 g_source_remove_poll(&ctx
->source
, &node
->pfd
);
124 /* If the lock is held, just mark the node as deleted */
125 if (ctx
->walking_handlers
) {
127 node
->pfd
.revents
= 0;
129 /* Otherwise, delete it for real. We can't just mark it as
130 * deleted because deleted nodes are only cleaned up after
131 * releasing the walking_handlers lock.
133 QLIST_REMOVE(node
, node
);
139 /* Alloc and insert if it's not already there */
140 node
= g_new0(AioHandler
, 1);
142 node
->pfd
.fd
= (uintptr_t)event_notifier_get_handle(e
);
143 node
->pfd
.events
= G_IO_IN
;
144 node
->is_external
= is_external
;
145 QLIST_INSERT_HEAD(&ctx
->aio_handlers
, node
, node
);
147 g_source_add_poll(&ctx
->source
, &node
->pfd
);
149 /* Update handler with latest information */
150 node
->io_notify
= io_notify
;
156 bool aio_prepare(AioContext
*ctx
)
158 static struct timeval tv0
;
160 bool have_select_revents
= false;
166 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
168 FD_SET ((SOCKET
)node
->pfd
.fd
, &rfds
);
170 if (node
->io_write
) {
171 FD_SET ((SOCKET
)node
->pfd
.fd
, &wfds
);
175 if (select(0, &rfds
, &wfds
, NULL
, &tv0
) > 0) {
176 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
177 node
->pfd
.revents
= 0;
178 if (FD_ISSET(node
->pfd
.fd
, &rfds
)) {
179 node
->pfd
.revents
|= G_IO_IN
;
180 have_select_revents
= true;
183 if (FD_ISSET(node
->pfd
.fd
, &wfds
)) {
184 node
->pfd
.revents
|= G_IO_OUT
;
185 have_select_revents
= true;
190 return have_select_revents
;
193 bool aio_pending(AioContext
*ctx
)
197 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
198 if (node
->pfd
.revents
&& node
->io_notify
) {
202 if ((node
->pfd
.revents
& G_IO_IN
) && node
->io_read
) {
205 if ((node
->pfd
.revents
& G_IO_OUT
) && node
->io_write
) {
213 static bool aio_dispatch_handlers(AioContext
*ctx
, HANDLE event
)
216 bool progress
= false;
219 * We have to walk very carefully in case aio_set_fd_handler is
220 * called while we're walking.
222 node
= QLIST_FIRST(&ctx
->aio_handlers
);
225 int revents
= node
->pfd
.revents
;
227 ctx
->walking_handlers
++;
229 if (!node
->deleted
&&
230 (revents
|| event_notifier_get_handle(node
->e
) == event
) &&
232 node
->pfd
.revents
= 0;
233 node
->io_notify(node
->e
);
235 /* aio_notify() does not count as progress */
236 if (node
->e
!= &ctx
->notifier
) {
241 if (!node
->deleted
&&
242 (node
->io_read
|| node
->io_write
)) {
243 node
->pfd
.revents
= 0;
244 if ((revents
& G_IO_IN
) && node
->io_read
) {
245 node
->io_read(node
->opaque
);
248 if ((revents
& G_IO_OUT
) && node
->io_write
) {
249 node
->io_write(node
->opaque
);
253 /* if the next select() will return an event, we have progressed */
254 if (event
== event_notifier_get_handle(&ctx
->notifier
)) {
256 WSAEnumNetworkEvents(node
->pfd
.fd
, event
, &ev
);
257 if (ev
.lNetworkEvents
) {
264 node
= QLIST_NEXT(node
, node
);
266 ctx
->walking_handlers
--;
268 if (!ctx
->walking_handlers
&& tmp
->deleted
) {
269 QLIST_REMOVE(tmp
, node
);
277 bool aio_dispatch(AioContext
*ctx
, bool dispatch_fds
)
281 progress
= aio_bh_poll(ctx
);
283 progress
|= aio_dispatch_handlers(ctx
, INVALID_HANDLE_VALUE
);
285 progress
|= timerlistgroup_run_timers(&ctx
->tlg
);
289 bool aio_poll(AioContext
*ctx
, bool blocking
)
292 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
293 bool progress
, have_select_revents
, first
;
297 aio_context_acquire(ctx
);
300 /* aio_notify can avoid the expensive event_notifier_set if
301 * everything (file descriptors, bottom halves, timers) will
302 * be re-evaluated before the next blocking poll(). This is
303 * already true when aio_poll is called with blocking == false;
304 * if blocking == true, it is only true after poll() returns,
305 * so disable the optimization now.
308 atomic_add(&ctx
->notify_me
, 2);
311 have_select_revents
= aio_prepare(ctx
);
313 ctx
->walking_handlers
++;
317 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
318 if (!node
->deleted
&& node
->io_notify
319 && aio_node_check(ctx
, node
->is_external
)) {
320 events
[count
++] = event_notifier_get_handle(node
->e
);
324 ctx
->walking_handlers
--;
327 /* ctx->notifier is always registered. */
330 /* Multiple iterations, all of them non-blocking except the first,
331 * may be necessary to process all pending events. After the first
332 * WaitForMultipleObjects call ctx->notify_me will be decremented.
338 timeout
= blocking
&& !have_select_revents
339 ? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx
)) : 0;
341 aio_context_release(ctx
);
343 ret
= WaitForMultipleObjects(count
, events
, FALSE
, timeout
);
346 atomic_sub(&ctx
->notify_me
, 2);
349 aio_context_acquire(ctx
);
353 aio_notify_accept(ctx
);
354 progress
|= aio_bh_poll(ctx
);
358 /* if we have any signaled events, dispatch event */
360 if ((DWORD
) (ret
- WAIT_OBJECT_0
) < count
) {
361 event
= events
[ret
- WAIT_OBJECT_0
];
362 events
[ret
- WAIT_OBJECT_0
] = events
[--count
];
363 } else if (!have_select_revents
) {
367 have_select_revents
= false;
370 progress
|= aio_dispatch_handlers(ctx
, event
);
373 progress
|= timerlistgroup_run_timers(&ctx
->tlg
);
375 aio_context_release(ctx
);
379 void aio_context_setup(AioContext
*ctx
)
383 void aio_context_set_poll_params(AioContext
*ctx
, int64_t max_ns
, Error
**errp
)
385 error_setg(errp
, "AioContext polling is not implemented on Windows");