Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 1 | /* |
| 2 | * include/linux/hrtimer.h |
| 3 | * |
| 4 | * hrtimers - High-resolution kernel timers |
| 5 | * |
| 6 | * Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de> |
| 7 | * Copyright(C) 2005, Red Hat, Inc., Ingo Molnar |
| 8 | * |
| 9 | * data type definitions, declarations, prototypes |
| 10 | * |
| 11 | * Started by: Thomas Gleixner and Ingo Molnar |
| 12 | * |
| 13 | * For licencing details see kernel-base/COPYING |
| 14 | */ |
| 15 | #ifndef _LINUX_HRTIMER_H |
| 16 | #define _LINUX_HRTIMER_H |
| 17 | |
| 18 | #include <linux/rbtree.h> |
| 19 | #include <linux/ktime.h> |
| 20 | #include <linux/init.h> |
| 21 | #include <linux/list.h> |
| 22 | #include <linux/wait.h> |
| 23 | |
| 24 | /* |
| 25 | * Mode arguments of xxx_hrtimer functions: |
| 26 | */ |
| 27 | enum hrtimer_mode { |
| 28 | HRTIMER_ABS, /* Time value is absolute */ |
| 29 | HRTIMER_REL, /* Time value is relative to now */ |
| 30 | }; |
| 31 | |
| 32 | enum hrtimer_restart { |
| 33 | HRTIMER_NORESTART, |
| 34 | HRTIMER_RESTART, |
| 35 | }; |
| 36 | |
Roman Zippel | b75f7a5 | 2006-03-26 01:38:09 -0800 | [diff] [blame] | 37 | #define HRTIMER_INACTIVE ((void *)1UL) |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 38 | |
| 39 | struct hrtimer_base; |
| 40 | |
| 41 | /** |
| 42 | * struct hrtimer - the basic hrtimer structure |
| 43 | * |
| 44 | * @node: red black tree node for time ordered insertion |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 45 | * @expires: the absolute expiry time in the hrtimers internal |
| 46 | * representation. The time is related to the clock on |
| 47 | * which the timer is based. |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 48 | * @function: timer expiry callback function |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 49 | * @base: pointer to the timer base (per cpu and per clock) |
| 50 | * |
| 51 | * The hrtimer structure must be initialized by init_hrtimer_#CLOCKTYPE() |
| 52 | */ |
| 53 | struct hrtimer { |
| 54 | struct rb_node node; |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 55 | ktime_t expires; |
Roman Zippel | 05cfb61 | 2006-03-26 01:38:12 -0800 | [diff] [blame] | 56 | int (*function)(struct hrtimer *); |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 57 | struct hrtimer_base *base; |
| 58 | }; |
| 59 | |
| 60 | /** |
Thomas Gleixner | 00362e3 | 2006-03-31 02:31:17 -0800 | [diff] [blame] | 61 | * struct hrtimer_sleeper - simple sleeper structure |
| 62 | * |
| 63 | * @timer: embedded timer structure |
| 64 | * @task: task to wake up |
| 65 | * |
| 66 | * task is set to NULL, when the timer expires. |
| 67 | */ |
| 68 | struct hrtimer_sleeper { |
| 69 | struct hrtimer timer; |
| 70 | struct task_struct *task; |
| 71 | }; |
| 72 | |
| 73 | /** |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 74 | * struct hrtimer_base - the timer base for a specific clock |
| 75 | * |
Thomas Gleixner | 92127c7 | 2006-03-26 01:38:05 -0800 | [diff] [blame] | 76 | * @index: clock type index for per_cpu support when moving a timer |
| 77 | * to a base on another cpu. |
| 78 | * @lock: lock protecting the base and associated timers |
| 79 | * @active: red black tree root node for the active timers |
| 80 | * @first: pointer to the timer node which expires first |
| 81 | * @resolution: the resolution of the clock, in nanoseconds |
| 82 | * @get_time: function to retrieve the current time of the clock |
Martin Waitz | a580290 | 2006-04-02 13:59:55 +0200 | [diff] [blame] | 83 | * @get_softirq_time: function to retrieve the current time from the softirq |
Thomas Gleixner | 92127c7 | 2006-03-26 01:38:05 -0800 | [diff] [blame] | 84 | * @curr_timer: the timer which is executing a callback right now |
| 85 | * @softirq_time: the time when running the hrtimer queue in the softirq |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 86 | */ |
| 87 | struct hrtimer_base { |
| 88 | clockid_t index; |
| 89 | spinlock_t lock; |
| 90 | struct rb_root active; |
Thomas Gleixner | 288867e | 2006-01-12 11:25:54 +0100 | [diff] [blame] | 91 | struct rb_node *first; |
Thomas Gleixner | e278763 | 2006-01-12 11:36:14 +0100 | [diff] [blame] | 92 | ktime_t resolution; |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 93 | ktime_t (*get_time)(void); |
Thomas Gleixner | 92127c7 | 2006-03-26 01:38:05 -0800 | [diff] [blame] | 94 | ktime_t (*get_softirq_time)(void); |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 95 | struct hrtimer *curr_timer; |
Thomas Gleixner | 92127c7 | 2006-03-26 01:38:05 -0800 | [diff] [blame] | 96 | ktime_t softirq_time; |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 97 | }; |
| 98 | |
Thomas Gleixner | becf8b5 | 2006-01-09 20:52:38 -0800 | [diff] [blame] | 99 | /* |
| 100 | * clock_was_set() is a NOP for non- high-resolution systems. The |
| 101 | * time-sorted order guarantees that a timer does not expire early and |
| 102 | * is expired in the next softirq when the clock was advanced. |
| 103 | */ |
| 104 | #define clock_was_set() do { } while (0) |
| 105 | |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 106 | /* Exported timer functions: */ |
| 107 | |
| 108 | /* Initialize timers: */ |
George Anzinger | 7978672 | 2006-02-01 03:05:11 -0800 | [diff] [blame] | 109 | extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock, |
| 110 | enum hrtimer_mode mode); |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 111 | |
| 112 | /* Basic timer operations: */ |
| 113 | extern int hrtimer_start(struct hrtimer *timer, ktime_t tim, |
| 114 | const enum hrtimer_mode mode); |
| 115 | extern int hrtimer_cancel(struct hrtimer *timer); |
| 116 | extern int hrtimer_try_to_cancel(struct hrtimer *timer); |
| 117 | |
| 118 | #define hrtimer_restart(timer) hrtimer_start((timer), (timer)->expires, HRTIMER_ABS) |
| 119 | |
| 120 | /* Query timers: */ |
| 121 | extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer); |
| 122 | extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp); |
| 123 | |
Tony Lindgren | 6923974 | 2006-03-06 15:42:45 -0800 | [diff] [blame] | 124 | #ifdef CONFIG_NO_IDLE_HZ |
| 125 | extern ktime_t hrtimer_get_next_event(void); |
| 126 | #endif |
| 127 | |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 128 | static inline int hrtimer_active(const struct hrtimer *timer) |
| 129 | { |
David Woodhouse | ed198cb | 2006-04-22 02:38:50 +0100 | [diff] [blame] | 130 | return rb_parent(&timer->node) != &timer->node; |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | /* Forward a hrtimer so it expires after now: */ |
Roman Zippel | 44f2147 | 2006-03-26 01:38:06 -0800 | [diff] [blame] | 134 | extern unsigned long |
| 135 | hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval); |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 136 | |
Thomas Gleixner | 10c94ec | 2006-01-09 20:52:35 -0800 | [diff] [blame] | 137 | /* Precise sleep: */ |
| 138 | extern long hrtimer_nanosleep(struct timespec *rqtp, |
| 139 | struct timespec __user *rmtp, |
| 140 | const enum hrtimer_mode mode, |
| 141 | const clockid_t clockid); |
| 142 | |
Thomas Gleixner | 00362e3 | 2006-03-31 02:31:17 -0800 | [diff] [blame] | 143 | extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, |
| 144 | struct task_struct *tsk); |
| 145 | |
Thomas Gleixner | c0a3132 | 2006-01-09 20:52:32 -0800 | [diff] [blame] | 146 | /* Soft interrupt function to run the hrtimer queues: */ |
| 147 | extern void hrtimer_run_queues(void); |
| 148 | |
| 149 | /* Bootup initialization: */ |
| 150 | extern void __init hrtimers_init(void); |
| 151 | |
| 152 | #endif |