diff options
Diffstat (limited to 'util/aio-posix.c')
-rw-r--r-- | util/aio-posix.c | 451 |
1 files changed, 144 insertions, 307 deletions
diff --git a/util/aio-posix.c b/util/aio-posix.c index 9e1befc0c0..cd6cf0a4a9 100644 --- a/util/aio-posix.c +++ b/util/aio-posix.c @@ -20,191 +20,25 @@ #include "qemu/sockets.h" #include "qemu/cutils.h" #include "trace.h" -#ifdef CONFIG_EPOLL_CREATE1 -#include <sys/epoll.h> -#endif +#include "aio-posix.h" -struct AioHandler -{ - GPollFD pfd; - IOHandler *io_read; - IOHandler *io_write; - AioPollFn *io_poll; - IOHandler *io_poll_begin; - IOHandler *io_poll_end; - void *opaque; - bool is_external; - QLIST_ENTRY(AioHandler) node; - QLIST_ENTRY(AioHandler) node_ready; /* only used during aio_poll() */ - QLIST_ENTRY(AioHandler) node_deleted; -}; - -/* Add a handler to a ready list */ -static void add_ready_handler(AioHandlerList *ready_list, - AioHandler *node, - int revents) -{ - QLIST_SAFE_REMOVE(node, node_ready); /* remove from nested parent's list */ - node->pfd.revents = revents; - QLIST_INSERT_HEAD(ready_list, node, node_ready); -} - -#ifdef CONFIG_EPOLL_CREATE1 - -/* The fd number threshold to switch to epoll */ -#define EPOLL_ENABLE_THRESHOLD 64 - -static void aio_epoll_disable(AioContext *ctx) -{ - ctx->epoll_enabled = false; - if (!ctx->epoll_available) { - return; - } - ctx->epoll_available = false; - close(ctx->epollfd); -} - -static inline int epoll_events_from_pfd(int pfd_events) -{ - return (pfd_events & G_IO_IN ? EPOLLIN : 0) | - (pfd_events & G_IO_OUT ? EPOLLOUT : 0) | - (pfd_events & G_IO_HUP ? EPOLLHUP : 0) | - (pfd_events & G_IO_ERR ? EPOLLERR : 0); -} - -static bool aio_epoll_try_enable(AioContext *ctx) -{ - AioHandler *node; - struct epoll_event event; - - QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) { - int r; - if (QLIST_IS_INSERTED(node, node_deleted) || !node->pfd.events) { - continue; - } - event.events = epoll_events_from_pfd(node->pfd.events); - event.data.ptr = node; - r = epoll_ctl(ctx->epollfd, EPOLL_CTL_ADD, node->pfd.fd, &event); - if (r) { - return false; - } - } - ctx->epoll_enabled = true; - return true; -} - -static void aio_epoll_update(AioContext *ctx, AioHandler *node, bool is_new) -{ - struct epoll_event event; - int r; - int ctl; - - if (!ctx->epoll_enabled) { - return; - } - if (!node->pfd.events) { - ctl = EPOLL_CTL_DEL; - } else { - event.data.ptr = node; - event.events = epoll_events_from_pfd(node->pfd.events); - ctl = is_new ? EPOLL_CTL_ADD : EPOLL_CTL_MOD; - } - - r = epoll_ctl(ctx->epollfd, ctl, node->pfd.fd, &event); - if (r) { - aio_epoll_disable(ctx); - } -} - -static int aio_epoll(AioContext *ctx, AioHandlerList *ready_list, - int64_t timeout) -{ - GPollFD pfd = { - .fd = ctx->epollfd, - .events = G_IO_IN | G_IO_OUT | G_IO_HUP | G_IO_ERR, - }; - AioHandler *node; - int i, ret = 0; - struct epoll_event events[128]; - - if (timeout > 0) { - ret = qemu_poll_ns(&pfd, 1, timeout); - if (ret > 0) { - timeout = 0; - } - } - if (timeout <= 0 || ret > 0) { - ret = epoll_wait(ctx->epollfd, events, - ARRAY_SIZE(events), - timeout); - if (ret <= 0) { - goto out; - } - for (i = 0; i < ret; i++) { - int ev = events[i].events; - int revents = (ev & EPOLLIN ? G_IO_IN : 0) | - (ev & EPOLLOUT ? G_IO_OUT : 0) | - (ev & EPOLLHUP ? G_IO_HUP : 0) | - (ev & EPOLLERR ? G_IO_ERR : 0); - - node = events[i].data.ptr; - add_ready_handler(ready_list, node, revents); - } - } -out: - return ret; -} +/* Stop userspace polling on a handler if it isn't active for some time */ +#define POLL_IDLE_INTERVAL_NS (7 * NANOSECONDS_PER_SECOND) -static bool aio_epoll_enabled(AioContext *ctx) +bool aio_poll_disabled(AioContext *ctx) { - /* Fall back to ppoll when external clients are disabled. */ - return !aio_external_disabled(ctx) && ctx->epoll_enabled; + return atomic_read(&ctx->poll_disable_cnt); } -static bool aio_epoll_check_poll(AioContext *ctx, GPollFD *pfds, - unsigned npfd, int64_t timeout) +void aio_add_ready_handler(AioHandlerList *ready_list, + AioHandler *node, + int revents) { - if (!ctx->epoll_available) { - return false; - } - if (aio_epoll_enabled(ctx)) { - return true; - } - if (npfd >= EPOLL_ENABLE_THRESHOLD) { - if (aio_epoll_try_enable(ctx)) { - return true; - } else { - aio_epoll_disable(ctx); - } - } - return false; -} - -#else - -static void aio_epoll_update(AioContext *ctx, AioHandler *node, bool is_new) -{ -} - -static int aio_epoll(AioContext *ctx, AioHandlerList *ready_list, - int64_t timeout) -{ - assert(false); -} - -static bool aio_epoll_enabled(AioContext *ctx) -{ - return false; -} - -static bool aio_epoll_check_poll(AioContext *ctx, GPollFD *pfds, - unsigned npfd, int64_t timeout) -{ - return false; + QLIST_SAFE_REMOVE(node, node_ready); /* remove from nested parent's list */ + node->pfd.revents = revents; + QLIST_INSERT_HEAD(ready_list, node, node_ready); } -#endif - static AioHandler *find_aio_handler(AioContext *ctx, int fd) { AioHandler *node; @@ -231,16 +65,23 @@ static bool aio_remove_fd_handler(AioContext *ctx, AioHandler *node) g_source_remove_poll(&ctx->source, &node->pfd); } + node->pfd.revents = 0; + + /* If the fd monitor has already marked it deleted, leave it alone */ + if (QLIST_IS_INSERTED(node, node_deleted)) { + return false; + } + /* If a read is in progress, just mark the node as deleted */ if (qemu_lockcnt_count(&ctx->list_lock)) { QLIST_INSERT_HEAD_RCU(&ctx->deleted_aio_handlers, node, node_deleted); - node->pfd.revents = 0; return false; } /* Otherwise, delete it for real. We can't just mark it as * deleted because deleted nodes are only cleaned up while * no one is walking the handlers list. */ + QLIST_SAFE_REMOVE(node, node_poll); QLIST_REMOVE(node, node); return true; } @@ -300,9 +141,6 @@ void aio_set_fd_handler(AioContext *ctx, QLIST_INSERT_HEAD_RCU(&ctx->aio_handlers, new_node, node); } - if (node) { - deleted = aio_remove_fd_handler(ctx, node); - } /* No need to order poll_disable_cnt writes against other updates; * the counter is only used to avoid wasting time and latency on @@ -313,11 +151,9 @@ void aio_set_fd_handler(AioContext *ctx, atomic_set(&ctx->poll_disable_cnt, atomic_read(&ctx->poll_disable_cnt) + poll_disable_change); - if (new_node) { - aio_epoll_update(ctx, new_node, is_new); - } else if (node) { - /* Unregister deleted fd_handler */ - aio_epoll_update(ctx, node, false); + ctx->fdmon_ops->update(ctx, node, new_node); + if (node) { + deleted = aio_remove_fd_handler(ctx, node); } qemu_lockcnt_unlock(&ctx->list_lock); aio_notify(ctx); @@ -361,18 +197,19 @@ void aio_set_event_notifier_poll(AioContext *ctx, (IOHandler *)io_poll_end); } -static void poll_set_started(AioContext *ctx, bool started) +static bool poll_set_started(AioContext *ctx, bool started) { AioHandler *node; + bool progress = false; if (started == ctx->poll_started) { - return; + return false; } ctx->poll_started = started; qemu_lockcnt_inc(&ctx->list_lock); - QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) { + QLIST_FOREACH(node, &ctx->poll_aio_handlers, node_poll) { IOHandler *fn; if (QLIST_IS_INSERTED(node, node_deleted)) { @@ -388,8 +225,15 @@ static void poll_set_started(AioContext *ctx, bool started) if (fn) { fn(node->opaque); } + + /* Poll one last time in case ->io_poll_end() raced with the event */ + if (!started) { + progress = node->io_poll(node->opaque) || progress; + } } qemu_lockcnt_dec(&ctx->list_lock); + + return progress; } @@ -446,6 +290,7 @@ static void aio_free_deleted_handlers(AioContext *ctx) while ((node = QLIST_FIRST_RCU(&ctx->deleted_aio_handlers))) { QLIST_REMOVE(node, node); QLIST_REMOVE(node, node_deleted); + QLIST_SAFE_REMOVE(node, node_poll); g_free(node); } @@ -460,6 +305,22 @@ static bool aio_dispatch_handler(AioContext *ctx, AioHandler *node) revents = node->pfd.revents & node->pfd.events; node->pfd.revents = 0; + /* + * Start polling AioHandlers when they become ready because activity is + * likely to continue. Note that starvation is theoretically possible when + * fdmon_supports_polling(), but only until the fd fires for the first + * time. + */ + if (!QLIST_IS_INSERTED(node, node_deleted) && + !QLIST_IS_INSERTED(node, node_poll) && + node->io_poll) { + trace_poll_add(ctx, node, node->pfd.fd, revents); + if (ctx->poll_started && node->io_poll_begin) { + node->io_poll_begin(node->opaque); + } + QLIST_INSERT_HEAD(&ctx->poll_aio_handlers, node, node_poll); + } + if (!QLIST_IS_INSERTED(node, node_deleted) && (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) && aio_node_check(ctx, node->is_external) && @@ -493,7 +354,7 @@ static bool aio_dispatch_ready_handlers(AioContext *ctx, AioHandler *node; while ((node = QLIST_FIRST(ready_list))) { - QLIST_SAFE_REMOVE(node, node_ready); + QLIST_REMOVE(node, node_ready); progress = aio_dispatch_handler(ctx, node) || progress; } @@ -524,71 +385,19 @@ void aio_dispatch(AioContext *ctx) timerlistgroup_run_timers(&ctx->tlg); } -/* These thread-local variables are used only in a small part of aio_poll - * around the call to the poll() system call. In particular they are not - * used while aio_poll is performing callbacks, which makes it much easier - * to think about reentrancy! - * - * Stack-allocated arrays would be perfect but they have size limitations; - * heap allocation is expensive enough that we want to reuse arrays across - * calls to aio_poll(). And because poll() has to be called without holding - * any lock, the arrays cannot be stored in AioContext. Thread-local data - * has none of the disadvantages of these three options. - */ -static __thread GPollFD *pollfds; -static __thread AioHandler **nodes; -static __thread unsigned npfd, nalloc; -static __thread Notifier pollfds_cleanup_notifier; - -static void pollfds_cleanup(Notifier *n, void *unused) -{ - g_assert(npfd == 0); - g_free(pollfds); - g_free(nodes); - nalloc = 0; -} - -static void add_pollfd(AioHandler *node) -{ - if (npfd == nalloc) { - if (nalloc == 0) { - pollfds_cleanup_notifier.notify = pollfds_cleanup; - qemu_thread_atexit_add(&pollfds_cleanup_notifier); - nalloc = 8; - } else { - g_assert(nalloc <= INT_MAX); - nalloc *= 2; - } - pollfds = g_renew(GPollFD, pollfds, nalloc); - nodes = g_renew(AioHandler *, nodes, nalloc); - } - nodes[npfd] = node; - pollfds[npfd] = (GPollFD) { - .fd = node->pfd.fd, - .events = node->pfd.events, - }; - npfd++; -} - -static bool run_poll_handlers_once(AioContext *ctx, int64_t *timeout) +static bool run_poll_handlers_once(AioContext *ctx, + int64_t now, + int64_t *timeout) { bool progress = false; AioHandler *node; + AioHandler *tmp; - /* - * Optimization: ->io_poll() handlers often contain RCU read critical - * sections and we therefore see many rcu_read_lock() -> rcu_read_unlock() - * -> rcu_read_lock() -> ... sequences with expensive memory - * synchronization primitives. Make the entire polling loop an RCU - * critical section because nested rcu_read_lock()/rcu_read_unlock() calls - * are cheap. - */ - RCU_READ_LOCK_GUARD(); - - QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) { - if (!QLIST_IS_INSERTED(node, node_deleted) && node->io_poll && - aio_node_check(ctx, node->is_external) && + QLIST_FOREACH_SAFE(node, &ctx->poll_aio_handlers, node_poll, tmp) { + if (aio_node_check(ctx, node->is_external) && node->io_poll(node->opaque)) { + node->poll_idle_timeout = now + POLL_IDLE_INTERVAL_NS; + /* * Polling was successful, exit try_poll_mode immediately * to adjust the next polling time. @@ -605,6 +414,50 @@ static bool run_poll_handlers_once(AioContext *ctx, int64_t *timeout) return progress; } +static bool fdmon_supports_polling(AioContext *ctx) +{ + return ctx->fdmon_ops->need_wait != aio_poll_disabled; +} + +static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now) +{ + AioHandler *node; + AioHandler *tmp; + bool progress = false; + + /* + * File descriptor monitoring implementations without userspace polling + * support suffer from starvation when a subset of handlers is polled + * because fds will not be processed in a timely fashion. Don't remove + * idle poll handlers. + */ + if (!fdmon_supports_polling(ctx)) { + return false; + } + + QLIST_FOREACH_SAFE(node, &ctx->poll_aio_handlers, node_poll, tmp) { + if (node->poll_idle_timeout == 0LL) { + node->poll_idle_timeout = now + POLL_IDLE_INTERVAL_NS; + } else if (now >= node->poll_idle_timeout) { + trace_poll_remove(ctx, node, node->pfd.fd); + node->poll_idle_timeout = 0LL; + QLIST_SAFE_REMOVE(node, node_poll); + if (ctx->poll_started && node->io_poll_end) { + node->io_poll_end(node->opaque); + + /* + * Final poll in case ->io_poll_end() races with an event. + * Nevermind about re-adding the handler in the rare case where + * this causes progress. + */ + progress = node->io_poll(node->opaque) || progress; + } + } + } + + return progress; +} + /* run_poll_handlers: * @ctx: the AioContext * @max_ns: maximum time to poll for, in nanoseconds @@ -628,13 +481,28 @@ static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout) trace_run_poll_handlers_begin(ctx, max_ns, *timeout); + /* + * Optimization: ->io_poll() handlers often contain RCU read critical + * sections and we therefore see many rcu_read_lock() -> rcu_read_unlock() + * -> rcu_read_lock() -> ... sequences with expensive memory + * synchronization primitives. Make the entire polling loop an RCU + * critical section because nested rcu_read_lock()/rcu_read_unlock() calls + * are cheap. + */ + RCU_READ_LOCK_GUARD(); + start_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); do { - progress = run_poll_handlers_once(ctx, timeout); + progress = run_poll_handlers_once(ctx, start_time, timeout); elapsed_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - start_time; max_ns = qemu_soonest_timeout(*timeout, max_ns); assert(!(max_ns && progress)); - } while (elapsed_time < max_ns && !atomic_read(&ctx->poll_disable_cnt)); + } while (elapsed_time < max_ns && !ctx->fdmon_ops->need_wait(ctx)); + + if (remove_idle_poll_handlers(ctx, start_time + elapsed_time)) { + *timeout = 0; + progress = true; + } /* If time has passed with no successful polling, adjust *timeout to * keep the same ending time. @@ -660,9 +528,14 @@ static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout) */ static bool try_poll_mode(AioContext *ctx, int64_t *timeout) { - int64_t max_ns = qemu_soonest_timeout(*timeout, ctx->poll_ns); + int64_t max_ns; - if (max_ns && !atomic_read(&ctx->poll_disable_cnt)) { + if (QLIST_EMPTY_RCU(&ctx->poll_aio_handlers)) { + return false; + } + + max_ns = qemu_soonest_timeout(*timeout, ctx->poll_ns); + if (max_ns && !ctx->fdmon_ops->need_wait(ctx)) { poll_set_started(ctx, true); if (run_poll_handlers(ctx, max_ns, timeout)) { @@ -670,19 +543,17 @@ static bool try_poll_mode(AioContext *ctx, int64_t *timeout) } } - poll_set_started(ctx, false); + if (poll_set_started(ctx, false)) { + *timeout = 0; + return true; + } - /* Even if we don't run busy polling, try polling once in case it can make - * progress and the caller will be able to avoid ppoll(2)/epoll_wait(2). - */ - return run_poll_handlers_once(ctx, timeout); + return false; } bool aio_poll(AioContext *ctx, bool blocking) { AioHandlerList ready_list = QLIST_HEAD_INITIALIZER(ready_list); - AioHandler *node; - int i; int ret = 0; bool progress; int64_t timeout; @@ -714,27 +585,8 @@ bool aio_poll(AioContext *ctx, bool blocking) /* If polling is allowed, non-blocking aio_poll does not need the * system call---a single round of run_poll_handlers_once suffices. */ - if (timeout || atomic_read(&ctx->poll_disable_cnt)) { - assert(npfd == 0); - - /* fill pollfds */ - - if (!aio_epoll_enabled(ctx)) { - QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) { - if (!QLIST_IS_INSERTED(node, node_deleted) && node->pfd.events - && aio_node_check(ctx, node->is_external)) { - add_pollfd(node); - } - } - } - - /* wait until next event */ - if (aio_epoll_check_poll(ctx, pollfds, npfd, timeout)) { - npfd = 0; /* pollfds[] is not being used */ - ret = aio_epoll(ctx, &ready_list, timeout); - } else { - ret = qemu_poll_ns(pollfds, npfd, timeout); - } + if (timeout || ctx->fdmon_ops->need_wait(ctx)) { + ret = ctx->fdmon_ops->wait(ctx, &ready_list, timeout); } if (blocking) { @@ -783,19 +635,6 @@ bool aio_poll(AioContext *ctx, bool blocking) } } - /* if we have any readable fds, dispatch event */ - if (ret > 0) { - for (i = 0; i < npfd; i++) { - int revents = pollfds[i].revents; - - if (revents) { - add_ready_handler(&ready_list, nodes[i], revents); - } - } - } - - npfd = 0; - progress |= aio_bh_poll(ctx); if (ret > 0) { @@ -813,23 +652,21 @@ bool aio_poll(AioContext *ctx, bool blocking) void aio_context_setup(AioContext *ctx) { -#ifdef CONFIG_EPOLL_CREATE1 - assert(!ctx->epollfd); - ctx->epollfd = epoll_create1(EPOLL_CLOEXEC); - if (ctx->epollfd == -1) { - fprintf(stderr, "Failed to create epoll instance: %s", strerror(errno)); - ctx->epoll_available = false; - } else { - ctx->epoll_available = true; + ctx->fdmon_ops = &fdmon_poll_ops; + ctx->epollfd = -1; + + /* Use the fastest fd monitoring implementation if available */ + if (fdmon_io_uring_setup(ctx)) { + return; } -#endif + + fdmon_epoll_setup(ctx); } void aio_context_destroy(AioContext *ctx) { -#ifdef CONFIG_EPOLL_CREATE1 - aio_epoll_disable(ctx); -#endif + fdmon_io_uring_destroy(ctx); + fdmon_epoll_disable(ctx); } void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns, |