Merge remote-tracking branch 'remotes/kraxel/tags/pull-vga-20170103-1' into staging
[qemu.git] / aio-win32.c
1 /*
2 * QEMU aio implementation
3 *
4 * Copyright IBM Corp., 2008
5 * Copyright Red Hat Inc., 2012
6 *
7 * Authors:
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Paolo Bonzini <pbonzini@redhat.com>
10 *
11 * This work is licensed under the terms of the GNU GPL, version 2. See
12 * the COPYING file in the top-level directory.
13 *
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.
16 */
17
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
24 struct AioHandler {
25 EventNotifier *e;
26 IOHandler *io_read;
27 IOHandler *io_write;
28 EventNotifierHandler *io_notify;
29 GPollFD pfd;
30 int deleted;
31 void *opaque;
32 bool is_external;
33 QLIST_ENTRY(AioHandler) node;
34 };
35
36 void aio_set_fd_handler(AioContext *ctx,
37 int fd,
38 bool is_external,
39 IOHandler *io_read,
40 IOHandler *io_write,
41 void *opaque)
42 {
43 /* fd is a SOCKET in our case */
44 AioHandler *node;
45
46 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
47 if (node->pfd.fd == fd && !node->deleted) {
48 break;
49 }
50 }
51
52 /* Are we deleting the fd handler? */
53 if (!io_read && !io_write) {
54 if (node) {
55 /* If the lock is held, just mark the node as deleted */
56 if (ctx->walking_handlers) {
57 node->deleted = 1;
58 node->pfd.revents = 0;
59 } else {
60 /* Otherwise, delete it for real. We can't just mark it as
61 * deleted because deleted nodes are only cleaned up after
62 * releasing the walking_handlers lock.
63 */
64 QLIST_REMOVE(node, node);
65 g_free(node);
66 }
67 }
68 } else {
69 HANDLE event;
70
71 if (node == NULL) {
72 /* Alloc and insert if it's not already there */
73 node = g_new0(AioHandler, 1);
74 node->pfd.fd = fd;
75 QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
76 }
77
78 node->pfd.events = 0;
79 if (node->io_read) {
80 node->pfd.events |= G_IO_IN;
81 }
82 if (node->io_write) {
83 node->pfd.events |= G_IO_OUT;
84 }
85
86 node->e = &ctx->notifier;
87
88 /* Update handler with latest information */
89 node->opaque = opaque;
90 node->io_read = io_read;
91 node->io_write = io_write;
92 node->is_external = is_external;
93
94 event = event_notifier_get_handle(&ctx->notifier);
95 WSAEventSelect(node->pfd.fd, event,
96 FD_READ | FD_ACCEPT | FD_CLOSE |
97 FD_CONNECT | FD_WRITE | FD_OOB);
98 }
99
100 aio_notify(ctx);
101 }
102
103 void aio_set_event_notifier(AioContext *ctx,
104 EventNotifier *e,
105 bool is_external,
106 EventNotifierHandler *io_notify)
107 {
108 AioHandler *node;
109
110 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
111 if (node->e == e && !node->deleted) {
112 break;
113 }
114 }
115
116 /* Are we deleting the fd handler? */
117 if (!io_notify) {
118 if (node) {
119 g_source_remove_poll(&ctx->source, &node->pfd);
120
121 /* If the lock is held, just mark the node as deleted */
122 if (ctx->walking_handlers) {
123 node->deleted = 1;
124 node->pfd.revents = 0;
125 } else {
126 /* Otherwise, delete it for real. We can't just mark it as
127 * deleted because deleted nodes are only cleaned up after
128 * releasing the walking_handlers lock.
129 */
130 QLIST_REMOVE(node, node);
131 g_free(node);
132 }
133 }
134 } else {
135 if (node == NULL) {
136 /* Alloc and insert if it's not already there */
137 node = g_new0(AioHandler, 1);
138 node->e = e;
139 node->pfd.fd = (uintptr_t)event_notifier_get_handle(e);
140 node->pfd.events = G_IO_IN;
141 node->is_external = is_external;
142 QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
143
144 g_source_add_poll(&ctx->source, &node->pfd);
145 }
146 /* Update handler with latest information */
147 node->io_notify = io_notify;
148 }
149
150 aio_notify(ctx);
151 }
152
153 bool aio_prepare(AioContext *ctx)
154 {
155 static struct timeval tv0;
156 AioHandler *node;
157 bool have_select_revents = false;
158 fd_set rfds, wfds;
159
160 /* fill fd sets */
161 FD_ZERO(&rfds);
162 FD_ZERO(&wfds);
163 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
164 if (node->io_read) {
165 FD_SET ((SOCKET)node->pfd.fd, &rfds);
166 }
167 if (node->io_write) {
168 FD_SET ((SOCKET)node->pfd.fd, &wfds);
169 }
170 }
171
172 if (select(0, &rfds, &wfds, NULL, &tv0) > 0) {
173 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
174 node->pfd.revents = 0;
175 if (FD_ISSET(node->pfd.fd, &rfds)) {
176 node->pfd.revents |= G_IO_IN;
177 have_select_revents = true;
178 }
179
180 if (FD_ISSET(node->pfd.fd, &wfds)) {
181 node->pfd.revents |= G_IO_OUT;
182 have_select_revents = true;
183 }
184 }
185 }
186
187 return have_select_revents;
188 }
189
190 bool aio_pending(AioContext *ctx)
191 {
192 AioHandler *node;
193
194 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
195 if (node->pfd.revents && node->io_notify) {
196 return true;
197 }
198
199 if ((node->pfd.revents & G_IO_IN) && node->io_read) {
200 return true;
201 }
202 if ((node->pfd.revents & G_IO_OUT) && node->io_write) {
203 return true;
204 }
205 }
206
207 return false;
208 }
209
210 static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
211 {
212 AioHandler *node;
213 bool progress = false;
214
215 /*
216 * We have to walk very carefully in case aio_set_fd_handler is
217 * called while we're walking.
218 */
219 node = QLIST_FIRST(&ctx->aio_handlers);
220 while (node) {
221 AioHandler *tmp;
222 int revents = node->pfd.revents;
223
224 ctx->walking_handlers++;
225
226 if (!node->deleted &&
227 (revents || event_notifier_get_handle(node->e) == event) &&
228 node->io_notify) {
229 node->pfd.revents = 0;
230 node->io_notify(node->e);
231
232 /* aio_notify() does not count as progress */
233 if (node->e != &ctx->notifier) {
234 progress = true;
235 }
236 }
237
238 if (!node->deleted &&
239 (node->io_read || node->io_write)) {
240 node->pfd.revents = 0;
241 if ((revents & G_IO_IN) && node->io_read) {
242 node->io_read(node->opaque);
243 progress = true;
244 }
245 if ((revents & G_IO_OUT) && node->io_write) {
246 node->io_write(node->opaque);
247 progress = true;
248 }
249
250 /* if the next select() will return an event, we have progressed */
251 if (event == event_notifier_get_handle(&ctx->notifier)) {
252 WSANETWORKEVENTS ev;
253 WSAEnumNetworkEvents(node->pfd.fd, event, &ev);
254 if (ev.lNetworkEvents) {
255 progress = true;
256 }
257 }
258 }
259
260 tmp = node;
261 node = QLIST_NEXT(node, node);
262
263 ctx->walking_handlers--;
264
265 if (!ctx->walking_handlers && tmp->deleted) {
266 QLIST_REMOVE(tmp, node);
267 g_free(tmp);
268 }
269 }
270
271 return progress;
272 }
273
274 bool aio_dispatch(AioContext *ctx)
275 {
276 bool progress;
277
278 progress = aio_bh_poll(ctx);
279 progress |= aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
280 progress |= timerlistgroup_run_timers(&ctx->tlg);
281 return progress;
282 }
283
284 bool aio_poll(AioContext *ctx, bool blocking)
285 {
286 AioHandler *node;
287 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
288 bool progress, have_select_revents, first;
289 int count;
290 int timeout;
291
292 aio_context_acquire(ctx);
293 progress = false;
294
295 /* aio_notify can avoid the expensive event_notifier_set if
296 * everything (file descriptors, bottom halves, timers) will
297 * be re-evaluated before the next blocking poll(). This is
298 * already true when aio_poll is called with blocking == false;
299 * if blocking == true, it is only true after poll() returns,
300 * so disable the optimization now.
301 */
302 if (blocking) {
303 atomic_add(&ctx->notify_me, 2);
304 }
305
306 have_select_revents = aio_prepare(ctx);
307
308 ctx->walking_handlers++;
309
310 /* fill fd sets */
311 count = 0;
312 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
313 if (!node->deleted && node->io_notify
314 && aio_node_check(ctx, node->is_external)) {
315 events[count++] = event_notifier_get_handle(node->e);
316 }
317 }
318
319 ctx->walking_handlers--;
320 first = true;
321
322 /* ctx->notifier is always registered. */
323 assert(count > 0);
324
325 /* Multiple iterations, all of them non-blocking except the first,
326 * may be necessary to process all pending events. After the first
327 * WaitForMultipleObjects call ctx->notify_me will be decremented.
328 */
329 do {
330 HANDLE event;
331 int ret;
332
333 timeout = blocking && !have_select_revents
334 ? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx)) : 0;
335 if (timeout) {
336 aio_context_release(ctx);
337 }
338 ret = WaitForMultipleObjects(count, events, FALSE, timeout);
339 if (blocking) {
340 assert(first);
341 atomic_sub(&ctx->notify_me, 2);
342 }
343 if (timeout) {
344 aio_context_acquire(ctx);
345 }
346
347 if (first) {
348 aio_notify_accept(ctx);
349 progress |= aio_bh_poll(ctx);
350 first = false;
351 }
352
353 /* if we have any signaled events, dispatch event */
354 event = NULL;
355 if ((DWORD) (ret - WAIT_OBJECT_0) < count) {
356 event = events[ret - WAIT_OBJECT_0];
357 events[ret - WAIT_OBJECT_0] = events[--count];
358 } else if (!have_select_revents) {
359 break;
360 }
361
362 have_select_revents = false;
363 blocking = false;
364
365 progress |= aio_dispatch_handlers(ctx, event);
366 } while (count > 0);
367
368 progress |= timerlistgroup_run_timers(&ctx->tlg);
369
370 aio_context_release(ctx);
371 return progress;
372 }
373
374 void aio_context_setup(AioContext *ctx)
375 {
376 }