Commit 3d692649 authored by Vladimir Sementsov-Ogievskiy's avatar Vladimir Sementsov-Ogievskiy Committed by Eric Blake
Browse files

qemu-coroutine-sleep: introduce qemu_co_sleep_wake 



Introduce a function to gracefully wake a coroutine sleeping in
qemu_co_sleep_ns().

Signed-off-by: default avatarVladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: default avatarKevin Wolf <kwolf@redhat.com>
Reviewed-by: default avatarEric Blake <eblake@redhat.com>
Message-Id: <20191009084158.15614-2-vsementsov@virtuozzo.com>
Signed-off-by: default avatarEric Blake <eblake@redhat.com>
parent f9bec781

include/qemu/coroutine.h

+21 −2
Original line number Diff line number Diff line
@@ -273,10 +273,29 @@ void qemu_co_rwlock_wrlock(CoRwlock *lock); 
 */

void qemu_co_rwlock_unlock(CoRwlock *lock);



typedef struct QemuCoSleepState QemuCoSleepState;



/**

 * Yield the coroutine for a given duration. During this yield, @sleep_state

 * (if not NULL) is set to an opaque pointer, which may be used for

 * qemu_co_sleep_wake(). Be careful, the pointer is set back to zero when the

 * timer fires. Don't save the obtained value to other variables and don't call

 * qemu_co_sleep_wake from another aio context.

 */

void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,

                                            QemuCoSleepState **sleep_state);

static inline void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)

{

    qemu_co_sleep_ns_wakeable(type, ns, NULL);

}



/**

 * Yield the coroutine for a given duration

 * Wake a coroutine if it is sleeping in qemu_co_sleep_ns. The timer will be

 * deleted. @sleep_state must be the variable whose address was given to

 * qemu_co_sleep_ns() and should be checked to be non-NULL before calling

 * qemu_co_sleep_wake().

 */

void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns);

void qemu_co_sleep_wake(QemuCoSleepState *sleep_state);



/**

 * Yield until a file descriptor becomes readable

util/qemu-coroutine-sleep.c

+38 −13
Original line number Diff line number Diff line
@@ -17,31 +17,56 @@ 
#include "qemu/timer.h"

#include "block/aio.h"



static void co_sleep_cb(void *opaque)

{

    Coroutine *co = opaque;

static const char *qemu_co_sleep_ns__scheduled = "qemu_co_sleep_ns";



struct QemuCoSleepState {

    Coroutine *co;

    QEMUTimer *ts;

    QemuCoSleepState **user_state_pointer;

};



void qemu_co_sleep_wake(QemuCoSleepState *sleep_state)

{

    /* Write of schedule protected by barrier write in aio_co_schedule */

    atomic_set(&co->scheduled, NULL);

    aio_co_wake(co);

    const char *scheduled = atomic_cmpxchg(&sleep_state->co->scheduled,

                                           qemu_co_sleep_ns__scheduled, NULL);



    assert(scheduled == qemu_co_sleep_ns__scheduled);

    if (sleep_state->user_state_pointer) {

        *sleep_state->user_state_pointer = NULL;

    }

    timer_del(sleep_state->ts);

    aio_co_wake(sleep_state->co);

}



void coroutine_fn qemu_co_sleep_ns(QEMUClockType type, int64_t ns)

static void co_sleep_cb(void *opaque)

{

    qemu_co_sleep_wake(opaque);

}



void coroutine_fn qemu_co_sleep_ns_wakeable(QEMUClockType type, int64_t ns,

                                            QemuCoSleepState **sleep_state)

{

    AioContext *ctx = qemu_get_current_aio_context();

    QEMUTimer *ts;

    Coroutine *co = qemu_coroutine_self();

    QemuCoSleepState state = {

        .co = qemu_coroutine_self(),

        .ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &state),

        .user_state_pointer = sleep_state,

    };



    const char *scheduled = atomic_cmpxchg(&co->scheduled, NULL, __func__);

    const char *scheduled = atomic_cmpxchg(&state.co->scheduled, NULL,

                                           qemu_co_sleep_ns__scheduled);

    if (scheduled) {

        fprintf(stderr,

                "%s: Co-routine was already scheduled in '%s'\n",

                __func__, scheduled);

        abort();

    }

    ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, co);

    timer_mod(ts, qemu_clock_get_ns(type) + ns);



    if (sleep_state) {

        *sleep_state = &state;

    }

    timer_mod(state.ts, qemu_clock_get_ns(type) + ns);

    qemu_coroutine_yield();

    timer_del(ts);

    timer_free(ts);

    timer_free(state.ts);

}