util/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/main-loop.h"
  22 #include "qemu/queue.h"
  23 #include "qemu/sockets.h"
  24 #include "qapi/error.h"
  25 #include "qemu/rcu_queue.h"
  26
  27 struct AioHandler {
  28     EventNotifier *e;
  29     IOHandler *io_read;
  30     IOHandler *io_write;
  31     EventNotifierHandler *io_notify;
  32     GPollFD pfd;
  33     int deleted;
  34     void *opaque;
  35     bool is_external;
  36     QLIST_ENTRY(AioHandler) node;
  37 };
  38
  39 static void aio_remove_fd_handler(AioContext *ctx, AioHandler *node)
  40 {
  41     /*
  42      * If the GSource is in the process of being destroyed then
  43      * g_source_remove_poll() causes an assertion failure.  Skip
  44      * removal in that case, because glib cleans up its state during
  45      * destruction anyway.
  46      */
  47     if (!g_source_is_destroyed(&ctx->source)) {
  48         g_source_remove_poll(&ctx->source, &node->pfd);
  49     }
  50
  51     /* If aio_poll is in progress, just mark the node as deleted */
  52     if (qemu_lockcnt_count(&ctx->list_lock)) {
  53         node->deleted = 1;
  54         node->pfd.revents = 0;
  55     } else {
  56         /* Otherwise, delete it for real.  We can't just mark it as
  57          * deleted because deleted nodes are only cleaned up after
  58          * releasing the list_lock.
  59          */
  60         QLIST_REMOVE(node, node);
  61         g_free(node);
  62     }
  63 }
  64
  65 void aio_set_fd_handler(AioContext *ctx,
  66                         int fd,
  67                         bool is_external,
  68                         IOHandler *io_read,
  69                         IOHandler *io_write,
  70                         AioPollFn *io_poll,
  71                         IOHandler *io_poll_ready,
  72                         void *opaque)
  73 {
  74     /* fd is a SOCKET in our case */
  75     AioHandler *old_node;
  76     AioHandler *node = NULL;
  77
  78     qemu_lockcnt_lock(&ctx->list_lock);
  79     QLIST_FOREACH(old_node, &ctx->aio_handlers, node) {
  80         if (old_node->pfd.fd == fd && !old_node->deleted) {
  81             break;
  82         }
  83     }
  84
  85     if (io_read || io_write) {
  86         HANDLE event;
  87         long bitmask = 0;
  88
  89         /* Alloc and insert if it's not already there */
  90         node = g_new0(AioHandler, 1);
  91         node->pfd.fd = fd;
  92
  93         node->pfd.events = 0;
  94         if (node->io_read) {
  95             node->pfd.events |= G_IO_IN;
  96         }
  97         if (node->io_write) {
  98             node->pfd.events |= G_IO_OUT;
  99         }
 100
 101         node->e = &ctx->notifier;
 102
 103         /* Update handler with latest information */
 104         node->opaque = opaque;
 105         node->io_read = io_read;
 106         node->io_write = io_write;
 107         node->is_external = is_external;
 108
 109         if (io_read) {
 110             bitmask |= FD_READ | FD_ACCEPT | FD_CLOSE;
 111         }
 112
 113         if (io_write) {
 114             bitmask |= FD_WRITE | FD_CONNECT;
 115         }
 116
 117         QLIST_INSERT_HEAD_RCU(&ctx->aio_handlers, node, node);
 118         event = event_notifier_get_handle(&ctx->notifier);
 119         WSAEventSelect(node->pfd.fd, event, bitmask);
 120     }
 121     if (old_node) {
 122         aio_remove_fd_handler(ctx, old_node);
 123     }
 124
 125     qemu_lockcnt_unlock(&ctx->list_lock);
 126     aio_notify(ctx);
 127 }
 128
 129 void aio_set_fd_poll(AioContext *ctx, int fd,
 130                      IOHandler *io_poll_begin,
 131                      IOHandler *io_poll_end)
 132 {
 133     /* Not implemented */
 134 }
 135
 136 void aio_set_event_notifier(AioContext *ctx,
 137                             EventNotifier *e,
 138                             bool is_external,
 139                             EventNotifierHandler *io_notify,
 140                             AioPollFn *io_poll,
 141                             EventNotifierHandler *io_poll_ready)
 142 {
 143     AioHandler *node;
 144
 145     qemu_lockcnt_lock(&ctx->list_lock);
 146     QLIST_FOREACH(node, &ctx->aio_handlers, node) {
 147         if (node->e == e && !node->deleted) {
 148             break;
 149         }
 150     }
 151
 152     /* Are we deleting the fd handler? */
 153     if (!io_notify) {
 154         if (node) {
 155             aio_remove_fd_handler(ctx, node);
 156         }
 157     } else {
 158         if (node == NULL) {
 159             /* Alloc and insert if it's not already there */
 160             node = g_new0(AioHandler, 1);
 161             node->e = e;
 162             node->pfd.fd = (uintptr_t)event_notifier_get_handle(e);
 163             node->pfd.events = G_IO_IN;
 164             node->is_external = is_external;
 165             QLIST_INSERT_HEAD_RCU(&ctx->aio_handlers, node, node);
 166
 167             g_source_add_poll(&ctx->source, &node->pfd);
 168         }
 169         /* Update handler with latest information */
 170         node->io_notify = io_notify;
 171     }
 172
 173     qemu_lockcnt_unlock(&ctx->list_lock);
 174     aio_notify(ctx);
 175 }
 176
 177 void aio_set_event_notifier_poll(AioContext *ctx,
 178                                  EventNotifier *notifier,
 179                                  EventNotifierHandler *io_poll_begin,
 180                                  EventNotifierHandler *io_poll_end)
 181 {
 182     /* Not implemented */
 183 }
 184
 185 bool aio_prepare(AioContext *ctx)
 186 {
 187     static struct timeval tv0;
 188     AioHandler *node;
 189     bool have_select_revents = false;
 190     fd_set rfds, wfds;
 191
 192     /*
 193      * We have to walk very carefully in case aio_set_fd_handler is
 194      * called while we're walking.
 195      */
 196     qemu_lockcnt_inc(&ctx->list_lock);
 197
 198     /* fill fd sets */
 199     FD_ZERO(&rfds);
 200     FD_ZERO(&wfds);
 201     QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
 202         if (node->io_read) {
 203             FD_SET ((SOCKET)node->pfd.fd, &rfds);
 204         }
 205         if (node->io_write) {
 206             FD_SET ((SOCKET)node->pfd.fd, &wfds);
 207         }
 208     }
 209
 210     if (select(0, &rfds, &wfds, NULL, &tv0) > 0) {
 211         QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
 212             node->pfd.revents = 0;
 213             if (FD_ISSET(node->pfd.fd, &rfds)) {
 214                 node->pfd.revents |= G_IO_IN;
 215                 have_select_revents = true;
 216             }
 217
 218             if (FD_ISSET(node->pfd.fd, &wfds)) {
 219                 node->pfd.revents |= G_IO_OUT;
 220                 have_select_revents = true;
 221             }
 222         }
 223     }
 224
 225     qemu_lockcnt_dec(&ctx->list_lock);
 226     return have_select_revents;
 227 }
 228
 229 bool aio_pending(AioContext *ctx)
 230 {
 231     AioHandler *node;
 232     bool result = false;
 233
 234     /*
 235      * We have to walk very carefully in case aio_set_fd_handler is
 236      * called while we're walking.
 237      */
 238     qemu_lockcnt_inc(&ctx->list_lock);
 239     QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
 240         if (node->pfd.revents && node->io_notify) {
 241             result = true;
 242             break;
 243         }
 244
 245         if ((node->pfd.revents & G_IO_IN) && node->io_read) {
 246             result = true;
 247             break;
 248         }
 249         if ((node->pfd.revents & G_IO_OUT) && node->io_write) {
 250             result = true;
 251             break;
 252         }
 253     }
 254
 255     qemu_lockcnt_dec(&ctx->list_lock);
 256     return result;
 257 }
 258
 259 static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
 260 {
 261     AioHandler *node;
 262     bool progress = false;
 263     AioHandler *tmp;
 264
 265     /*
 266      * We have to walk very carefully in case aio_set_fd_handler is
 267      * called while we're walking.
 268      */
 269     QLIST_FOREACH_SAFE_RCU(node, &ctx->aio_handlers, node, tmp) {
 270         int revents = node->pfd.revents;
 271
 272         if (!node->deleted &&
 273             (revents || event_notifier_get_handle(node->e) == event) &&
 274             node->io_notify) {
 275             node->pfd.revents = 0;
 276             node->io_notify(node->e);
 277
 278             /* aio_notify() does not count as progress */
 279             if (node->e != &ctx->notifier) {
 280                 progress = true;
 281             }
 282         }
 283
 284         if (!node->deleted &&
 285             (node->io_read || node->io_write)) {
 286             node->pfd.revents = 0;
 287             if ((revents & G_IO_IN) && node->io_read) {
 288                 node->io_read(node->opaque);
 289                 progress = true;
 290             }
 291             if ((revents & G_IO_OUT) && node->io_write) {
 292                 node->io_write(node->opaque);
 293                 progress = true;
 294             }
 295
 296             /* if the next select() will return an event, we have progressed */
 297             if (event == event_notifier_get_handle(&ctx->notifier)) {
 298                 WSANETWORKEVENTS ev;
 299                 WSAEnumNetworkEvents(node->pfd.fd, event, &ev);
 300                 if (ev.lNetworkEvents) {
 301                     progress = true;
 302                 }
 303             }
 304         }
 305
 306         if (node->deleted) {
 307             if (qemu_lockcnt_dec_if_lock(&ctx->list_lock)) {
 308                 QLIST_REMOVE(node, node);
 309                 g_free(node);
 310                 qemu_lockcnt_inc_and_unlock(&ctx->list_lock);
 311             }
 312         }
 313     }
 314
 315     return progress;
 316 }
 317
 318 void aio_dispatch(AioContext *ctx)
 319 {
 320     qemu_lockcnt_inc(&ctx->list_lock);
 321     aio_bh_poll(ctx);
 322     aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
 323     qemu_lockcnt_dec(&ctx->list_lock);
 324     timerlistgroup_run_timers(&ctx->tlg);
 325 }
 326
 327 bool aio_poll(AioContext *ctx, bool blocking)
 328 {
 329     AioHandler *node;
 330     HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
 331     bool progress, have_select_revents, first;
 332     int count;
 333     int timeout;
 334
 335     /*
 336      * There cannot be two concurrent aio_poll calls for the same AioContext (or
 337      * an aio_poll concurrent with a GSource prepare/check/dispatch callback).
 338      * We rely on this below to avoid slow locked accesses to ctx->notify_me.
 339      *
 340      * aio_poll() may only be called in the AioContext's thread. iohandler_ctx
 341      * is special in that it runs in the main thread, but that thread's context
 342      * is qemu_aio_context.
 343      */
 344     assert(in_aio_context_home_thread(ctx == iohandler_get_aio_context() ?
 345                                       qemu_get_aio_context() : ctx));
 346     progress = false;
 347
 348     /* aio_notify can avoid the expensive event_notifier_set if
 349      * everything (file descriptors, bottom halves, timers) will
 350      * be re-evaluated before the next blocking poll().  This is
 351      * already true when aio_poll is called with blocking == false;
 352      * if blocking == true, it is only true after poll() returns,
 353      * so disable the optimization now.
 354      */
 355     if (blocking) {
 356         qatomic_set(&ctx->notify_me, qatomic_read(&ctx->notify_me) + 2);
 357         /*
 358          * Write ctx->notify_me before computing the timeout
 359          * (reading bottom half flags, etc.).  Pairs with
 360          * smp_mb in aio_notify().
 361          */
 362         smp_mb();
 363     }
 364
 365     qemu_lockcnt_inc(&ctx->list_lock);
 366     have_select_revents = aio_prepare(ctx);
 367
 368     /* fill fd sets */
 369     count = 0;
 370     QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
 371         if (!node->deleted && node->io_notify
 372             && aio_node_check(ctx, node->is_external)) {
 373             events[count++] = event_notifier_get_handle(node->e);
 374         }
 375     }
 376
 377     first = true;
 378
 379     /* ctx->notifier is always registered.  */
 380     assert(count > 0);
 381
 382     /* Multiple iterations, all of them non-blocking except the first,
 383      * may be necessary to process all pending events.  After the first
 384      * WaitForMultipleObjects call ctx->notify_me will be decremented.
 385      */
 386     do {
 387         HANDLE event;
 388         int ret;
 389
 390         timeout = blocking && !have_select_revents
 391             ? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx)) : 0;
 392         ret = WaitForMultipleObjects(count, events, FALSE, timeout);
 393         if (blocking) {
 394             assert(first);
 395             qatomic_store_release(&ctx->notify_me,
 396                                   qatomic_read(&ctx->notify_me) - 2);
 397             aio_notify_accept(ctx);
 398         }
 399
 400         if (first) {
 401             progress |= aio_bh_poll(ctx);
 402             first = false;
 403         }
 404
 405         /* if we have any signaled events, dispatch event */
 406         event = NULL;
 407         if ((DWORD) (ret - WAIT_OBJECT_0) < count) {
 408             event = events[ret - WAIT_OBJECT_0];
 409             events[ret - WAIT_OBJECT_0] = events[--count];
 410         } else if (!have_select_revents) {
 411             break;
 412         }
 413
 414         have_select_revents = false;
 415         blocking = false;
 416
 417         progress |= aio_dispatch_handlers(ctx, event);
 418     } while (count > 0);
 419
 420     qemu_lockcnt_dec(&ctx->list_lock);
 421
 422     progress |= timerlistgroup_run_timers(&ctx->tlg);
 423     return progress;
 424 }
 425
 426 void aio_context_setup(AioContext *ctx)
 427 {
 428 }
 429
 430 void aio_context_destroy(AioContext *ctx)
 431 {
 432 }
 433
 434 void aio_context_use_g_source(AioContext *ctx)
 435 {
 436 }
 437
 438 void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
 439                                  int64_t grow, int64_t shrink, Error **errp)
 440 {
 441     if (max_ns) {
 442         error_setg(errp, "AioContext polling is not implemented on Windows");
 443     }
 444 }
 445
 446 void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
 447                                 Error **errp)
 448 {
 449 }