target-i386: Use mulu2 and muls2
[qemu/pbrook.git] / aio-posix.c
blobb68eccd40ccc6d4c2af25349f61694f3cddb4d16
1 /*
2 * QEMU aio implementation
4 * Copyright IBM, Corp. 2008
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
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.
16 #include "qemu-common.h"
17 #include "block/block.h"
18 #include "qemu/queue.h"
19 #include "qemu/sockets.h"
21 struct AioHandler
23 GPollFD pfd;
24 IOHandler *io_read;
25 IOHandler *io_write;
26 AioFlushHandler *io_flush;
27 int deleted;
28 int pollfds_idx;
29 void *opaque;
30 QLIST_ENTRY(AioHandler) node;
33 static AioHandler *find_aio_handler(AioContext *ctx, int fd)
35 AioHandler *node;
37 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
38 if (node->pfd.fd == fd)
39 if (!node->deleted)
40 return node;
43 return NULL;
46 void aio_set_fd_handler(AioContext *ctx,
47 int fd,
48 IOHandler *io_read,
49 IOHandler *io_write,
50 AioFlushHandler *io_flush,
51 void *opaque)
53 AioHandler *node;
55 node = find_aio_handler(ctx, fd);
57 /* Are we deleting the fd handler? */
58 if (!io_read && !io_write) {
59 if (node) {
60 g_source_remove_poll(&ctx->source, &node->pfd);
62 /* If the lock is held, just mark the node as deleted */
63 if (ctx->walking_handlers) {
64 node->deleted = 1;
65 node->pfd.revents = 0;
66 } else {
67 /* Otherwise, delete it for real. We can't just mark it as
68 * deleted because deleted nodes are only cleaned up after
69 * releasing the walking_handlers lock.
71 QLIST_REMOVE(node, node);
72 g_free(node);
75 } else {
76 if (node == NULL) {
77 /* Alloc and insert if it's not already there */
78 node = g_malloc0(sizeof(AioHandler));
79 node->pfd.fd = fd;
80 QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
82 g_source_add_poll(&ctx->source, &node->pfd);
84 /* Update handler with latest information */
85 node->io_read = io_read;
86 node->io_write = io_write;
87 node->io_flush = io_flush;
88 node->opaque = opaque;
89 node->pollfds_idx = -1;
91 node->pfd.events = (io_read ? G_IO_IN | G_IO_HUP | G_IO_ERR : 0);
92 node->pfd.events |= (io_write ? G_IO_OUT | G_IO_ERR : 0);
95 aio_notify(ctx);
98 void aio_set_event_notifier(AioContext *ctx,
99 EventNotifier *notifier,
100 EventNotifierHandler *io_read,
101 AioFlushEventNotifierHandler *io_flush)
103 aio_set_fd_handler(ctx, event_notifier_get_fd(notifier),
104 (IOHandler *)io_read, NULL,
105 (AioFlushHandler *)io_flush, notifier);
108 bool aio_pending(AioContext *ctx)
110 AioHandler *node;
112 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
113 int revents;
115 revents = node->pfd.revents & node->pfd.events;
116 if (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR) && node->io_read) {
117 return true;
119 if (revents & (G_IO_OUT | G_IO_ERR) && node->io_write) {
120 return true;
124 return false;
127 static bool aio_dispatch(AioContext *ctx)
129 AioHandler *node;
130 bool progress = false;
133 * We have to walk very carefully in case qemu_aio_set_fd_handler is
134 * called while we're walking.
136 node = QLIST_FIRST(&ctx->aio_handlers);
137 while (node) {
138 AioHandler *tmp;
139 int revents;
141 ctx->walking_handlers++;
143 revents = node->pfd.revents & node->pfd.events;
144 node->pfd.revents = 0;
146 if (!node->deleted &&
147 (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
148 node->io_read) {
149 node->io_read(node->opaque);
150 progress = true;
152 if (!node->deleted &&
153 (revents & (G_IO_OUT | G_IO_ERR)) &&
154 node->io_write) {
155 node->io_write(node->opaque);
156 progress = true;
159 tmp = node;
160 node = QLIST_NEXT(node, node);
162 ctx->walking_handlers--;
164 if (!ctx->walking_handlers && tmp->deleted) {
165 QLIST_REMOVE(tmp, node);
166 g_free(tmp);
169 return progress;
172 bool aio_poll(AioContext *ctx, bool blocking)
174 AioHandler *node;
175 int ret;
176 bool busy, progress;
178 progress = false;
181 * If there are callbacks left that have been queued, we need to call them.
182 * Do not call select in this case, because it is possible that the caller
183 * does not need a complete flush (as is the case for qemu_aio_wait loops).
185 if (aio_bh_poll(ctx)) {
186 blocking = false;
187 progress = true;
190 if (aio_dispatch(ctx)) {
191 progress = true;
194 if (progress && !blocking) {
195 return true;
198 ctx->walking_handlers++;
200 g_array_set_size(ctx->pollfds, 0);
202 /* fill pollfds */
203 busy = false;
204 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
205 node->pollfds_idx = -1;
207 /* If there aren't pending AIO operations, don't invoke callbacks.
208 * Otherwise, if there are no AIO requests, qemu_aio_wait() would
209 * wait indefinitely.
211 if (!node->deleted && node->io_flush) {
212 if (node->io_flush(node->opaque) == 0) {
213 continue;
215 busy = true;
217 if (!node->deleted && node->pfd.events) {
218 GPollFD pfd = {
219 .fd = node->pfd.fd,
220 .events = node->pfd.events,
222 node->pollfds_idx = ctx->pollfds->len;
223 g_array_append_val(ctx->pollfds, pfd);
227 ctx->walking_handlers--;
229 /* No AIO operations? Get us out of here */
230 if (!busy) {
231 return progress;
234 /* wait until next event */
235 ret = g_poll((GPollFD *)ctx->pollfds->data,
236 ctx->pollfds->len,
237 blocking ? -1 : 0);
239 /* if we have any readable fds, dispatch event */
240 if (ret > 0) {
241 QLIST_FOREACH(node, &ctx->aio_handlers, node) {
242 if (node->pollfds_idx != -1) {
243 GPollFD *pfd = &g_array_index(ctx->pollfds, GPollFD,
244 node->pollfds_idx);
245 node->pfd.revents = pfd->revents;
248 if (aio_dispatch(ctx)) {
249 progress = true;
253 assert(progress || busy);
254 return true;