mirror of
https://github.com/qemu/qemu.git
synced 2024-11-27 13:53:45 +08:00
8c6b0356b5
The ctx->first_bh list contains all created BHs, including those that are not scheduled. The list is iterated by the event loop and therefore has O(n) time complexity with respected to the number of created BHs. Rewrite BHs so that only scheduled or deleted BHs are enqueued. Only BHs that actually require action will be iterated. One semantic change is required: qemu_bh_delete() enqueues the BH and therefore invokes aio_notify(). The tests/test-aio.c:test_source_bh_delete_from_cb() test case assumed that g_main_context_iteration(NULL, false) returns false after qemu_bh_delete() but it now returns true for one iteration. Fix up the test case. This patch makes aio_compute_timeout() and aio_bh_poll() drop from a CPU profile reported by perf-top(1). Previously they combined to 9% CPU utilization when AioContext polling is commented out and the guest has 2 virtio-blk,num-queues=1 and 99 virtio-blk,num-queues=32 devices. Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> Reviewed-by: Paolo Bonzini <pbonzini@redhat.com> Message-id: 20200221093951.1414693-1-stefanha@redhat.com Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
922 lines
27 KiB
C
922 lines
27 KiB
C
/*
|
|
* AioContext tests
|
|
*
|
|
* Copyright Red Hat, Inc. 2012
|
|
*
|
|
* Authors:
|
|
* Paolo Bonzini <pbonzini@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU LGPL, version 2 or later.
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "block/aio.h"
|
|
#include "qapi/error.h"
|
|
#include "qemu/timer.h"
|
|
#include "qemu/sockets.h"
|
|
#include "qemu/error-report.h"
|
|
#include "qemu/coroutine.h"
|
|
#include "qemu/main-loop.h"
|
|
|
|
static AioContext *ctx;
|
|
|
|
typedef struct {
|
|
EventNotifier e;
|
|
int n;
|
|
int active;
|
|
bool auto_set;
|
|
} EventNotifierTestData;
|
|
|
|
/* Wait until event notifier becomes inactive */
|
|
static void wait_until_inactive(EventNotifierTestData *data)
|
|
{
|
|
while (data->active > 0) {
|
|
aio_poll(ctx, true);
|
|
}
|
|
}
|
|
|
|
/* Simple callbacks for testing. */
|
|
|
|
typedef struct {
|
|
QEMUBH *bh;
|
|
int n;
|
|
int max;
|
|
} BHTestData;
|
|
|
|
typedef struct {
|
|
QEMUTimer timer;
|
|
QEMUClockType clock_type;
|
|
int n;
|
|
int max;
|
|
int64_t ns;
|
|
AioContext *ctx;
|
|
} TimerTestData;
|
|
|
|
static void bh_test_cb(void *opaque)
|
|
{
|
|
BHTestData *data = opaque;
|
|
if (++data->n < data->max) {
|
|
qemu_bh_schedule(data->bh);
|
|
}
|
|
}
|
|
|
|
static void timer_test_cb(void *opaque)
|
|
{
|
|
TimerTestData *data = opaque;
|
|
if (++data->n < data->max) {
|
|
timer_mod(&data->timer,
|
|
qemu_clock_get_ns(data->clock_type) + data->ns);
|
|
}
|
|
}
|
|
|
|
static void dummy_io_handler_read(EventNotifier *e)
|
|
{
|
|
}
|
|
|
|
static void bh_delete_cb(void *opaque)
|
|
{
|
|
BHTestData *data = opaque;
|
|
if (++data->n < data->max) {
|
|
qemu_bh_schedule(data->bh);
|
|
} else {
|
|
qemu_bh_delete(data->bh);
|
|
data->bh = NULL;
|
|
}
|
|
}
|
|
|
|
static void event_ready_cb(EventNotifier *e)
|
|
{
|
|
EventNotifierTestData *data = container_of(e, EventNotifierTestData, e);
|
|
g_assert(event_notifier_test_and_clear(e));
|
|
data->n++;
|
|
if (data->active > 0) {
|
|
data->active--;
|
|
}
|
|
if (data->auto_set && data->active) {
|
|
event_notifier_set(e);
|
|
}
|
|
}
|
|
|
|
/* Tests using aio_*. */
|
|
|
|
typedef struct {
|
|
QemuMutex start_lock;
|
|
EventNotifier notifier;
|
|
bool thread_acquired;
|
|
} AcquireTestData;
|
|
|
|
static void *test_acquire_thread(void *opaque)
|
|
{
|
|
AcquireTestData *data = opaque;
|
|
|
|
/* Wait for other thread to let us start */
|
|
qemu_mutex_lock(&data->start_lock);
|
|
qemu_mutex_unlock(&data->start_lock);
|
|
|
|
/* event_notifier_set might be called either before or after
|
|
* the main thread's call to poll(). The test case's outcome
|
|
* should be the same in either case.
|
|
*/
|
|
event_notifier_set(&data->notifier);
|
|
aio_context_acquire(ctx);
|
|
aio_context_release(ctx);
|
|
|
|
data->thread_acquired = true; /* success, we got here */
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void set_event_notifier(AioContext *ctx, EventNotifier *notifier,
|
|
EventNotifierHandler *handler)
|
|
{
|
|
aio_set_event_notifier(ctx, notifier, false, handler, NULL);
|
|
}
|
|
|
|
static void dummy_notifier_read(EventNotifier *n)
|
|
{
|
|
event_notifier_test_and_clear(n);
|
|
}
|
|
|
|
static void test_acquire(void)
|
|
{
|
|
QemuThread thread;
|
|
AcquireTestData data;
|
|
|
|
/* Dummy event notifier ensures aio_poll() will block */
|
|
event_notifier_init(&data.notifier, false);
|
|
set_event_notifier(ctx, &data.notifier, dummy_notifier_read);
|
|
g_assert(!aio_poll(ctx, false)); /* consume aio_notify() */
|
|
|
|
qemu_mutex_init(&data.start_lock);
|
|
qemu_mutex_lock(&data.start_lock);
|
|
data.thread_acquired = false;
|
|
|
|
qemu_thread_create(&thread, "test_acquire_thread",
|
|
test_acquire_thread,
|
|
&data, QEMU_THREAD_JOINABLE);
|
|
|
|
/* Block in aio_poll(), let other thread kick us and acquire context */
|
|
aio_context_acquire(ctx);
|
|
qemu_mutex_unlock(&data.start_lock); /* let the thread run */
|
|
g_assert(aio_poll(ctx, true));
|
|
g_assert(!data.thread_acquired);
|
|
aio_context_release(ctx);
|
|
|
|
qemu_thread_join(&thread);
|
|
set_event_notifier(ctx, &data.notifier, NULL);
|
|
event_notifier_cleanup(&data.notifier);
|
|
|
|
g_assert(data.thread_acquired);
|
|
}
|
|
|
|
static void test_bh_schedule(void)
|
|
{
|
|
BHTestData data = { .n = 0 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(aio_poll(ctx, true));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
qemu_bh_delete(data.bh);
|
|
}
|
|
|
|
static void test_bh_schedule10(void)
|
|
{
|
|
BHTestData data = { .n = 0, .max = 10 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
g_assert(aio_poll(ctx, true));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
|
|
while (data.n < 10) {
|
|
aio_poll(ctx, true);
|
|
}
|
|
g_assert_cmpint(data.n, ==, 10);
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 10);
|
|
qemu_bh_delete(data.bh);
|
|
}
|
|
|
|
static void test_bh_cancel(void)
|
|
{
|
|
BHTestData data = { .n = 0 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
qemu_bh_cancel(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
qemu_bh_delete(data.bh);
|
|
}
|
|
|
|
static void test_bh_delete(void)
|
|
{
|
|
BHTestData data = { .n = 0 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
qemu_bh_delete(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
}
|
|
|
|
static void test_bh_delete_from_cb(void)
|
|
{
|
|
BHTestData data1 = { .n = 0, .max = 1 };
|
|
|
|
data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
|
|
|
|
qemu_bh_schedule(data1.bh);
|
|
g_assert_cmpint(data1.n, ==, 0);
|
|
|
|
while (data1.n < data1.max) {
|
|
aio_poll(ctx, true);
|
|
}
|
|
g_assert_cmpint(data1.n, ==, data1.max);
|
|
g_assert(data1.bh == NULL);
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
}
|
|
|
|
static void test_bh_delete_from_cb_many(void)
|
|
{
|
|
BHTestData data1 = { .n = 0, .max = 1 };
|
|
BHTestData data2 = { .n = 0, .max = 3 };
|
|
BHTestData data3 = { .n = 0, .max = 2 };
|
|
BHTestData data4 = { .n = 0, .max = 4 };
|
|
|
|
data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
|
|
data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2);
|
|
data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3);
|
|
data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4);
|
|
|
|
qemu_bh_schedule(data1.bh);
|
|
qemu_bh_schedule(data2.bh);
|
|
qemu_bh_schedule(data3.bh);
|
|
qemu_bh_schedule(data4.bh);
|
|
g_assert_cmpint(data1.n, ==, 0);
|
|
g_assert_cmpint(data2.n, ==, 0);
|
|
g_assert_cmpint(data3.n, ==, 0);
|
|
g_assert_cmpint(data4.n, ==, 0);
|
|
|
|
g_assert(aio_poll(ctx, false));
|
|
g_assert_cmpint(data1.n, ==, 1);
|
|
g_assert_cmpint(data2.n, ==, 1);
|
|
g_assert_cmpint(data3.n, ==, 1);
|
|
g_assert_cmpint(data4.n, ==, 1);
|
|
g_assert(data1.bh == NULL);
|
|
|
|
while (data1.n < data1.max ||
|
|
data2.n < data2.max ||
|
|
data3.n < data3.max ||
|
|
data4.n < data4.max) {
|
|
aio_poll(ctx, true);
|
|
}
|
|
g_assert_cmpint(data1.n, ==, data1.max);
|
|
g_assert_cmpint(data2.n, ==, data2.max);
|
|
g_assert_cmpint(data3.n, ==, data3.max);
|
|
g_assert_cmpint(data4.n, ==, data4.max);
|
|
g_assert(data1.bh == NULL);
|
|
g_assert(data2.bh == NULL);
|
|
g_assert(data3.bh == NULL);
|
|
g_assert(data4.bh == NULL);
|
|
}
|
|
|
|
static void test_bh_flush(void)
|
|
{
|
|
BHTestData data = { .n = 0 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(aio_poll(ctx, true));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
qemu_bh_delete(data.bh);
|
|
}
|
|
|
|
static void test_set_event_notifier(void)
|
|
{
|
|
EventNotifierTestData data = { .n = 0, .active = 0 };
|
|
event_notifier_init(&data.e, false);
|
|
set_event_notifier(ctx, &data.e, event_ready_cb);
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
|
|
static void test_wait_event_notifier(void)
|
|
{
|
|
EventNotifierTestData data = { .n = 0, .active = 1 };
|
|
event_notifier_init(&data.e, false);
|
|
set_event_notifier(ctx, &data.e, event_ready_cb);
|
|
while (aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
g_assert_cmpint(data.active, ==, 1);
|
|
|
|
event_notifier_set(&data.e);
|
|
g_assert(aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
g_assert_cmpint(data.active, ==, 0);
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
g_assert_cmpint(data.active, ==, 0);
|
|
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
|
|
static void test_flush_event_notifier(void)
|
|
{
|
|
EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
|
|
event_notifier_init(&data.e, false);
|
|
set_event_notifier(ctx, &data.e, event_ready_cb);
|
|
while (aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
g_assert_cmpint(data.active, ==, 10);
|
|
|
|
event_notifier_set(&data.e);
|
|
g_assert(aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
g_assert_cmpint(data.active, ==, 9);
|
|
g_assert(aio_poll(ctx, false));
|
|
|
|
wait_until_inactive(&data);
|
|
g_assert_cmpint(data.n, ==, 10);
|
|
g_assert_cmpint(data.active, ==, 0);
|
|
g_assert(!aio_poll(ctx, false));
|
|
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
g_assert(!aio_poll(ctx, false));
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
|
|
static void test_aio_external_client(void)
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 1; i < 3; i++) {
|
|
EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
|
|
event_notifier_init(&data.e, false);
|
|
aio_set_event_notifier(ctx, &data.e, true, event_ready_cb, NULL);
|
|
event_notifier_set(&data.e);
|
|
for (j = 0; j < i; j++) {
|
|
aio_disable_external(ctx);
|
|
}
|
|
for (j = 0; j < i; j++) {
|
|
assert(!aio_poll(ctx, false));
|
|
assert(event_notifier_test_and_clear(&data.e));
|
|
event_notifier_set(&data.e);
|
|
aio_enable_external(ctx);
|
|
}
|
|
assert(aio_poll(ctx, false));
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
}
|
|
|
|
static void test_wait_event_notifier_noflush(void)
|
|
{
|
|
EventNotifierTestData data = { .n = 0 };
|
|
EventNotifierTestData dummy = { .n = 0, .active = 1 };
|
|
|
|
event_notifier_init(&data.e, false);
|
|
set_event_notifier(ctx, &data.e, event_ready_cb);
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
/* Until there is an active descriptor, aio_poll may or may not call
|
|
* event_ready_cb. Still, it must not block. */
|
|
event_notifier_set(&data.e);
|
|
g_assert(aio_poll(ctx, true));
|
|
data.n = 0;
|
|
|
|
/* An active event notifier forces aio_poll to look at EventNotifiers. */
|
|
event_notifier_init(&dummy.e, false);
|
|
set_event_notifier(ctx, &dummy.e, event_ready_cb);
|
|
|
|
event_notifier_set(&data.e);
|
|
g_assert(aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
event_notifier_set(&data.e);
|
|
g_assert(aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
|
|
event_notifier_set(&dummy.e);
|
|
wait_until_inactive(&dummy);
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
g_assert_cmpint(dummy.n, ==, 1);
|
|
g_assert_cmpint(dummy.active, ==, 0);
|
|
|
|
set_event_notifier(ctx, &dummy.e, NULL);
|
|
event_notifier_cleanup(&dummy.e);
|
|
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
|
|
static void test_timer_schedule(void)
|
|
{
|
|
TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL,
|
|
.max = 2,
|
|
.clock_type = QEMU_CLOCK_REALTIME };
|
|
EventNotifier e;
|
|
|
|
/* aio_poll will not block to wait for timers to complete unless it has
|
|
* an fd to wait on. Fixing this breaks other tests. So create a dummy one.
|
|
*/
|
|
event_notifier_init(&e, false);
|
|
set_event_notifier(ctx, &e, dummy_io_handler_read);
|
|
aio_poll(ctx, false);
|
|
|
|
aio_timer_init(ctx, &data.timer, data.clock_type,
|
|
SCALE_NS, timer_test_cb, &data);
|
|
timer_mod(&data.timer,
|
|
qemu_clock_get_ns(data.clock_type) +
|
|
data.ns);
|
|
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
/* timer_mod may well cause an event notifer to have gone off,
|
|
* so clear that
|
|
*/
|
|
do {} while (aio_poll(ctx, false));
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_usleep(1 * G_USEC_PER_SEC);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
/* timer_mod called by our callback */
|
|
do {} while (aio_poll(ctx, false));
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
g_assert(aio_poll(ctx, true));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
|
|
/* As max is now 2, an event notifier should not have gone off */
|
|
|
|
g_assert(!aio_poll(ctx, false));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
|
|
set_event_notifier(ctx, &e, NULL);
|
|
event_notifier_cleanup(&e);
|
|
|
|
timer_del(&data.timer);
|
|
}
|
|
|
|
/* Now the same tests, using the context as a GSource. They are
|
|
* very similar to the ones above, with g_main_context_iteration
|
|
* replacing aio_poll. However:
|
|
* - sometimes both the AioContext and the glib main loop wake
|
|
* themselves up. Hence, some "g_assert(!aio_poll(ctx, false));"
|
|
* are replaced by "while (g_main_context_iteration(NULL, false));".
|
|
* - there is no exact replacement for a blocking wait.
|
|
* "while (g_main_context_iteration(NULL, true)" seems to work,
|
|
* but it is not documented _why_ it works. For these tests a
|
|
* non-blocking loop like "while (g_main_context_iteration(NULL, false)"
|
|
* works well, and that's what I am using.
|
|
*/
|
|
|
|
static void test_source_flush(void)
|
|
{
|
|
g_assert(!g_main_context_iteration(NULL, false));
|
|
aio_notify(ctx);
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert(!g_main_context_iteration(NULL, false));
|
|
}
|
|
|
|
static void test_source_bh_schedule(void)
|
|
{
|
|
BHTestData data = { .n = 0 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(g_main_context_iteration(NULL, true));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
g_assert(!g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
qemu_bh_delete(data.bh);
|
|
}
|
|
|
|
static void test_source_bh_schedule10(void)
|
|
{
|
|
BHTestData data = { .n = 0, .max = 10 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
g_assert(g_main_context_iteration(NULL, true));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 10);
|
|
|
|
g_assert(!g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 10);
|
|
qemu_bh_delete(data.bh);
|
|
}
|
|
|
|
static void test_source_bh_cancel(void)
|
|
{
|
|
BHTestData data = { .n = 0 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
qemu_bh_cancel(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
qemu_bh_delete(data.bh);
|
|
}
|
|
|
|
static void test_source_bh_delete(void)
|
|
{
|
|
BHTestData data = { .n = 0 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
qemu_bh_delete(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
}
|
|
|
|
static void test_source_bh_delete_from_cb(void)
|
|
{
|
|
BHTestData data1 = { .n = 0, .max = 1 };
|
|
|
|
data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
|
|
|
|
qemu_bh_schedule(data1.bh);
|
|
g_assert_cmpint(data1.n, ==, 0);
|
|
|
|
g_main_context_iteration(NULL, true);
|
|
g_assert_cmpint(data1.n, ==, data1.max);
|
|
g_assert(data1.bh == NULL);
|
|
|
|
assert(g_main_context_iteration(NULL, false));
|
|
assert(!g_main_context_iteration(NULL, false));
|
|
}
|
|
|
|
static void test_source_bh_delete_from_cb_many(void)
|
|
{
|
|
BHTestData data1 = { .n = 0, .max = 1 };
|
|
BHTestData data2 = { .n = 0, .max = 3 };
|
|
BHTestData data3 = { .n = 0, .max = 2 };
|
|
BHTestData data4 = { .n = 0, .max = 4 };
|
|
|
|
data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
|
|
data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2);
|
|
data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3);
|
|
data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4);
|
|
|
|
qemu_bh_schedule(data1.bh);
|
|
qemu_bh_schedule(data2.bh);
|
|
qemu_bh_schedule(data3.bh);
|
|
qemu_bh_schedule(data4.bh);
|
|
g_assert_cmpint(data1.n, ==, 0);
|
|
g_assert_cmpint(data2.n, ==, 0);
|
|
g_assert_cmpint(data3.n, ==, 0);
|
|
g_assert_cmpint(data4.n, ==, 0);
|
|
|
|
g_assert(g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data1.n, ==, 1);
|
|
g_assert_cmpint(data2.n, ==, 1);
|
|
g_assert_cmpint(data3.n, ==, 1);
|
|
g_assert_cmpint(data4.n, ==, 1);
|
|
g_assert(data1.bh == NULL);
|
|
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data1.n, ==, data1.max);
|
|
g_assert_cmpint(data2.n, ==, data2.max);
|
|
g_assert_cmpint(data3.n, ==, data3.max);
|
|
g_assert_cmpint(data4.n, ==, data4.max);
|
|
g_assert(data1.bh == NULL);
|
|
g_assert(data2.bh == NULL);
|
|
g_assert(data3.bh == NULL);
|
|
g_assert(data4.bh == NULL);
|
|
}
|
|
|
|
static void test_source_bh_flush(void)
|
|
{
|
|
BHTestData data = { .n = 0 };
|
|
data.bh = aio_bh_new(ctx, bh_test_cb, &data);
|
|
|
|
qemu_bh_schedule(data.bh);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(g_main_context_iteration(NULL, true));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
g_assert(!g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
qemu_bh_delete(data.bh);
|
|
}
|
|
|
|
static void test_source_set_event_notifier(void)
|
|
{
|
|
EventNotifierTestData data = { .n = 0, .active = 0 };
|
|
event_notifier_init(&data.e, false);
|
|
set_event_notifier(ctx, &data.e, event_ready_cb);
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
|
|
static void test_source_wait_event_notifier(void)
|
|
{
|
|
EventNotifierTestData data = { .n = 0, .active = 1 };
|
|
event_notifier_init(&data.e, false);
|
|
set_event_notifier(ctx, &data.e, event_ready_cb);
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
g_assert_cmpint(data.active, ==, 1);
|
|
|
|
event_notifier_set(&data.e);
|
|
g_assert(g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
g_assert_cmpint(data.active, ==, 0);
|
|
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
g_assert_cmpint(data.active, ==, 0);
|
|
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
|
|
static void test_source_flush_event_notifier(void)
|
|
{
|
|
EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
|
|
event_notifier_init(&data.e, false);
|
|
set_event_notifier(ctx, &data.e, event_ready_cb);
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
g_assert_cmpint(data.active, ==, 10);
|
|
|
|
event_notifier_set(&data.e);
|
|
g_assert(g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
g_assert_cmpint(data.active, ==, 9);
|
|
g_assert(g_main_context_iteration(NULL, false));
|
|
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 10);
|
|
g_assert_cmpint(data.active, ==, 0);
|
|
g_assert(!g_main_context_iteration(NULL, false));
|
|
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
while (g_main_context_iteration(NULL, false));
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
|
|
static void test_source_wait_event_notifier_noflush(void)
|
|
{
|
|
EventNotifierTestData data = { .n = 0 };
|
|
EventNotifierTestData dummy = { .n = 0, .active = 1 };
|
|
|
|
event_notifier_init(&data.e, false);
|
|
set_event_notifier(ctx, &data.e, event_ready_cb);
|
|
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
/* Until there is an active descriptor, glib may or may not call
|
|
* event_ready_cb. Still, it must not block. */
|
|
event_notifier_set(&data.e);
|
|
g_main_context_iteration(NULL, true);
|
|
data.n = 0;
|
|
|
|
/* An active event notifier forces aio_poll to look at EventNotifiers. */
|
|
event_notifier_init(&dummy.e, false);
|
|
set_event_notifier(ctx, &dummy.e, event_ready_cb);
|
|
|
|
event_notifier_set(&data.e);
|
|
g_assert(g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
g_assert(!g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
|
|
event_notifier_set(&data.e);
|
|
g_assert(g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
g_assert(!g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
|
|
event_notifier_set(&dummy.e);
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
g_assert_cmpint(dummy.n, ==, 1);
|
|
g_assert_cmpint(dummy.active, ==, 0);
|
|
|
|
set_event_notifier(ctx, &dummy.e, NULL);
|
|
event_notifier_cleanup(&dummy.e);
|
|
|
|
set_event_notifier(ctx, &data.e, NULL);
|
|
while (g_main_context_iteration(NULL, false));
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
|
|
event_notifier_cleanup(&data.e);
|
|
}
|
|
|
|
static void test_source_timer_schedule(void)
|
|
{
|
|
TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL,
|
|
.max = 2,
|
|
.clock_type = QEMU_CLOCK_REALTIME };
|
|
EventNotifier e;
|
|
int64_t expiry;
|
|
|
|
/* aio_poll will not block to wait for timers to complete unless it has
|
|
* an fd to wait on. Fixing this breaks other tests. So create a dummy one.
|
|
*/
|
|
event_notifier_init(&e, false);
|
|
set_event_notifier(ctx, &e, dummy_io_handler_read);
|
|
do {} while (g_main_context_iteration(NULL, false));
|
|
|
|
aio_timer_init(ctx, &data.timer, data.clock_type,
|
|
SCALE_NS, timer_test_cb, &data);
|
|
expiry = qemu_clock_get_ns(data.clock_type) +
|
|
data.ns;
|
|
timer_mod(&data.timer, expiry);
|
|
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_usleep(1 * G_USEC_PER_SEC);
|
|
g_assert_cmpint(data.n, ==, 0);
|
|
|
|
g_assert(g_main_context_iteration(NULL, true));
|
|
g_assert_cmpint(data.n, ==, 1);
|
|
expiry += data.ns;
|
|
|
|
while (data.n < 2) {
|
|
g_main_context_iteration(NULL, true);
|
|
}
|
|
|
|
g_assert_cmpint(data.n, ==, 2);
|
|
g_assert(qemu_clock_get_ns(data.clock_type) > expiry);
|
|
|
|
set_event_notifier(ctx, &e, NULL);
|
|
event_notifier_cleanup(&e);
|
|
|
|
timer_del(&data.timer);
|
|
}
|
|
|
|
/*
|
|
* Check that aio_co_enter() can chain many times
|
|
*
|
|
* Two coroutines should be able to invoke each other via aio_co_enter() many
|
|
* times without hitting a limit like stack exhaustion. In other words, the
|
|
* calls should be chained instead of nested.
|
|
*/
|
|
|
|
typedef struct {
|
|
Coroutine *other;
|
|
unsigned i;
|
|
unsigned max;
|
|
} ChainData;
|
|
|
|
static void coroutine_fn chain(void *opaque)
|
|
{
|
|
ChainData *data = opaque;
|
|
|
|
for (data->i = 0; data->i < data->max; data->i++) {
|
|
/* Queue up the other coroutine... */
|
|
aio_co_enter(ctx, data->other);
|
|
|
|
/* ...and give control to it */
|
|
qemu_coroutine_yield();
|
|
}
|
|
}
|
|
|
|
static void test_queue_chaining(void)
|
|
{
|
|
/* This number of iterations hit stack exhaustion in the past: */
|
|
ChainData data_a = { .max = 25000 };
|
|
ChainData data_b = { .max = 25000 };
|
|
|
|
data_b.other = qemu_coroutine_create(chain, &data_a);
|
|
data_a.other = qemu_coroutine_create(chain, &data_b);
|
|
|
|
qemu_coroutine_enter(data_b.other);
|
|
|
|
g_assert_cmpint(data_a.i, ==, data_a.max);
|
|
g_assert_cmpint(data_b.i, ==, data_b.max - 1);
|
|
|
|
/* Allow the second coroutine to terminate */
|
|
qemu_coroutine_enter(data_a.other);
|
|
|
|
g_assert_cmpint(data_b.i, ==, data_b.max);
|
|
}
|
|
|
|
/* End of tests. */
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
qemu_init_main_loop(&error_fatal);
|
|
ctx = qemu_get_aio_context();
|
|
|
|
while (g_main_context_iteration(NULL, false));
|
|
|
|
g_test_init(&argc, &argv, NULL);
|
|
g_test_add_func("/aio/acquire", test_acquire);
|
|
g_test_add_func("/aio/bh/schedule", test_bh_schedule);
|
|
g_test_add_func("/aio/bh/schedule10", test_bh_schedule10);
|
|
g_test_add_func("/aio/bh/cancel", test_bh_cancel);
|
|
g_test_add_func("/aio/bh/delete", test_bh_delete);
|
|
g_test_add_func("/aio/bh/callback-delete/one", test_bh_delete_from_cb);
|
|
g_test_add_func("/aio/bh/callback-delete/many", test_bh_delete_from_cb_many);
|
|
g_test_add_func("/aio/bh/flush", test_bh_flush);
|
|
g_test_add_func("/aio/event/add-remove", test_set_event_notifier);
|
|
g_test_add_func("/aio/event/wait", test_wait_event_notifier);
|
|
g_test_add_func("/aio/event/wait/no-flush-cb", test_wait_event_notifier_noflush);
|
|
g_test_add_func("/aio/event/flush", test_flush_event_notifier);
|
|
g_test_add_func("/aio/external-client", test_aio_external_client);
|
|
g_test_add_func("/aio/timer/schedule", test_timer_schedule);
|
|
|
|
g_test_add_func("/aio/coroutine/queue-chaining", test_queue_chaining);
|
|
|
|
g_test_add_func("/aio-gsource/flush", test_source_flush);
|
|
g_test_add_func("/aio-gsource/bh/schedule", test_source_bh_schedule);
|
|
g_test_add_func("/aio-gsource/bh/schedule10", test_source_bh_schedule10);
|
|
g_test_add_func("/aio-gsource/bh/cancel", test_source_bh_cancel);
|
|
g_test_add_func("/aio-gsource/bh/delete", test_source_bh_delete);
|
|
g_test_add_func("/aio-gsource/bh/callback-delete/one", test_source_bh_delete_from_cb);
|
|
g_test_add_func("/aio-gsource/bh/callback-delete/many", test_source_bh_delete_from_cb_many);
|
|
g_test_add_func("/aio-gsource/bh/flush", test_source_bh_flush);
|
|
g_test_add_func("/aio-gsource/event/add-remove", test_source_set_event_notifier);
|
|
g_test_add_func("/aio-gsource/event/wait", test_source_wait_event_notifier);
|
|
g_test_add_func("/aio-gsource/event/wait/no-flush-cb", test_source_wait_event_notifier_noflush);
|
|
g_test_add_func("/aio-gsource/event/flush", test_source_flush_event_notifier);
|
|
g_test_add_func("/aio-gsource/timer/schedule", test_source_timer_schedule);
|
|
return g_test_run();
|
|
}
|