]> git.proxmox.com Git - qemu.git/blob - aio-posix.c
35131a3ef733d4c893e985fcd58c395a1dd49002
[qemu.git] / aio-posix.c
1 /*
2 * QEMU aio implementation
3 *
4 * Copyright IBM, Corp. 2008
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
14 */
15
16 #include "qemu-common.h"
17 #include "block/block.h"
18 #include "qemu/queue.h"
19 #include "qemu/sockets.h"
20
21 struct AioHandler
22 {
23 GPollFD pfd;
24 IOHandler *io_read;
25 IOHandler *io_write;
26 AioFlushHandler *io_flush;
27 int deleted;
28 void *opaque;
29 QLIST_ENTRY(AioHandler) node;
30 };
31
32 static AioHandler *find_aio_handler(AioContext *ctx, int fd)
33 {
34 AioHandler *node;
35
36 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
37 if (node->pfd.fd == fd)
38 if (!node->deleted)
39 return node;
40 }
41
42 return NULL;
43 }
44
45 void aio_set_fd_handler(AioContext *ctx,
46 int fd,
47 IOHandler *io_read,
48 IOHandler *io_write,
49 AioFlushHandler *io_flush,
50 void *opaque)
51 {
52 AioHandler *node;
53
54 node = find_aio_handler(ctx, fd);
55
56 /* Are we deleting the fd handler? */
57 if (!io_read && !io_write) {
58 if (node) {
59 g_source_remove_poll(&ctx->source, &node->pfd);
60
61 /* If the lock is held, just mark the node as deleted */
62 if (ctx->walking_handlers) {
63 node->deleted = 1;
64 node->pfd.revents = 0;
65 } else {
66 /* Otherwise, delete it for real. We can't just mark it as
67 * deleted because deleted nodes are only cleaned up after
68 * releasing the walking_handlers lock.
69 */
70 QLIST_REMOVE(node, node);
71 g_free(node);
72 }
73 }
74 } else {
75 if (node == NULL) {
76 /* Alloc and insert if it's not already there */
77 node = g_malloc0(sizeof(AioHandler));
78 node->pfd.fd = fd;
79 QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
80
81 g_source_add_poll(&ctx->source, &node->pfd);
82 }
83 /* Update handler with latest information */
84 node->io_read = io_read;
85 node->io_write = io_write;
86 node->io_flush = io_flush;
87 node->opaque = opaque;
88
89 node->pfd.events = (io_read ? G_IO_IN | G_IO_HUP : 0);
90 node->pfd.events |= (io_write ? G_IO_OUT : 0);
91 }
92
93 aio_notify(ctx);
94 }
95
96 void aio_set_event_notifier(AioContext *ctx,
97 EventNotifier *notifier,
98 EventNotifierHandler *io_read,
99 AioFlushEventNotifierHandler *io_flush)
100 {
101 aio_set_fd_handler(ctx, event_notifier_get_fd(notifier),
102 (IOHandler *)io_read, NULL,
103 (AioFlushHandler *)io_flush, notifier);
104 }
105
106 bool aio_pending(AioContext *ctx)
107 {
108 AioHandler *node;
109
110 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
111 int revents;
112
113 /*
114 * FIXME: right now we cannot get G_IO_HUP and G_IO_ERR because
115 * main-loop.c is still select based (due to the slirp legacy).
116 * If main-loop.c ever switches to poll, G_IO_ERR should be
117 * tested too. Dispatching G_IO_ERR to both handlers should be
118 * okay, since handlers need to be ready for spurious wakeups.
119 */
120 revents = node->pfd.revents & node->pfd.events;
121 if (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR) && node->io_read) {
122 return true;
123 }
124 if (revents & (G_IO_OUT | G_IO_ERR) && node->io_write) {
125 return true;
126 }
127 }
128
129 return false;
130 }
131
132 static bool aio_dispatch(AioContext *ctx)
133 {
134 AioHandler *node;
135 bool progress = false;
136
137 /*
138 * We have to walk very carefully in case qemu_aio_set_fd_handler is
139 * called while we're walking.
140 */
141 node = QLIST_FIRST(&ctx->aio_handlers);
142 while (node) {
143 AioHandler *tmp;
144 int revents;
145
146 ctx->walking_handlers++;
147
148 revents = node->pfd.revents & node->pfd.events;
149 node->pfd.revents = 0;
150
151 /* See comment in aio_pending. */
152 if (!node->deleted &&
153 (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
154 node->io_read) {
155 node->io_read(node->opaque);
156 progress = true;
157 }
158 if (!node->deleted &&
159 (revents & (G_IO_OUT | G_IO_ERR)) &&
160 node->io_write) {
161 node->io_write(node->opaque);
162 progress = true;
163 }
164
165 tmp = node;
166 node = QLIST_NEXT(node, node);
167
168 ctx->walking_handlers--;
169
170 if (!ctx->walking_handlers && tmp->deleted) {
171 QLIST_REMOVE(tmp, node);
172 g_free(tmp);
173 }
174 }
175 return progress;
176 }
177
178 bool aio_poll(AioContext *ctx, bool blocking)
179 {
180 static struct timeval tv0;
181 AioHandler *node;
182 fd_set rdfds, wrfds;
183 int max_fd = -1;
184 int ret;
185 bool busy, progress;
186
187 progress = false;
188
189 /*
190 * If there are callbacks left that have been queued, we need to call them.
191 * Do not call select in this case, because it is possible that the caller
192 * does not need a complete flush (as is the case for qemu_aio_wait loops).
193 */
194 if (aio_bh_poll(ctx)) {
195 blocking = false;
196 progress = true;
197 }
198
199 if (aio_dispatch(ctx)) {
200 progress = true;
201 }
202
203 if (progress && !blocking) {
204 return true;
205 }
206
207 ctx->walking_handlers++;
208
209 FD_ZERO(&rdfds);
210 FD_ZERO(&wrfds);
211
212 /* fill fd sets */
213 busy = false;
214 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
215 /* If there aren't pending AIO operations, don't invoke callbacks.
216 * Otherwise, if there are no AIO requests, qemu_aio_wait() would
217 * wait indefinitely.
218 */
219 if (!node->deleted && node->io_flush) {
220 if (node->io_flush(node->opaque) == 0) {
221 continue;
222 }
223 busy = true;
224 }
225 if (!node->deleted && node->io_read) {
226 FD_SET(node->pfd.fd, &rdfds);
227 max_fd = MAX(max_fd, node->pfd.fd + 1);
228 }
229 if (!node->deleted && node->io_write) {
230 FD_SET(node->pfd.fd, &wrfds);
231 max_fd = MAX(max_fd, node->pfd.fd + 1);
232 }
233 }
234
235 ctx->walking_handlers--;
236
237 /* No AIO operations? Get us out of here */
238 if (!busy) {
239 return progress;
240 }
241
242 /* wait until next event */
243 ret = select(max_fd, &rdfds, &wrfds, NULL, blocking ? NULL : &tv0);
244
245 /* if we have any readable fds, dispatch event */
246 if (ret > 0) {
247 /* we have to walk very carefully in case
248 * qemu_aio_set_fd_handler is called while we're walking */
249 node = QLIST_FIRST(&ctx->aio_handlers);
250 while (node) {
251 AioHandler *tmp;
252
253 ctx->walking_handlers++;
254
255 if (!node->deleted &&
256 FD_ISSET(node->pfd.fd, &rdfds) &&
257 node->io_read) {
258 node->io_read(node->opaque);
259 progress = true;
260 }
261 if (!node->deleted &&
262 FD_ISSET(node->pfd.fd, &wrfds) &&
263 node->io_write) {
264 node->io_write(node->opaque);
265 progress = true;
266 }
267
268 tmp = node;
269 node = QLIST_NEXT(node, node);
270
271 ctx->walking_handlers--;
272
273 if (!ctx->walking_handlers && tmp->deleted) {
274 QLIST_REMOVE(tmp, node);
275 g_free(tmp);
276 }
277 }
278 }
279
280 assert(progress || busy);
281 return true;
282 }