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_fd_poll(AioContext
*ctx
, int fd
,
106 IOHandler
*io_poll_begin
,
107 IOHandler
*io_poll_end
)
109 /* Not implemented */
112 void aio_set_event_notifier(AioContext
*ctx
,
115 EventNotifierHandler
*io_notify
,
120 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
121 if (node
->e
== e
&& !node
->deleted
) {
126 /* Are we deleting the fd handler? */
129 g_source_remove_poll(&ctx
->source
, &node
->pfd
);
131 /* If the lock is held, just mark the node as deleted */
132 if (ctx
->walking_handlers
) {
134 node
->pfd
.revents
= 0;
136 /* Otherwise, delete it for real. We can't just mark it as
137 * deleted because deleted nodes are only cleaned up after
138 * releasing the walking_handlers lock.
140 QLIST_REMOVE(node
, node
);
146 /* Alloc and insert if it's not already there */
147 node
= g_new0(AioHandler
, 1);
149 node
->pfd
.fd
= (uintptr_t)event_notifier_get_handle(e
);
150 node
->pfd
.events
= G_IO_IN
;
151 node
->is_external
= is_external
;
152 QLIST_INSERT_HEAD(&ctx
->aio_handlers
, node
, node
);
154 g_source_add_poll(&ctx
->source
, &node
->pfd
);
156 /* Update handler with latest information */
157 node
->io_notify
= io_notify
;
163 void aio_set_event_notifier_poll(AioContext
*ctx
,
164 EventNotifier
*notifier
,
165 EventNotifierHandler
*io_poll_begin
,
166 EventNotifierHandler
*io_poll_end
)
168 /* Not implemented */
171 bool aio_prepare(AioContext
*ctx
)
173 static struct timeval tv0
;
175 bool have_select_revents
= false;
181 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
183 FD_SET ((SOCKET
)node
->pfd
.fd
, &rfds
);
185 if (node
->io_write
) {
186 FD_SET ((SOCKET
)node
->pfd
.fd
, &wfds
);
190 if (select(0, &rfds
, &wfds
, NULL
, &tv0
) > 0) {
191 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
192 node
->pfd
.revents
= 0;
193 if (FD_ISSET(node
->pfd
.fd
, &rfds
)) {
194 node
->pfd
.revents
|= G_IO_IN
;
195 have_select_revents
= true;
198 if (FD_ISSET(node
->pfd
.fd
, &wfds
)) {
199 node
->pfd
.revents
|= G_IO_OUT
;
200 have_select_revents
= true;
205 return have_select_revents
;
208 bool aio_pending(AioContext
*ctx
)
212 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
213 if (node
->pfd
.revents
&& node
->io_notify
) {
217 if ((node
->pfd
.revents
& G_IO_IN
) && node
->io_read
) {
220 if ((node
->pfd
.revents
& G_IO_OUT
) && node
->io_write
) {
228 static bool aio_dispatch_handlers(AioContext
*ctx
, HANDLE event
)
230 AioHandler
*node
, *tmp
;
231 bool progress
= false;
233 ctx
->walking_handlers
++;
236 * We have to walk very carefully in case aio_set_fd_handler is
237 * called while we're walking.
239 QLIST_FOREACH_SAFE(node
, &ctx
->aio_handlers
, node
, tmp
) {
240 int revents
= node
->pfd
.revents
;
242 if (!node
->deleted
&&
243 (revents
|| event_notifier_get_handle(node
->e
) == event
) &&
245 node
->pfd
.revents
= 0;
246 node
->io_notify(node
->e
);
248 /* aio_notify() does not count as progress */
249 if (node
->e
!= &ctx
->notifier
) {
254 if (!node
->deleted
&&
255 (node
->io_read
|| node
->io_write
)) {
256 node
->pfd
.revents
= 0;
257 if ((revents
& G_IO_IN
) && node
->io_read
) {
258 node
->io_read(node
->opaque
);
261 if ((revents
& G_IO_OUT
) && node
->io_write
) {
262 node
->io_write(node
->opaque
);
266 /* if the next select() will return an event, we have progressed */
267 if (event
== event_notifier_get_handle(&ctx
->notifier
)) {
269 WSAEnumNetworkEvents(node
->pfd
.fd
, event
, &ev
);
270 if (ev
.lNetworkEvents
) {
277 ctx
->walking_handlers
--;
278 if (!ctx
->walking_handlers
) {
279 QLIST_REMOVE(node
, node
);
282 ctx
->walking_handlers
++;
286 ctx
->walking_handlers
--;
290 bool aio_dispatch(AioContext
*ctx
, bool dispatch_fds
)
294 progress
= aio_bh_poll(ctx
);
296 progress
|= aio_dispatch_handlers(ctx
, INVALID_HANDLE_VALUE
);
298 progress
|= timerlistgroup_run_timers(&ctx
->tlg
);
302 bool aio_poll(AioContext
*ctx
, bool blocking
)
305 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
306 bool progress
, have_select_revents
, first
;
310 aio_context_acquire(ctx
);
313 /* aio_notify can avoid the expensive event_notifier_set if
314 * everything (file descriptors, bottom halves, timers) will
315 * be re-evaluated before the next blocking poll(). This is
316 * already true when aio_poll is called with blocking == false;
317 * if blocking == true, it is only true after poll() returns,
318 * so disable the optimization now.
321 atomic_add(&ctx
->notify_me
, 2);
324 have_select_revents
= aio_prepare(ctx
);
326 ctx
->walking_handlers
++;
330 QLIST_FOREACH(node
, &ctx
->aio_handlers
, node
) {
331 if (!node
->deleted
&& node
->io_notify
332 && aio_node_check(ctx
, node
->is_external
)) {
333 events
[count
++] = event_notifier_get_handle(node
->e
);
337 ctx
->walking_handlers
--;
340 /* ctx->notifier is always registered. */
343 /* Multiple iterations, all of them non-blocking except the first,
344 * may be necessary to process all pending events. After the first
345 * WaitForMultipleObjects call ctx->notify_me will be decremented.
351 timeout
= blocking
&& !have_select_revents
352 ? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx
)) : 0;
354 aio_context_release(ctx
);
356 ret
= WaitForMultipleObjects(count
, events
, FALSE
, timeout
);
359 atomic_sub(&ctx
->notify_me
, 2);
362 aio_context_acquire(ctx
);
366 aio_notify_accept(ctx
);
367 progress
|= aio_bh_poll(ctx
);
371 /* if we have any signaled events, dispatch event */
373 if ((DWORD
) (ret
- WAIT_OBJECT_0
) < count
) {
374 event
= events
[ret
- WAIT_OBJECT_0
];
375 events
[ret
- WAIT_OBJECT_0
] = events
[--count
];
376 } else if (!have_select_revents
) {
380 have_select_revents
= false;
383 progress
|= aio_dispatch_handlers(ctx
, event
);
386 progress
|= timerlistgroup_run_timers(&ctx
->tlg
);
388 aio_context_release(ctx
);
392 void aio_context_setup(AioContext
*ctx
)
396 void aio_context_set_poll_params(AioContext
*ctx
, int64_t max_ns
,
397 int64_t grow
, int64_t shrink
, Error
**errp
)
399 error_setg(errp
, "AioContext polling is not implemented on Windows");