Commit a0710f79 authored by Paolo Bonzini's avatar Paolo Bonzini Committed by Kevin Wolf
Browse files

iothread: release iothread around aio_poll 



This is the first step towards having fine-grained critical sections in
dataplane threads, which resolves lock ordering problems between
address_space_* functions (which need the BQL when doing MMIO, even
after we complete RCU-based dispatch) and the AioContext.

Because AioContext does not use contention callbacks anymore, the
unit test has to be changed.

Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
Reviewed-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Message-id: 1424449612-18215-4-git-send-email-pbonzini@redhat.com
Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parent 49110174

async.c

+1 −7
Original line number Diff line number Diff line
@@ -280,12 +280,6 @@ static void aio_timerlist_notify(void *opaque) 
    aio_notify(opaque);

}



static void aio_rfifolock_cb(void *opaque)

{

    /* Kick owner thread in case they are blocked in aio_poll() */

    aio_notify(opaque);

}



AioContext *aio_context_new(Error **errp)

{

    int ret;
@@ -303,7 +297,7 @@ AioContext *aio_context_new(Error **errp) 
                           event_notifier_test_and_clear);

    ctx->thread_pool = NULL;

    qemu_mutex_init(&ctx->bh_lock);

    rfifolock_init(&ctx->lock, aio_rfifolock_cb, ctx);

    rfifolock_init(&ctx->lock, NULL, NULL);

    timerlistgroup_init(&ctx->tlg, aio_timerlist_notify, ctx);



    return ctx;

iothread.c

+2 −9
Original line number Diff line number Diff line
@@ -31,21 +31,14 @@ typedef ObjectClass IOThreadClass; 
static void *iothread_run(void *opaque)

{

    IOThread *iothread = opaque;

    bool blocking;



    qemu_mutex_lock(&iothread->init_done_lock);

    iothread->thread_id = qemu_get_thread_id();

    qemu_cond_signal(&iothread->init_done_cond);

    qemu_mutex_unlock(&iothread->init_done_lock);



    while (!iothread->stopping) {

        aio_context_acquire(iothread->ctx);

        blocking = true;

        while (!iothread->stopping && aio_poll(iothread->ctx, blocking)) {

            /* Progress was made, keep going */

            blocking = false;

        }

        aio_context_release(iothread->ctx);

    while (!atomic_read(&iothread->stopping)) {

        aio_poll(iothread->ctx, true);

    }

    return NULL;

}

tests/test-aio.c

+11 −8
Original line number Diff line number Diff line
@@ -107,6 +107,7 @@ static void test_notify(void) 


typedef struct {

    QemuMutex start_lock;

    EventNotifier notifier;

    bool thread_acquired;

} AcquireTestData;
@@ -118,6 +119,8 @@ static void *test_acquire_thread(void *opaque) 
    qemu_mutex_lock(&data->start_lock);

    qemu_mutex_unlock(&data->start_lock);



    g_usleep(500000);

    event_notifier_set(&data->notifier);

    aio_context_acquire(ctx);

    aio_context_release(ctx);
@@ -126,20 +129,19 @@ static void *test_acquire_thread(void *opaque) 
    return NULL;

}



static void dummy_notifier_read(EventNotifier *unused)

static void dummy_notifier_read(EventNotifier *n)

{

    g_assert(false); /* should never be invoked */

    event_notifier_test_and_clear(n);

}



static void test_acquire(void)

{

    QemuThread thread;

    EventNotifier notifier;

    AcquireTestData data;



    /* Dummy event notifier ensures aio_poll() will block */

    event_notifier_init(&notifier, false);

    aio_set_event_notifier(ctx, &notifier, dummy_notifier_read);

    event_notifier_init(&data.notifier, false);

    aio_set_event_notifier(ctx, &data.notifier, dummy_notifier_read);

    g_assert(!aio_poll(ctx, false)); /* consume aio_notify() */



    qemu_mutex_init(&data.start_lock);
@@ -153,12 +155,13 @@ static void test_acquire(void) 
    /* 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(aio_poll(ctx, true));

    g_assert(!data.thread_acquired);

    aio_context_release(ctx);



    qemu_thread_join(&thread);

    aio_set_event_notifier(ctx, &notifier, NULL);

    event_notifier_cleanup(&notifier);

    aio_set_event_notifier(ctx, &data.notifier, NULL);

    event_notifier_cleanup(&data.notifier);



    g_assert(data.thread_acquired);

}