trap signals for "-serial mon:stdio"
[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-common.h"
19 #include "block/block.h"
20 #include "qemu/queue.h"
21 #include "qemu/sockets.h"
22
23 struct AioHandler {
24 EventNotifier *e;
25 EventNotifierHandler *io_notify;
26 AioFlushEventNotifierHandler *io_flush;
27 GPollFD pfd;
28 int deleted;
29 QLIST_ENTRY(AioHandler) node;
30 };
31
32 void aio_set_event_notifier(AioContext *ctx,
33 EventNotifier *e,
34 EventNotifierHandler *io_notify,
35 AioFlushEventNotifierHandler *io_flush)
36 {
37 AioHandler *node;
38
39 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
40 if (node->e == e && !node->deleted) {
41 break;
42 }
43 }
44
45 /* Are we deleting the fd handler? */
46 if (!io_notify) {
47 if (node) {
48 g_source_remove_poll(&ctx->source, &node->pfd);
49
50 /* If the lock is held, just mark the node as deleted */
51 if (ctx->walking_handlers) {
52 node->deleted = 1;
53 node->pfd.revents = 0;
54 } else {
55 /* Otherwise, delete it for real. We can't just mark it as
56 * deleted because deleted nodes are only cleaned up after
57 * releasing the walking_handlers lock.
58 */
59 QLIST_REMOVE(node, node);
60 g_free(node);
61 }
62 }
63 } else {
64 if (node == NULL) {
65 /* Alloc and insert if it's not already there */
66 node = g_malloc0(sizeof(AioHandler));
67 node->e = e;
68 node->pfd.fd = (uintptr_t)event_notifier_get_handle(e);
69 node->pfd.events = G_IO_IN;
70 QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
71
72 g_source_add_poll(&ctx->source, &node->pfd);
73 }
74 /* Update handler with latest information */
75 node->io_notify = io_notify;
76 node->io_flush = io_flush;
77 }
78
79 aio_notify(ctx);
80 }
81
82 bool aio_pending(AioContext *ctx)
83 {
84 AioHandler *node;
85
86 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
87 if (node->pfd.revents && node->io_notify) {
88 return true;
89 }
90 }
91
92 return false;
93 }
94
95 bool aio_poll(AioContext *ctx, bool blocking)
96 {
97 AioHandler *node;
98 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
99 bool busy, progress;
100 int count;
101
102 progress = false;
103
104 /*
105 * If there are callbacks left that have been queued, we need to call then.
106 * Do not call select in this case, because it is possible that the caller
107 * does not need a complete flush (as is the case for qemu_aio_wait loops).
108 */
109 if (aio_bh_poll(ctx)) {
110 blocking = false;
111 progress = true;
112 }
113
114 /*
115 * Then dispatch any pending callbacks from the GSource.
116 *
117 * We have to walk very carefully in case qemu_aio_set_fd_handler is
118 * called while we're walking.
119 */
120 node = QLIST_FIRST(&ctx->aio_handlers);
121 while (node) {
122 AioHandler *tmp;
123
124 ctx->walking_handlers++;
125
126 if (node->pfd.revents && node->io_notify) {
127 node->pfd.revents = 0;
128 node->io_notify(node->e);
129 progress = true;
130 }
131
132 tmp = node;
133 node = QLIST_NEXT(node, node);
134
135 ctx->walking_handlers--;
136
137 if (!ctx->walking_handlers && tmp->deleted) {
138 QLIST_REMOVE(tmp, node);
139 g_free(tmp);
140 }
141 }
142
143 if (progress && !blocking) {
144 return true;
145 }
146
147 ctx->walking_handlers++;
148
149 /* fill fd sets */
150 busy = false;
151 count = 0;
152 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
153 /* If there aren't pending AIO operations, don't invoke callbacks.
154 * Otherwise, if there are no AIO requests, qemu_aio_wait() would
155 * wait indefinitely.
156 */
157 if (!node->deleted && node->io_flush) {
158 if (node->io_flush(node->e) == 0) {
159 continue;
160 }
161 busy = true;
162 }
163 if (!node->deleted && node->io_notify) {
164 events[count++] = event_notifier_get_handle(node->e);
165 }
166 }
167
168 ctx->walking_handlers--;
169
170 /* No AIO operations? Get us out of here */
171 if (!busy) {
172 return progress;
173 }
174
175 /* wait until next event */
176 while (count > 0) {
177 int timeout = blocking ? INFINITE : 0;
178 int ret = WaitForMultipleObjects(count, events, FALSE, timeout);
179
180 /* if we have any signaled events, dispatch event */
181 if ((DWORD) (ret - WAIT_OBJECT_0) >= count) {
182 break;
183 }
184
185 blocking = false;
186
187 /* we have to walk very carefully in case
188 * qemu_aio_set_fd_handler is called while we're walking */
189 node = QLIST_FIRST(&ctx->aio_handlers);
190 while (node) {
191 AioHandler *tmp;
192
193 ctx->walking_handlers++;
194
195 if (!node->deleted &&
196 event_notifier_get_handle(node->e) == events[ret - WAIT_OBJECT_0] &&
197 node->io_notify) {
198 node->io_notify(node->e);
199 progress = true;
200 }
201
202 tmp = node;
203 node = QLIST_NEXT(node, node);
204
205 ctx->walking_handlers--;
206
207 if (!ctx->walking_handlers && tmp->deleted) {
208 QLIST_REMOVE(tmp, node);
209 g_free(tmp);
210 }
211 }
212
213 /* Try again, but only call each handler once. */
214 events[ret - WAIT_OBJECT_0] = events[--count];
215 }
216
217 assert(progress || busy);
218 return true;
219 }