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