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: Alex Bligh <alex@alex.org.uk>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

1 files changed, 341 insertions, 273 deletions

diff --git a/include/qemu/timer.h b/include/qemu/timer.h
index 5c30f91bbe..35556e7bdf 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);