Commit 40daca54 authored by Alex Bligh's avatar Alex Bligh Committed by Stefan Hajnoczi
Browse files

aio / timers: Rearrange timer.h & make legacy functions call non-legacy



Rearrange timer.h so it is in order by function type.

Make legacy functions call non-legacy functions rather than vice-versa.

Convert cpus.c to use new API.
Signed-off-by: default avatarAlex Bligh <alex@alex.org.uk>
Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
parent 55a197da
...@@ -207,7 +207,7 @@ static void icount_adjust(void) ...@@ -207,7 +207,7 @@ static void icount_adjust(void)
return; return;
} }
cur_time = cpu_get_clock(); cur_time = cpu_get_clock();
cur_icount = qemu_get_clock_ns(vm_clock); cur_icount = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
delta = cur_icount - cur_time; delta = cur_icount - cur_time;
/* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */ /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
if (delta > 0 if (delta > 0
...@@ -228,15 +228,16 @@ static void icount_adjust(void) ...@@ -228,15 +228,16 @@ static void icount_adjust(void)
static void icount_adjust_rt(void *opaque) static void icount_adjust_rt(void *opaque)
{ {
qemu_mod_timer(icount_rt_timer, timer_mod(icount_rt_timer,
qemu_get_clock_ms(rt_clock) + 1000); qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
icount_adjust(); icount_adjust();
} }
static void icount_adjust_vm(void *opaque) static void icount_adjust_vm(void *opaque)
{ {
qemu_mod_timer(icount_vm_timer, timer_mod(icount_vm_timer,
qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10); qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
get_ticks_per_sec() / 10);
icount_adjust(); icount_adjust();
} }
...@@ -252,22 +253,22 @@ static void icount_warp_rt(void *opaque) ...@@ -252,22 +253,22 @@ static void icount_warp_rt(void *opaque)
} }
if (runstate_is_running()) { if (runstate_is_running()) {
int64_t clock = qemu_get_clock_ns(rt_clock); int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
int64_t warp_delta = clock - vm_clock_warp_start; int64_t warp_delta = clock - vm_clock_warp_start;
if (use_icount == 1) { if (use_icount == 1) {
qemu_icount_bias += warp_delta; qemu_icount_bias += warp_delta;
} else { } else {
/* /*
* In adaptive mode, do not let the vm_clock run too * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
* far ahead of real time. * far ahead of real time.
*/ */
int64_t cur_time = cpu_get_clock(); int64_t cur_time = cpu_get_clock();
int64_t cur_icount = qemu_get_clock_ns(vm_clock); int64_t cur_icount = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
int64_t delta = cur_time - cur_icount; int64_t delta = cur_time - cur_icount;
qemu_icount_bias += MIN(warp_delta, delta); qemu_icount_bias += MIN(warp_delta, delta);
} }
if (qemu_clock_expired(vm_clock)) { if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
qemu_clock_notify(vm_clock); qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
} }
} }
vm_clock_warp_start = -1; vm_clock_warp_start = -1;
...@@ -275,19 +276,19 @@ static void icount_warp_rt(void *opaque) ...@@ -275,19 +276,19 @@ static void icount_warp_rt(void *opaque)
void qtest_clock_warp(int64_t dest) void qtest_clock_warp(int64_t dest)
{ {
int64_t clock = qemu_get_clock_ns(vm_clock); int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
assert(qtest_enabled()); assert(qtest_enabled());
while (clock < dest) { while (clock < dest) {
int64_t deadline = qemu_clock_deadline_ns_all(vm_clock); int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
int64_t warp = MIN(dest - clock, deadline); int64_t warp = MIN(dest - clock, deadline);
qemu_icount_bias += warp; qemu_icount_bias += warp;
qemu_run_timers(vm_clock); qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
clock = qemu_get_clock_ns(vm_clock); clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
} }
qemu_clock_notify(vm_clock); qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
} }
void qemu_clock_warp(QEMUClock *clock) void qemu_clock_warp(QEMUClockType type)
{ {
int64_t deadline; int64_t deadline;
...@@ -296,20 +297,20 @@ void qemu_clock_warp(QEMUClock *clock) ...@@ -296,20 +297,20 @@ void qemu_clock_warp(QEMUClock *clock)
* applicable to other clocks. But a clock argument removes the * applicable to other clocks. But a clock argument removes the
* need for if statements all over the place. * need for if statements all over the place.
*/ */
if (clock != vm_clock || !use_icount) { if (type != QEMU_CLOCK_VIRTUAL || !use_icount) {
return; return;
} }
/* /*
* If the CPUs have been sleeping, advance the vm_clock timer now. This * If the CPUs have been sleeping, advance QEMU_CLOCK_VIRTUAL timer now.
* ensures that the deadline for the timer is computed correctly below. * This ensures that the deadline for the timer is computed correctly below.
* This also makes sure that the insn counter is synchronized before the * This also makes sure that the insn counter is synchronized before the
* CPU starts running, in case the CPU is woken by an event other than * CPU starts running, in case the CPU is woken by an event other than
* the earliest vm_clock timer. * the earliest QEMU_CLOCK_VIRTUAL timer.
*/ */
icount_warp_rt(NULL); icount_warp_rt(NULL);
if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock)) { if (!all_cpu_threads_idle() || !qemu_clock_has_timers(QEMU_CLOCK_VIRTUAL)) {
qemu_del_timer(icount_warp_timer); timer_del(icount_warp_timer);
return; return;
} }
...@@ -318,12 +319,12 @@ void qemu_clock_warp(QEMUClock *clock) ...@@ -318,12 +319,12 @@ void qemu_clock_warp(QEMUClock *clock)
return; return;
} }
vm_clock_warp_start = qemu_get_clock_ns(rt_clock); vm_clock_warp_start = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
/* We want to use the earliest deadline from ALL vm_clocks */ /* We want to use the earliest deadline from ALL vm_clocks */
deadline = qemu_clock_deadline_ns_all(vm_clock); deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
/* Maintain prior (possibly buggy) behaviour where if no deadline /* Maintain prior (possibly buggy) behaviour where if no deadline
* was set (as there is no vm_clock timer) or it is more than * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
* INT32_MAX nanoseconds ahead, we still use INT32_MAX * INT32_MAX nanoseconds ahead, we still use INT32_MAX
* nanoseconds. * nanoseconds.
*/ */
...@@ -333,24 +334,25 @@ void qemu_clock_warp(QEMUClock *clock) ...@@ -333,24 +334,25 @@ void qemu_clock_warp(QEMUClock *clock)
if (deadline > 0) { if (deadline > 0) {
/* /*
* Ensure the vm_clock proceeds even when the virtual CPU goes to * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
* sleep. Otherwise, the CPU might be waiting for a future timer * sleep. Otherwise, the CPU might be waiting for a future timer
* interrupt to wake it up, but the interrupt never comes because * interrupt to wake it up, but the interrupt never comes because
* the vCPU isn't running any insns and thus doesn't advance the * the vCPU isn't running any insns and thus doesn't advance the
* vm_clock. * QEMU_CLOCK_VIRTUAL.
* *
* An extreme solution for this problem would be to never let VCPUs * An extreme solution for this problem would be to never let VCPUs
* sleep in icount mode if there is a pending vm_clock timer; rather * sleep in icount mode if there is a pending QEMU_CLOCK_VIRTUAL
* time could just advance to the next vm_clock event. Instead, we * timer; rather time could just advance to the next QEMU_CLOCK_VIRTUAL
* do stop VCPUs and only advance vm_clock after some "real" time, * event. Instead, we do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL
* (related to the time left until the next event) has passed. This * after some e"real" time, (related to the time left until the next
* rt_clock timer will do this. This avoids that the warps are too * event) has passed. The QEMU_CLOCK_REALTIME timer will do this.
* visible externally---for example, you will not be sending network * This avoids that the warps are visible externally; for example,
* packets continuously instead of every 100ms. * you will not be sending network packets continuously instead of
* every 100ms.
*/ */
qemu_mod_timer(icount_warp_timer, vm_clock_warp_start + deadline); timer_mod(icount_warp_timer, vm_clock_warp_start + deadline);
} else if (deadline == 0) { } else if (deadline == 0) {
qemu_clock_notify(vm_clock); qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
} }
} }
...@@ -374,7 +376,8 @@ void configure_icount(const char *option) ...@@ -374,7 +376,8 @@ void configure_icount(const char *option)
return; return;
} }
icount_warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL); icount_warp_timer = timer_new_ns(QEMU_CLOCK_REALTIME,
icount_warp_rt, NULL);
if (strcmp(option, "auto") != 0) { if (strcmp(option, "auto") != 0) {
icount_time_shift = strtol(option, NULL, 0); icount_time_shift = strtol(option, NULL, 0);
use_icount = 1; use_icount = 1;
...@@ -392,12 +395,15 @@ void configure_icount(const char *option) ...@@ -392,12 +395,15 @@ void configure_icount(const char *option)
the virtual time trigger catches emulated time passing too fast. the virtual time trigger catches emulated time passing too fast.
Realtime triggers occur even when idle, so use them less frequently Realtime triggers occur even when idle, so use them less frequently
than VM triggers. */ than VM triggers. */
icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL); icount_rt_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
qemu_mod_timer(icount_rt_timer, icount_adjust_rt, NULL);
qemu_get_clock_ms(rt_clock) + 1000); timer_mod(icount_rt_timer,
icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL); qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
qemu_mod_timer(icount_vm_timer, icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10); icount_adjust_vm, NULL);
timer_mod(icount_vm_timer,
qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
get_ticks_per_sec() / 10);
} }
/***********************************************************/ /***********************************************************/
...@@ -746,7 +752,7 @@ static void qemu_tcg_wait_io_event(void) ...@@ -746,7 +752,7 @@ static void qemu_tcg_wait_io_event(void)
while (all_cpu_threads_idle()) { while (all_cpu_threads_idle()) {
/* Start accounting real time to the virtual clock if the CPUs /* Start accounting real time to the virtual clock if the CPUs
are idle. */ are idle. */
qemu_clock_warp(vm_clock); qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex); qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
} }
...@@ -879,10 +885,10 @@ static void *qemu_tcg_cpu_thread_fn(void *arg) ...@@ -879,10 +885,10 @@ static void *qemu_tcg_cpu_thread_fn(void *arg)
tcg_exec_all(); tcg_exec_all();
if (use_icount) { if (use_icount) {
int64_t deadline = qemu_clock_deadline_ns_all(vm_clock); int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
if (deadline == 0) { if (deadline == 0) {
qemu_clock_notify(vm_clock); qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
} }
} }
qemu_tcg_wait_io_event(); qemu_tcg_wait_io_event();
...@@ -1001,7 +1007,7 @@ void pause_all_vcpus(void) ...@@ -1001,7 +1007,7 @@ void pause_all_vcpus(void)
{ {
CPUState *cpu = first_cpu; CPUState *cpu = first_cpu;
qemu_clock_enable(vm_clock, false); qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
while (cpu) { while (cpu) {
cpu->stop = true; cpu->stop = true;
qemu_cpu_kick(cpu); qemu_cpu_kick(cpu);
...@@ -1042,7 +1048,7 @@ void resume_all_vcpus(void) ...@@ -1042,7 +1048,7 @@ void resume_all_vcpus(void)
{ {
CPUState *cpu = first_cpu; CPUState *cpu = first_cpu;
qemu_clock_enable(vm_clock, true); qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
while (cpu) { while (cpu) {
cpu_resume(cpu); cpu_resume(cpu);
cpu = cpu->next_cpu; cpu = cpu->next_cpu;
...@@ -1166,10 +1172,10 @@ static int tcg_cpu_exec(CPUArchState *env) ...@@ -1166,10 +1172,10 @@ static int tcg_cpu_exec(CPUArchState *env)
qemu_icount -= (env->icount_decr.u16.low + env->icount_extra); qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
env->icount_decr.u16.low = 0; env->icount_decr.u16.low = 0;
env->icount_extra = 0; env->icount_extra = 0;
deadline = qemu_clock_deadline_ns_all(vm_clock); deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
/* Maintain prior (possibly buggy) behaviour where if no deadline /* Maintain prior (possibly buggy) behaviour where if no deadline
* was set (as there is no vm_clock timer) or it is more than * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
* INT32_MAX nanoseconds ahead, we still use INT32_MAX * INT32_MAX nanoseconds ahead, we still use INT32_MAX
* nanoseconds. * nanoseconds.
*/ */
...@@ -1203,8 +1209,8 @@ static void tcg_exec_all(void) ...@@ -1203,8 +1209,8 @@ static void tcg_exec_all(void)
{ {
int r; int r;
/* Account partial waits to the vm_clock. */ /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
qemu_clock_warp(vm_clock); qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
if (next_cpu == NULL) { if (next_cpu == NULL) {
next_cpu = first_cpu; next_cpu = first_cpu;
...@@ -1213,7 +1219,7 @@ static void tcg_exec_all(void) ...@@ -1213,7 +1219,7 @@ static void tcg_exec_all(void)
CPUState *cpu = next_cpu; CPUState *cpu = next_cpu;
CPUArchState *env = cpu->env_ptr; CPUArchState *env = cpu->env_ptr;
qemu_clock_enable(vm_clock, qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
(cpu->singlestep_enabled & SSTEP_NOTIMER) == 0); (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
if (cpu_can_run(cpu)) { if (cpu_can_run(cpu)) {
......
...@@ -263,7 +263,7 @@ static int acpi_load_old(QEMUFile *f, void *opaque, int version_id) ...@@ -263,7 +263,7 @@ static int acpi_load_old(QEMUFile *f, void *opaque, int version_id)
return ret; return ret;
} }
qemu_get_timer(f, s->ar.tmr.timer); timer_get(f, s->ar.tmr.timer);
qemu_get_sbe64s(f, &s->ar.tmr.overflow_time); qemu_get_sbe64s(f, &s->ar.tmr.overflow_time);
qemu_get_be16s(f, (uint16_t *)s->ar.gpe.sts); qemu_get_be16s(f, (uint16_t *)s->ar.gpe.sts);
......
...@@ -449,7 +449,7 @@ static void tsc2005_save(QEMUFile *f, void *opaque) ...@@ -449,7 +449,7 @@ static void tsc2005_save(QEMUFile *f, void *opaque)
qemu_put_be16s(f, &s->dav); qemu_put_be16s(f, &s->dav);
qemu_put_be16s(f, &s->data); qemu_put_be16s(f, &s->data);
qemu_put_timer(f, s->timer); timer_put(f, s->timer);
qemu_put_byte(f, s->enabled); qemu_put_byte(f, s->enabled);
qemu_put_byte(f, s->host_mode); qemu_put_byte(f, s->host_mode);
qemu_put_byte(f, s->function); qemu_put_byte(f, s->function);
...@@ -490,7 +490,7 @@ static int tsc2005_load(QEMUFile *f, void *opaque, int version_id) ...@@ -490,7 +490,7 @@ static int tsc2005_load(QEMUFile *f, void *opaque, int version_id)
qemu_get_be16s(f, &s->dav); qemu_get_be16s(f, &s->dav);
qemu_get_be16s(f, &s->data); qemu_get_be16s(f, &s->data);
qemu_get_timer(f, s->timer); timer_get(f, s->timer);
s->enabled = qemu_get_byte(f); s->enabled = qemu_get_byte(f);
s->host_mode = qemu_get_byte(f); s->host_mode = qemu_get_byte(f);
s->function = qemu_get_byte(f); s->function = qemu_get_byte(f);
......
...@@ -1020,7 +1020,7 @@ static void tsc210x_save(QEMUFile *f, void *opaque) ...@@ -1020,7 +1020,7 @@ static void tsc210x_save(QEMUFile *f, void *opaque)
qemu_put_byte(f, s->irq); qemu_put_byte(f, s->irq);
qemu_put_be16s(f, &s->dav); qemu_put_be16s(f, &s->dav);
qemu_put_timer(f, s->timer); timer_put(f, s->timer);
qemu_put_byte(f, s->enabled); qemu_put_byte(f, s->enabled);
qemu_put_byte(f, s->host_mode); qemu_put_byte(f, s->host_mode);
qemu_put_byte(f, s->function); qemu_put_byte(f, s->function);
...@@ -1066,7 +1066,7 @@ static int tsc210x_load(QEMUFile *f, void *opaque, int version_id) ...@@ -1066,7 +1066,7 @@ static int tsc210x_load(QEMUFile *f, void *opaque, int version_id)
s->irq = qemu_get_byte(f); s->irq = qemu_get_byte(f);
qemu_get_be16s(f, &s->dav); qemu_get_be16s(f, &s->dav);
qemu_get_timer(f, s->timer); timer_get(f, s->timer);
s->enabled = qemu_get_byte(f); s->enabled = qemu_get_byte(f);
s->host_mode = qemu_get_byte(f); s->host_mode = qemu_get_byte(f);
s->function = qemu_get_byte(f); s->function = qemu_get_byte(f);
......
...@@ -363,7 +363,7 @@ void cpu_put_timer(QEMUFile *f, CPUTimer *s) ...@@ -363,7 +363,7 @@ void cpu_put_timer(QEMUFile *f, CPUTimer *s)
qemu_put_be64s(f, &s->disabled_mask); qemu_put_be64s(f, &s->disabled_mask);
qemu_put_sbe64s(f, &s->clock_offset); qemu_put_sbe64s(f, &s->clock_offset);
qemu_put_timer(f, s->qtimer); timer_put(f, s->qtimer);
} }
void cpu_get_timer(QEMUFile *f, CPUTimer *s) void cpu_get_timer(QEMUFile *f, CPUTimer *s)
...@@ -373,7 +373,7 @@ void cpu_get_timer(QEMUFile *f, CPUTimer *s) ...@@ -373,7 +373,7 @@ void cpu_get_timer(QEMUFile *f, CPUTimer *s)
qemu_get_be64s(f, &s->disabled_mask); qemu_get_be64s(f, &s->disabled_mask);
qemu_get_sbe64s(f, &s->clock_offset); qemu_get_sbe64s(f, &s->clock_offset);
qemu_get_timer(f, s->qtimer); timer_get(f, s->qtimer);
} }
static CPUTimer *cpu_timer_create(const char *name, SPARCCPU *cpu, static CPUTimer *cpu_timer_create(const char *name, SPARCCPU *cpu,
......
This diff is collapsed.
...@@ -487,7 +487,7 @@ int main_loop_wait(int nonblocking) ...@@ -487,7 +487,7 @@ int main_loop_wait(int nonblocking)
slirp_pollfds_poll(gpollfds, (ret < 0)); slirp_pollfds_poll(gpollfds, (ret < 0));
#endif #endif
qemu_run_all_timers(); qemu_clock_run_all_timers();
return ret; return ret;
} }
......
...@@ -132,25 +132,27 @@ static QEMUClock *qemu_clock_new(QEMUClockType type) ...@@ -132,25 +132,27 @@ static QEMUClock *qemu_clock_new(QEMUClockType type)
return clock; return clock;
} }
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; QEMUTimerList *timer_list;
QEMUClock *clock = qemu_clock_ptr(type);
QLIST_FOREACH(timer_list, &clock->timerlists, list) { QLIST_FOREACH(timer_list, &clock->timerlists, list) {
timerlist_notify(timer_list); timerlist_notify(timer_list);
} }
} }
void qemu_clock_enable(QEMUClock *clock, bool enabled) void qemu_clock_enable(QEMUClockType type, bool enabled)
{ {
QEMUClock *clock = qemu_clock_ptr(type);
bool old = clock->enabled; bool old = clock->enabled;
clock->enabled = enabled; clock->enabled = enabled;
if (enabled && !old) { if (enabled && !old) {
qemu_clock_notify(clock); qemu_clock_notify(type);
} }
} }
...@@ -159,21 +161,23 @@ bool timerlist_has_timers(QEMUTimerList *timer_list) ...@@ -159,21 +161,23 @@ bool timerlist_has_timers(QEMUTimerList *timer_list)
return !!timer_list->active_timers; 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(
qemu_clock_ptr(type)->main_loop_timerlist);
} }
bool timerlist_expired(QEMUTimerList *timer_list) bool timerlist_expired(QEMUTimerList *timer_list)
{ {
return (timer_list->active_timers && return (timer_list->active_timers &&
timer_list->active_timers->expire_time < timer_list->active_timers->expire_time <
qemu_get_clock_ns(timer_list->clock)); qemu_clock_get_ns(timer_list->clock->type));
} }
bool qemu_clock_expired(QEMUClock *clock) bool qemu_clock_expired(QEMUClockType type)
{ {
return timerlist_expired(clock->main_loop_timerlist); return timerlist_expired(
qemu_clock_ptr(type)->main_loop_timerlist);
} }
/* /*
...@@ -190,7 +194,7 @@ int64_t timerlist_deadline_ns(QEMUTimerList *timer_list) ...@@ -190,7 +194,7 @@ int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
} }
delta = timer_list->active_timers->expire_time - delta = timer_list->active_timers->expire_time -
qemu_get_clock_ns(timer_list->clock); qemu_clock_get_ns(timer_list->clock->type);
if (delta <= 0) { if (delta <= 0) {
return 0; return 0;
...@@ -199,20 +203,16 @@ int64_t timerlist_deadline_ns(QEMUTimerList *timer_list) ...@@ -199,20 +203,16 @@ int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
return delta; 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 /* Calculate the soonest deadline across all timerlists attached
* to the clock. This is used for the icount timeout so we * to the clock. This is used for the icount timeout so we
* ignore whether or not the clock should be used in deadline * ignore whether or not the clock should be used in deadline
* calculations. * calculations.
*/ */
int64_t qemu_clock_deadline_ns_all(QEMUClock *clock) int64_t qemu_clock_deadline_ns_all(QEMUClockType type)
{ {
int64_t deadline = -1; int64_t deadline = -1;
QEMUTimerList *timer_list; QEMUTimerList *timer_list;
QEMUClock *clock = qemu_clock_ptr(type);
QLIST_FOREACH(timer_list, &clock->timerlists, list) { QLIST_FOREACH(timer_list, &clock->timerlists, list) {
deadline = qemu_soonest_timeout(deadline, deadline = qemu_soonest_timeout(deadline,
timerlist_deadline_ns(timer_list)); timerlist_deadline_ns(timer_list));
...@@ -220,14 +220,14 @@ int64_t qemu_clock_deadline_ns_all(QEMUClock *clock) ...@@ -220,14 +220,14 @@ int64_t qemu_clock_deadline_ns_all(QEMUClock *clock)
return deadline; 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;