/***********************************************************/
/* timers */
-struct QEMUClock {
- QEMUTimerList *main_loop_timerlist;
+typedef struct QEMUClock {
+ /* We rely on BQL to protect the timerlists */
QLIST_HEAD(, QEMUTimerList) timerlists;
NotifierList reset_notifiers;
QEMUClockType type;
bool enabled;
-};
+} QEMUClock;
QEMUTimerListGroup main_loop_tlg;
-QEMUClock *qemu_clocks[QEMU_CLOCK_MAX];
+static QEMUClock qemu_clocks[QEMU_CLOCK_MAX];
/* A QEMUTimerList is a list of timers attached to a clock. More
* than one QEMUTimerList can be attached to each clock, for instance
struct QEMUTimerList {
QEMUClock *clock;
+ QemuMutex active_timers_lock;
QEMUTimer *active_timers;
QLIST_ENTRY(QEMUTimerList) list;
QEMUTimerListNotifyCB *notify_cb;
void *notify_opaque;
+
+ /* lightweight method to mark the end of timerlist's running */
+ QemuEvent timers_done_ev;
};
+/**
+ * qemu_clock_ptr:
+ * @type: type of clock
+ *
+ * Translate a clock type into a pointer to QEMUClock object.
+ *
+ * Returns: a pointer to the QEMUClock object
+ */
+static inline QEMUClock *qemu_clock_ptr(QEMUClockType type)
+{
+ return &qemu_clocks[type];
+}
+
static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
{
return timer_head && (timer_head->expire_time <= current_time);
}
-static QEMUTimerList *timerlist_new_from_clock(QEMUClock *clock,
- QEMUTimerListNotifyCB *cb,
- void *opaque)
+QEMUTimerList *timerlist_new(QEMUClockType type,
+ QEMUTimerListNotifyCB *cb,
+ void *opaque)
{
QEMUTimerList *timer_list;
-
- /* Assert if we do not have a clock. If you see this
- * assertion in means that the clocks have not been
- * initialised before a timerlist is needed. This
- * normally happens if an AioContext is used before
- * init_clocks() is called within main().
- */
- assert(clock);
+ QEMUClock *clock = qemu_clock_ptr(type);
timer_list = g_malloc0(sizeof(QEMUTimerList));
+ qemu_event_init(&timer_list->timers_done_ev, false);
timer_list->clock = clock;
timer_list->notify_cb = cb;
timer_list->notify_opaque = opaque;
+ qemu_mutex_init(&timer_list->active_timers_lock);
QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list);
return timer_list;
}
-QEMUTimerList *timerlist_new(QEMUClockType type,
- QEMUTimerListNotifyCB *cb, void *opaque)
-{
- return timerlist_new_from_clock(qemu_clock_ptr(type), cb, opaque);
-}
-
void timerlist_free(QEMUTimerList *timer_list)
{
assert(!timerlist_has_timers(timer_list));
if (timer_list->clock) {
QLIST_REMOVE(timer_list, list);
- if (timer_list->clock->main_loop_timerlist == timer_list) {
- timer_list->clock->main_loop_timerlist = NULL;
- }
}
+ qemu_mutex_destroy(&timer_list->active_timers_lock);
g_free(timer_list);
}
-static QEMUClock *qemu_clock_new(QEMUClockType type)
+static void qemu_clock_init(QEMUClockType type)
{
- QEMUClock *clock;
+ QEMUClock *clock = qemu_clock_ptr(type);
+
+ /* Assert that the clock of type TYPE has not been initialized yet. */
+ assert(main_loop_tlg.tl[type] == NULL);
- clock = g_malloc0(sizeof(QEMUClock));
clock->type = type;
clock->enabled = true;
clock->last = INT64_MIN;
QLIST_INIT(&clock->timerlists);
notifier_list_init(&clock->reset_notifiers);
- clock->main_loop_timerlist = timerlist_new_from_clock(clock, NULL, NULL);
- return clock;
+ main_loop_tlg.tl[type] = timerlist_new(type, NULL, NULL);
}
-bool qemu_clock_use_for_deadline(QEMUClock *clock)
+bool qemu_clock_use_for_deadline(QEMUClockType type)
{
- return !(use_icount && (clock->type == QEMU_CLOCK_VIRTUAL));
+ return !(use_icount && (type == QEMU_CLOCK_VIRTUAL));
}
-void qemu_clock_notify(QEMUClock *clock)
+void qemu_clock_notify(QEMUClockType type)
{
QEMUTimerList *timer_list;
+ QEMUClock *clock = qemu_clock_ptr(type);
QLIST_FOREACH(timer_list, &clock->timerlists, list) {
timerlist_notify(timer_list);
}
}
-void qemu_clock_enable(QEMUClock *clock, bool enabled)
+/* Disabling the clock will wait for related timerlists to stop
+ * executing qemu_run_timers. Thus, this functions should not
+ * be used from the callback of a timer that is based on @clock.
+ * Doing so would cause a deadlock.
+ *
+ * Caller should hold BQL.
+ */
+void qemu_clock_enable(QEMUClockType type, bool enabled)
{
+ QEMUClock *clock = qemu_clock_ptr(type);
+ QEMUTimerList *tl;
bool old = clock->enabled;
clock->enabled = enabled;
if (enabled && !old) {
- qemu_clock_notify(clock);
+ qemu_clock_notify(type);
+ } else if (!enabled && old) {
+ QLIST_FOREACH(tl, &clock->timerlists, list) {
+ qemu_event_wait(&tl->timers_done_ev);
+ }
}
}
return !!timer_list->active_timers;
}
-bool qemu_clock_has_timers(QEMUClock *clock)
+bool qemu_clock_has_timers(QEMUClockType type)
{
- return timerlist_has_timers(clock->main_loop_timerlist);
+ return timerlist_has_timers(
+ main_loop_tlg.tl[type]);
}
bool timerlist_expired(QEMUTimerList *timer_list)
{
- return (timer_list->active_timers &&
- timer_list->active_timers->expire_time <
- qemu_get_clock_ns(timer_list->clock));
-}
-
-bool qemu_clock_expired(QEMUClock *clock)
-{
- return timerlist_expired(clock->main_loop_timerlist);
-}
-
-int64_t timerlist_deadline(QEMUTimerList *timer_list)
-{
- /* To avoid problems with overflow limit this to 2^32. */
- int64_t delta = INT32_MAX;
+ int64_t expire_time;
- if (timer_list->clock->enabled && timer_list->active_timers) {
- delta = timer_list->active_timers->expire_time -
- qemu_get_clock_ns(timer_list->clock);
- }
- if (delta < 0) {
- delta = 0;
+ qemu_mutex_lock(&timer_list->active_timers_lock);
+ if (!timer_list->active_timers) {
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
+ return false;
}
- return delta;
+ expire_time = timer_list->active_timers->expire_time;
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
+
+ return expire_time < qemu_clock_get_ns(timer_list->clock->type);
}
-int64_t qemu_clock_deadline(QEMUClock *clock)
+bool qemu_clock_expired(QEMUClockType type)
{
- return timerlist_deadline(clock->main_loop_timerlist);
+ return timerlist_expired(
+ main_loop_tlg.tl[type]);
}
/*
int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
{
int64_t delta;
+ int64_t expire_time;
+
+ if (!timer_list->clock->enabled) {
+ return -1;
+ }
- if (!timer_list->clock->enabled || !timer_list->active_timers) {
+ /* The active timers list may be modified before the caller uses our return
+ * value but ->notify_cb() is called when the deadline changes. Therefore
+ * the caller should notice the change and there is no race condition.
+ */
+ qemu_mutex_lock(&timer_list->active_timers_lock);
+ if (!timer_list->active_timers) {
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
return -1;
}
+ expire_time = timer_list->active_timers->expire_time;
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
- delta = timer_list->active_timers->expire_time -
- qemu_get_clock_ns(timer_list->clock);
+ delta = expire_time - qemu_clock_get_ns(timer_list->clock->type);
if (delta <= 0) {
return 0;
return delta;
}
-int64_t qemu_clock_deadline_ns(QEMUClock *clock)
-{
- return timerlist_deadline_ns(clock->main_loop_timerlist);
-}
-
/* Calculate the soonest deadline across all timerlists attached
* to the clock. This is used for the icount timeout so we
* ignore whether or not the clock should be used in deadline
* calculations.
*/
-int64_t qemu_clock_deadline_ns_all(QEMUClock *clock)
+int64_t qemu_clock_deadline_ns_all(QEMUClockType type)
{
int64_t deadline = -1;
QEMUTimerList *timer_list;
+ QEMUClock *clock = qemu_clock_ptr(type);
QLIST_FOREACH(timer_list, &clock->timerlists, list) {
deadline = qemu_soonest_timeout(deadline,
timerlist_deadline_ns(timer_list));
return deadline;
}
-QEMUClock *timerlist_get_clock(QEMUTimerList *timer_list)
+QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list)
{
- return timer_list->clock;
+ return timer_list->clock->type;
}
-QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClock *clock)
+QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type)
{
- return clock->main_loop_timerlist;
+ return main_loop_tlg.tl[type];
}
void timerlist_notify(QEMUTimerList *timer_list)
ts->cb = cb;
ts->opaque = opaque;
ts->scale = scale;
+ ts->expire_time = -1;
}
-QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
- QEMUTimerCB *cb, void *opaque)
-{
- return timer_new_tl(clock->main_loop_timerlist,
- scale, cb, opaque);
-}
-
-void qemu_free_timer(QEMUTimer *ts)
+void timer_free(QEMUTimer *ts)
{
g_free(ts);
}
-/* stop a timer, but do not dealloc it */
-void qemu_del_timer(QEMUTimer *ts)
+static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts)
{
QEMUTimer **pt, *t;
- /* NOTE: this code must be signal safe because
- timer_expired() can be called from a signal. */
- pt = &ts->timer_list->active_timers;
+ ts->expire_time = -1;
+ pt = &timer_list->active_timers;
for(;;) {
t = *pt;
if (!t)
}
}
-/* modify the current timer so that it will be fired when current_time
- >= expire_time. The corresponding callback will be called. */
-void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
+static bool timer_mod_ns_locked(QEMUTimerList *timer_list,
+ QEMUTimer *ts, int64_t expire_time)
{
QEMUTimer **pt, *t;
- qemu_del_timer(ts);
-
/* add the timer in the sorted list */
- /* NOTE: this code must be signal safe because
- timer_expired() can be called from a signal. */
- pt = &ts->timer_list->active_timers;
- for(;;) {
+ pt = &timer_list->active_timers;
+ for (;;) {
t = *pt;
if (!timer_expired_ns(t, expire_time)) {
break;
}
pt = &t->next;
}
- ts->expire_time = expire_time;
+ ts->expire_time = MAX(expire_time, 0);
ts->next = *pt;
*pt = ts;
- /* Rearm if necessary */
- if (pt == &ts->timer_list->active_timers) {
- /* Interrupt execution to force deadline recalculation. */
- qemu_clock_warp(ts->timer_list->clock);
- timerlist_notify(ts->timer_list);
- }
+ return pt == &timer_list->active_timers;
}
-void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
+static void timerlist_rearm(QEMUTimerList *timer_list)
{
- qemu_mod_timer_ns(ts, expire_time * ts->scale);
+ /* Interrupt execution to force deadline recalculation. */
+ qemu_clock_warp(timer_list->clock->type);
+ timerlist_notify(timer_list);
}
-bool timer_pending(QEMUTimer *ts)
+/* stop a timer, but do not dealloc it */
+void timer_del(QEMUTimer *ts)
{
- QEMUTimer *t;
- for (t = ts->timer_list->active_timers; t != NULL; t = t->next) {
- if (t == ts) {
- return true;
+ QEMUTimerList *timer_list = ts->timer_list;
+
+ qemu_mutex_lock(&timer_list->active_timers_lock);
+ timer_del_locked(timer_list, ts);
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
+}
+
+/* modify the current timer so that it will be fired when current_time
+ >= expire_time. The corresponding callback will be called. */
+void timer_mod_ns(QEMUTimer *ts, int64_t expire_time)
+{
+ QEMUTimerList *timer_list = ts->timer_list;
+ bool rearm;
+
+ qemu_mutex_lock(&timer_list->active_timers_lock);
+ timer_del_locked(timer_list, ts);
+ rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
+
+ if (rearm) {
+ timerlist_rearm(timer_list);
+ }
+}
+
+/* modify the current timer so that it will be fired when current_time
+ >= expire_time or the current deadline, whichever comes earlier.
+ The corresponding callback will be called. */
+void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time)
+{
+ QEMUTimerList *timer_list = ts->timer_list;
+ bool rearm;
+
+ qemu_mutex_lock(&timer_list->active_timers_lock);
+ if (ts->expire_time == -1 || ts->expire_time > expire_time) {
+ if (ts->expire_time != -1) {
+ timer_del_locked(timer_list, ts);
}
+ rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
+ } else {
+ rearm = false;
+ }
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
+
+ if (rearm) {
+ timerlist_rearm(timer_list);
}
- return false;
+}
+
+void timer_mod(QEMUTimer *ts, int64_t expire_time)
+{
+ timer_mod_ns(ts, expire_time * ts->scale);
+}
+
+void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time)
+{
+ timer_mod_anticipate_ns(ts, expire_time * ts->scale);
+}
+
+bool timer_pending(QEMUTimer *ts)
+{
+ return ts->expire_time >= 0;
}
bool timer_expired(QEMUTimer *timer_head, int64_t current_time)
QEMUTimer *ts;
int64_t current_time;
bool progress = false;
-
+ QEMUTimerCB *cb;
+ void *opaque;
+
+ qemu_event_reset(&timer_list->timers_done_ev);
if (!timer_list->clock->enabled) {
- return progress;
+ goto out;
}
- current_time = qemu_get_clock_ns(timer_list->clock);
+ current_time = qemu_clock_get_ns(timer_list->clock->type);
for(;;) {
+ qemu_mutex_lock(&timer_list->active_timers_lock);
ts = timer_list->active_timers;
if (!timer_expired_ns(ts, current_time)) {
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
break;
}
+
/* remove timer from the list before calling the callback */
timer_list->active_timers = ts->next;
ts->next = NULL;
+ ts->expire_time = -1;
+ cb = ts->cb;
+ opaque = ts->opaque;
+ qemu_mutex_unlock(&timer_list->active_timers_lock);
/* run the callback (the timer list can be modified) */
- ts->cb(ts->opaque);
+ cb(opaque);
progress = true;
}
+
+out:
+ qemu_event_set(&timer_list->timers_done_ev);
return progress;
}
-bool qemu_run_timers(QEMUClock *clock)
+bool qemu_clock_run_timers(QEMUClockType type)
{
- return timerlist_run_timers(clock->main_loop_timerlist);
+ return timerlist_run_timers(main_loop_tlg.tl[type]);
}
void timerlistgroup_init(QEMUTimerListGroup *tlg,
int64_t deadline = -1;
QEMUClockType type;
for (type = 0; type < QEMU_CLOCK_MAX; type++) {
- if (qemu_clock_use_for_deadline(tlg->tl[type]->clock)) {
+ if (qemu_clock_use_for_deadline(tlg->tl[type]->clock->type)) {
deadline = qemu_soonest_timeout(deadline,
timerlist_deadline_ns(
tlg->tl[type]));
return deadline;
}
-int64_t qemu_get_clock_ns(QEMUClock *clock)
+int64_t qemu_clock_get_ns(QEMUClockType type)
{
int64_t now, last;
+ QEMUClock *clock = qemu_clock_ptr(type);
- switch(clock->type) {
+ switch (type) {
case QEMU_CLOCK_REALTIME:
return get_clock();
default:
}
}
-void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
+void qemu_clock_register_reset_notifier(QEMUClockType type,
+ Notifier *notifier)
{
+ QEMUClock *clock = qemu_clock_ptr(type);
notifier_list_add(&clock->reset_notifiers, notifier);
}
-void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
+void qemu_clock_unregister_reset_notifier(QEMUClockType type,
+ Notifier *notifier)
{
notifier_remove(notifier);
}
{
QEMUClockType type;
for (type = 0; type < QEMU_CLOCK_MAX; type++) {
- if (!qemu_clocks[type]) {
- qemu_clocks[type] = qemu_clock_new(type);
- main_loop_tlg.tl[type] = qemu_clocks[type]->main_loop_timerlist;
- }
+ qemu_clock_init(type);
}
#ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
return timer_pending(ts) ? ts->expire_time : -1;
}
-bool qemu_run_all_timers(void)
+bool qemu_clock_run_all_timers(void)
{
bool progress = false;
QEMUClockType type;
for (type = 0; type < QEMU_CLOCK_MAX; type++) {
- progress |= qemu_run_timers(qemu_clock_ptr(type));
+ progress |= qemu_clock_run_timers(type);
}
return progress;
projects / qemu.git / blobdiff