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