2006-01-10 04:52:32 +00:00
|
|
|
/*
|
|
|
|
* include/linux/hrtimer.h
|
|
|
|
*
|
|
|
|
* hrtimers - High-resolution kernel timers
|
|
|
|
*
|
|
|
|
* Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
|
|
|
|
* Copyright(C) 2005, Red Hat, Inc., Ingo Molnar
|
|
|
|
*
|
|
|
|
* data type definitions, declarations, prototypes
|
|
|
|
*
|
|
|
|
* Started by: Thomas Gleixner and Ingo Molnar
|
|
|
|
*
|
|
|
|
* For licencing details see kernel-base/COPYING
|
|
|
|
*/
|
|
|
|
#ifndef _LINUX_HRTIMER_H
|
|
|
|
#define _LINUX_HRTIMER_H
|
|
|
|
|
|
|
|
#include <linux/rbtree.h>
|
|
|
|
#include <linux/ktime.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/wait.h>
|
2008-10-15 03:20:28 +00:00
|
|
|
#include <linux/percpu.h>
|
2009-06-23 15:38:15 +00:00
|
|
|
#include <linux/timer.h>
|
2010-09-21 02:19:17 +00:00
|
|
|
#include <linux/timerqueue.h>
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2007-02-16 09:27:50 +00:00
|
|
|
struct hrtimer_clock_base;
|
|
|
|
struct hrtimer_cpu_base;
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/*
|
|
|
|
* Mode arguments of xxx_hrtimer functions:
|
|
|
|
*/
|
|
|
|
enum hrtimer_mode {
|
2009-04-16 06:43:26 +00:00
|
|
|
HRTIMER_MODE_ABS = 0x0, /* Time value is absolute */
|
|
|
|
HRTIMER_MODE_REL = 0x1, /* Time value is relative to now */
|
|
|
|
HRTIMER_MODE_PINNED = 0x02, /* Timer is bound to CPU */
|
|
|
|
HRTIMER_MODE_ABS_PINNED = 0x02,
|
|
|
|
HRTIMER_MODE_REL_PINNED = 0x03,
|
2006-01-10 04:52:32 +00:00
|
|
|
};
|
|
|
|
|
2007-02-16 09:27:49 +00:00
|
|
|
/*
|
|
|
|
* Return values for the callback function
|
|
|
|
*/
|
2006-01-10 04:52:32 +00:00
|
|
|
enum hrtimer_restart {
|
2007-02-16 09:27:49 +00:00
|
|
|
HRTIMER_NORESTART, /* Timer is not restarted */
|
|
|
|
HRTIMER_RESTART, /* Timer must be restarted */
|
2006-01-10 04:52:32 +00:00
|
|
|
};
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
/*
|
|
|
|
* Values to track state of the timer
|
2007-02-16 09:27:51 +00:00
|
|
|
*
|
|
|
|
* Possible states:
|
|
|
|
*
|
|
|
|
* 0x00 inactive
|
|
|
|
* 0x01 enqueued into rbtree
|
|
|
|
* 0x02 callback function running
|
2011-03-10 17:26:33 +00:00
|
|
|
* 0x04 timer is migrated to another cpu
|
2007-02-16 09:28:11 +00:00
|
|
|
*
|
2008-09-29 13:44:46 +00:00
|
|
|
* Special cases:
|
2007-02-16 09:27:51 +00:00
|
|
|
* 0x03 callback function running and enqueued
|
|
|
|
* (was requeued on another CPU)
|
2011-03-10 17:26:33 +00:00
|
|
|
* 0x05 timer was migrated on CPU hotunplug
|
|
|
|
*
|
2007-02-16 09:27:51 +00:00
|
|
|
* The "callback function running and enqueued" status is only possible on
|
|
|
|
* SMP. It happens for example when a posix timer expired and the callback
|
|
|
|
* queued a signal. Between dropping the lock which protects the posix timer
|
|
|
|
* and reacquiring the base lock of the hrtimer, another CPU can deliver the
|
|
|
|
* signal and rearm the timer. We have to preserve the callback running state,
|
|
|
|
* as otherwise the timer could be removed before the softirq code finishes the
|
|
|
|
* the handling of the timer.
|
|
|
|
*
|
2011-03-10 17:26:33 +00:00
|
|
|
* The HRTIMER_STATE_ENQUEUED bit is always or'ed to the current state
|
|
|
|
* to preserve the HRTIMER_STATE_CALLBACK in the above scenario. This
|
|
|
|
* also affects HRTIMER_STATE_MIGRATE where the preservation is not
|
|
|
|
* necessary. HRTIMER_STATE_MIGRATE is cleared after the timer is
|
|
|
|
* enqueued on the new cpu.
|
2007-02-16 09:27:51 +00:00
|
|
|
*
|
|
|
|
* All state transitions are protected by cpu_base->lock.
|
|
|
|
*/
|
|
|
|
#define HRTIMER_STATE_INACTIVE 0x00
|
|
|
|
#define HRTIMER_STATE_ENQUEUED 0x01
|
|
|
|
#define HRTIMER_STATE_CALLBACK 0x02
|
2008-11-25 11:43:51 +00:00
|
|
|
#define HRTIMER_STATE_MIGRATE 0x04
|
2007-02-16 09:27:51 +00:00
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/**
|
|
|
|
* struct hrtimer - the basic hrtimer structure
|
2010-09-21 02:19:17 +00:00
|
|
|
* @node: timerqueue node, which also manages node.expires,
|
|
|
|
* the absolute expiry time in the hrtimers internal
|
2006-01-10 04:52:32 +00:00
|
|
|
* representation. The time is related to the clock on
|
2008-10-20 14:38:19 +00:00
|
|
|
* which the timer is based. Is setup by adding
|
|
|
|
* slack to the _softexpires value. For non range timers
|
|
|
|
* identical to _softexpires.
|
|
|
|
* @_softexpires: the absolute earliest expiry time of the hrtimer.
|
|
|
|
* The time which was given as expiry time when the timer
|
|
|
|
* was armed.
|
2006-01-10 04:52:32 +00:00
|
|
|
* @function: timer expiry callback function
|
|
|
|
* @base: pointer to the timer base (per cpu and per clock)
|
2007-02-16 09:27:51 +00:00
|
|
|
* @state: state information (See bit values above)
|
2014-03-19 10:51:33 +00:00
|
|
|
* @start_pid: timer statistics field to store the pid of the task which
|
|
|
|
* started the timer
|
2007-02-16 09:28:11 +00:00
|
|
|
* @start_site: timer statistics field to store the site where the timer
|
|
|
|
* was started
|
|
|
|
* @start_comm: timer statistics field to store the name of the process which
|
|
|
|
* started the timer
|
2006-01-10 04:52:32 +00:00
|
|
|
*
|
2007-02-16 09:28:11 +00:00
|
|
|
* The hrtimer structure must be initialized by hrtimer_init()
|
2006-01-10 04:52:32 +00:00
|
|
|
*/
|
|
|
|
struct hrtimer {
|
2010-09-21 02:19:17 +00:00
|
|
|
struct timerqueue_node node;
|
2008-09-01 22:47:08 +00:00
|
|
|
ktime_t _softexpires;
|
2007-02-16 09:27:50 +00:00
|
|
|
enum hrtimer_restart (*function)(struct hrtimer *);
|
|
|
|
struct hrtimer_clock_base *base;
|
2007-02-16 09:27:51 +00:00
|
|
|
unsigned long state;
|
[PATCH] Add debugging feature /proc/timer_stat
Add /proc/timer_stats support: debugging feature to profile timer expiration.
Both the starting site, process/PID and the expiration function is captured.
This allows the quick identification of timer event sources in a system.
Sample output:
# echo 1 > /proc/timer_stats
# cat /proc/timer_stats
Timer Stats Version: v0.1
Sample period: 4.010 s
24, 0 swapper hrtimer_stop_sched_tick (hrtimer_sched_tick)
11, 0 swapper sk_reset_timer (tcp_delack_timer)
6, 0 swapper hrtimer_stop_sched_tick (hrtimer_sched_tick)
2, 1 swapper queue_delayed_work_on (delayed_work_timer_fn)
17, 0 swapper hrtimer_restart_sched_tick (hrtimer_sched_tick)
2, 1 swapper queue_delayed_work_on (delayed_work_timer_fn)
4, 2050 pcscd do_nanosleep (hrtimer_wakeup)
5, 4179 sshd sk_reset_timer (tcp_write_timer)
4, 2248 yum-updatesd schedule_timeout (process_timeout)
18, 0 swapper hrtimer_restart_sched_tick (hrtimer_sched_tick)
3, 0 swapper sk_reset_timer (tcp_delack_timer)
1, 1 swapper neigh_table_init_no_netlink (neigh_periodic_timer)
2, 1 swapper e1000_up (e1000_watchdog)
1, 1 init schedule_timeout (process_timeout)
100 total events, 25.24 events/sec
[ cleanups and hrtimers support from Thomas Gleixner <tglx@linutronix.de> ]
[bunk@stusta.de: nr_entries can become static]
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Cc: Andi Kleen <ak@suse.de>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 09:28:13 +00:00
|
|
|
#ifdef CONFIG_TIMER_STATS
|
2008-09-22 21:42:43 +00:00
|
|
|
int start_pid;
|
[PATCH] Add debugging feature /proc/timer_stat
Add /proc/timer_stats support: debugging feature to profile timer expiration.
Both the starting site, process/PID and the expiration function is captured.
This allows the quick identification of timer event sources in a system.
Sample output:
# echo 1 > /proc/timer_stats
# cat /proc/timer_stats
Timer Stats Version: v0.1
Sample period: 4.010 s
24, 0 swapper hrtimer_stop_sched_tick (hrtimer_sched_tick)
11, 0 swapper sk_reset_timer (tcp_delack_timer)
6, 0 swapper hrtimer_stop_sched_tick (hrtimer_sched_tick)
2, 1 swapper queue_delayed_work_on (delayed_work_timer_fn)
17, 0 swapper hrtimer_restart_sched_tick (hrtimer_sched_tick)
2, 1 swapper queue_delayed_work_on (delayed_work_timer_fn)
4, 2050 pcscd do_nanosleep (hrtimer_wakeup)
5, 4179 sshd sk_reset_timer (tcp_write_timer)
4, 2248 yum-updatesd schedule_timeout (process_timeout)
18, 0 swapper hrtimer_restart_sched_tick (hrtimer_sched_tick)
3, 0 swapper sk_reset_timer (tcp_delack_timer)
1, 1 swapper neigh_table_init_no_netlink (neigh_periodic_timer)
2, 1 swapper e1000_up (e1000_watchdog)
1, 1 init schedule_timeout (process_timeout)
100 total events, 25.24 events/sec
[ cleanups and hrtimers support from Thomas Gleixner <tglx@linutronix.de> ]
[bunk@stusta.de: nr_entries can become static]
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Cc: Andi Kleen <ak@suse.de>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 09:28:13 +00:00
|
|
|
void *start_site;
|
|
|
|
char start_comm[16];
|
|
|
|
#endif
|
2006-01-10 04:52:32 +00:00
|
|
|
};
|
|
|
|
|
2006-03-31 10:31:17 +00:00
|
|
|
/**
|
|
|
|
* struct hrtimer_sleeper - simple sleeper structure
|
|
|
|
* @timer: embedded timer structure
|
|
|
|
* @task: task to wake up
|
|
|
|
*
|
|
|
|
* task is set to NULL, when the timer expires.
|
|
|
|
*/
|
|
|
|
struct hrtimer_sleeper {
|
|
|
|
struct hrtimer timer;
|
|
|
|
struct task_struct *task;
|
|
|
|
};
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/**
|
2007-03-06 09:42:07 +00:00
|
|
|
* struct hrtimer_clock_base - the timer base for a specific clock
|
2007-03-01 04:12:13 +00:00
|
|
|
* @cpu_base: per cpu clock base
|
2007-02-16 09:27:50 +00:00
|
|
|
* @index: clock type index for per_cpu support when moving a
|
|
|
|
* timer to a base on another cpu.
|
2011-06-27 16:07:08 +00:00
|
|
|
* @clockid: clock id for per_cpu support
|
2006-03-26 09:38:05 +00:00
|
|
|
* @active: red black tree root node for the active timers
|
|
|
|
* @get_time: function to retrieve the current time of the clock
|
|
|
|
* @softirq_time: the time when running the hrtimer queue in the softirq
|
2007-02-16 09:28:11 +00:00
|
|
|
* @offset: offset of this clock to the monotonic base
|
2006-01-10 04:52:32 +00:00
|
|
|
*/
|
2007-02-16 09:27:50 +00:00
|
|
|
struct hrtimer_clock_base {
|
|
|
|
struct hrtimer_cpu_base *cpu_base;
|
2011-05-20 11:05:15 +00:00
|
|
|
int index;
|
|
|
|
clockid_t clockid;
|
2010-09-21 02:19:17 +00:00
|
|
|
struct timerqueue_head active;
|
2006-01-10 04:52:32 +00:00
|
|
|
ktime_t (*get_time)(void);
|
2006-03-26 09:38:05 +00:00
|
|
|
ktime_t softirq_time;
|
2007-02-16 09:28:11 +00:00
|
|
|
ktime_t offset;
|
2007-02-16 09:27:50 +00:00
|
|
|
};
|
|
|
|
|
2010-12-15 03:37:07 +00:00
|
|
|
enum hrtimer_base_type {
|
|
|
|
HRTIMER_BASE_MONOTONIC,
|
2011-05-20 21:14:04 +00:00
|
|
|
HRTIMER_BASE_REALTIME,
|
2011-02-15 18:45:16 +00:00
|
|
|
HRTIMER_BASE_BOOTTIME,
|
2013-01-22 01:00:11 +00:00
|
|
|
HRTIMER_BASE_TAI,
|
2010-12-15 03:37:07 +00:00
|
|
|
HRTIMER_MAX_CLOCK_BASES,
|
|
|
|
};
|
2007-02-16 09:27:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* struct hrtimer_cpu_base - the per cpu clock bases
|
|
|
|
* @lock: lock protecting the base and associated clock bases
|
|
|
|
* and timers
|
2014-06-21 23:29:15 +00:00
|
|
|
* @cpu: cpu number
|
2011-05-20 11:05:15 +00:00
|
|
|
* @active_bases: Bitfield to mark bases with active timers
|
2012-07-10 22:43:19 +00:00
|
|
|
* @clock_was_set: Indicates that clock was set from irq context.
|
2007-02-16 09:28:11 +00:00
|
|
|
* @expires_next: absolute time of the next event which was scheduled
|
|
|
|
* via clock_set_next_event()
|
2015-01-20 20:24:10 +00:00
|
|
|
* @in_hrtirq: hrtimer_interrupt() is currently executing
|
2007-02-16 09:28:11 +00:00
|
|
|
* @hres_active: State of high resolution mode
|
2009-11-13 16:05:44 +00:00
|
|
|
* @hang_detected: The last hrtimer interrupt detected a hang
|
|
|
|
* @nr_events: Total number of hrtimer interrupt events
|
|
|
|
* @nr_retries: Total number of hrtimer interrupt retries
|
|
|
|
* @nr_hangs: Total number of hrtimer interrupt hangs
|
|
|
|
* @max_hang_time: Maximum time spent in hrtimer_interrupt
|
2011-05-20 11:05:15 +00:00
|
|
|
* @clock_base: array of clock bases for this cpu
|
2007-02-16 09:27:50 +00:00
|
|
|
*/
|
|
|
|
struct hrtimer_cpu_base {
|
2009-11-17 15:36:54 +00:00
|
|
|
raw_spinlock_t lock;
|
2014-06-21 23:29:15 +00:00
|
|
|
unsigned int cpu;
|
2012-07-10 22:43:19 +00:00
|
|
|
unsigned int active_bases;
|
|
|
|
unsigned int clock_was_set;
|
2007-02-16 09:28:11 +00:00
|
|
|
#ifdef CONFIG_HIGH_RES_TIMERS
|
|
|
|
ktime_t expires_next;
|
2015-01-20 20:24:10 +00:00
|
|
|
int in_hrtirq;
|
2007-02-16 09:28:11 +00:00
|
|
|
int hres_active;
|
2009-11-13 16:05:44 +00:00
|
|
|
int hang_detected;
|
2015-04-14 21:08:34 +00:00
|
|
|
unsigned int nr_events;
|
|
|
|
unsigned int nr_retries;
|
|
|
|
unsigned int nr_hangs;
|
|
|
|
unsigned int max_hang_time;
|
2007-02-16 09:28:11 +00:00
|
|
|
#endif
|
2011-05-20 11:02:58 +00:00
|
|
|
struct hrtimer_clock_base clock_base[HRTIMER_MAX_CLOCK_BASES];
|
2006-01-10 04:52:32 +00:00
|
|
|
};
|
|
|
|
|
2008-09-01 21:35:02 +00:00
|
|
|
static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = time;
|
2008-09-01 22:47:08 +00:00
|
|
|
timer->_softexpires = time;
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
2008-09-01 22:47:08 +00:00
|
|
|
|
|
|
|
static inline void hrtimer_set_expires_range(struct hrtimer *timer, ktime_t time, ktime_t delta)
|
|
|
|
{
|
|
|
|
timer->_softexpires = time;
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = ktime_add_safe(time, delta);
|
2008-09-01 22:47:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, unsigned long delta)
|
|
|
|
{
|
|
|
|
timer->_softexpires = time;
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = ktime_add_safe(time, ns_to_ktime(delta));
|
2008-09-01 22:47:08 +00:00
|
|
|
}
|
|
|
|
|
2008-09-01 21:35:02 +00:00
|
|
|
static inline void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires.tv64 = tv64;
|
2008-09-01 22:47:08 +00:00
|
|
|
timer->_softexpires.tv64 = tv64;
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hrtimer_add_expires(struct hrtimer *timer, ktime_t time)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = ktime_add_safe(timer->node.expires, time);
|
2008-09-01 22:47:08 +00:00
|
|
|
timer->_softexpires = ktime_add_safe(timer->_softexpires, time);
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
2008-11-05 17:38:47 +00:00
|
|
|
static inline void hrtimer_add_expires_ns(struct hrtimer *timer, u64 ns)
|
2008-09-01 21:35:02 +00:00
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = ktime_add_ns(timer->node.expires, ns);
|
2008-09-01 22:47:08 +00:00
|
|
|
timer->_softexpires = ktime_add_ns(timer->_softexpires, ns);
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline ktime_t hrtimer_get_expires(const struct hrtimer *timer)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
return timer->node.expires;
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
2008-09-01 22:47:08 +00:00
|
|
|
static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return timer->_softexpires;
|
|
|
|
}
|
|
|
|
|
2008-09-01 21:35:02 +00:00
|
|
|
static inline s64 hrtimer_get_expires_tv64(const struct hrtimer *timer)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
return timer->node.expires.tv64;
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
2008-09-01 22:47:08 +00:00
|
|
|
static inline s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return timer->_softexpires.tv64;
|
|
|
|
}
|
2008-09-01 21:35:02 +00:00
|
|
|
|
|
|
|
static inline s64 hrtimer_get_expires_ns(const struct hrtimer *timer)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
return ktime_to_ns(timer->node.expires);
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
return ktime_sub(timer->node.expires, timer->base->get_time());
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
#ifdef CONFIG_HIGH_RES_TIMERS
|
|
|
|
struct clock_event_device;
|
|
|
|
|
|
|
|
extern void hrtimer_interrupt(struct clock_event_device *dev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In high resolution mode the time reference must be read accurate
|
|
|
|
*/
|
|
|
|
static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return timer->base->get_time();
|
|
|
|
}
|
|
|
|
|
2008-01-25 20:08:29 +00:00
|
|
|
static inline int hrtimer_is_hres_active(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return timer->base->cpu_base->hres_active;
|
|
|
|
}
|
|
|
|
|
2008-10-07 17:57:54 +00:00
|
|
|
extern void hrtimer_peek_ahead_timers(void);
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
/*
|
|
|
|
* The resolution of the clocks. The resolution value is returned in
|
|
|
|
* the clock_getres() system call to give application programmers an
|
|
|
|
* idea of the (in)accuracy of timers. Timer values are rounded up to
|
|
|
|
* this resolution values.
|
|
|
|
*/
|
2008-02-07 22:24:52 +00:00
|
|
|
# define HIGH_RES_NSEC 1
|
|
|
|
# define KTIME_HIGH_RES (ktime_t) { .tv64 = HIGH_RES_NSEC }
|
|
|
|
# define MONOTONIC_RES_NSEC HIGH_RES_NSEC
|
2007-02-16 09:28:11 +00:00
|
|
|
# define KTIME_MONOTONIC_RES KTIME_HIGH_RES
|
|
|
|
|
2012-07-10 22:43:19 +00:00
|
|
|
extern void clock_was_set_delayed(void);
|
|
|
|
|
2015-04-14 21:08:27 +00:00
|
|
|
extern unsigned int hrtimer_resolution;
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
#else
|
|
|
|
|
2008-02-07 22:24:52 +00:00
|
|
|
# define MONOTONIC_RES_NSEC LOW_RES_NSEC
|
2007-02-16 09:28:11 +00:00
|
|
|
# define KTIME_MONOTONIC_RES KTIME_LOW_RES
|
|
|
|
|
2015-04-14 21:08:27 +00:00
|
|
|
#define hrtimer_resolution LOW_RES_NSEC
|
|
|
|
|
2008-10-07 17:57:54 +00:00
|
|
|
static inline void hrtimer_peek_ahead_timers(void) { }
|
2007-02-16 09:28:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* In non high resolution mode the time reference is taken from
|
|
|
|
* the base softirq time variable.
|
|
|
|
*/
|
|
|
|
static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return timer->base->softirq_time;
|
|
|
|
}
|
|
|
|
|
2008-01-25 20:08:29 +00:00
|
|
|
static inline int hrtimer_is_hres_active(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2012-07-10 22:43:19 +00:00
|
|
|
|
|
|
|
static inline void clock_was_set_delayed(void) { }
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
#endif
|
|
|
|
|
2011-05-02 14:48:57 +00:00
|
|
|
extern void clock_was_set(void);
|
2011-05-20 14:18:50 +00:00
|
|
|
#ifdef CONFIG_TIMERFD
|
|
|
|
extern void timerfd_clock_was_set(void);
|
|
|
|
#else
|
|
|
|
static inline void timerfd_clock_was_set(void) { }
|
|
|
|
#endif
|
2011-05-02 14:48:57 +00:00
|
|
|
extern void hrtimers_resume(void);
|
|
|
|
|
2008-09-10 23:06:00 +00:00
|
|
|
DECLARE_PER_CPU(struct tick_device, tick_cpu_device);
|
|
|
|
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/* Exported timer functions: */
|
|
|
|
|
|
|
|
/* Initialize timers: */
|
2006-02-01 11:05:11 +00:00
|
|
|
extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
|
|
|
|
enum hrtimer_mode mode);
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2008-04-30 07:55:04 +00:00
|
|
|
#ifdef CONFIG_DEBUG_OBJECTS_TIMERS
|
|
|
|
extern void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t which_clock,
|
|
|
|
enum hrtimer_mode mode);
|
|
|
|
|
|
|
|
extern void destroy_hrtimer_on_stack(struct hrtimer *timer);
|
|
|
|
#else
|
|
|
|
static inline void hrtimer_init_on_stack(struct hrtimer *timer,
|
|
|
|
clockid_t which_clock,
|
|
|
|
enum hrtimer_mode mode)
|
|
|
|
{
|
|
|
|
hrtimer_init(timer, which_clock, mode);
|
|
|
|
}
|
|
|
|
static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
|
|
|
|
#endif
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/* Basic timer operations: */
|
|
|
|
extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
|
|
|
|
const enum hrtimer_mode mode);
|
2008-09-07 17:47:46 +00:00
|
|
|
extern int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
|
|
|
|
unsigned long range_ns, const enum hrtimer_mode mode);
|
2009-03-13 11:21:27 +00:00
|
|
|
extern int
|
|
|
|
__hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
|
|
|
|
unsigned long delta_ns,
|
|
|
|
const enum hrtimer_mode mode, int wakeup);
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
extern int hrtimer_cancel(struct hrtimer *timer);
|
|
|
|
extern int hrtimer_try_to_cancel(struct hrtimer *timer);
|
|
|
|
|
2008-09-01 21:35:02 +00:00
|
|
|
static inline int hrtimer_start_expires(struct hrtimer *timer,
|
|
|
|
enum hrtimer_mode mode)
|
|
|
|
{
|
2008-09-07 17:47:46 +00:00
|
|
|
unsigned long delta;
|
|
|
|
ktime_t soft, hard;
|
|
|
|
soft = hrtimer_get_softexpires(timer);
|
|
|
|
hard = hrtimer_get_expires(timer);
|
|
|
|
delta = ktime_to_ns(ktime_sub(hard, soft));
|
2008-09-07 22:31:39 +00:00
|
|
|
return hrtimer_start_range_ns(timer, soft, delta, mode);
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 09:27:49 +00:00
|
|
|
static inline int hrtimer_restart(struct hrtimer *timer)
|
|
|
|
{
|
2008-09-01 22:47:08 +00:00
|
|
|
return hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
|
2007-02-16 09:27:49 +00:00
|
|
|
}
|
2006-01-10 04:52:32 +00:00
|
|
|
|
|
|
|
/* Query timers: */
|
|
|
|
extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
|
|
|
|
|
2006-03-06 23:42:45 +00:00
|
|
|
extern ktime_t hrtimer_get_next_event(void);
|
|
|
|
|
2007-02-16 09:27:51 +00:00
|
|
|
/*
|
2011-03-10 17:26:33 +00:00
|
|
|
* A timer is active, when it is enqueued into the rbtree or the
|
|
|
|
* callback function is running or it's in the state of being migrated
|
|
|
|
* to another cpu.
|
2007-02-16 09:27:51 +00:00
|
|
|
*/
|
2006-01-10 04:52:32 +00:00
|
|
|
static inline int hrtimer_active(const struct hrtimer *timer)
|
|
|
|
{
|
2007-02-16 09:27:51 +00:00
|
|
|
return timer->state != HRTIMER_STATE_INACTIVE;
|
2006-01-10 04:52:32 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
/*
|
|
|
|
* Helper function to check, whether the timer is on one of the queues
|
|
|
|
*/
|
|
|
|
static inline int hrtimer_is_queued(struct hrtimer *timer)
|
|
|
|
{
|
2008-11-25 11:43:51 +00:00
|
|
|
return timer->state & HRTIMER_STATE_ENQUEUED;
|
2007-02-16 09:28:11 +00:00
|
|
|
}
|
|
|
|
|
2008-04-30 21:04:37 +00:00
|
|
|
/*
|
|
|
|
* Helper function to check, whether the timer is running the callback
|
|
|
|
* function
|
|
|
|
*/
|
|
|
|
static inline int hrtimer_callback_running(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return timer->state & HRTIMER_STATE_CALLBACK;
|
|
|
|
}
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/* Forward a hrtimer so it expires after now: */
|
timerfd: new timerfd API
This is the new timerfd API as it is implemented by the following patch:
int timerfd_create(int clockid, int flags);
int timerfd_settime(int ufd, int flags,
const struct itimerspec *utmr,
struct itimerspec *otmr);
int timerfd_gettime(int ufd, struct itimerspec *otmr);
The timerfd_create() API creates an un-programmed timerfd fd. The "clockid"
parameter can be either CLOCK_MONOTONIC or CLOCK_REALTIME.
The timerfd_settime() API give new settings by the timerfd fd, by optionally
retrieving the previous expiration time (in case the "otmr" parameter is not
NULL).
The time value specified in "utmr" is absolute, if the TFD_TIMER_ABSTIME bit
is set in the "flags" parameter. Otherwise it's a relative time.
The timerfd_gettime() API returns the next expiration time of the timer, or
{0, 0} if the timerfd has not been set yet.
Like the previous timerfd API implementation, read(2) and poll(2) are
supported (with the same interface). Here's a simple test program I used to
exercise the new timerfd APIs:
http://www.xmailserver.org/timerfd-test2.c
[akpm@linux-foundation.org: coding-style cleanups]
[akpm@linux-foundation.org: fix ia64 build]
[akpm@linux-foundation.org: fix m68k build]
[akpm@linux-foundation.org: fix mips build]
[akpm@linux-foundation.org: fix alpha, arm, blackfin, cris, m68k, s390, sparc and sparc64 builds]
[heiko.carstens@de.ibm.com: fix s390]
[akpm@linux-foundation.org: fix powerpc build]
[akpm@linux-foundation.org: fix sparc64 more]
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Michael Kerrisk <mtk.manpages@gmail.com>
Cc: Davide Libenzi <davidel@xmailserver.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-05 06:27:26 +00:00
|
|
|
extern u64
|
2006-03-26 09:38:06 +00:00
|
|
|
hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2015-04-13 21:02:22 +00:00
|
|
|
/**
|
|
|
|
* hrtimer_forward_now - forward the timer expiry so it expires after now
|
|
|
|
* @timer: hrtimer to forward
|
|
|
|
* @interval: the interval to forward
|
|
|
|
*
|
|
|
|
* Forward the timer expiry so it will expire after the current time
|
|
|
|
* of the hrtimer clock base. Returns the number of overruns.
|
|
|
|
*
|
|
|
|
* Can be safely called from the callback function of @timer. If
|
|
|
|
* called from other contexts @timer must neither be enqueued nor
|
|
|
|
* running the callback and the caller needs to take care of
|
|
|
|
* serialization.
|
|
|
|
*
|
|
|
|
* Note: This only updates the timer expiry value and does not requeue
|
|
|
|
* the timer.
|
|
|
|
*/
|
timerfd: new timerfd API
This is the new timerfd API as it is implemented by the following patch:
int timerfd_create(int clockid, int flags);
int timerfd_settime(int ufd, int flags,
const struct itimerspec *utmr,
struct itimerspec *otmr);
int timerfd_gettime(int ufd, struct itimerspec *otmr);
The timerfd_create() API creates an un-programmed timerfd fd. The "clockid"
parameter can be either CLOCK_MONOTONIC or CLOCK_REALTIME.
The timerfd_settime() API give new settings by the timerfd fd, by optionally
retrieving the previous expiration time (in case the "otmr" parameter is not
NULL).
The time value specified in "utmr" is absolute, if the TFD_TIMER_ABSTIME bit
is set in the "flags" parameter. Otherwise it's a relative time.
The timerfd_gettime() API returns the next expiration time of the timer, or
{0, 0} if the timerfd has not been set yet.
Like the previous timerfd API implementation, read(2) and poll(2) are
supported (with the same interface). Here's a simple test program I used to
exercise the new timerfd APIs:
http://www.xmailserver.org/timerfd-test2.c
[akpm@linux-foundation.org: coding-style cleanups]
[akpm@linux-foundation.org: fix ia64 build]
[akpm@linux-foundation.org: fix m68k build]
[akpm@linux-foundation.org: fix mips build]
[akpm@linux-foundation.org: fix alpha, arm, blackfin, cris, m68k, s390, sparc and sparc64 builds]
[heiko.carstens@de.ibm.com: fix s390]
[akpm@linux-foundation.org: fix powerpc build]
[akpm@linux-foundation.org: fix sparc64 more]
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Michael Kerrisk <mtk.manpages@gmail.com>
Cc: Davide Libenzi <davidel@xmailserver.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-05 06:27:26 +00:00
|
|
|
static inline u64 hrtimer_forward_now(struct hrtimer *timer,
|
|
|
|
ktime_t interval)
|
2008-02-05 06:27:25 +00:00
|
|
|
{
|
|
|
|
return hrtimer_forward(timer, timer->base->get_time(), interval);
|
|
|
|
}
|
|
|
|
|
2006-01-10 04:52:35 +00:00
|
|
|
/* Precise sleep: */
|
|
|
|
extern long hrtimer_nanosleep(struct timespec *rqtp,
|
2008-02-01 14:29:05 +00:00
|
|
|
struct timespec __user *rmtp,
|
2006-01-10 04:52:35 +00:00
|
|
|
const enum hrtimer_mode mode,
|
|
|
|
const clockid_t clockid);
|
2006-09-29 09:00:28 +00:00
|
|
|
extern long hrtimer_nanosleep_restart(struct restart_block *restart_block);
|
2006-01-10 04:52:35 +00:00
|
|
|
|
2006-03-31 10:31:17 +00:00
|
|
|
extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
|
|
|
|
struct task_struct *tsk);
|
|
|
|
|
2008-09-01 22:47:08 +00:00
|
|
|
extern int schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
|
|
|
|
const enum hrtimer_mode mode);
|
2010-04-02 20:40:19 +00:00
|
|
|
extern int schedule_hrtimeout_range_clock(ktime_t *expires,
|
|
|
|
unsigned long delta, const enum hrtimer_mode mode, int clock);
|
2008-08-31 15:05:58 +00:00
|
|
|
extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/* Soft interrupt function to run the hrtimer queues: */
|
|
|
|
extern void hrtimer_run_queues(void);
|
2008-01-25 20:08:31 +00:00
|
|
|
extern void hrtimer_run_pending(void);
|
2006-01-10 04:52:32 +00:00
|
|
|
|
|
|
|
/* Bootup initialization: */
|
|
|
|
extern void __init hrtimers_init(void);
|
|
|
|
|
2007-02-16 09:28:16 +00:00
|
|
|
/* Show pending timers: */
|
|
|
|
extern void sysrq_timer_list_show(void);
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
#endif
|