xemu-project/xemu
1
0
Fork 0
mirror of https://github.com/xemu-project/xemu.git synced 2024-11-24 03:59:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

qemu-coroutine-sleep: introduce qemu_co_sleep_wake

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

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20191009084158.15614-2-vsementsov@virtuozzo.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2019-10-09 11:41:56 +03:00 committed by Eric Blake
parent f9bec78137
commit 3d692649d1
2 changed files with 59 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/qemu/coroutine.h
View File

@ -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
* 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(QEMUClockType type, int64_t ns);
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);
}
/**
* 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 qemu_co_sleep_wake(QemuCoSleepState *sleep_state);
/**
* Yield until a file descriptor becomes readable

53
util/qemu-coroutine-sleep.c
View File

@ -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);
qemu_coroutine_yield();
timer_del(ts);
timer_free(ts);
if (sleep_state) {
*sleep_state = &state;
}
timer_mod(state.ts, qemu_clock_get_ns(type) + ns);
qemu_coroutine_yield();
timer_free(state.ts);
}