From patchwork Thu Aug 8 21:42:16 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alex Bligh X-Patchwork-Id: 265833 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (unknown [IPv6:2001:4830:134:3::12]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 159912C00AB for ; Fri, 9 Aug 2013 07:54:19 +1000 (EST) Received: from localhost ([::1]:44959 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1V7Y9x-00034A-0D for incoming@patchwork.ozlabs.org; Thu, 08 Aug 2013 17:54:17 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:54837) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1V7Xz8-0006h4-El for qemu-devel@nongnu.org; Thu, 08 Aug 2013 17:43:07 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1V7Xz7-00077z-0r for qemu-devel@nongnu.org; Thu, 08 Aug 2013 17:43:06 -0400 Received: from mail.avalus.com ([2001:41c8:10:1dd::10]:41190) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1V7Xz6-00077m-PD for qemu-devel@nongnu.org; Thu, 08 Aug 2013 17:43:04 -0400 Received: by mail.avalus.com (Postfix) with ESMTPSA id 254A9C561BD; Thu, 8 Aug 2013 22:43:03 +0100 (BST) From: Alex Bligh To: qemu-devel@nongnu.org Date: Thu, 8 Aug 2013 22:42:16 +0100 Message-Id: <1375998147-24292-20-git-send-email-alex@alex.org.uk> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1375998147-24292-1-git-send-email-alex@alex.org.uk> References: <1375998147-24292-1-git-send-email-alex@alex.org.uk> X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-Received-From: 2001:41c8:10:1dd::10 Cc: Kevin Wolf , Anthony Liguori , Alex Bligh , liu ping fan , Stefan Hajnoczi , Paolo Bonzini , MORITA Kazutaka , rth@twiddle.net Subject: [Qemu-devel] [RFC] [PATCHv8 19/30] aio / timers: Add documentation and new format calls X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Add documentation for existing qemu timer calls. Add new format calls of the format qemu_timer_XXX rather than qemu_XXX_timer for consistency. Signed-off-by: Alex Bligh --- configure | 18 +++++ include/qemu/timer.h | 215 +++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 231 insertions(+), 2 deletions(-) diff --git a/configure b/configure index 5659412..0a55c20 100755 --- a/configure +++ b/configure @@ -2834,6 +2834,21 @@ if compile_prog "" "" ; then ppoll=yes fi +# check for prctl(PR_SET_TIMERSLACK , ... ) support +prctl_pr_set_timerslack=no +cat > $TMPC << EOF +#include + +int main(void) +{ + prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0); + return 0; +} +EOF +if compile_prog "" "" ; then + prctl_pr_set_timerslack=yes +fi + # check for epoll support epoll=no cat > $TMPC << EOF @@ -3833,6 +3848,9 @@ fi if test "$ppoll" = "yes" ; then echo "CONFIG_PPOLL=y" >> $config_host_mak fi +if test "$prctl_pr_set_timerslack" = "yes" ; then + echo "CONFIG_PRCTL_PR_SET_TIMERSLACK=y" >> $config_host_mak +fi if test "$epoll" = "yes" ; then echo "CONFIG_EPOLL=y" >> $config_host_mak fi diff --git a/include/qemu/timer.h b/include/qemu/timer.h index 7a44741..9003688 100644 --- a/include/qemu/timer.h +++ b/include/qemu/timer.h @@ -79,8 +79,52 @@ static inline QEMUClock *qemu_clock_ptr(QEMUClockType type) #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 + * + * Get the nanosecond value of a clock with + * type @type + * + * 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)); +} + +/** + * qemu_clock_has_timers: + * @clock: the clock to operate on + * + * Determines whether a clock's default timer list + * has timers attached + * + * Returns: true if the clock's default timer list + * has timers attached + */ bool qemu_clock_has_timers(QEMUClock *clock); + +/** + * qemu_clock_expired: + * @clock: the clock to operate on + * + * Determines whether a clock's default timer list + * has an expired clock. + * + * Returns: true if the clock's default timer list has + * an expired timer + */ bool qemu_clock_expired(QEMUClock *clock); int64_t qemu_clock_deadline(QEMUClock *clock); @@ -293,7 +337,7 @@ void timerlistgroup_deinit(QEMUTimerListGroup tlg); bool timerlistgroup_run_timers(QEMUTimerListGroup tlg); /** - * timerlistgroup_deadline_ns + * timerlistgroup_deadline_ns: * @tlg: the timer list group * * Determine the deadline of the soonest timer to @@ -329,13 +373,57 @@ int qemu_timeout_ns_to_ms(int64_t ns); * Returns: number of fds ready */ int qemu_poll_ns(GPollFD *fds, uint 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 qemu_timer_new instead. + * + * Returns: a pointer to the new timer allocated. + */ QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale, QEMUTimerCB *cb, void *opaque); @@ -371,12 +459,129 @@ static inline QEMUTimer *qemu_timer_new(QEMUClockType type, int scale, return timer_new(main_loop_tlg[type], scale, cb, opaque); } +/** + * qemu_free_timer: + * @ts: the timer to operate on + * + * free the timer @ts. @ts must not be active. + * + * This is a legacy function. Use qemu_timer_free instead. + */ void qemu_free_timer(QEMUTimer *ts); + +/** + * qemu_timer_free: + * @ts: the timer to operate on + * + * free the timer @ts. @ts must not be active. + */ +static inline void qemu_timer_free(QEMUTimer *ts) +{ + qemu_free_timer(ts); +} + +/** + * 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 qemu_timer_del instead. + */ void qemu_del_timer(QEMUTimer *ts); + +/** + * qemu_timer_del: + * @ts: the timer to operate on + * + * Delete a timer. This makes it inactive. It does not free + * memory. + */ +static inline void qemu_timer_del(QEMUTimer *ts) +{ + qemu_del_timer(ts); +} + +/** + * 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 qemu_timer_mod_ns. + */ void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time); + +/** + * qemu_timer_mod_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 + */ +static inline void qemu_timer_mod_ns(QEMUTimer *ts, int64_t expire_time) +{ + qemu_mod_timer_ns(ts, expire_time); +} + +/** + * 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 qemu_timer_mod. + */ void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time); + +/** + * qemu_timer_mod: + * @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 the timer's scale + */ +static inline void qemu_timer_mod(QEMUTimer *ts, int64_t expire_time) +{ + qemu_mod_timer(ts, expire_time); +} + +/** + * qemu_timer_pending: + * @ts: the timer to operate on + * + * Determines whether a timer is pending (i.e. is on the + * active list of timers, whether or not it has not yet expired). + * + * Returns: true if the timer is pending + */ bool qemu_timer_pending(QEMUTimer *ts); + +/** + * qemu_timer_expired: + * @ts: the timer to operate on + * + * Determines whether a timer has expired. + * + * Returns: true if the timer has expired + */ bool qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time); + +/** + * qemu_timer_expire_time_ns: + * @ts: the timer to operate on + * + * Determines the time until a timer expires + * + * Returns: the time (in nanoseonds) until a timer expires + */ uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts); /* New format calling conventions for timers */ @@ -490,9 +695,15 @@ bool qemu_run_timers(QEMUClock *clock); bool qemu_run_all_timers(void); void configure_alarms(char const *opt); -void init_clocks(void); int init_timer_alarm(void); +/** + * initclocks: + * + * 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);