2008-09-23 03:17:18 +08:00
|
|
|
/*
|
|
|
|
* QEMU aio implementation
|
|
|
|
*
|
2012-06-09 10:01:51 +08:00
|
|
|
* Copyright IBM Corp., 2008
|
|
|
|
* Copyright Red Hat Inc., 2012
|
2008-09-23 03:17:18 +08:00
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
2012-06-09 10:01:51 +08:00
|
|
|
* Paolo Bonzini <pbonzini@redhat.com>
|
2008-09-23 03:17:18 +08:00
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
|
|
|
*
|
2012-01-14 00:44:23 +08:00
|
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
2008-09-23 03:17:18 +08:00
|
|
|
*/
|
|
|
|
|
2016-01-30 01:50:05 +08:00
|
|
|
#include "qemu/osdep.h"
|
2008-09-23 03:17:18 +08:00
|
|
|
#include "qemu-common.h"
|
2012-12-18 01:19:44 +08:00
|
|
|
#include "block/block.h"
|
2012-12-18 01:20:00 +08:00
|
|
|
#include "qemu/queue.h"
|
|
|
|
#include "qemu/sockets.h"
|
2016-12-02 03:26:42 +08:00
|
|
|
#include "qapi/error.h"
|
2017-01-13 02:07:58 +08:00
|
|
|
#include "qemu/rcu_queue.h"
|
2008-09-23 03:17:18 +08:00
|
|
|
|
2012-06-09 10:01:51 +08:00
|
|
|
struct AioHandler {
|
|
|
|
EventNotifier *e;
|
2014-07-09 17:53:10 +08:00
|
|
|
IOHandler *io_read;
|
|
|
|
IOHandler *io_write;
|
2012-06-09 10:01:51 +08:00
|
|
|
EventNotifierHandler *io_notify;
|
2012-09-24 20:57:22 +08:00
|
|
|
GPollFD pfd;
|
2008-09-23 03:17:18 +08:00
|
|
|
int deleted;
|
2014-07-09 17:53:10 +08:00
|
|
|
void *opaque;
|
2015-10-23 11:08:05 +08:00
|
|
|
bool is_external;
|
2009-09-12 15:36:22 +08:00
|
|
|
QLIST_ENTRY(AioHandler) node;
|
2008-09-23 03:17:18 +08:00
|
|
|
};
|
|
|
|
|
2018-12-20 23:20:30 +08:00
|
|
|
static void aio_remove_fd_handler(AioContext *ctx, AioHandler *node)
|
|
|
|
{
|
|
|
|
/* If aio_poll is in progress, just mark the node as deleted */
|
|
|
|
if (qemu_lockcnt_count(&ctx->list_lock)) {
|
|
|
|
node->deleted = 1;
|
|
|
|
node->pfd.revents = 0;
|
|
|
|
} else {
|
|
|
|
/* Otherwise, delete it for real. We can't just mark it as
|
|
|
|
* deleted because deleted nodes are only cleaned up after
|
|
|
|
* releasing the list_lock.
|
|
|
|
*/
|
|
|
|
QLIST_REMOVE(node, node);
|
|
|
|
g_free(node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-09 17:53:10 +08:00
|
|
|
void aio_set_fd_handler(AioContext *ctx,
|
|
|
|
int fd,
|
2015-10-23 11:08:05 +08:00
|
|
|
bool is_external,
|
2014-07-09 17:53:10 +08:00
|
|
|
IOHandler *io_read,
|
|
|
|
IOHandler *io_write,
|
2016-12-02 03:26:42 +08:00
|
|
|
AioPollFn *io_poll,
|
2014-07-09 17:53:10 +08:00
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
/* fd is a SOCKET in our case */
|
2018-12-20 23:20:30 +08:00
|
|
|
AioHandler *old_node;
|
|
|
|
AioHandler *node = NULL;
|
2014-07-09 17:53:10 +08:00
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
qemu_lockcnt_lock(&ctx->list_lock);
|
2018-12-20 23:20:30 +08:00
|
|
|
QLIST_FOREACH(old_node, &ctx->aio_handlers, node) {
|
|
|
|
if (old_node->pfd.fd == fd && !old_node->deleted) {
|
2014-07-09 17:53:10 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-20 23:20:30 +08:00
|
|
|
if (io_read || io_write) {
|
2014-07-09 17:53:10 +08:00
|
|
|
HANDLE event;
|
2017-07-07 04:15:14 +08:00
|
|
|
long bitmask = 0;
|
2014-07-09 17:53:10 +08:00
|
|
|
|
2018-12-20 23:20:30 +08:00
|
|
|
/* Alloc and insert if it's not already there */
|
|
|
|
node = g_new0(AioHandler, 1);
|
|
|
|
node->pfd.fd = fd;
|
2014-07-09 17:53:10 +08:00
|
|
|
|
|
|
|
node->pfd.events = 0;
|
|
|
|
if (node->io_read) {
|
|
|
|
node->pfd.events |= G_IO_IN;
|
|
|
|
}
|
|
|
|
if (node->io_write) {
|
|
|
|
node->pfd.events |= G_IO_OUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
node->e = &ctx->notifier;
|
|
|
|
|
|
|
|
/* Update handler with latest information */
|
|
|
|
node->opaque = opaque;
|
|
|
|
node->io_read = io_read;
|
|
|
|
node->io_write = io_write;
|
2015-10-23 11:08:05 +08:00
|
|
|
node->is_external = is_external;
|
2014-07-09 17:53:10 +08:00
|
|
|
|
2017-07-07 04:15:14 +08:00
|
|
|
if (io_read) {
|
|
|
|
bitmask |= FD_READ | FD_ACCEPT | FD_CLOSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (io_write) {
|
|
|
|
bitmask |= FD_WRITE | FD_CONNECT;
|
|
|
|
}
|
|
|
|
|
2018-12-20 23:20:30 +08:00
|
|
|
QLIST_INSERT_HEAD_RCU(&ctx->aio_handlers, node, node);
|
2014-07-09 17:53:10 +08:00
|
|
|
event = event_notifier_get_handle(&ctx->notifier);
|
2017-07-07 04:15:14 +08:00
|
|
|
WSAEventSelect(node->pfd.fd, event, bitmask);
|
2014-07-09 17:53:10 +08:00
|
|
|
}
|
2018-12-20 23:20:30 +08:00
|
|
|
if (old_node) {
|
|
|
|
aio_remove_fd_handler(ctx, old_node);
|
|
|
|
}
|
2014-07-09 17:53:10 +08:00
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
qemu_lockcnt_unlock(&ctx->list_lock);
|
2014-07-09 17:53:10 +08:00
|
|
|
aio_notify(ctx);
|
|
|
|
}
|
|
|
|
|
2016-12-02 03:26:49 +08:00
|
|
|
void aio_set_fd_poll(AioContext *ctx, int fd,
|
|
|
|
IOHandler *io_poll_begin,
|
|
|
|
IOHandler *io_poll_end)
|
|
|
|
{
|
|
|
|
/* Not implemented */
|
|
|
|
}
|
|
|
|
|
2012-06-09 10:01:51 +08:00
|
|
|
void aio_set_event_notifier(AioContext *ctx,
|
|
|
|
EventNotifier *e,
|
2015-10-23 11:08:05 +08:00
|
|
|
bool is_external,
|
2016-12-02 03:26:42 +08:00
|
|
|
EventNotifierHandler *io_notify,
|
|
|
|
AioPollFn *io_poll)
|
2008-09-23 03:17:18 +08:00
|
|
|
{
|
|
|
|
AioHandler *node;
|
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
qemu_lockcnt_lock(&ctx->list_lock);
|
2012-09-13 18:28:51 +08:00
|
|
|
QLIST_FOREACH(node, &ctx->aio_handlers, node) {
|
2012-06-09 10:01:51 +08:00
|
|
|
if (node->e == e && !node->deleted) {
|
|
|
|
break;
|
|
|
|
}
|
2008-09-23 03:17:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Are we deleting the fd handler? */
|
2012-06-09 10:01:51 +08:00
|
|
|
if (!io_notify) {
|
2008-09-23 03:17:18 +08:00
|
|
|
if (node) {
|
2012-09-24 20:57:41 +08:00
|
|
|
g_source_remove_poll(&ctx->source, &node->pfd);
|
|
|
|
|
2018-12-20 23:20:30 +08:00
|
|
|
aio_remove_fd_handler(ctx, node);
|
2008-09-23 03:17:18 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (node == NULL) {
|
|
|
|
/* Alloc and insert if it's not already there */
|
2014-12-04 20:55:09 +08:00
|
|
|
node = g_new0(AioHandler, 1);
|
2012-06-09 10:01:51 +08:00
|
|
|
node->e = e;
|
|
|
|
node->pfd.fd = (uintptr_t)event_notifier_get_handle(e);
|
|
|
|
node->pfd.events = G_IO_IN;
|
2015-10-23 11:08:05 +08:00
|
|
|
node->is_external = is_external;
|
2017-01-13 02:07:58 +08:00
|
|
|
QLIST_INSERT_HEAD_RCU(&ctx->aio_handlers, node, node);
|
2012-09-24 20:57:41 +08:00
|
|
|
|
|
|
|
g_source_add_poll(&ctx->source, &node->pfd);
|
2008-09-23 03:17:18 +08:00
|
|
|
}
|
|
|
|
/* Update handler with latest information */
|
2012-06-09 10:01:51 +08:00
|
|
|
node->io_notify = io_notify;
|
2008-09-23 03:17:18 +08:00
|
|
|
}
|
2012-09-25 16:22:39 +08:00
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
qemu_lockcnt_unlock(&ctx->list_lock);
|
2012-09-25 16:22:39 +08:00
|
|
|
aio_notify(ctx);
|
2012-06-09 09:44:00 +08:00
|
|
|
}
|
|
|
|
|
2016-12-02 03:26:49 +08:00
|
|
|
void aio_set_event_notifier_poll(AioContext *ctx,
|
|
|
|
EventNotifier *notifier,
|
|
|
|
EventNotifierHandler *io_poll_begin,
|
|
|
|
EventNotifierHandler *io_poll_end)
|
|
|
|
{
|
|
|
|
/* Not implemented */
|
|
|
|
}
|
|
|
|
|
2014-07-09 17:53:08 +08:00
|
|
|
bool aio_prepare(AioContext *ctx)
|
|
|
|
{
|
2014-07-09 17:53:10 +08:00
|
|
|
static struct timeval tv0;
|
|
|
|
AioHandler *node;
|
|
|
|
bool have_select_revents = false;
|
|
|
|
fd_set rfds, wfds;
|
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
/*
|
|
|
|
* We have to walk very carefully in case aio_set_fd_handler is
|
|
|
|
* called while we're walking.
|
|
|
|
*/
|
|
|
|
qemu_lockcnt_inc(&ctx->list_lock);
|
|
|
|
|
2014-07-09 17:53:10 +08:00
|
|
|
/* fill fd sets */
|
|
|
|
FD_ZERO(&rfds);
|
|
|
|
FD_ZERO(&wfds);
|
2017-01-13 02:07:58 +08:00
|
|
|
QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
|
2014-07-09 17:53:10 +08:00
|
|
|
if (node->io_read) {
|
|
|
|
FD_SET ((SOCKET)node->pfd.fd, &rfds);
|
|
|
|
}
|
|
|
|
if (node->io_write) {
|
|
|
|
FD_SET ((SOCKET)node->pfd.fd, &wfds);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (select(0, &rfds, &wfds, NULL, &tv0) > 0) {
|
2017-01-13 02:07:58 +08:00
|
|
|
QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
|
2014-07-09 17:53:10 +08:00
|
|
|
node->pfd.revents = 0;
|
|
|
|
if (FD_ISSET(node->pfd.fd, &rfds)) {
|
|
|
|
node->pfd.revents |= G_IO_IN;
|
|
|
|
have_select_revents = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FD_ISSET(node->pfd.fd, &wfds)) {
|
|
|
|
node->pfd.revents |= G_IO_OUT;
|
|
|
|
have_select_revents = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
qemu_lockcnt_dec(&ctx->list_lock);
|
2014-07-09 17:53:10 +08:00
|
|
|
return have_select_revents;
|
2014-07-09 17:53:08 +08:00
|
|
|
}
|
|
|
|
|
2012-09-24 20:57:22 +08:00
|
|
|
bool aio_pending(AioContext *ctx)
|
|
|
|
{
|
|
|
|
AioHandler *node;
|
2017-01-13 02:07:58 +08:00
|
|
|
bool result = false;
|
2012-09-24 20:57:22 +08:00
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
/*
|
|
|
|
* We have to walk very carefully in case aio_set_fd_handler is
|
|
|
|
* called while we're walking.
|
|
|
|
*/
|
|
|
|
qemu_lockcnt_inc(&ctx->list_lock);
|
|
|
|
QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
|
2012-06-09 10:01:51 +08:00
|
|
|
if (node->pfd.revents && node->io_notify) {
|
2017-01-13 02:07:58 +08:00
|
|
|
result = true;
|
|
|
|
break;
|
2012-09-24 20:57:22 +08:00
|
|
|
}
|
2014-07-09 17:53:10 +08:00
|
|
|
|
|
|
|
if ((node->pfd.revents & G_IO_IN) && node->io_read) {
|
2017-01-13 02:07:58 +08:00
|
|
|
result = true;
|
|
|
|
break;
|
2014-07-09 17:53:10 +08:00
|
|
|
}
|
|
|
|
if ((node->pfd.revents & G_IO_OUT) && node->io_write) {
|
2017-01-13 02:07:58 +08:00
|
|
|
result = true;
|
|
|
|
break;
|
2014-07-09 17:53:10 +08:00
|
|
|
}
|
2012-09-24 20:57:22 +08:00
|
|
|
}
|
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
qemu_lockcnt_dec(&ctx->list_lock);
|
|
|
|
return result;
|
2012-09-24 20:57:22 +08:00
|
|
|
}
|
|
|
|
|
2014-07-09 17:53:03 +08:00
|
|
|
static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
|
2008-09-23 03:17:18 +08:00
|
|
|
{
|
2017-01-13 02:07:58 +08:00
|
|
|
AioHandler *node;
|
2014-07-09 17:53:03 +08:00
|
|
|
bool progress = false;
|
2017-01-13 02:07:58 +08:00
|
|
|
AioHandler *tmp;
|
2012-09-24 20:37:53 +08:00
|
|
|
|
2012-09-24 20:57:22 +08:00
|
|
|
/*
|
2014-07-07 21:18:02 +08:00
|
|
|
* We have to walk very carefully in case aio_set_fd_handler is
|
2012-09-24 20:57:22 +08:00
|
|
|
* called while we're walking.
|
|
|
|
*/
|
2017-01-13 02:07:58 +08:00
|
|
|
QLIST_FOREACH_SAFE_RCU(node, &ctx->aio_handlers, node, tmp) {
|
2014-07-09 17:53:10 +08:00
|
|
|
int revents = node->pfd.revents;
|
2012-09-24 20:57:22 +08:00
|
|
|
|
2014-07-09 17:53:03 +08:00
|
|
|
if (!node->deleted &&
|
2014-07-09 17:53:10 +08:00
|
|
|
(revents || event_notifier_get_handle(node->e) == event) &&
|
2014-07-09 17:53:03 +08:00
|
|
|
node->io_notify) {
|
2012-06-09 10:01:51 +08:00
|
|
|
node->pfd.revents = 0;
|
|
|
|
node->io_notify(node->e);
|
2013-04-11 22:56:50 +08:00
|
|
|
|
|
|
|
/* aio_notify() does not count as progress */
|
2013-08-22 21:28:35 +08:00
|
|
|
if (node->e != &ctx->notifier) {
|
2013-04-11 22:56:50 +08:00
|
|
|
progress = true;
|
|
|
|
}
|
2012-09-24 20:57:22 +08:00
|
|
|
}
|
|
|
|
|
2014-07-09 17:53:10 +08:00
|
|
|
if (!node->deleted &&
|
|
|
|
(node->io_read || node->io_write)) {
|
|
|
|
node->pfd.revents = 0;
|
|
|
|
if ((revents & G_IO_IN) && node->io_read) {
|
|
|
|
node->io_read(node->opaque);
|
|
|
|
progress = true;
|
|
|
|
}
|
|
|
|
if ((revents & G_IO_OUT) && node->io_write) {
|
|
|
|
node->io_write(node->opaque);
|
|
|
|
progress = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if the next select() will return an event, we have progressed */
|
|
|
|
if (event == event_notifier_get_handle(&ctx->notifier)) {
|
|
|
|
WSANETWORKEVENTS ev;
|
|
|
|
WSAEnumNetworkEvents(node->pfd.fd, event, &ev);
|
|
|
|
if (ev.lNetworkEvents) {
|
|
|
|
progress = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-13 02:07:56 +08:00
|
|
|
if (node->deleted) {
|
2017-01-13 02:07:58 +08:00
|
|
|
if (qemu_lockcnt_dec_if_lock(&ctx->list_lock)) {
|
2017-01-13 02:07:56 +08:00
|
|
|
QLIST_REMOVE(node, node);
|
|
|
|
g_free(node);
|
2017-01-13 02:07:58 +08:00
|
|
|
qemu_lockcnt_inc_and_unlock(&ctx->list_lock);
|
2017-01-13 02:07:56 +08:00
|
|
|
}
|
2012-09-24 20:57:22 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-09 17:53:03 +08:00
|
|
|
return progress;
|
|
|
|
}
|
|
|
|
|
2017-02-13 21:52:33 +08:00
|
|
|
void aio_dispatch(AioContext *ctx)
|
2014-07-09 17:53:03 +08:00
|
|
|
{
|
2017-02-13 21:52:34 +08:00
|
|
|
qemu_lockcnt_inc(&ctx->list_lock);
|
2017-02-13 21:52:33 +08:00
|
|
|
aio_bh_poll(ctx);
|
|
|
|
aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
|
2017-02-13 21:52:34 +08:00
|
|
|
qemu_lockcnt_dec(&ctx->list_lock);
|
2017-02-13 21:52:33 +08:00
|
|
|
timerlistgroup_run_timers(&ctx->tlg);
|
2014-07-09 17:53:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool aio_poll(AioContext *ctx, bool blocking)
|
|
|
|
{
|
|
|
|
AioHandler *node;
|
|
|
|
HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
|
AioContext: fix broken ctx->dispatching optimization
This patch rewrites the ctx->dispatching optimization, which was the cause
of some mysterious hangs that could be reproduced on aarch64 KVM only.
The hangs were indirectly caused by aio_poll() and in particular by
flash memory updates's call to blk_write(), which invokes aio_poll().
Fun stuff: they had an extremely short race window, so much that
adding all kind of tracing to either the kernel or QEMU made it
go away (a single printf made it half as reproducible).
On the plus side, the failure mode (a hang until the next keypress)
made it very easy to examine the state of the process with a debugger.
And there was a very nice reproducer from Laszlo, which failed pretty
often (more than half of the time) on any version of QEMU with a non-debug
kernel; it also failed fast, while still in the firmware. So, it could
have been worse.
For some unknown reason they happened only with virtio-scsi, but
that's not important. It's more interesting that they disappeared with
io=native, making thread-pool.c a likely suspect for where the bug arose.
thread-pool.c is also one of the few places which use bottom halves
across threads, by the way.
I hope that no other similar bugs exist, but just in case :) I am
going to describe how the successful debugging went... Since the
likely culprit was the ctx->dispatching optimization, which mostly
affects bottom halves, the first observation was that there are two
qemu_bh_schedule() invocations in the thread pool: the one in the aio
worker and the one in thread_pool_completion_bh. The latter always
causes the optimization to trigger, the former may or may not. In
order to restrict the possibilities, I introduced new functions
qemu_bh_schedule_slow() and qemu_bh_schedule_fast():
/* qemu_bh_schedule_slow: */
ctx = bh->ctx;
bh->idle = 0;
if (atomic_xchg(&bh->scheduled, 1) == 0) {
event_notifier_set(&ctx->notifier);
}
/* qemu_bh_schedule_fast: */
ctx = bh->ctx;
bh->idle = 0;
assert(ctx->dispatching);
atomic_xchg(&bh->scheduled, 1);
Notice how the atomic_xchg is still in qemu_bh_schedule_slow(). This
was already debated a few months ago, so I assumed it to be correct.
In retrospect this was a very good idea, as you'll see later.
Changing thread_pool_completion_bh() to qemu_bh_schedule_fast() didn't
trigger the assertion (as expected). Changing the worker's invocation
to qemu_bh_schedule_slow() didn't hide the bug (another assumption
which luckily held). This already limited heavily the amount of
interaction between the threads, hinting that the problematic events
must have triggered around thread_pool_completion_bh().
As mentioned early, invoking a debugger to examine the state of a
hung process was pretty easy; the iothread was always waiting on a
poll(..., -1) system call. Infinite timeouts are much rarer on x86,
and this could be the reason why the bug was never observed there.
With the buggy sequence more or less resolved to an interaction between
thread_pool_completion_bh() and poll(..., -1), my "tracing" strategy was
to just add a few qemu_clock_get_ns(QEMU_CLOCK_REALTIME) calls, hoping
that the ordering of aio_ctx_prepare(), aio_ctx_dispatch, poll() and
qemu_bh_schedule_fast() would provide some hint. The output was:
(gdb) p last_prepare
$3 = 103885451
(gdb) p last_dispatch
$4 = 103876492
(gdb) p last_poll
$5 = 115909333
(gdb) p last_schedule
$6 = 115925212
Notice how the last call to qemu_poll_ns() came after aio_ctx_dispatch().
This makes little sense unless there is an aio_poll() call involved,
and indeed with a slightly different instrumentation you can see that
there is one:
(gdb) p last_prepare
$3 = 107569679
(gdb) p last_dispatch
$4 = 107561600
(gdb) p last_aio_poll
$5 = 110671400
(gdb) p last_schedule
$6 = 110698917
So the scenario becomes clearer:
iothread VCPU thread
--------------------------------------------------------------------------
aio_ctx_prepare
aio_ctx_check
qemu_poll_ns(timeout=-1)
aio_poll
aio_dispatch
thread_pool_completion_bh
qemu_bh_schedule()
At this point bh->scheduled = 1 and the iothread has not been woken up.
The solution must be close, but this alone should not be a problem,
because the bottom half is only rescheduled to account for rare situations
(see commit 3c80ca1, thread-pool: avoid deadlock in nested aio_poll()
calls, 2014-07-15).
Introducing a third thread---a thread pool worker thread, which
also does qemu_bh_schedule()---does bring out the problematic case.
The third thread must be awakened *after* the callback is complete and
thread_pool_completion_bh has redone the whole loop, explaining the
short race window. And then this is what happens:
thread pool worker
--------------------------------------------------------------------------
<I/O completes>
qemu_bh_schedule()
Tada, bh->scheduled is already 1, so qemu_bh_schedule() does nothing
and the iothread is never woken up. This is where the bh->scheduled
optimization comes into play---it is correct, but removing it would
have masked the bug.
So, what is the bug?
Well, the question asked by the ctx->dispatching optimization ("is any
active aio_poll dispatching?") was wrong. The right question to ask
instead is "is any active aio_poll *not* dispatching", i.e. in the prepare
or poll phases? In that case, the aio_poll is sleeping or might go to
sleep anytime soon, and the EventNotifier must be invoked to wake
it up.
In any other case (including if there is *no* active aio_poll at all!)
we can just wait for the next prepare phase to pick up the event (e.g. a
bottom half); the prepare phase will avoid the blocking and service the
bottom half.
Expressing the invariant with a logic formula, the broken one looked like:
!(exists(thread): in_dispatching(thread)) => !optimize
or equivalently:
!(exists(thread):
in_aio_poll(thread) && in_dispatching(thread)) => !optimize
In the correct one, the negation is in a slightly different place:
(exists(thread):
in_aio_poll(thread) && !in_dispatching(thread)) => !optimize
or equivalently:
(exists(thread): in_prepare_or_poll(thread)) => !optimize
Even if the difference boils down to moving an exclamation mark :)
the implementation is quite different. However, I think the new
one is simpler to understand.
In the old implementation, the "exists" was implemented with a boolean
value. This didn't really support well the case of multiple concurrent
event loops, but I thought that this was okay: aio_poll holds the
AioContext lock so there cannot be concurrent aio_poll invocations, and
I was just considering nested event loops. However, aio_poll _could_
indeed be concurrent with the GSource. This is why I came up with the
wrong invariant.
In the new implementation, "exists" is computed simply by counting how many
threads are in the prepare or poll phases. There are some interesting
points to consider, but the gist of the idea remains:
1) AioContext can be used through GSource as well; as mentioned in the
patch, bit 0 of the counter is reserved for the GSource.
2) the counter need not be updated for a non-blocking aio_poll, because
it won't sleep forever anyway. This is just a matter of checking
the "blocking" variable. This requires some changes to the win32
implementation, but is otherwise not too complicated.
3) as mentioned above, the new implementation will not call aio_notify
when there is *no* active aio_poll at all. The tests have to be
adjusted for this change. The calls to aio_notify in async.c are fine;
they only want to kick aio_poll out of a blocking wait, but need not
do anything if aio_poll is not running.
4) nested aio_poll: these just work with the new implementation; when
a nested event loop is invoked, the outer event loop is never in the
prepare or poll phases. The outer event loop thus has already decremented
the counter.
Reported-by: Richard W. M. Jones <rjones@redhat.com>
Reported-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Richard W.M. Jones <rjones@redhat.com>
Message-id: 1437487673-23740-5-git-send-email-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-07-21 22:07:51 +08:00
|
|
|
bool progress, have_select_revents, first;
|
2014-07-09 17:53:03 +08:00
|
|
|
int count;
|
|
|
|
int timeout;
|
|
|
|
|
|
|
|
progress = false;
|
|
|
|
|
2014-07-09 17:53:07 +08:00
|
|
|
/* aio_notify can avoid the expensive event_notifier_set if
|
|
|
|
* everything (file descriptors, bottom halves, timers) will
|
|
|
|
* be re-evaluated before the next blocking poll(). This is
|
|
|
|
* already true when aio_poll is called with blocking == false;
|
AioContext: fix broken ctx->dispatching optimization
This patch rewrites the ctx->dispatching optimization, which was the cause
of some mysterious hangs that could be reproduced on aarch64 KVM only.
The hangs were indirectly caused by aio_poll() and in particular by
flash memory updates's call to blk_write(), which invokes aio_poll().
Fun stuff: they had an extremely short race window, so much that
adding all kind of tracing to either the kernel or QEMU made it
go away (a single printf made it half as reproducible).
On the plus side, the failure mode (a hang until the next keypress)
made it very easy to examine the state of the process with a debugger.
And there was a very nice reproducer from Laszlo, which failed pretty
often (more than half of the time) on any version of QEMU with a non-debug
kernel; it also failed fast, while still in the firmware. So, it could
have been worse.
For some unknown reason they happened only with virtio-scsi, but
that's not important. It's more interesting that they disappeared with
io=native, making thread-pool.c a likely suspect for where the bug arose.
thread-pool.c is also one of the few places which use bottom halves
across threads, by the way.
I hope that no other similar bugs exist, but just in case :) I am
going to describe how the successful debugging went... Since the
likely culprit was the ctx->dispatching optimization, which mostly
affects bottom halves, the first observation was that there are two
qemu_bh_schedule() invocations in the thread pool: the one in the aio
worker and the one in thread_pool_completion_bh. The latter always
causes the optimization to trigger, the former may or may not. In
order to restrict the possibilities, I introduced new functions
qemu_bh_schedule_slow() and qemu_bh_schedule_fast():
/* qemu_bh_schedule_slow: */
ctx = bh->ctx;
bh->idle = 0;
if (atomic_xchg(&bh->scheduled, 1) == 0) {
event_notifier_set(&ctx->notifier);
}
/* qemu_bh_schedule_fast: */
ctx = bh->ctx;
bh->idle = 0;
assert(ctx->dispatching);
atomic_xchg(&bh->scheduled, 1);
Notice how the atomic_xchg is still in qemu_bh_schedule_slow(). This
was already debated a few months ago, so I assumed it to be correct.
In retrospect this was a very good idea, as you'll see later.
Changing thread_pool_completion_bh() to qemu_bh_schedule_fast() didn't
trigger the assertion (as expected). Changing the worker's invocation
to qemu_bh_schedule_slow() didn't hide the bug (another assumption
which luckily held). This already limited heavily the amount of
interaction between the threads, hinting that the problematic events
must have triggered around thread_pool_completion_bh().
As mentioned early, invoking a debugger to examine the state of a
hung process was pretty easy; the iothread was always waiting on a
poll(..., -1) system call. Infinite timeouts are much rarer on x86,
and this could be the reason why the bug was never observed there.
With the buggy sequence more or less resolved to an interaction between
thread_pool_completion_bh() and poll(..., -1), my "tracing" strategy was
to just add a few qemu_clock_get_ns(QEMU_CLOCK_REALTIME) calls, hoping
that the ordering of aio_ctx_prepare(), aio_ctx_dispatch, poll() and
qemu_bh_schedule_fast() would provide some hint. The output was:
(gdb) p last_prepare
$3 = 103885451
(gdb) p last_dispatch
$4 = 103876492
(gdb) p last_poll
$5 = 115909333
(gdb) p last_schedule
$6 = 115925212
Notice how the last call to qemu_poll_ns() came after aio_ctx_dispatch().
This makes little sense unless there is an aio_poll() call involved,
and indeed with a slightly different instrumentation you can see that
there is one:
(gdb) p last_prepare
$3 = 107569679
(gdb) p last_dispatch
$4 = 107561600
(gdb) p last_aio_poll
$5 = 110671400
(gdb) p last_schedule
$6 = 110698917
So the scenario becomes clearer:
iothread VCPU thread
--------------------------------------------------------------------------
aio_ctx_prepare
aio_ctx_check
qemu_poll_ns(timeout=-1)
aio_poll
aio_dispatch
thread_pool_completion_bh
qemu_bh_schedule()
At this point bh->scheduled = 1 and the iothread has not been woken up.
The solution must be close, but this alone should not be a problem,
because the bottom half is only rescheduled to account for rare situations
(see commit 3c80ca1, thread-pool: avoid deadlock in nested aio_poll()
calls, 2014-07-15).
Introducing a third thread---a thread pool worker thread, which
also does qemu_bh_schedule()---does bring out the problematic case.
The third thread must be awakened *after* the callback is complete and
thread_pool_completion_bh has redone the whole loop, explaining the
short race window. And then this is what happens:
thread pool worker
--------------------------------------------------------------------------
<I/O completes>
qemu_bh_schedule()
Tada, bh->scheduled is already 1, so qemu_bh_schedule() does nothing
and the iothread is never woken up. This is where the bh->scheduled
optimization comes into play---it is correct, but removing it would
have masked the bug.
So, what is the bug?
Well, the question asked by the ctx->dispatching optimization ("is any
active aio_poll dispatching?") was wrong. The right question to ask
instead is "is any active aio_poll *not* dispatching", i.e. in the prepare
or poll phases? In that case, the aio_poll is sleeping or might go to
sleep anytime soon, and the EventNotifier must be invoked to wake
it up.
In any other case (including if there is *no* active aio_poll at all!)
we can just wait for the next prepare phase to pick up the event (e.g. a
bottom half); the prepare phase will avoid the blocking and service the
bottom half.
Expressing the invariant with a logic formula, the broken one looked like:
!(exists(thread): in_dispatching(thread)) => !optimize
or equivalently:
!(exists(thread):
in_aio_poll(thread) && in_dispatching(thread)) => !optimize
In the correct one, the negation is in a slightly different place:
(exists(thread):
in_aio_poll(thread) && !in_dispatching(thread)) => !optimize
or equivalently:
(exists(thread): in_prepare_or_poll(thread)) => !optimize
Even if the difference boils down to moving an exclamation mark :)
the implementation is quite different. However, I think the new
one is simpler to understand.
In the old implementation, the "exists" was implemented with a boolean
value. This didn't really support well the case of multiple concurrent
event loops, but I thought that this was okay: aio_poll holds the
AioContext lock so there cannot be concurrent aio_poll invocations, and
I was just considering nested event loops. However, aio_poll _could_
indeed be concurrent with the GSource. This is why I came up with the
wrong invariant.
In the new implementation, "exists" is computed simply by counting how many
threads are in the prepare or poll phases. There are some interesting
points to consider, but the gist of the idea remains:
1) AioContext can be used through GSource as well; as mentioned in the
patch, bit 0 of the counter is reserved for the GSource.
2) the counter need not be updated for a non-blocking aio_poll, because
it won't sleep forever anyway. This is just a matter of checking
the "blocking" variable. This requires some changes to the win32
implementation, but is otherwise not too complicated.
3) as mentioned above, the new implementation will not call aio_notify
when there is *no* active aio_poll at all. The tests have to be
adjusted for this change. The calls to aio_notify in async.c are fine;
they only want to kick aio_poll out of a blocking wait, but need not
do anything if aio_poll is not running.
4) nested aio_poll: these just work with the new implementation; when
a nested event loop is invoked, the outer event loop is never in the
prepare or poll phases. The outer event loop thus has already decremented
the counter.
Reported-by: Richard W. M. Jones <rjones@redhat.com>
Reported-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Richard W.M. Jones <rjones@redhat.com>
Message-id: 1437487673-23740-5-git-send-email-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-07-21 22:07:51 +08:00
|
|
|
* if blocking == true, it is only true after poll() returns,
|
|
|
|
* so disable the optimization now.
|
2014-07-09 17:53:07 +08:00
|
|
|
*/
|
AioContext: fix broken ctx->dispatching optimization
This patch rewrites the ctx->dispatching optimization, which was the cause
of some mysterious hangs that could be reproduced on aarch64 KVM only.
The hangs were indirectly caused by aio_poll() and in particular by
flash memory updates's call to blk_write(), which invokes aio_poll().
Fun stuff: they had an extremely short race window, so much that
adding all kind of tracing to either the kernel or QEMU made it
go away (a single printf made it half as reproducible).
On the plus side, the failure mode (a hang until the next keypress)
made it very easy to examine the state of the process with a debugger.
And there was a very nice reproducer from Laszlo, which failed pretty
often (more than half of the time) on any version of QEMU with a non-debug
kernel; it also failed fast, while still in the firmware. So, it could
have been worse.
For some unknown reason they happened only with virtio-scsi, but
that's not important. It's more interesting that they disappeared with
io=native, making thread-pool.c a likely suspect for where the bug arose.
thread-pool.c is also one of the few places which use bottom halves
across threads, by the way.
I hope that no other similar bugs exist, but just in case :) I am
going to describe how the successful debugging went... Since the
likely culprit was the ctx->dispatching optimization, which mostly
affects bottom halves, the first observation was that there are two
qemu_bh_schedule() invocations in the thread pool: the one in the aio
worker and the one in thread_pool_completion_bh. The latter always
causes the optimization to trigger, the former may or may not. In
order to restrict the possibilities, I introduced new functions
qemu_bh_schedule_slow() and qemu_bh_schedule_fast():
/* qemu_bh_schedule_slow: */
ctx = bh->ctx;
bh->idle = 0;
if (atomic_xchg(&bh->scheduled, 1) == 0) {
event_notifier_set(&ctx->notifier);
}
/* qemu_bh_schedule_fast: */
ctx = bh->ctx;
bh->idle = 0;
assert(ctx->dispatching);
atomic_xchg(&bh->scheduled, 1);
Notice how the atomic_xchg is still in qemu_bh_schedule_slow(). This
was already debated a few months ago, so I assumed it to be correct.
In retrospect this was a very good idea, as you'll see later.
Changing thread_pool_completion_bh() to qemu_bh_schedule_fast() didn't
trigger the assertion (as expected). Changing the worker's invocation
to qemu_bh_schedule_slow() didn't hide the bug (another assumption
which luckily held). This already limited heavily the amount of
interaction between the threads, hinting that the problematic events
must have triggered around thread_pool_completion_bh().
As mentioned early, invoking a debugger to examine the state of a
hung process was pretty easy; the iothread was always waiting on a
poll(..., -1) system call. Infinite timeouts are much rarer on x86,
and this could be the reason why the bug was never observed there.
With the buggy sequence more or less resolved to an interaction between
thread_pool_completion_bh() and poll(..., -1), my "tracing" strategy was
to just add a few qemu_clock_get_ns(QEMU_CLOCK_REALTIME) calls, hoping
that the ordering of aio_ctx_prepare(), aio_ctx_dispatch, poll() and
qemu_bh_schedule_fast() would provide some hint. The output was:
(gdb) p last_prepare
$3 = 103885451
(gdb) p last_dispatch
$4 = 103876492
(gdb) p last_poll
$5 = 115909333
(gdb) p last_schedule
$6 = 115925212
Notice how the last call to qemu_poll_ns() came after aio_ctx_dispatch().
This makes little sense unless there is an aio_poll() call involved,
and indeed with a slightly different instrumentation you can see that
there is one:
(gdb) p last_prepare
$3 = 107569679
(gdb) p last_dispatch
$4 = 107561600
(gdb) p last_aio_poll
$5 = 110671400
(gdb) p last_schedule
$6 = 110698917
So the scenario becomes clearer:
iothread VCPU thread
--------------------------------------------------------------------------
aio_ctx_prepare
aio_ctx_check
qemu_poll_ns(timeout=-1)
aio_poll
aio_dispatch
thread_pool_completion_bh
qemu_bh_schedule()
At this point bh->scheduled = 1 and the iothread has not been woken up.
The solution must be close, but this alone should not be a problem,
because the bottom half is only rescheduled to account for rare situations
(see commit 3c80ca1, thread-pool: avoid deadlock in nested aio_poll()
calls, 2014-07-15).
Introducing a third thread---a thread pool worker thread, which
also does qemu_bh_schedule()---does bring out the problematic case.
The third thread must be awakened *after* the callback is complete and
thread_pool_completion_bh has redone the whole loop, explaining the
short race window. And then this is what happens:
thread pool worker
--------------------------------------------------------------------------
<I/O completes>
qemu_bh_schedule()
Tada, bh->scheduled is already 1, so qemu_bh_schedule() does nothing
and the iothread is never woken up. This is where the bh->scheduled
optimization comes into play---it is correct, but removing it would
have masked the bug.
So, what is the bug?
Well, the question asked by the ctx->dispatching optimization ("is any
active aio_poll dispatching?") was wrong. The right question to ask
instead is "is any active aio_poll *not* dispatching", i.e. in the prepare
or poll phases? In that case, the aio_poll is sleeping or might go to
sleep anytime soon, and the EventNotifier must be invoked to wake
it up.
In any other case (including if there is *no* active aio_poll at all!)
we can just wait for the next prepare phase to pick up the event (e.g. a
bottom half); the prepare phase will avoid the blocking and service the
bottom half.
Expressing the invariant with a logic formula, the broken one looked like:
!(exists(thread): in_dispatching(thread)) => !optimize
or equivalently:
!(exists(thread):
in_aio_poll(thread) && in_dispatching(thread)) => !optimize
In the correct one, the negation is in a slightly different place:
(exists(thread):
in_aio_poll(thread) && !in_dispatching(thread)) => !optimize
or equivalently:
(exists(thread): in_prepare_or_poll(thread)) => !optimize
Even if the difference boils down to moving an exclamation mark :)
the implementation is quite different. However, I think the new
one is simpler to understand.
In the old implementation, the "exists" was implemented with a boolean
value. This didn't really support well the case of multiple concurrent
event loops, but I thought that this was okay: aio_poll holds the
AioContext lock so there cannot be concurrent aio_poll invocations, and
I was just considering nested event loops. However, aio_poll _could_
indeed be concurrent with the GSource. This is why I came up with the
wrong invariant.
In the new implementation, "exists" is computed simply by counting how many
threads are in the prepare or poll phases. There are some interesting
points to consider, but the gist of the idea remains:
1) AioContext can be used through GSource as well; as mentioned in the
patch, bit 0 of the counter is reserved for the GSource.
2) the counter need not be updated for a non-blocking aio_poll, because
it won't sleep forever anyway. This is just a matter of checking
the "blocking" variable. This requires some changes to the win32
implementation, but is otherwise not too complicated.
3) as mentioned above, the new implementation will not call aio_notify
when there is *no* active aio_poll at all. The tests have to be
adjusted for this change. The calls to aio_notify in async.c are fine;
they only want to kick aio_poll out of a blocking wait, but need not
do anything if aio_poll is not running.
4) nested aio_poll: these just work with the new implementation; when
a nested event loop is invoked, the outer event loop is never in the
prepare or poll phases. The outer event loop thus has already decremented
the counter.
Reported-by: Richard W. M. Jones <rjones@redhat.com>
Reported-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Richard W.M. Jones <rjones@redhat.com>
Message-id: 1437487673-23740-5-git-send-email-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-07-21 22:07:51 +08:00
|
|
|
if (blocking) {
|
|
|
|
atomic_add(&ctx->notify_me, 2);
|
|
|
|
}
|
2014-07-09 17:53:07 +08:00
|
|
|
|
2017-01-13 02:07:58 +08:00
|
|
|
qemu_lockcnt_inc(&ctx->list_lock);
|
2015-07-21 22:07:50 +08:00
|
|
|
have_select_revents = aio_prepare(ctx);
|
|
|
|
|
2012-04-12 20:00:56 +08:00
|
|
|
/* fill fd sets */
|
2012-06-09 10:01:51 +08:00
|
|
|
count = 0;
|
2017-01-13 02:07:58 +08:00
|
|
|
QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) {
|
2015-10-23 11:08:08 +08:00
|
|
|
if (!node->deleted && node->io_notify
|
|
|
|
&& aio_node_check(ctx, node->is_external)) {
|
2012-06-09 10:01:51 +08:00
|
|
|
events[count++] = event_notifier_get_handle(node->e);
|
2012-04-12 20:00:56 +08:00
|
|
|
}
|
|
|
|
}
|
2008-09-23 03:17:18 +08:00
|
|
|
|
2014-07-09 17:53:04 +08:00
|
|
|
first = true;
|
2008-09-23 03:17:18 +08:00
|
|
|
|
2015-07-21 22:07:50 +08:00
|
|
|
/* ctx->notifier is always registered. */
|
|
|
|
assert(count > 0);
|
|
|
|
|
|
|
|
/* Multiple iterations, all of them non-blocking except the first,
|
|
|
|
* may be necessary to process all pending events. After the first
|
|
|
|
* WaitForMultipleObjects call ctx->notify_me will be decremented.
|
|
|
|
*/
|
|
|
|
do {
|
2014-07-09 17:53:10 +08:00
|
|
|
HANDLE event;
|
2013-08-21 23:02:53 +08:00
|
|
|
int ret;
|
|
|
|
|
2015-07-21 22:07:50 +08:00
|
|
|
timeout = blocking && !have_select_revents
|
2014-07-09 17:53:01 +08:00
|
|
|
? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx)) : 0;
|
2013-08-21 23:02:53 +08:00
|
|
|
ret = WaitForMultipleObjects(count, events, FALSE, timeout);
|
AioContext: fix broken ctx->dispatching optimization
This patch rewrites the ctx->dispatching optimization, which was the cause
of some mysterious hangs that could be reproduced on aarch64 KVM only.
The hangs were indirectly caused by aio_poll() and in particular by
flash memory updates's call to blk_write(), which invokes aio_poll().
Fun stuff: they had an extremely short race window, so much that
adding all kind of tracing to either the kernel or QEMU made it
go away (a single printf made it half as reproducible).
On the plus side, the failure mode (a hang until the next keypress)
made it very easy to examine the state of the process with a debugger.
And there was a very nice reproducer from Laszlo, which failed pretty
often (more than half of the time) on any version of QEMU with a non-debug
kernel; it also failed fast, while still in the firmware. So, it could
have been worse.
For some unknown reason they happened only with virtio-scsi, but
that's not important. It's more interesting that they disappeared with
io=native, making thread-pool.c a likely suspect for where the bug arose.
thread-pool.c is also one of the few places which use bottom halves
across threads, by the way.
I hope that no other similar bugs exist, but just in case :) I am
going to describe how the successful debugging went... Since the
likely culprit was the ctx->dispatching optimization, which mostly
affects bottom halves, the first observation was that there are two
qemu_bh_schedule() invocations in the thread pool: the one in the aio
worker and the one in thread_pool_completion_bh. The latter always
causes the optimization to trigger, the former may or may not. In
order to restrict the possibilities, I introduced new functions
qemu_bh_schedule_slow() and qemu_bh_schedule_fast():
/* qemu_bh_schedule_slow: */
ctx = bh->ctx;
bh->idle = 0;
if (atomic_xchg(&bh->scheduled, 1) == 0) {
event_notifier_set(&ctx->notifier);
}
/* qemu_bh_schedule_fast: */
ctx = bh->ctx;
bh->idle = 0;
assert(ctx->dispatching);
atomic_xchg(&bh->scheduled, 1);
Notice how the atomic_xchg is still in qemu_bh_schedule_slow(). This
was already debated a few months ago, so I assumed it to be correct.
In retrospect this was a very good idea, as you'll see later.
Changing thread_pool_completion_bh() to qemu_bh_schedule_fast() didn't
trigger the assertion (as expected). Changing the worker's invocation
to qemu_bh_schedule_slow() didn't hide the bug (another assumption
which luckily held). This already limited heavily the amount of
interaction between the threads, hinting that the problematic events
must have triggered around thread_pool_completion_bh().
As mentioned early, invoking a debugger to examine the state of a
hung process was pretty easy; the iothread was always waiting on a
poll(..., -1) system call. Infinite timeouts are much rarer on x86,
and this could be the reason why the bug was never observed there.
With the buggy sequence more or less resolved to an interaction between
thread_pool_completion_bh() and poll(..., -1), my "tracing" strategy was
to just add a few qemu_clock_get_ns(QEMU_CLOCK_REALTIME) calls, hoping
that the ordering of aio_ctx_prepare(), aio_ctx_dispatch, poll() and
qemu_bh_schedule_fast() would provide some hint. The output was:
(gdb) p last_prepare
$3 = 103885451
(gdb) p last_dispatch
$4 = 103876492
(gdb) p last_poll
$5 = 115909333
(gdb) p last_schedule
$6 = 115925212
Notice how the last call to qemu_poll_ns() came after aio_ctx_dispatch().
This makes little sense unless there is an aio_poll() call involved,
and indeed with a slightly different instrumentation you can see that
there is one:
(gdb) p last_prepare
$3 = 107569679
(gdb) p last_dispatch
$4 = 107561600
(gdb) p last_aio_poll
$5 = 110671400
(gdb) p last_schedule
$6 = 110698917
So the scenario becomes clearer:
iothread VCPU thread
--------------------------------------------------------------------------
aio_ctx_prepare
aio_ctx_check
qemu_poll_ns(timeout=-1)
aio_poll
aio_dispatch
thread_pool_completion_bh
qemu_bh_schedule()
At this point bh->scheduled = 1 and the iothread has not been woken up.
The solution must be close, but this alone should not be a problem,
because the bottom half is only rescheduled to account for rare situations
(see commit 3c80ca1, thread-pool: avoid deadlock in nested aio_poll()
calls, 2014-07-15).
Introducing a third thread---a thread pool worker thread, which
also does qemu_bh_schedule()---does bring out the problematic case.
The third thread must be awakened *after* the callback is complete and
thread_pool_completion_bh has redone the whole loop, explaining the
short race window. And then this is what happens:
thread pool worker
--------------------------------------------------------------------------
<I/O completes>
qemu_bh_schedule()
Tada, bh->scheduled is already 1, so qemu_bh_schedule() does nothing
and the iothread is never woken up. This is where the bh->scheduled
optimization comes into play---it is correct, but removing it would
have masked the bug.
So, what is the bug?
Well, the question asked by the ctx->dispatching optimization ("is any
active aio_poll dispatching?") was wrong. The right question to ask
instead is "is any active aio_poll *not* dispatching", i.e. in the prepare
or poll phases? In that case, the aio_poll is sleeping or might go to
sleep anytime soon, and the EventNotifier must be invoked to wake
it up.
In any other case (including if there is *no* active aio_poll at all!)
we can just wait for the next prepare phase to pick up the event (e.g. a
bottom half); the prepare phase will avoid the blocking and service the
bottom half.
Expressing the invariant with a logic formula, the broken one looked like:
!(exists(thread): in_dispatching(thread)) => !optimize
or equivalently:
!(exists(thread):
in_aio_poll(thread) && in_dispatching(thread)) => !optimize
In the correct one, the negation is in a slightly different place:
(exists(thread):
in_aio_poll(thread) && !in_dispatching(thread)) => !optimize
or equivalently:
(exists(thread): in_prepare_or_poll(thread)) => !optimize
Even if the difference boils down to moving an exclamation mark :)
the implementation is quite different. However, I think the new
one is simpler to understand.
In the old implementation, the "exists" was implemented with a boolean
value. This didn't really support well the case of multiple concurrent
event loops, but I thought that this was okay: aio_poll holds the
AioContext lock so there cannot be concurrent aio_poll invocations, and
I was just considering nested event loops. However, aio_poll _could_
indeed be concurrent with the GSource. This is why I came up with the
wrong invariant.
In the new implementation, "exists" is computed simply by counting how many
threads are in the prepare or poll phases. There are some interesting
points to consider, but the gist of the idea remains:
1) AioContext can be used through GSource as well; as mentioned in the
patch, bit 0 of the counter is reserved for the GSource.
2) the counter need not be updated for a non-blocking aio_poll, because
it won't sleep forever anyway. This is just a matter of checking
the "blocking" variable. This requires some changes to the win32
implementation, but is otherwise not too complicated.
3) as mentioned above, the new implementation will not call aio_notify
when there is *no* active aio_poll at all. The tests have to be
adjusted for this change. The calls to aio_notify in async.c are fine;
they only want to kick aio_poll out of a blocking wait, but need not
do anything if aio_poll is not running.
4) nested aio_poll: these just work with the new implementation; when
a nested event loop is invoked, the outer event loop is never in the
prepare or poll phases. The outer event loop thus has already decremented
the counter.
Reported-by: Richard W. M. Jones <rjones@redhat.com>
Reported-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Richard W.M. Jones <rjones@redhat.com>
Message-id: 1437487673-23740-5-git-send-email-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-07-21 22:07:51 +08:00
|
|
|
if (blocking) {
|
|
|
|
assert(first);
|
aio: Do aio_notify_accept only during blocking aio_poll
An aio_notify() pairs with an aio_notify_accept(). The former should
happen in the main thread or a vCPU thread, and the latter should be
done in the IOThread.
There is one rare case that the main thread or vCPU thread may "steal"
the aio_notify() event just raised by itself, in bdrv_set_aio_context()
[1]. The sequence is like this:
main thread IO Thread
===============================================================
bdrv_drained_begin()
aio_disable_external(ctx)
aio_poll(ctx, true)
ctx->notify_me += 2
...
bdrv_drained_end()
...
aio_notify()
...
bdrv_set_aio_context()
aio_poll(ctx, false)
[1] aio_notify_accept(ctx)
ppoll() /* Hang! */
[1] is problematic. It will clear the ctx->notifier event so that
the blocked ppoll() will not return.
(For the curious, this bug was noticed when booting a number of VMs
simultaneously in RHV. One or two of the VMs will hit this race
condition, making the VIRTIO device unresponsive to I/O commands. When
it hangs, Seabios is busy waiting for a read request to complete (read
MBR), right after initializing the virtio-blk-pci device, using 100%
guest CPU. See also https://bugzilla.redhat.com/show_bug.cgi?id=1562750
for the original bug analysis.)
aio_notify() only injects an event when ctx->notify_me is set,
correspondingly aio_notify_accept() is only useful when ctx->notify_me
_was_ set. Move the call to it into the "blocking" branch. This will
effectively skip [1] and fix the hang.
Furthermore, blocking aio_poll is only allowed on home thread
(in_aio_context_home_thread), because otherwise two blocking
aio_poll()'s can steal each other's ctx->notifier event and cause
hanging just like described above.
Cc: qemu-stable@nongnu.org
Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
Message-Id: <20180809132259.18402-3-famz@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
2018-08-09 21:22:59 +08:00
|
|
|
assert(in_aio_context_home_thread(ctx));
|
AioContext: fix broken ctx->dispatching optimization
This patch rewrites the ctx->dispatching optimization, which was the cause
of some mysterious hangs that could be reproduced on aarch64 KVM only.
The hangs were indirectly caused by aio_poll() and in particular by
flash memory updates's call to blk_write(), which invokes aio_poll().
Fun stuff: they had an extremely short race window, so much that
adding all kind of tracing to either the kernel or QEMU made it
go away (a single printf made it half as reproducible).
On the plus side, the failure mode (a hang until the next keypress)
made it very easy to examine the state of the process with a debugger.
And there was a very nice reproducer from Laszlo, which failed pretty
often (more than half of the time) on any version of QEMU with a non-debug
kernel; it also failed fast, while still in the firmware. So, it could
have been worse.
For some unknown reason they happened only with virtio-scsi, but
that's not important. It's more interesting that they disappeared with
io=native, making thread-pool.c a likely suspect for where the bug arose.
thread-pool.c is also one of the few places which use bottom halves
across threads, by the way.
I hope that no other similar bugs exist, but just in case :) I am
going to describe how the successful debugging went... Since the
likely culprit was the ctx->dispatching optimization, which mostly
affects bottom halves, the first observation was that there are two
qemu_bh_schedule() invocations in the thread pool: the one in the aio
worker and the one in thread_pool_completion_bh. The latter always
causes the optimization to trigger, the former may or may not. In
order to restrict the possibilities, I introduced new functions
qemu_bh_schedule_slow() and qemu_bh_schedule_fast():
/* qemu_bh_schedule_slow: */
ctx = bh->ctx;
bh->idle = 0;
if (atomic_xchg(&bh->scheduled, 1) == 0) {
event_notifier_set(&ctx->notifier);
}
/* qemu_bh_schedule_fast: */
ctx = bh->ctx;
bh->idle = 0;
assert(ctx->dispatching);
atomic_xchg(&bh->scheduled, 1);
Notice how the atomic_xchg is still in qemu_bh_schedule_slow(). This
was already debated a few months ago, so I assumed it to be correct.
In retrospect this was a very good idea, as you'll see later.
Changing thread_pool_completion_bh() to qemu_bh_schedule_fast() didn't
trigger the assertion (as expected). Changing the worker's invocation
to qemu_bh_schedule_slow() didn't hide the bug (another assumption
which luckily held). This already limited heavily the amount of
interaction between the threads, hinting that the problematic events
must have triggered around thread_pool_completion_bh().
As mentioned early, invoking a debugger to examine the state of a
hung process was pretty easy; the iothread was always waiting on a
poll(..., -1) system call. Infinite timeouts are much rarer on x86,
and this could be the reason why the bug was never observed there.
With the buggy sequence more or less resolved to an interaction between
thread_pool_completion_bh() and poll(..., -1), my "tracing" strategy was
to just add a few qemu_clock_get_ns(QEMU_CLOCK_REALTIME) calls, hoping
that the ordering of aio_ctx_prepare(), aio_ctx_dispatch, poll() and
qemu_bh_schedule_fast() would provide some hint. The output was:
(gdb) p last_prepare
$3 = 103885451
(gdb) p last_dispatch
$4 = 103876492
(gdb) p last_poll
$5 = 115909333
(gdb) p last_schedule
$6 = 115925212
Notice how the last call to qemu_poll_ns() came after aio_ctx_dispatch().
This makes little sense unless there is an aio_poll() call involved,
and indeed with a slightly different instrumentation you can see that
there is one:
(gdb) p last_prepare
$3 = 107569679
(gdb) p last_dispatch
$4 = 107561600
(gdb) p last_aio_poll
$5 = 110671400
(gdb) p last_schedule
$6 = 110698917
So the scenario becomes clearer:
iothread VCPU thread
--------------------------------------------------------------------------
aio_ctx_prepare
aio_ctx_check
qemu_poll_ns(timeout=-1)
aio_poll
aio_dispatch
thread_pool_completion_bh
qemu_bh_schedule()
At this point bh->scheduled = 1 and the iothread has not been woken up.
The solution must be close, but this alone should not be a problem,
because the bottom half is only rescheduled to account for rare situations
(see commit 3c80ca1, thread-pool: avoid deadlock in nested aio_poll()
calls, 2014-07-15).
Introducing a third thread---a thread pool worker thread, which
also does qemu_bh_schedule()---does bring out the problematic case.
The third thread must be awakened *after* the callback is complete and
thread_pool_completion_bh has redone the whole loop, explaining the
short race window. And then this is what happens:
thread pool worker
--------------------------------------------------------------------------
<I/O completes>
qemu_bh_schedule()
Tada, bh->scheduled is already 1, so qemu_bh_schedule() does nothing
and the iothread is never woken up. This is where the bh->scheduled
optimization comes into play---it is correct, but removing it would
have masked the bug.
So, what is the bug?
Well, the question asked by the ctx->dispatching optimization ("is any
active aio_poll dispatching?") was wrong. The right question to ask
instead is "is any active aio_poll *not* dispatching", i.e. in the prepare
or poll phases? In that case, the aio_poll is sleeping or might go to
sleep anytime soon, and the EventNotifier must be invoked to wake
it up.
In any other case (including if there is *no* active aio_poll at all!)
we can just wait for the next prepare phase to pick up the event (e.g. a
bottom half); the prepare phase will avoid the blocking and service the
bottom half.
Expressing the invariant with a logic formula, the broken one looked like:
!(exists(thread): in_dispatching(thread)) => !optimize
or equivalently:
!(exists(thread):
in_aio_poll(thread) && in_dispatching(thread)) => !optimize
In the correct one, the negation is in a slightly different place:
(exists(thread):
in_aio_poll(thread) && !in_dispatching(thread)) => !optimize
or equivalently:
(exists(thread): in_prepare_or_poll(thread)) => !optimize
Even if the difference boils down to moving an exclamation mark :)
the implementation is quite different. However, I think the new
one is simpler to understand.
In the old implementation, the "exists" was implemented with a boolean
value. This didn't really support well the case of multiple concurrent
event loops, but I thought that this was okay: aio_poll holds the
AioContext lock so there cannot be concurrent aio_poll invocations, and
I was just considering nested event loops. However, aio_poll _could_
indeed be concurrent with the GSource. This is why I came up with the
wrong invariant.
In the new implementation, "exists" is computed simply by counting how many
threads are in the prepare or poll phases. There are some interesting
points to consider, but the gist of the idea remains:
1) AioContext can be used through GSource as well; as mentioned in the
patch, bit 0 of the counter is reserved for the GSource.
2) the counter need not be updated for a non-blocking aio_poll, because
it won't sleep forever anyway. This is just a matter of checking
the "blocking" variable. This requires some changes to the win32
implementation, but is otherwise not too complicated.
3) as mentioned above, the new implementation will not call aio_notify
when there is *no* active aio_poll at all. The tests have to be
adjusted for this change. The calls to aio_notify in async.c are fine;
they only want to kick aio_poll out of a blocking wait, but need not
do anything if aio_poll is not running.
4) nested aio_poll: these just work with the new implementation; when
a nested event loop is invoked, the outer event loop is never in the
prepare or poll phases. The outer event loop thus has already decremented
the counter.
Reported-by: Richard W. M. Jones <rjones@redhat.com>
Reported-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Richard W.M. Jones <rjones@redhat.com>
Message-id: 1437487673-23740-5-git-send-email-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-07-21 22:07:51 +08:00
|
|
|
atomic_sub(&ctx->notify_me, 2);
|
aio: Do aio_notify_accept only during blocking aio_poll
An aio_notify() pairs with an aio_notify_accept(). The former should
happen in the main thread or a vCPU thread, and the latter should be
done in the IOThread.
There is one rare case that the main thread or vCPU thread may "steal"
the aio_notify() event just raised by itself, in bdrv_set_aio_context()
[1]. The sequence is like this:
main thread IO Thread
===============================================================
bdrv_drained_begin()
aio_disable_external(ctx)
aio_poll(ctx, true)
ctx->notify_me += 2
...
bdrv_drained_end()
...
aio_notify()
...
bdrv_set_aio_context()
aio_poll(ctx, false)
[1] aio_notify_accept(ctx)
ppoll() /* Hang! */
[1] is problematic. It will clear the ctx->notifier event so that
the blocked ppoll() will not return.
(For the curious, this bug was noticed when booting a number of VMs
simultaneously in RHV. One or two of the VMs will hit this race
condition, making the VIRTIO device unresponsive to I/O commands. When
it hangs, Seabios is busy waiting for a read request to complete (read
MBR), right after initializing the virtio-blk-pci device, using 100%
guest CPU. See also https://bugzilla.redhat.com/show_bug.cgi?id=1562750
for the original bug analysis.)
aio_notify() only injects an event when ctx->notify_me is set,
correspondingly aio_notify_accept() is only useful when ctx->notify_me
_was_ set. Move the call to it into the "blocking" branch. This will
effectively skip [1] and fix the hang.
Furthermore, blocking aio_poll is only allowed on home thread
(in_aio_context_home_thread), because otherwise two blocking
aio_poll()'s can steal each other's ctx->notifier event and cause
hanging just like described above.
Cc: qemu-stable@nongnu.org
Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
Message-Id: <20180809132259.18402-3-famz@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
2018-08-09 21:22:59 +08:00
|
|
|
aio_notify_accept(ctx);
|
AioContext: fix broken ctx->dispatching optimization
This patch rewrites the ctx->dispatching optimization, which was the cause
of some mysterious hangs that could be reproduced on aarch64 KVM only.
The hangs were indirectly caused by aio_poll() and in particular by
flash memory updates's call to blk_write(), which invokes aio_poll().
Fun stuff: they had an extremely short race window, so much that
adding all kind of tracing to either the kernel or QEMU made it
go away (a single printf made it half as reproducible).
On the plus side, the failure mode (a hang until the next keypress)
made it very easy to examine the state of the process with a debugger.
And there was a very nice reproducer from Laszlo, which failed pretty
often (more than half of the time) on any version of QEMU with a non-debug
kernel; it also failed fast, while still in the firmware. So, it could
have been worse.
For some unknown reason they happened only with virtio-scsi, but
that's not important. It's more interesting that they disappeared with
io=native, making thread-pool.c a likely suspect for where the bug arose.
thread-pool.c is also one of the few places which use bottom halves
across threads, by the way.
I hope that no other similar bugs exist, but just in case :) I am
going to describe how the successful debugging went... Since the
likely culprit was the ctx->dispatching optimization, which mostly
affects bottom halves, the first observation was that there are two
qemu_bh_schedule() invocations in the thread pool: the one in the aio
worker and the one in thread_pool_completion_bh. The latter always
causes the optimization to trigger, the former may or may not. In
order to restrict the possibilities, I introduced new functions
qemu_bh_schedule_slow() and qemu_bh_schedule_fast():
/* qemu_bh_schedule_slow: */
ctx = bh->ctx;
bh->idle = 0;
if (atomic_xchg(&bh->scheduled, 1) == 0) {
event_notifier_set(&ctx->notifier);
}
/* qemu_bh_schedule_fast: */
ctx = bh->ctx;
bh->idle = 0;
assert(ctx->dispatching);
atomic_xchg(&bh->scheduled, 1);
Notice how the atomic_xchg is still in qemu_bh_schedule_slow(). This
was already debated a few months ago, so I assumed it to be correct.
In retrospect this was a very good idea, as you'll see later.
Changing thread_pool_completion_bh() to qemu_bh_schedule_fast() didn't
trigger the assertion (as expected). Changing the worker's invocation
to qemu_bh_schedule_slow() didn't hide the bug (another assumption
which luckily held). This already limited heavily the amount of
interaction between the threads, hinting that the problematic events
must have triggered around thread_pool_completion_bh().
As mentioned early, invoking a debugger to examine the state of a
hung process was pretty easy; the iothread was always waiting on a
poll(..., -1) system call. Infinite timeouts are much rarer on x86,
and this could be the reason why the bug was never observed there.
With the buggy sequence more or less resolved to an interaction between
thread_pool_completion_bh() and poll(..., -1), my "tracing" strategy was
to just add a few qemu_clock_get_ns(QEMU_CLOCK_REALTIME) calls, hoping
that the ordering of aio_ctx_prepare(), aio_ctx_dispatch, poll() and
qemu_bh_schedule_fast() would provide some hint. The output was:
(gdb) p last_prepare
$3 = 103885451
(gdb) p last_dispatch
$4 = 103876492
(gdb) p last_poll
$5 = 115909333
(gdb) p last_schedule
$6 = 115925212
Notice how the last call to qemu_poll_ns() came after aio_ctx_dispatch().
This makes little sense unless there is an aio_poll() call involved,
and indeed with a slightly different instrumentation you can see that
there is one:
(gdb) p last_prepare
$3 = 107569679
(gdb) p last_dispatch
$4 = 107561600
(gdb) p last_aio_poll
$5 = 110671400
(gdb) p last_schedule
$6 = 110698917
So the scenario becomes clearer:
iothread VCPU thread
--------------------------------------------------------------------------
aio_ctx_prepare
aio_ctx_check
qemu_poll_ns(timeout=-1)
aio_poll
aio_dispatch
thread_pool_completion_bh
qemu_bh_schedule()
At this point bh->scheduled = 1 and the iothread has not been woken up.
The solution must be close, but this alone should not be a problem,
because the bottom half is only rescheduled to account for rare situations
(see commit 3c80ca1, thread-pool: avoid deadlock in nested aio_poll()
calls, 2014-07-15).
Introducing a third thread---a thread pool worker thread, which
also does qemu_bh_schedule()---does bring out the problematic case.
The third thread must be awakened *after* the callback is complete and
thread_pool_completion_bh has redone the whole loop, explaining the
short race window. And then this is what happens:
thread pool worker
--------------------------------------------------------------------------
<I/O completes>
qemu_bh_schedule()
Tada, bh->scheduled is already 1, so qemu_bh_schedule() does nothing
and the iothread is never woken up. This is where the bh->scheduled
optimization comes into play---it is correct, but removing it would
have masked the bug.
So, what is the bug?
Well, the question asked by the ctx->dispatching optimization ("is any
active aio_poll dispatching?") was wrong. The right question to ask
instead is "is any active aio_poll *not* dispatching", i.e. in the prepare
or poll phases? In that case, the aio_poll is sleeping or might go to
sleep anytime soon, and the EventNotifier must be invoked to wake
it up.
In any other case (including if there is *no* active aio_poll at all!)
we can just wait for the next prepare phase to pick up the event (e.g. a
bottom half); the prepare phase will avoid the blocking and service the
bottom half.
Expressing the invariant with a logic formula, the broken one looked like:
!(exists(thread): in_dispatching(thread)) => !optimize
or equivalently:
!(exists(thread):
in_aio_poll(thread) && in_dispatching(thread)) => !optimize
In the correct one, the negation is in a slightly different place:
(exists(thread):
in_aio_poll(thread) && !in_dispatching(thread)) => !optimize
or equivalently:
(exists(thread): in_prepare_or_poll(thread)) => !optimize
Even if the difference boils down to moving an exclamation mark :)
the implementation is quite different. However, I think the new
one is simpler to understand.
In the old implementation, the "exists" was implemented with a boolean
value. This didn't really support well the case of multiple concurrent
event loops, but I thought that this was okay: aio_poll holds the
AioContext lock so there cannot be concurrent aio_poll invocations, and
I was just considering nested event loops. However, aio_poll _could_
indeed be concurrent with the GSource. This is why I came up with the
wrong invariant.
In the new implementation, "exists" is computed simply by counting how many
threads are in the prepare or poll phases. There are some interesting
points to consider, but the gist of the idea remains:
1) AioContext can be used through GSource as well; as mentioned in the
patch, bit 0 of the counter is reserved for the GSource.
2) the counter need not be updated for a non-blocking aio_poll, because
it won't sleep forever anyway. This is just a matter of checking
the "blocking" variable. This requires some changes to the win32
implementation, but is otherwise not too complicated.
3) as mentioned above, the new implementation will not call aio_notify
when there is *no* active aio_poll at all. The tests have to be
adjusted for this change. The calls to aio_notify in async.c are fine;
they only want to kick aio_poll out of a blocking wait, but need not
do anything if aio_poll is not running.
4) nested aio_poll: these just work with the new implementation; when
a nested event loop is invoked, the outer event loop is never in the
prepare or poll phases. The outer event loop thus has already decremented
the counter.
Reported-by: Richard W. M. Jones <rjones@redhat.com>
Reported-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Richard W.M. Jones <rjones@redhat.com>
Message-id: 1437487673-23740-5-git-send-email-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-07-21 22:07:51 +08:00
|
|
|
}
|
2012-06-09 10:01:51 +08:00
|
|
|
|
2015-07-21 22:07:52 +08:00
|
|
|
if (first) {
|
|
|
|
progress |= aio_bh_poll(ctx);
|
|
|
|
first = false;
|
2014-07-09 17:53:04 +08:00
|
|
|
}
|
|
|
|
|
2012-06-09 10:01:51 +08:00
|
|
|
/* if we have any signaled events, dispatch event */
|
2014-07-09 17:53:10 +08:00
|
|
|
event = NULL;
|
|
|
|
if ((DWORD) (ret - WAIT_OBJECT_0) < count) {
|
|
|
|
event = events[ret - WAIT_OBJECT_0];
|
2014-09-15 20:52:58 +08:00
|
|
|
events[ret - WAIT_OBJECT_0] = events[--count];
|
2014-07-09 17:53:10 +08:00
|
|
|
} else if (!have_select_revents) {
|
2012-06-09 10:01:51 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-07-09 17:53:10 +08:00
|
|
|
have_select_revents = false;
|
2012-06-09 10:01:51 +08:00
|
|
|
blocking = false;
|
2012-04-12 20:00:56 +08:00
|
|
|
|
2014-07-09 17:53:10 +08:00
|
|
|
progress |= aio_dispatch_handlers(ctx, event);
|
2015-07-21 22:07:50 +08:00
|
|
|
} while (count > 0);
|
2012-04-12 20:00:55 +08:00
|
|
|
|
2017-02-13 21:52:34 +08:00
|
|
|
qemu_lockcnt_dec(&ctx->list_lock);
|
|
|
|
|
2014-07-09 17:53:05 +08:00
|
|
|
progress |= timerlistgroup_run_timers(&ctx->tlg);
|
2013-04-11 22:56:50 +08:00
|
|
|
return progress;
|
2008-09-23 03:17:18 +08:00
|
|
|
}
|
2015-10-30 12:06:28 +08:00
|
|
|
|
2016-07-15 18:28:44 +08:00
|
|
|
void aio_context_setup(AioContext *ctx)
|
2015-10-30 12:06:28 +08:00
|
|
|
{
|
|
|
|
}
|
2016-12-02 03:26:42 +08:00
|
|
|
|
2018-05-17 08:42:43 +08:00
|
|
|
void aio_context_destroy(AioContext *ctx)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2016-12-02 03:26:51 +08:00
|
|
|
void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
|
|
|
|
int64_t grow, int64_t shrink, Error **errp)
|
2016-12-02 03:26:42 +08:00
|
|
|
{
|
2018-03-22 16:56:30 +08:00
|
|
|
if (max_ns) {
|
|
|
|
error_setg(errp, "AioContext polling is not implemented on Windows");
|
|
|
|
}
|
2016-12-02 03:26:42 +08:00
|
|
|
}
|