diff options
| -rw-r--r-- | cpus.c | 112 | ||||
| -rw-r--r-- | hw/acpi/piix4.c | 2 | ||||
| -rw-r--r-- | hw/input/tsc2005.c | 4 | ||||
| -rw-r--r-- | hw/input/tsc210x.c | 4 | ||||
| -rw-r--r-- | hw/sparc64/sun4u.c | 4 | ||||
| -rw-r--r-- | include/qemu/timer.h | 614 | ||||
| -rw-r--r-- | main-loop.c | 2 | ||||
| -rw-r--r-- | qemu-timer.c | 100 | ||||
| -rw-r--r-- | qtest.c | 2 | ||||
| -rw-r--r-- | savevm.c | 8 | ||||
| -rw-r--r-- | stubs/clock-warp.c | 2 |
11 files changed, 477 insertions, 377 deletions
@@ -207,7 +207,7 @@ static void icount_adjust(void) return; } 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; /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */ if (delta > 0 @@ -228,15 +228,16 @@ static void icount_adjust(void) static void icount_adjust_rt(void *opaque) { - qemu_mod_timer(icount_rt_timer, - qemu_get_clock_ms(rt_clock) + 1000); + timer_mod(icount_rt_timer, + qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000); icount_adjust(); } static void icount_adjust_vm(void *opaque) { - qemu_mod_timer(icount_vm_timer, - qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10); + timer_mod(icount_vm_timer, + qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + + get_ticks_per_sec() / 10); icount_adjust(); } @@ -252,22 +253,22 @@ static void icount_warp_rt(void *opaque) } 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; if (use_icount == 1) { qemu_icount_bias += warp_delta; } 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. */ 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; qemu_icount_bias += MIN(warp_delta, delta); } - if (qemu_clock_expired(vm_clock)) { - qemu_clock_notify(vm_clock); + if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) { + qemu_clock_notify(QEMU_CLOCK_VIRTUAL); } } vm_clock_warp_start = -1; @@ -275,19 +276,19 @@ static void icount_warp_rt(void *opaque) 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()); 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); qemu_icount_bias += warp; - qemu_run_timers(vm_clock); - clock = qemu_get_clock_ns(vm_clock); + qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL); + 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; @@ -296,20 +297,20 @@ void qemu_clock_warp(QEMUClock *clock) * applicable to other clocks. But a clock argument removes the * need for if statements all over the place. */ - if (clock != vm_clock || !use_icount) { + if (type != QEMU_CLOCK_VIRTUAL || !use_icount) { return; } /* - * If the CPUs have been sleeping, advance the vm_clock timer now. This - * ensures that the deadline for the timer is computed correctly below. + * If the CPUs have been sleeping, advance QEMU_CLOCK_VIRTUAL timer now. + * This ensures that the deadline for the timer is computed correctly below. * 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 - * the earliest vm_clock timer. + * the earliest QEMU_CLOCK_VIRTUAL timer. */ icount_warp_rt(NULL); - if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock)) { - qemu_del_timer(icount_warp_timer); + if (!all_cpu_threads_idle() || !qemu_clock_has_timers(QEMU_CLOCK_VIRTUAL)) { + timer_del(icount_warp_timer); return; } @@ -318,12 +319,12 @@ void qemu_clock_warp(QEMUClock *clock) 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 */ - 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 - * 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 * nanoseconds. */ @@ -333,24 +334,25 @@ void qemu_clock_warp(QEMUClock *clock) 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 * interrupt to wake it up, but the interrupt never comes because * 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 - * sleep in icount mode if there is a pending vm_clock timer; rather - * time could just advance to the next vm_clock event. Instead, we - * do stop VCPUs and only advance vm_clock after some "real" time, - * (related to the time left until the next event) has passed. This - * rt_clock timer will do this. This avoids that the warps are too - * visible externally---for example, you will not be sending network - * packets continuously instead of every 100ms. + * sleep in icount mode if there is a pending QEMU_CLOCK_VIRTUAL + * timer; rather time could just advance to the next QEMU_CLOCK_VIRTUAL + * event. Instead, we do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL + * after some e"real" time, (related to the time left until the next + * event) has passed. The QEMU_CLOCK_REALTIME timer will do this. + * This avoids that the warps are visible externally; for example, + * 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) { - qemu_clock_notify(vm_clock); + qemu_clock_notify(QEMU_CLOCK_VIRTUAL); } } @@ -374,7 +376,8 @@ void configure_icount(const char *option) 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) { icount_time_shift = strtol(option, NULL, 0); use_icount = 1; @@ -392,12 +395,15 @@ void configure_icount(const char *option) the virtual time trigger catches emulated time passing too fast. Realtime triggers occur even when idle, so use them less frequently than VM triggers. */ - icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL); - qemu_mod_timer(icount_rt_timer, - qemu_get_clock_ms(rt_clock) + 1000); - icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL); - qemu_mod_timer(icount_vm_timer, - qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10); + icount_rt_timer = timer_new_ms(QEMU_CLOCK_REALTIME, + icount_adjust_rt, NULL); + timer_mod(icount_rt_timer, + qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000); + icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, + 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) while (all_cpu_threads_idle()) { /* Start accounting real time to the virtual clock if the CPUs are idle. */ - qemu_clock_warp(vm_clock); + qemu_clock_warp(QEMU_CLOCK_VIRTUAL); qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex); } @@ -879,10 +885,10 @@ static void *qemu_tcg_cpu_thread_fn(void *arg) tcg_exec_all(); 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) { - qemu_clock_notify(vm_clock); + qemu_clock_notify(QEMU_CLOCK_VIRTUAL); } } qemu_tcg_wait_io_event(); @@ -1001,7 +1007,7 @@ void pause_all_vcpus(void) { CPUState *cpu = first_cpu; - qemu_clock_enable(vm_clock, false); + qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false); while (cpu) { cpu->stop = true; qemu_cpu_kick(cpu); @@ -1042,7 +1048,7 @@ void resume_all_vcpus(void) { CPUState *cpu = first_cpu; - qemu_clock_enable(vm_clock, true); + qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true); while (cpu) { cpu_resume(cpu); cpu = cpu->next_cpu; @@ -1166,10 +1172,10 @@ static int tcg_cpu_exec(CPUArchState *env) qemu_icount -= (env->icount_decr.u16.low + env->icount_extra); env->icount_decr.u16.low = 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 - * 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 * nanoseconds. */ @@ -1203,8 +1209,8 @@ static void tcg_exec_all(void) { int r; - /* Account partial waits to the vm_clock. */ - qemu_clock_warp(vm_clock); + /* Account partial waits to QEMU_CLOCK_VIRTUAL. */ + qemu_clock_warp(QEMU_CLOCK_VIRTUAL); if (next_cpu == NULL) { next_cpu = first_cpu; @@ -1213,7 +1219,7 @@ static void tcg_exec_all(void) CPUState *cpu = next_cpu; CPUArchState *env = cpu->env_ptr; - qemu_clock_enable(vm_clock, + qemu_clock_enable(QEMU_CLOCK_VIRTUAL, (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0); if (cpu_can_run(cpu)) { diff --git a/hw/acpi/piix4.c b/hw/acpi/piix4.c index c885690..613d987 100644 --- a/hw/acpi/piix4.c +++ b/hw/acpi/piix4.c @@ -263,7 +263,7 @@ static int acpi_load_old(QEMUFile *f, void *opaque, int version_id) 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_be16s(f, (uint16_t *)s->ar.gpe.sts); diff --git a/hw/input/tsc2005.c b/hw/input/tsc2005.c index ebd1b7e..fa9714b 100644 --- a/hw/input/tsc2005.c +++ b/hw/input/tsc2005.c @@ -449,7 +449,7 @@ static void tsc2005_save(QEMUFile *f, void *opaque) qemu_put_be16s(f, &s->dav); 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->host_mode); qemu_put_byte(f, s->function); @@ -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->data); - qemu_get_timer(f, s->timer); + timer_get(f, s->timer); s->enabled = qemu_get_byte(f); s->host_mode = qemu_get_byte(f); s->function = qemu_get_byte(f); diff --git a/hw/input/tsc210x.c b/hw/input/tsc210x.c index 0067f98..96fdb84 100644 --- a/hw/input/tsc210x.c +++ b/hw/input/tsc210x.c @@ -1020,7 +1020,7 @@ static void tsc210x_save(QEMUFile *f, void *opaque) qemu_put_byte(f, s->irq); 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->host_mode); qemu_put_byte(f, s->function); @@ -1066,7 +1066,7 @@ static int tsc210x_load(QEMUFile *f, void *opaque, int version_id) s->irq = qemu_get_byte(f); qemu_get_be16s(f, &s->dav); - qemu_get_timer(f, s->timer); + timer_get(f, s->timer); s->enabled = qemu_get_byte(f); s->host_mode = qemu_get_byte(f); s->function = qemu_get_byte(f); diff --git a/hw/sparc64/sun4u.c b/hw/sparc64/sun4u.c index a7214a3..2165bb0 100644 --- a/hw/sparc64/sun4u.c +++ b/hw/sparc64/sun4u.c @@ -363,7 +363,7 @@ void cpu_put_timer(QEMUFile *f, CPUTimer *s) qemu_put_be64s(f, &s->disabled_mask); 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) @@ -373,7 +373,7 @@ void cpu_get_timer(QEMUFile *f, CPUTimer *s) qemu_get_be64s(f, &s->disabled_mask); 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, diff --git a/include/qemu/timer.h b/include/qemu/timer.h index 5c30f91..35556e7 100644 --- a/include/qemu/timer.h +++ b/include/qemu/timer.h @@ -23,16 +23,12 @@ * machine is stopped. The real time clock has a frequency of 1000 * Hz. * - * Formerly rt_clock - * * @QEMU_CLOCK_VIRTUAL: virtual clock * * The virtual clock is only run during the emulation. It is stopped * when the virtual machine is stopped. Virtual timers use a high * precision clock, usually cpu cycles (use ticks_per_sec). * - * Formerly vm_clock - * * @QEMU_CLOCK_HOST: host clock * * The host clock should be use for device models that emulate accurate @@ -40,8 +36,6 @@ * is suspended, and it will reflect system time changes the host may * undergo (e.g. due to NTP). The host clock has the same precision as * the virtual clock. - * - * Formerly host_clock */ typedef enum { @@ -73,6 +67,10 @@ struct QEMUTimer { extern QEMUTimerListGroup main_loop_tlg; extern QEMUClock *qemu_clocks[QEMU_CLOCK_MAX]; +/* + * QEMUClock & QEMUClockType + */ + /** * qemu_clock_ptr: * @type: type of clock @@ -86,23 +84,6 @@ static inline QEMUClock *qemu_clock_ptr(QEMUClockType type) return qemu_clocks[type]; } -/* These three clocks are maintained here with separate variable - * names for compatibility only. - */ -#define rt_clock (qemu_clock_ptr(QEMU_CLOCK_REALTIME)) -#define vm_clock (qemu_clock_ptr(QEMU_CLOCK_VIRTUAL)) -#define host_clock (qemu_clock_ptr(QEMU_CLOCK_HOST)) - -/** - * qemu_get_clock_ns: - * @clock: the clock to operate on - * - * Get the nanosecond value of a clock - * - * Returns: the clock value in nanoseconds - */ -int64_t qemu_get_clock_ns(QEMUClock *clock); - /** * qemu_clock_get_ns; * @type: the clock type @@ -112,10 +93,7 @@ int64_t qemu_get_clock_ns(QEMUClock *clock); * * Returns: the clock value in nanoseconds */ -static inline int64_t qemu_clock_get_ns(QEMUClockType type) -{ - return qemu_get_clock_ns(qemu_clock_ptr(type)); -} +int64_t qemu_clock_get_ns(QEMUClockType type); /** * qemu_clock_get_ms; @@ -147,7 +125,7 @@ static inline int64_t qemu_clock_get_us(QEMUClockType type) /** * qemu_clock_has_timers: - * @clock: the clock to operate on + * @type: the clock type * * Determines whether a clock's default timer list * has timers attached @@ -155,11 +133,11 @@ static inline int64_t qemu_clock_get_us(QEMUClockType type) * Returns: true if the clock's default timer list * has timers attached */ -bool qemu_clock_has_timers(QEMUClock *clock); +bool qemu_clock_has_timers(QEMUClockType type); /** * qemu_clock_expired: - * @clock: the clock to operate on + * @type: the clock type * * Determines whether a clock's default timer list * has an expired clock. @@ -167,23 +145,11 @@ bool qemu_clock_has_timers(QEMUClock *clock); * Returns: true if the clock's default timer list has * an expired timer */ -bool qemu_clock_expired(QEMUClock *clock); - -/** - * qemu_clock_deadline_ns: - * @clock: the clock to operate on - * - * Calculate the timeout of the earliest expiring timer - * on the default timer list associated with the clock - * in nanoseconds, or -1 if no timer is set to expire. - * - * Returns: time until expiry in nanoseconds or -1 - */ -int64_t qemu_clock_deadline_ns(QEMUClock *clock); +bool qemu_clock_expired(QEMUClockType type); /** * qemu_clock_use_for_deadline: - * @clock: the clock to operate on + * @type: the clock type * * Determine whether a clock should be used for deadline * calculations. Some clocks, for instance vm_clock with @@ -195,11 +161,11 @@ int64_t qemu_clock_deadline_ns(QEMUClock *clock); * Returns: true if the clock runs in nanoseconds and * should be used for a deadline. */ -bool qemu_clock_use_for_deadline(QEMUClock *clock); +bool qemu_clock_use_for_deadline(QEMUClockType type); /** - * qemu_clock_use_for_deadline: - * @clock: the clock to operate on + * qemu_clock_deadline_ns_all: + * @type: the clock type * * Calculate the deadline across all timer lists associated * with a clock (as opposed to just the default one) @@ -207,26 +173,90 @@ bool qemu_clock_use_for_deadline(QEMUClock *clock); * * Returns: time until expiry in nanoseconds or -1 */ -int64_t qemu_clock_deadline_ns_all(QEMUClock *clock); +int64_t qemu_clock_deadline_ns_all(QEMUClockType type); /** * qemu_clock_get_main_loop_timerlist: - * @clock: the clock to operate on + * @type: the clock type * * Return the default timer list assocatiated with a clock. * * Returns: the default timer list */ -QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClock *clock); +QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type); /** * qemu_clock_nofify: - * @clock: the clock to operate on + * @type: the clock type * * Call the notifier callback connected with the default timer * list linked to the clock, or qemu_notify() if none. */ -void qemu_clock_notify(QEMUClock *clock); +void qemu_clock_notify(QEMUClockType type); + +/** + * qemu_clock_enable: + * @type: the clock type + * @enabled: true to enable, false to disable + * + * Enable or disable a clock + */ +void qemu_clock_enable(QEMUClockType type, bool enabled); + +/** + * qemu_clock_warp: + * @type: the clock type + * + * Warp a clock to a new value + */ +void qemu_clock_warp(QEMUClockType type); + +/** + * qemu_clock_register_reset_notifier: + * @type: the clock type + * @notifier: the notifier function + * + * Register a notifier function to call when the clock + * concerned is reset. + */ +void qemu_clock_register_reset_notifier(QEMUClockType type, + Notifier *notifier); + +/** + * qemu_clock_unregister_reset_notifier: + * @type: the clock type + * @notifier: the notifier function + * + * Unregister a notifier function to call when the clock + * concerned is reset. + */ +void qemu_clock_unregister_reset_notifier(QEMUClockType type, + Notifier *notifier); + +/** + * qemu_clock_run_timers: + * @type: clock on which to operate + * + * Run all the timers associated with the default timer list + * of a clock. + * + * Returns: true if any timer ran. + */ +bool qemu_clock_run_timers(QEMUClockType type); + +/** + * qemu_clock_run_all_timers: + * + * Run all the timers associated with the default timer list + * of every clock. + * + * Returns: true if any timer ran. + */ +bool qemu_clock_run_all_timers(void); + +/* + * QEMUTimerList + */ /** * timerlist_new: @@ -286,14 +316,15 @@ bool timerlist_expired(QEMUTimerList *timer_list); int64_t timerlist_deadline_ns(QEMUTimerList *timer_list); /** - * timerlist_getclock: + * timerlist_get_clock: * @timer_list: the timer list to operate on * - * Determine the clock associated with a timer list. + * Determine the clock type associated with a timer list. * - * Returns: the clock associated with the timer list. + * Returns: the clock type associated with the + * timer list. */ -QEMUClock *timerlist_get_clock(QEMUTimerList *timer_list); +QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list); /** * timerlist_run_timers: @@ -313,6 +344,10 @@ bool timerlist_run_timers(QEMUTimerList *timer_list); */ void timerlist_notify(QEMUTimerList *timer_list); +/* + * QEMUTimerListGroup + */ + /** * timerlistgroup_init: * @tlg: the timer list group @@ -363,82 +398,9 @@ bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg); */ int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg); -/** - * qemu_timeout_ns_to_ms: - * @ns: nanosecond timeout value - * - * Convert a nanosecond timeout value (or -1) to - * a millisecond value (or -1), always rounding up. - * - * Returns: millisecond timeout value - */ -int qemu_timeout_ns_to_ms(int64_t ns); - -/** - * qemu_poll_ns: - * @fds: Array of file descriptors - * @nfds: number of file descriptors - * @timeout: timeout in nanoseconds - * - * Perform a poll like g_poll but with a timeout in nanoseconds. - * See g_poll documentation for further details. - * - * Returns: number of fds ready - */ -int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout); - -/** - * qemu_clock_enable: - * @clock: the clock to operate on - * @enabled: true to enable, false to disable - * - * Enable or disable a clock - */ -void qemu_clock_enable(QEMUClock *clock, bool enabled); - -/** - * qemu_clock_warp: - * @clock: the clock to operate on - * - * Warp a clock to a new value - */ -void qemu_clock_warp(QEMUClock *clock); - -/** - * qemu_register_clock_reset_notifier: - * @clock: the clock to operate on - * @notifier: the notifier function - * - * Register a notifier function to call when the clock - * concerned is reset. - */ -void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier); - -/** - * qemu_unregister_clock_reset_notifier: - * @clock: the clock to operate on - * @notifier: the notifier function - * - * Unregister a notifier function to call when the clock - * concerned is reset. - */ -void qemu_unregister_clock_reset_notifier(QEMUClock *clock, - Notifier *notifier); - -/** - * qemu_new_timer: - * @clock: the clock to operate on - * @scale: the scale of the clock - * @cb: the callback function to call when the timer expires - * @opaque: an opaque pointer to pass to the callback - * - * Produce a new timer attached to clock @clock. This is a legacy - * function. Use timer_new instead. - * - * Returns: a pointer to the new timer allocated. +/* + * QEMUTimer */ -QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale, - QEMUTimerCB *cb, void *opaque); /** * timer_init: @@ -502,102 +464,94 @@ static inline QEMUTimer *timer_new(QEMUClockType type, int scale, } /** - * qemu_free_timer: - * @ts: the timer to operate on - * - * free the timer @ts. @ts must not be active. + * timer_new_ns: + * @clock: the clock to associate with the timer + * @callback: the callback to call when the timer expires + * @opaque: the opaque pointer to pass to the callback * - * This is a legacy function. Use timer_free instead. - */ -void qemu_free_timer(QEMUTimer *ts); - -/** - * timer_free: - * @ts: the timer to operate on + * Create a new timer with nanosecond scale on the default timer list + * associated with the clock. * - * free the timer @ts. @ts must not be active. + * Returns: a pointer to the newly created timer */ -static inline void timer_free(QEMUTimer *ts) +static inline QEMUTimer *timer_new_ns(QEMUClockType type, QEMUTimerCB *cb, + void *opaque) { - qemu_free_timer(ts); + return timer_new(type, SCALE_NS, cb, opaque); } /** - * qemu_del_timer: - * @ts: the timer to operate on + * timer_new_us: + * @clock: the clock to associate with the timer + * @callback: the callback to call when the timer expires + * @opaque: the opaque pointer to pass to the callback * - * Delete a timer. This makes it inactive. It does not free - * memory. + * Create a new timer with microsecond scale on the default timer list + * associated with the clock. * - * This is a legacy function. Use timer_del instead. + * Returns: a pointer to the newly created timer */ -void qemu_del_timer(QEMUTimer *ts); +static inline QEMUTimer *timer_new_us(QEMUClockType type, QEMUTimerCB *cb, + void *opaque) +{ + return timer_new(type, SCALE_US, cb, opaque); +} /** - * timer_del: - * @ts: the timer to operate on + * timer_new_ms: + * @clock: the clock to associate with the timer + * @callback: the callback to call when the timer expires + * @opaque: the opaque pointer to pass to the callback * - * Delete a timer. This makes it inactive. It does not free - * memory. + * Create a new timer with millisecond scale on the default timer list + * associated with the clock. + * + * Returns: a pointer to the newly created timer */ -static inline void timer_del(QEMUTimer *ts) +static inline QEMUTimer *timer_new_ms(QEMUClockType type, QEMUTimerCB *cb, + void *opaque) { - qemu_del_timer(ts); + return timer_new(type, SCALE_MS, cb, opaque); } /** - * qemu_mod_timer_ns: - * @ts: the timer to operate on - * @expire_time: the expiry time in nanoseconds - * - * Modify a timer such that the expiry time is @expire_time - * as measured in nanoseconds + * timer_free: + * @ts: the timer * - * This is a legacy function. Use timer_mod_ns. + * Free a timer (it must not be on the active list) */ -void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time); +void timer_free(QEMUTimer *ts); /** - * timer_mod_ns: - * @ts: the timer to operate on - * @expire_time: the expiry time in nanoseconds + * timer_del: + * @ts: the timer * - * Modify a timer such that the expiry time is @expire_time - * as measured in nanoseconds + * Delete a timer from the active list. */ -static inline void timer_mod_ns(QEMUTimer *ts, int64_t expire_time) -{ - qemu_mod_timer_ns(ts, expire_time); -} +void timer_del(QEMUTimer *ts); /** - * qemu_mod_timer: - * @ts: the timer to operate on - * @expire_time: the expiry time - * - * Modify a timer such that the expiry time is @expire_time - * as measured in the timer's scale + * timer_mod_ns: + * @ts: the timer + * @expire_time: the expiry time in nanoseconds * - * This is a legacy function. Use timer_mod. + * Modify a timer to expire at @expire_time */ -void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time); +void timer_mod_ns(QEMUTimer *ts, int64_t expire_time); /** * timer_mod: - * @ts: the timer to operate on - * @expire_time: the expiry time in nanoseconds + * @ts: the timer + * @expire_time: the expire time in the units associated with the timer * - * Modify a timer such that the expiry time is @expire_time - * as measured in the timer's scale + * Modify a timer to expiry at @expire_time, taking into + * account the scale associated with the timer. */ -static inline void timer_mod(QEMUTimer *ts, int64_t expire_time) -{ - qemu_mod_timer(ts, expire_time); -} +void timer_mod(QEMUTimer *ts, int64_t expire_timer); /** * timer_pending: - * @ts: the timer to operate on + * @ts: the timer * * Determines whether a timer is pending (i.e. is on the * active list of timers, whether or not it has not yet expired). @@ -608,7 +562,7 @@ bool timer_pending(QEMUTimer *ts); /** * timer_expired: - * @ts: the timer to operate on + * @ts: the timer * * Determines whether a timer has expired. * @@ -618,45 +572,57 @@ bool timer_expired(QEMUTimer *timer_head, int64_t current_time); /** * timer_expire_time_ns: - * @ts: the timer to operate on + * @ts: the timer * - * Determines the time until a timer expires + * Determine the expiry time of a timer * - * Returns: the time (in nanoseonds) until a timer expires + * Returns: the expiry time in nanoseconds */ uint64_t timer_expire_time_ns(QEMUTimer *ts); /** - * qemu_run_timers: - * @clock: clock on which to operate - * - * Run all the timers associated with the default timer list - * of a clock. + * timer_get: + * @f: the file + * @ts: the timer * - * Returns: true if any timer ran. + * Read a timer @ts from a file @f */ -bool qemu_run_timers(QEMUClock *clock); +void timer_get(QEMUFile *f, QEMUTimer *ts); /** - * qemu_run_all_timers: + * timer_put: + * @f: the file + * @ts: the timer + */ +void timer_put(QEMUFile *f, QEMUTimer *ts); + +/* + * General utility functions + */ + +/** + * qemu_timeout_ns_to_ms: + * @ns: nanosecond timeout value * - * Run all the timers associated with the default timer list - * of every clock. + * Convert a nanosecond timeout value (or -1) to + * a millisecond value (or -1), always rounding up. * - * Returns: true if any timer ran. + * Returns: millisecond timeout value */ -bool qemu_run_all_timers(void); +int qemu_timeout_ns_to_ms(int64_t ns); /** - * initclocks: + * qemu_poll_ns: + * @fds: Array of file descriptors + * @nfds: number of file descriptors + * @timeout: timeout in nanoseconds * - * Initialise the clock & timer infrastructure + * Perform a poll like g_poll but with a timeout in nanoseconds. + * See g_poll documentation for further details. + * + * Returns: number of fds ready */ -void init_clocks(void); - -int64_t cpu_get_ticks(void); -void cpu_enable_ticks(void); -void cpu_disable_ticks(void); +int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout); /** * qemu_soonest_timeout: @@ -678,59 +644,181 @@ static inline int64_t qemu_soonest_timeout(int64_t timeout1, int64_t timeout2) } /** - * qemu_new_timer_ns: - * @clock: the clock to associate with the timer - * @callback: the callback to call when the timer expires - * @opaque: the opaque pointer to pass to the callback + * initclocks: * - * Create a new timer with nanosecond scale on the default timer list - * associated with the clock. + * Initialise the clock & timer infrastructure + */ +void init_clocks(void); + +int64_t cpu_get_ticks(void); +void cpu_enable_ticks(void); +void cpu_disable_ticks(void); + +static inline int64_t get_ticks_per_sec(void) +{ + return 1000000000LL; +} + +/************************************************** + * LEGACY API SECTION * - * Returns: a pointer to the newly created timer + * All these calls will be deleted in due course */ -static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb, - void *opaque) + +/* These three clocks are maintained here with separate variable + * names for compatibility only. + */ +#define rt_clock (qemu_clock_ptr(QEMU_CLOCK_REALTIME)) +#define vm_clock (qemu_clock_ptr(QEMU_CLOCK_VIRTUAL)) +#define host_clock (qemu_clock_ptr(QEMU_CLOCK_HOST)) + +/** LEGACY + * qemu_get_clock_ns: + * @clock: the clock to operate on + * + * Get the nanosecond value of a clock + * + * Returns: the clock value in nanoseconds + */ +int64_t qemu_get_clock_ns(QEMUClock *clock); + +/** LEGACY + * qemu_get_clock_ms: + * @clock: the clock to operate on + * + * Get the millisecond value of a clock + * + * Returns: the clock value in milliseconds + */ +static inline int64_t qemu_get_clock_ms(QEMUClock *clock) { - return qemu_new_timer(clock, SCALE_NS, cb, opaque); + return qemu_get_clock_ns(clock) / SCALE_MS; } -/** - * timer_new_ns: - * @clock: the clock to associate with the timer - * @callback: the callback to call when the timer expires - * @opaque: the opaque pointer to pass to the callback +/** LEGACY + * qemu_register_clock_reset_notifier: + * @clock: the clock to operate on + * @notifier: the notifier function * - * Create a new timer with nanosecond scale on the default timer list - * associated with the clock. + * Register a notifier function to call when the clock + * concerned is reset. + */ +void qemu_register_clock_reset_notifier(QEMUClock *clock, + Notifier *notifier); + +/** LEGACY + * qemu_unregister_clock_reset_notifier: + * @clock: the clock to operate on + * @notifier: the notifier function * - * Returns: a pointer to the newly created timer + * Unregister a notifier function to call when the clock + * concerned is reset. */ -static inline QEMUTimer *timer_new_ns(QEMUClockType type, QEMUTimerCB *cb, - void *opaque) +void qemu_unregister_clock_reset_notifier(QEMUClock *clock, + Notifier *notifier); + +/** LEGACY + * qemu_new_timer: + * @clock: the clock to operate on + * @scale: the scale of the clock + * @cb: the callback function to call when the timer expires + * @opaque: an opaque pointer to pass to the callback + * + * Produce a new timer attached to clock @clock. This is a legacy + * function. Use timer_new instead. + * + * Returns: a pointer to the new timer allocated. + */ +QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale, + QEMUTimerCB *cb, void *opaque); + +/** LEGACY + * qemu_free_timer: + * @ts: the timer to operate on + * + * free the timer @ts. @ts must not be active. + * + * This is a legacy function. Use timer_free instead. + */ +static inline void qemu_free_timer(QEMUTimer *ts) { - return timer_new(type, SCALE_NS, cb, opaque); + timer_free(ts); } -/** - * qemu_new_timer_us: +/** LEGACY + * qemu_del_timer: + * @ts: the timer to operate on + * + * Delete a timer. This makes it inactive. It does not free + * memory. + * + * This is a legacy function. Use timer_del instead. + */ +static inline void qemu_del_timer(QEMUTimer *ts) +{ + timer_del(ts); +} + +/** LEGACY + * qemu_mod_timer_ns: + * @ts: the timer to operate on + * @expire_time: the expiry time in nanoseconds + * + * Modify a timer such that the expiry time is @expire_time + * as measured in nanoseconds + * + * This is a legacy function. Use timer_mod_ns. + */ +static inline void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time) +{ + timer_mod_ns(ts, expire_time); +} + +/** LEGACY + * qemu_mod_timer: + * @ts: the timer to operate on + * @expire_time: the expiry time + * + * Modify a timer such that the expiry time is @expire_time + * as measured in the timer's scale + * + * This is a legacy function. Use timer_mod. + */ +static inline void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time) +{ + timer_mod(ts, expire_time); +} + +/** LEGACY + * qemu_run_timers: + * @clock: clock on which to operate + * + * Run all the timers associated with the default timer list + * of a clock. + * + * Returns: true if any timer ran. + */ +bool qemu_run_timers(QEMUClock *clock); + +/** LEGACY + * qemu_new_timer_ns: * @clock: the clock to associate with the timer * @callback: the callback to call when the timer expires * @opaque: the opaque pointer to pass to the callback * - * Create a new timer with microsecond scale on the default timer list + * Create a new timer with nanosecond scale on the default timer list * associated with the clock. * * Returns: a pointer to the newly created timer */ -static inline QEMUTimer *qemu_new_timer_us(QEMUClock *clock, - QEMUTimerCB *cb, +static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb, void *opaque) { - return qemu_new_timer(clock, SCALE_US, cb, opaque); + return qemu_new_timer(clock, SCALE_NS, cb, opaque); } -/** - * timer_new_us: +/** LEGACY + * qemu_new_timer_us: * @clock: the clock to associate with the timer * @callback: the callback to call when the timer expires * @opaque: the opaque pointer to pass to the callback @@ -740,13 +828,14 @@ static inline QEMUTimer *qemu_new_timer_us(QEMUClock *clock, * * Returns: a pointer to the newly created timer */ -static inline QEMUTimer *timer_new_us(QEMUClockType type, QEMUTimerCB *cb, - void *opaque) +static inline QEMUTimer *qemu_new_timer_us(QEMUClock *clock, + QEMUTimerCB *cb, + void *opaque) { - return timer_new(type, SCALE_US, cb, opaque); + return qemu_new_timer(clock, SCALE_US, cb, opaque); } -/** +/** LEGACY * qemu_new_timer_ms: * @clock: the clock to associate with the timer * @callback: the callback to call when the timer expires @@ -764,32 +853,14 @@ static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, return qemu_new_timer(clock, SCALE_MS, cb, opaque); } -/** - * timer_new_ms: - * @clock: the clock to associate with the timer - * @callback: the callback to call when the timer expires - * @opaque: the opaque pointer to pass to the callback - * - * Create a new timer with millisecond scale on the default timer list - * associated with the clock. - * - * Returns: a pointer to the newly created timer +/**************************************************** + * END OF LEGACY API SECTION */ -static inline QEMUTimer *timer_new_ms(QEMUClockType type, QEMUTimerCB *cb, - void *opaque) -{ - return timer_new(type, SCALE_MS, cb, opaque); -} -static inline int64_t qemu_get_clock_ms(QEMUClock *clock) -{ - return qemu_get_clock_ns(clock) / SCALE_MS; -} -static inline int64_t get_ticks_per_sec(void) -{ - return 1000000000LL; -} +/* + * Low level clock functions + */ /* real time host monotonic timer */ static inline int64_t get_clock_realtime(void) @@ -834,9 +905,6 @@ static inline int64_t get_clock(void) } #endif -void qemu_get_timer(QEMUFile *f, QEMUTimer *ts); -void qemu_put_timer(QEMUFile *f, QEMUTimer *ts); - /* icount */ int64_t cpu_get_icount(void); int64_t cpu_get_clock(void); diff --git a/main-loop.c b/main-loop.c index 543a01f..1c38ea2 100644 --- a/main-loop.c +++ b/main-loop.c @@ -487,7 +487,7 @@ int main_loop_wait(int nonblocking) slirp_pollfds_poll(gpollfds, (ret < 0)); #endif - qemu_run_all_timers(); + qemu_clock_run_all_timers(); return ret; } diff --git a/qemu-timer.c b/qemu-timer.c index b6f9304..14794b8 100644 --- a/qemu-timer.c +++ b/qemu-timer.c @@ -132,25 +132,27 @@ static QEMUClock *qemu_clock_new(QEMUClockType type) 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; + 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) +void qemu_clock_enable(QEMUClockType type, bool enabled) { + QEMUClock *clock = qemu_clock_ptr(type); bool old = clock->enabled; clock->enabled = enabled; if (enabled && !old) { - qemu_clock_notify(clock); + qemu_clock_notify(type); } } @@ -159,21 +161,23 @@ bool timerlist_has_timers(QEMUTimerList *timer_list) 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) { return (timer_list->active_timers && 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) } 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) { return 0; @@ -199,20 +203,16 @@ int64_t timerlist_deadline_ns(QEMUTimerList *timer_list) 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)); @@ -220,14 +220,14 @@ int64_t qemu_clock_deadline_ns_all(QEMUClock *clock) 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 qemu_clock_ptr(type)->main_loop_timerlist; } void timerlist_notify(QEMUTimerList *timer_list) @@ -304,13 +304,13 @@ QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale, 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) +void timer_del(QEMUTimer *ts) { QEMUTimer **pt, *t; @@ -331,11 +331,11 @@ void qemu_del_timer(QEMUTimer *ts) /* 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) +void timer_mod_ns(QEMUTimer *ts, int64_t expire_time) { QEMUTimer **pt, *t; - qemu_del_timer(ts); + timer_del(ts); /* add the timer in the sorted list */ /* NOTE: this code must be signal safe because @@ -355,14 +355,14 @@ void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time) /* Rearm if necessary */ if (pt == &ts->timer_list->active_timers) { /* Interrupt execution to force deadline recalculation. */ - qemu_clock_warp(ts->timer_list->clock); + qemu_clock_warp(ts->timer_list->clock->type); timerlist_notify(ts->timer_list); } } -void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time) +void timer_mod(QEMUTimer *ts, int64_t expire_time) { - qemu_mod_timer_ns(ts, expire_time * ts->scale); + timer_mod_ns(ts, expire_time * ts->scale); } bool timer_pending(QEMUTimer *ts) @@ -391,7 +391,7 @@ bool timerlist_run_timers(QEMUTimerList *timer_list) return progress; } - current_time = qemu_get_clock_ns(timer_list->clock); + current_time = qemu_clock_get_ns(timer_list->clock->type); for(;;) { ts = timer_list->active_timers; if (!timer_expired_ns(ts, current_time)) { @@ -408,9 +408,14 @@ bool timerlist_run_timers(QEMUTimerList *timer_list) return progress; } +bool qemu_clock_run_timers(QEMUClockType type) +{ + return timerlist_run_timers(qemu_clock_ptr(type)->main_loop_timerlist); +} + bool qemu_run_timers(QEMUClock *clock) { - return timerlist_run_timers(clock->main_loop_timerlist); + return qemu_clock_run_timers(clock->type); } void timerlistgroup_init(QEMUTimerListGroup *tlg, @@ -445,7 +450,7 @@ int64_t timerlistgroup_deadline_ns(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])); @@ -454,11 +459,12 @@ int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg) 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: @@ -479,16 +485,36 @@ int64_t qemu_get_clock_ns(QEMUClock *clock) } } -void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier) +int64_t qemu_get_clock_ns(QEMUClock *clock) { + return qemu_clock_get_ns(clock->type); +} + +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); } +void qemu_register_clock_reset_notifier(QEMUClock *clock, + Notifier *notifier) +{ + qemu_clock_register_reset_notifier(clock->type, notifier); +} + +void qemu_unregister_clock_reset_notifier(QEMUClock *clock, + Notifier *notifier) +{ + qemu_clock_unregister_reset_notifier(clock->type, notifier); +} + void init_clocks(void) { QEMUClockType type; @@ -509,13 +535,13 @@ uint64_t timer_expire_time_ns(QEMUTimer *ts) 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; @@ -412,7 +412,7 @@ static void qtest_process_command(CharDriverState *chr, gchar **words) if (words[1]) { ns = strtoll(words[1], NULL, 0); } else { - ns = qemu_clock_deadline_ns_all(vm_clock); + ns = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL); } qtest_clock_warp(qemu_get_clock_ns(vm_clock) + ns); qtest_send_prefix(chr); @@ -979,7 +979,7 @@ uint64_t qemu_get_be64(QEMUFile *f) /* timer */ -void qemu_put_timer(QEMUFile *f, QEMUTimer *ts) +void timer_put(QEMUFile *f, QEMUTimer *ts) { uint64_t expire_time; @@ -987,7 +987,7 @@ void qemu_put_timer(QEMUFile *f, QEMUTimer *ts) qemu_put_be64(f, expire_time); } -void qemu_get_timer(QEMUFile *f, QEMUTimer *ts) +void timer_get(QEMUFile *f, QEMUTimer *ts) { uint64_t expire_time; @@ -1339,14 +1339,14 @@ const VMStateInfo vmstate_info_float64 = { static int get_timer(QEMUFile *f, void *pv, size_t size) { QEMUTimer *v = pv; - qemu_get_timer(f, v); + timer_get(f, v); return 0; } static void put_timer(QEMUFile *f, void *pv, size_t size) { QEMUTimer *v = pv; - qemu_put_timer(f, v); + timer_put(f, v); } const VMStateInfo vmstate_info_timer = { diff --git a/stubs/clock-warp.c b/stubs/clock-warp.c index b64c462..5565118 100644 --- a/stubs/clock-warp.c +++ b/stubs/clock-warp.c @@ -1,7 +1,7 @@ #include "qemu-common.h" #include "qemu/timer.h" -void qemu_clock_warp(QEMUClock *clock) +void qemu_clock_warp(QEMUClockType type) { } |