2009-10-22 17:54:37 +02:00
|
|
|
/*
|
|
|
|
* QEMU System Emulator
|
|
|
|
*
|
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu-common.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/aio.h"
|
2013-03-07 13:41:47 +01:00
|
|
|
#include "block/thread-pool.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/main-loop.h"
|
2014-07-07 15:18:04 +02:00
|
|
|
#include "qemu/atomic.h"
|
2009-10-22 17:54:38 +02:00
|
|
|
|
2009-10-22 17:54:37 +02:00
|
|
|
/***********************************************************/
|
|
|
|
/* bottom halves (can be seen as timers which expire ASAP) */
|
|
|
|
|
|
|
|
struct QEMUBH {
|
2012-09-24 18:44:14 +02:00
|
|
|
AioContext *ctx;
|
2009-10-22 17:54:37 +02:00
|
|
|
QEMUBHFunc *cb;
|
|
|
|
void *opaque;
|
|
|
|
QEMUBH *next;
|
2012-04-29 19:08:45 +02:00
|
|
|
bool scheduled;
|
|
|
|
bool idle;
|
|
|
|
bool deleted;
|
2009-10-22 17:54:37 +02:00
|
|
|
};
|
|
|
|
|
2012-10-29 23:45:23 +01:00
|
|
|
QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
|
2009-10-22 17:54:37 +02:00
|
|
|
{
|
|
|
|
QEMUBH *bh;
|
2014-12-17 16:10:00 +01:00
|
|
|
bh = g_new(QEMUBH, 1);
|
|
|
|
*bh = (QEMUBH){
|
|
|
|
.ctx = ctx,
|
|
|
|
.cb = cb,
|
|
|
|
.opaque = opaque,
|
|
|
|
};
|
2013-07-16 06:28:58 +02:00
|
|
|
qemu_mutex_lock(&ctx->bh_lock);
|
2012-10-29 23:45:23 +01:00
|
|
|
bh->next = ctx->first_bh;
|
2013-07-16 06:28:58 +02:00
|
|
|
/* Make sure that the members are ready before putting bh into list */
|
|
|
|
smp_wmb();
|
2012-10-29 23:45:23 +01:00
|
|
|
ctx->first_bh = bh;
|
2013-07-16 06:28:58 +02:00
|
|
|
qemu_mutex_unlock(&ctx->bh_lock);
|
2009-10-22 17:54:37 +02:00
|
|
|
return bh;
|
|
|
|
}
|
|
|
|
|
2013-07-16 06:28:58 +02:00
|
|
|
/* Multiple occurrences of aio_bh_poll cannot be called concurrently */
|
2012-10-29 23:45:23 +01:00
|
|
|
int aio_bh_poll(AioContext *ctx)
|
2009-10-22 17:54:37 +02:00
|
|
|
{
|
2011-06-07 17:51:21 +02:00
|
|
|
QEMUBH *bh, **bhp, *next;
|
2009-10-22 17:54:37 +02:00
|
|
|
int ret;
|
2011-09-01 16:16:10 +02:00
|
|
|
|
2012-10-29 23:45:23 +01:00
|
|
|
ctx->walking_bh++;
|
2009-10-22 17:54:37 +02:00
|
|
|
|
|
|
|
ret = 0;
|
2012-10-29 23:45:23 +01:00
|
|
|
for (bh = ctx->first_bh; bh; bh = next) {
|
2013-07-16 06:28:58 +02:00
|
|
|
/* Make sure that fetching bh happens before accessing its members */
|
|
|
|
smp_read_barrier_depends();
|
2011-06-07 17:51:21 +02:00
|
|
|
next = bh->next;
|
aio: strengthen memory barriers for bottom half scheduling
There are two problems with memory barriers in async.c. The fix is
to use atomic_xchg in order to achieve sequential consistency between
the scheduling of a bottom half and the corresponding execution.
First, if bh->scheduled is already 1 in qemu_bh_schedule, QEMU does
not execute a memory barrier to order any writes needed by the callback
before the read of bh->scheduled. If the other side sees req->state as
THREAD_ACTIVE, the callback is not invoked and you get deadlock.
Second, the memory barrier in aio_bh_poll is too weak. Without this
patch, it is possible that bh->scheduled = 0 is not "published" until
after the callback has returned. Another thread wants to schedule the
bottom half, but it sees bh->scheduled = 1 and does nothing. This causes
a lost wakeup. The memory barrier should have been changed to smp_mb()
in commit 924fe12 (aio: fix qemu_bh_schedule() bh->ctx race condition,
2014-06-03) together with qemu_bh_schedule()'s. Guess who reviewed
that patch?
Both of these involve a store and a load, so they are reproducible on
x86_64 as well. It is however much easier on aarch64, where the
libguestfs test suite triggers the bug fairly easily. Even there the
failure can go away or appear depending on compiler optimization level,
tracing options, or even kernel debugging options.
Paul Leveille however reported how to trigger the problem within 15
minutes on x86_64 as well. His (untested) recipe, reproduced here
for reference, is the following:
1) Qcow2 (or 3) is critical – raw files alone seem to avoid the problem.
2) Use “cache=directsync” rather than the default of
“cache=none” to make it happen easier.
3) Use a server with a write-back RAID controller to allow for rapid
IO rates.
4) Run a random-access load that (mostly) writes chunks to various
files on the virtual block device.
a. I use ‘diskload.exe c:25’, a Microsoft HCT load
generator, on Windows VMs.
b. Iometer can probably be configured to generate a similar load.
5) Run multiple VMs in parallel, against the same storage device,
to shake the failure out sooner.
6) IvyBridge and Haswell processors for certain; not sure about others.
A similar patch survived over 12 hours of testing, where an unpatched
QEMU would fail within 15 minutes.
This bug is, most likely, also the cause of failures in the libguestfs
testsuite on AArch64.
Thanks to Laszlo Ersek for initially reporting this bug, to Stefan
Hajnoczi for suggesting closer examination of qemu_bh_schedule, and to
Paul for providing test input and a prototype patch.
Reported-by: Laszlo Ersek <lersek@redhat.com>
Reported-by: Paul Leveille <Paul.Leveille@stratus.com>
Reported-by: John Snow <jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1428419779-26062-1-git-send-email-pbonzini@redhat.com
Suggested-by: Paul Leveille <Paul.Leveille@stratus.com>
Suggested-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-04-07 17:16:19 +02:00
|
|
|
/* The atomic_xchg is paired with the one in qemu_bh_schedule. The
|
|
|
|
* implicit memory barrier ensures that the callback sees all writes
|
|
|
|
* done by the scheduling thread. It also ensures that the scheduling
|
|
|
|
* thread sees the zero before bh->cb has run, and thus will call
|
|
|
|
* aio_notify again if necessary.
|
|
|
|
*/
|
|
|
|
if (!bh->deleted && atomic_xchg(&bh->scheduled, 0)) {
|
2009-10-22 17:54:37 +02:00
|
|
|
if (!bh->idle)
|
|
|
|
ret = 1;
|
|
|
|
bh->idle = 0;
|
|
|
|
bh->cb(bh->opaque);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-29 23:45:23 +01:00
|
|
|
ctx->walking_bh--;
|
2011-09-01 16:16:10 +02:00
|
|
|
|
2009-10-22 17:54:37 +02:00
|
|
|
/* remove deleted bhs */
|
2012-10-29 23:45:23 +01:00
|
|
|
if (!ctx->walking_bh) {
|
2013-07-16 06:28:58 +02:00
|
|
|
qemu_mutex_lock(&ctx->bh_lock);
|
2012-10-29 23:45:23 +01:00
|
|
|
bhp = &ctx->first_bh;
|
2011-09-01 16:16:10 +02:00
|
|
|
while (*bhp) {
|
|
|
|
bh = *bhp;
|
|
|
|
if (bh->deleted) {
|
|
|
|
*bhp = bh->next;
|
|
|
|
g_free(bh);
|
|
|
|
} else {
|
|
|
|
bhp = &bh->next;
|
|
|
|
}
|
|
|
|
}
|
2013-07-16 06:28:58 +02:00
|
|
|
qemu_mutex_unlock(&ctx->bh_lock);
|
2009-10-22 17:54:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_bh_schedule_idle(QEMUBH *bh)
|
|
|
|
{
|
|
|
|
bh->idle = 1;
|
2013-07-16 06:28:58 +02:00
|
|
|
/* Make sure that idle & any writes needed by the callback are done
|
|
|
|
* before the locations are read in the aio_bh_poll.
|
|
|
|
*/
|
aio: strengthen memory barriers for bottom half scheduling
There are two problems with memory barriers in async.c. The fix is
to use atomic_xchg in order to achieve sequential consistency between
the scheduling of a bottom half and the corresponding execution.
First, if bh->scheduled is already 1 in qemu_bh_schedule, QEMU does
not execute a memory barrier to order any writes needed by the callback
before the read of bh->scheduled. If the other side sees req->state as
THREAD_ACTIVE, the callback is not invoked and you get deadlock.
Second, the memory barrier in aio_bh_poll is too weak. Without this
patch, it is possible that bh->scheduled = 0 is not "published" until
after the callback has returned. Another thread wants to schedule the
bottom half, but it sees bh->scheduled = 1 and does nothing. This causes
a lost wakeup. The memory barrier should have been changed to smp_mb()
in commit 924fe12 (aio: fix qemu_bh_schedule() bh->ctx race condition,
2014-06-03) together with qemu_bh_schedule()'s. Guess who reviewed
that patch?
Both of these involve a store and a load, so they are reproducible on
x86_64 as well. It is however much easier on aarch64, where the
libguestfs test suite triggers the bug fairly easily. Even there the
failure can go away or appear depending on compiler optimization level,
tracing options, or even kernel debugging options.
Paul Leveille however reported how to trigger the problem within 15
minutes on x86_64 as well. His (untested) recipe, reproduced here
for reference, is the following:
1) Qcow2 (or 3) is critical – raw files alone seem to avoid the problem.
2) Use “cache=directsync” rather than the default of
“cache=none” to make it happen easier.
3) Use a server with a write-back RAID controller to allow for rapid
IO rates.
4) Run a random-access load that (mostly) writes chunks to various
files on the virtual block device.
a. I use ‘diskload.exe c:25’, a Microsoft HCT load
generator, on Windows VMs.
b. Iometer can probably be configured to generate a similar load.
5) Run multiple VMs in parallel, against the same storage device,
to shake the failure out sooner.
6) IvyBridge and Haswell processors for certain; not sure about others.
A similar patch survived over 12 hours of testing, where an unpatched
QEMU would fail within 15 minutes.
This bug is, most likely, also the cause of failures in the libguestfs
testsuite on AArch64.
Thanks to Laszlo Ersek for initially reporting this bug, to Stefan
Hajnoczi for suggesting closer examination of qemu_bh_schedule, and to
Paul for providing test input and a prototype patch.
Reported-by: Laszlo Ersek <lersek@redhat.com>
Reported-by: Paul Leveille <Paul.Leveille@stratus.com>
Reported-by: John Snow <jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1428419779-26062-1-git-send-email-pbonzini@redhat.com
Suggested-by: Paul Leveille <Paul.Leveille@stratus.com>
Suggested-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-04-07 17:16:19 +02:00
|
|
|
atomic_mb_set(&bh->scheduled, 1);
|
2009-10-22 17:54:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_bh_schedule(QEMUBH *bh)
|
|
|
|
{
|
2014-06-03 11:21:01 +02:00
|
|
|
AioContext *ctx;
|
|
|
|
|
|
|
|
ctx = bh->ctx;
|
2009-10-22 17:54:37 +02:00
|
|
|
bh->idle = 0;
|
aio: strengthen memory barriers for bottom half scheduling
There are two problems with memory barriers in async.c. The fix is
to use atomic_xchg in order to achieve sequential consistency between
the scheduling of a bottom half and the corresponding execution.
First, if bh->scheduled is already 1 in qemu_bh_schedule, QEMU does
not execute a memory barrier to order any writes needed by the callback
before the read of bh->scheduled. If the other side sees req->state as
THREAD_ACTIVE, the callback is not invoked and you get deadlock.
Second, the memory barrier in aio_bh_poll is too weak. Without this
patch, it is possible that bh->scheduled = 0 is not "published" until
after the callback has returned. Another thread wants to schedule the
bottom half, but it sees bh->scheduled = 1 and does nothing. This causes
a lost wakeup. The memory barrier should have been changed to smp_mb()
in commit 924fe12 (aio: fix qemu_bh_schedule() bh->ctx race condition,
2014-06-03) together with qemu_bh_schedule()'s. Guess who reviewed
that patch?
Both of these involve a store and a load, so they are reproducible on
x86_64 as well. It is however much easier on aarch64, where the
libguestfs test suite triggers the bug fairly easily. Even there the
failure can go away or appear depending on compiler optimization level,
tracing options, or even kernel debugging options.
Paul Leveille however reported how to trigger the problem within 15
minutes on x86_64 as well. His (untested) recipe, reproduced here
for reference, is the following:
1) Qcow2 (or 3) is critical – raw files alone seem to avoid the problem.
2) Use “cache=directsync” rather than the default of
“cache=none” to make it happen easier.
3) Use a server with a write-back RAID controller to allow for rapid
IO rates.
4) Run a random-access load that (mostly) writes chunks to various
files on the virtual block device.
a. I use ‘diskload.exe c:25’, a Microsoft HCT load
generator, on Windows VMs.
b. Iometer can probably be configured to generate a similar load.
5) Run multiple VMs in parallel, against the same storage device,
to shake the failure out sooner.
6) IvyBridge and Haswell processors for certain; not sure about others.
A similar patch survived over 12 hours of testing, where an unpatched
QEMU would fail within 15 minutes.
This bug is, most likely, also the cause of failures in the libguestfs
testsuite on AArch64.
Thanks to Laszlo Ersek for initially reporting this bug, to Stefan
Hajnoczi for suggesting closer examination of qemu_bh_schedule, and to
Paul for providing test input and a prototype patch.
Reported-by: Laszlo Ersek <lersek@redhat.com>
Reported-by: Paul Leveille <Paul.Leveille@stratus.com>
Reported-by: John Snow <jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1428419779-26062-1-git-send-email-pbonzini@redhat.com
Suggested-by: Paul Leveille <Paul.Leveille@stratus.com>
Suggested-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-04-07 17:16:19 +02:00
|
|
|
/* The memory barrier implicit in atomic_xchg makes sure that:
|
2014-06-03 11:21:01 +02:00
|
|
|
* 1. idle & any writes needed by the callback are done before the
|
|
|
|
* locations are read in the aio_bh_poll.
|
|
|
|
* 2. ctx is loaded before scheduled is set and the callback has a chance
|
|
|
|
* to execute.
|
2013-07-16 06:28:58 +02:00
|
|
|
*/
|
aio: strengthen memory barriers for bottom half scheduling
There are two problems with memory barriers in async.c. The fix is
to use atomic_xchg in order to achieve sequential consistency between
the scheduling of a bottom half and the corresponding execution.
First, if bh->scheduled is already 1 in qemu_bh_schedule, QEMU does
not execute a memory barrier to order any writes needed by the callback
before the read of bh->scheduled. If the other side sees req->state as
THREAD_ACTIVE, the callback is not invoked and you get deadlock.
Second, the memory barrier in aio_bh_poll is too weak. Without this
patch, it is possible that bh->scheduled = 0 is not "published" until
after the callback has returned. Another thread wants to schedule the
bottom half, but it sees bh->scheduled = 1 and does nothing. This causes
a lost wakeup. The memory barrier should have been changed to smp_mb()
in commit 924fe12 (aio: fix qemu_bh_schedule() bh->ctx race condition,
2014-06-03) together with qemu_bh_schedule()'s. Guess who reviewed
that patch?
Both of these involve a store and a load, so they are reproducible on
x86_64 as well. It is however much easier on aarch64, where the
libguestfs test suite triggers the bug fairly easily. Even there the
failure can go away or appear depending on compiler optimization level,
tracing options, or even kernel debugging options.
Paul Leveille however reported how to trigger the problem within 15
minutes on x86_64 as well. His (untested) recipe, reproduced here
for reference, is the following:
1) Qcow2 (or 3) is critical – raw files alone seem to avoid the problem.
2) Use “cache=directsync” rather than the default of
“cache=none” to make it happen easier.
3) Use a server with a write-back RAID controller to allow for rapid
IO rates.
4) Run a random-access load that (mostly) writes chunks to various
files on the virtual block device.
a. I use ‘diskload.exe c:25’, a Microsoft HCT load
generator, on Windows VMs.
b. Iometer can probably be configured to generate a similar load.
5) Run multiple VMs in parallel, against the same storage device,
to shake the failure out sooner.
6) IvyBridge and Haswell processors for certain; not sure about others.
A similar patch survived over 12 hours of testing, where an unpatched
QEMU would fail within 15 minutes.
This bug is, most likely, also the cause of failures in the libguestfs
testsuite on AArch64.
Thanks to Laszlo Ersek for initially reporting this bug, to Stefan
Hajnoczi for suggesting closer examination of qemu_bh_schedule, and to
Paul for providing test input and a prototype patch.
Reported-by: Laszlo Ersek <lersek@redhat.com>
Reported-by: Paul Leveille <Paul.Leveille@stratus.com>
Reported-by: John Snow <jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1428419779-26062-1-git-send-email-pbonzini@redhat.com
Suggested-by: Paul Leveille <Paul.Leveille@stratus.com>
Suggested-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-04-07 17:16:19 +02:00
|
|
|
if (atomic_xchg(&bh->scheduled, 1) == 0) {
|
|
|
|
aio_notify(ctx);
|
|
|
|
}
|
2009-10-22 17:54:37 +02:00
|
|
|
}
|
|
|
|
|
2013-07-16 06:28:58 +02:00
|
|
|
|
|
|
|
/* This func is async.
|
|
|
|
*/
|
2009-10-22 17:54:37 +02:00
|
|
|
void qemu_bh_cancel(QEMUBH *bh)
|
|
|
|
{
|
|
|
|
bh->scheduled = 0;
|
|
|
|
}
|
|
|
|
|
2013-07-16 06:28:58 +02:00
|
|
|
/* This func is async.The bottom half will do the delete action at the finial
|
|
|
|
* end.
|
|
|
|
*/
|
2009-10-22 17:54:37 +02:00
|
|
|
void qemu_bh_delete(QEMUBH *bh)
|
|
|
|
{
|
|
|
|
bh->scheduled = 0;
|
|
|
|
bh->deleted = 1;
|
|
|
|
}
|
|
|
|
|
2014-07-09 11:53:01 +02:00
|
|
|
int64_t
|
|
|
|
aio_compute_timeout(AioContext *ctx)
|
2009-10-22 17:54:37 +02:00
|
|
|
{
|
2014-07-09 11:53:01 +02:00
|
|
|
int64_t deadline;
|
|
|
|
int timeout = -1;
|
2009-10-22 17:54:37 +02:00
|
|
|
QEMUBH *bh;
|
|
|
|
|
2012-10-29 23:45:23 +01:00
|
|
|
for (bh = ctx->first_bh; bh; bh = bh->next) {
|
2009-10-22 17:54:37 +02:00
|
|
|
if (!bh->deleted && bh->scheduled) {
|
|
|
|
if (bh->idle) {
|
|
|
|
/* idle bottom halves will be polled at least
|
|
|
|
* every 10ms */
|
2014-07-09 11:53:01 +02:00
|
|
|
timeout = 10000000;
|
2009-10-22 17:54:37 +02:00
|
|
|
} else {
|
|
|
|
/* non-idle bottom halves will be executed
|
|
|
|
* immediately */
|
2014-07-09 11:53:01 +02:00
|
|
|
return 0;
|
2009-10-22 17:54:37 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-09-24 14:57:41 +02:00
|
|
|
|
2014-07-09 11:53:01 +02:00
|
|
|
deadline = timerlistgroup_deadline_ns(&ctx->tlg);
|
2013-08-21 17:02:51 +02:00
|
|
|
if (deadline == 0) {
|
2014-07-09 11:53:01 +02:00
|
|
|
return 0;
|
2013-08-21 17:02:51 +02:00
|
|
|
} else {
|
2014-07-09 11:53:01 +02:00
|
|
|
return qemu_soonest_timeout(timeout, deadline);
|
2013-08-21 17:02:51 +02:00
|
|
|
}
|
2014-07-09 11:53:01 +02:00
|
|
|
}
|
2013-08-21 17:02:51 +02:00
|
|
|
|
2014-07-09 11:53:01 +02:00
|
|
|
static gboolean
|
|
|
|
aio_ctx_prepare(GSource *source, gint *timeout)
|
|
|
|
{
|
|
|
|
AioContext *ctx = (AioContext *) source;
|
|
|
|
|
|
|
|
/* We assume there is no timeout already supplied */
|
|
|
|
*timeout = qemu_timeout_ns_to_ms(aio_compute_timeout(ctx));
|
2014-07-09 11:53:08 +02:00
|
|
|
|
|
|
|
if (aio_prepare(ctx)) {
|
|
|
|
*timeout = 0;
|
|
|
|
}
|
|
|
|
|
2014-07-09 11:53:01 +02:00
|
|
|
return *timeout == 0;
|
2012-09-24 14:57:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
aio_ctx_check(GSource *source)
|
|
|
|
{
|
|
|
|
AioContext *ctx = (AioContext *) source;
|
|
|
|
QEMUBH *bh;
|
|
|
|
|
|
|
|
for (bh = ctx->first_bh; bh; bh = bh->next) {
|
|
|
|
if (!bh->deleted && bh->scheduled) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2013-08-21 17:02:51 +02:00
|
|
|
return aio_pending(ctx) || (timerlistgroup_deadline_ns(&ctx->tlg) == 0);
|
2012-09-24 14:57:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
aio_ctx_dispatch(GSource *source,
|
|
|
|
GSourceFunc callback,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
AioContext *ctx = (AioContext *) source;
|
|
|
|
|
|
|
|
assert(callback == NULL);
|
2014-07-09 11:53:05 +02:00
|
|
|
aio_dispatch(ctx);
|
2012-09-24 14:57:41 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-09-24 18:44:14 +02:00
|
|
|
static void
|
|
|
|
aio_ctx_finalize(GSource *source)
|
|
|
|
{
|
|
|
|
AioContext *ctx = (AioContext *) source;
|
|
|
|
|
2013-03-07 13:41:47 +01:00
|
|
|
thread_pool_free(ctx->thread_pool);
|
2013-04-11 17:26:25 +02:00
|
|
|
aio_set_event_notifier(ctx, &ctx->notifier, NULL);
|
2012-09-24 18:44:14 +02:00
|
|
|
event_notifier_cleanup(&ctx->notifier);
|
2014-03-03 11:30:04 +01:00
|
|
|
rfifolock_destroy(&ctx->lock);
|
2013-07-16 06:28:58 +02:00
|
|
|
qemu_mutex_destroy(&ctx->bh_lock);
|
2013-02-20 11:28:32 +01:00
|
|
|
g_array_free(ctx->pollfds, TRUE);
|
2013-08-21 17:02:49 +02:00
|
|
|
timerlistgroup_deinit(&ctx->tlg);
|
2012-09-24 18:44:14 +02:00
|
|
|
}
|
|
|
|
|
2012-09-24 14:57:41 +02:00
|
|
|
static GSourceFuncs aio_source_funcs = {
|
|
|
|
aio_ctx_prepare,
|
|
|
|
aio_ctx_check,
|
|
|
|
aio_ctx_dispatch,
|
2012-09-24 18:44:14 +02:00
|
|
|
aio_ctx_finalize
|
2012-09-24 14:57:41 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
GSource *aio_get_g_source(AioContext *ctx)
|
|
|
|
{
|
|
|
|
g_source_ref(&ctx->source);
|
|
|
|
return &ctx->source;
|
|
|
|
}
|
2012-09-13 12:28:51 +02:00
|
|
|
|
2013-03-07 13:41:47 +01:00
|
|
|
ThreadPool *aio_get_thread_pool(AioContext *ctx)
|
|
|
|
{
|
|
|
|
if (!ctx->thread_pool) {
|
|
|
|
ctx->thread_pool = thread_pool_new(ctx);
|
|
|
|
}
|
|
|
|
return ctx->thread_pool;
|
|
|
|
}
|
|
|
|
|
2014-07-07 15:18:04 +02:00
|
|
|
void aio_set_dispatching(AioContext *ctx, bool dispatching)
|
|
|
|
{
|
|
|
|
ctx->dispatching = dispatching;
|
|
|
|
if (!dispatching) {
|
|
|
|
/* Write ctx->dispatching before reading e.g. bh->scheduled.
|
|
|
|
* Optimization: this is only needed when we're entering the "unsafe"
|
|
|
|
* phase where other threads must call event_notifier_set.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-24 18:44:14 +02:00
|
|
|
void aio_notify(AioContext *ctx)
|
|
|
|
{
|
2014-07-07 15:18:04 +02:00
|
|
|
/* Write e.g. bh->scheduled before reading ctx->dispatching. */
|
|
|
|
smp_mb();
|
|
|
|
if (!ctx->dispatching) {
|
|
|
|
event_notifier_set(&ctx->notifier);
|
|
|
|
}
|
2012-09-24 18:44:14 +02:00
|
|
|
}
|
|
|
|
|
2013-08-21 17:02:50 +02:00
|
|
|
static void aio_timerlist_notify(void *opaque)
|
|
|
|
{
|
|
|
|
aio_notify(opaque);
|
|
|
|
}
|
|
|
|
|
2014-03-03 11:30:04 +01:00
|
|
|
static void aio_rfifolock_cb(void *opaque)
|
|
|
|
{
|
|
|
|
/* Kick owner thread in case they are blocked in aio_poll() */
|
|
|
|
aio_notify(opaque);
|
|
|
|
}
|
|
|
|
|
2014-09-18 13:30:49 +02:00
|
|
|
AioContext *aio_context_new(Error **errp)
|
2012-10-29 23:45:23 +01:00
|
|
|
{
|
2014-09-18 13:30:49 +02:00
|
|
|
int ret;
|
2012-09-24 18:44:14 +02:00
|
|
|
AioContext *ctx;
|
|
|
|
ctx = (AioContext *) g_source_new(&aio_source_funcs, sizeof(AioContext));
|
2014-09-18 13:30:49 +02:00
|
|
|
ret = event_notifier_init(&ctx->notifier, false);
|
|
|
|
if (ret < 0) {
|
|
|
|
g_source_destroy(&ctx->source);
|
|
|
|
error_setg_errno(errp, -ret, "Failed to initialize event notifier");
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-12-17 16:09:58 +01:00
|
|
|
g_source_set_can_recurse(&ctx->source, true);
|
2014-09-18 13:30:49 +02:00
|
|
|
aio_set_event_notifier(ctx, &ctx->notifier,
|
|
|
|
(EventNotifierHandler *)
|
|
|
|
event_notifier_test_and_clear);
|
2013-02-20 11:28:32 +01:00
|
|
|
ctx->pollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD));
|
2013-03-07 13:41:47 +01:00
|
|
|
ctx->thread_pool = NULL;
|
2013-07-16 06:28:58 +02:00
|
|
|
qemu_mutex_init(&ctx->bh_lock);
|
2014-03-03 11:30:04 +01:00
|
|
|
rfifolock_init(&ctx->lock, aio_rfifolock_cb, ctx);
|
2013-08-21 17:02:50 +02:00
|
|
|
timerlistgroup_init(&ctx->tlg, aio_timerlist_notify, ctx);
|
2012-09-24 18:44:14 +02:00
|
|
|
|
|
|
|
return ctx;
|
2012-09-24 14:57:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void aio_context_ref(AioContext *ctx)
|
|
|
|
{
|
|
|
|
g_source_ref(&ctx->source);
|
|
|
|
}
|
|
|
|
|
|
|
|
void aio_context_unref(AioContext *ctx)
|
|
|
|
{
|
|
|
|
g_source_unref(&ctx->source);
|
2012-10-29 23:45:23 +01:00
|
|
|
}
|
2014-03-03 11:30:04 +01:00
|
|
|
|
|
|
|
void aio_context_acquire(AioContext *ctx)
|
|
|
|
{
|
|
|
|
rfifolock_lock(&ctx->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void aio_context_release(AioContext *ctx)
|
|
|
|
{
|
|
|
|
rfifolock_unlock(&ctx->lock);
|
|
|
|
}
|