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#include <linux/percpu.h> 24#include <linux/timer.h> 25#include <linux/timerqueue.h> 26 27struct hrtimer_clock_base; 28struct hrtimer_cpu_base; 29 30/* 31 * Mode arguments of xxx_hrtimer functions: 32 */ 33enum hrtimer_mode { 34 HRTIMER_MODE_ABS = 0x0, /* Time value is absolute */ 35 HRTIMER_MODE_REL = 0x1, /* Time value is relative to now */ 36 HRTIMER_MODE_PINNED = 0x02, /* Timer is bound to CPU */ 37 HRTIMER_MODE_ABS_PINNED = 0x02, 38 HRTIMER_MODE_REL_PINNED = 0x03, 39}; 40 41/* 42 * Return values for the callback function 43 */ 44enum hrtimer_restart { 45 HRTIMER_NORESTART, /* Timer is not restarted */ 46 HRTIMER_RESTART, /* Timer must be restarted */ 47}; 48 49/* 50 * Values to track state of the timer 51 * 52 * Possible states: 53 * 54 * 0x00 inactive 55 * 0x01 enqueued into rbtree 56 * 0x02 callback function running 57 * 0x04 timer is migrated to another cpu 58 * 59 * Special cases: 60 * 0x03 callback function running and enqueued 61 * (was requeued on another CPU) 62 * 0x05 timer was migrated on CPU hotunplug 63 * 64 * The "callback function running and enqueued" status is only possible on 65 * SMP. It happens for example when a posix timer expired and the callback 66 * queued a signal. Between dropping the lock which protects the posix timer 67 * and reacquiring the base lock of the hrtimer, another CPU can deliver the 68 * signal and rearm the timer. We have to preserve the callback running state, 69 * as otherwise the timer could be removed before the softirq code finishes the 70 * the handling of the timer. 71 * 72 * The HRTIMER_STATE_ENQUEUED bit is always or'ed to the current state 73 * to preserve the HRTIMER_STATE_CALLBACK in the above scenario. This 74 * also affects HRTIMER_STATE_MIGRATE where the preservation is not 75 * necessary. HRTIMER_STATE_MIGRATE is cleared after the timer is 76 * enqueued on the new cpu. 77 * 78 * All state transitions are protected by cpu_base->lock. 79 */ 80#define HRTIMER_STATE_INACTIVE 0x00 81#define HRTIMER_STATE_ENQUEUED 0x01 82#define HRTIMER_STATE_CALLBACK 0x02 83#define HRTIMER_STATE_MIGRATE 0x04 84 85/** 86 * struct hrtimer - the basic hrtimer structure 87 * @node: timerqueue node, which also manages node.expires, 88 * the absolute expiry time in the hrtimers internal 89 * representation. The time is related to the clock on 90 * which the timer is based. Is setup by adding 91 * slack to the _softexpires value. For non range timers 92 * identical to _softexpires. 93 * @_softexpires: the absolute earliest expiry time of the hrtimer. 94 * The time which was given as expiry time when the timer 95 * was armed. 96 * @function: timer expiry callback function 97 * @base: pointer to the timer base (per cpu and per clock) 98 * @state: state information (See bit values above) 99 * @start_pid: timer statistics field to store the pid of the task which 100 * started the timer 101 * @start_site: timer statistics field to store the site where the timer 102 * was started 103 * @start_comm: timer statistics field to store the name of the process which 104 * started the timer 105 * 106 * The hrtimer structure must be initialized by hrtimer_init() 107 */ 108struct hrtimer { 109 struct timerqueue_node node; 110 ktime_t _softexpires; 111 enum hrtimer_restart (*function)(struct hrtimer *); 112 struct hrtimer_clock_base *base; 113 unsigned long state; 114#ifdef CONFIG_TIMER_STATS 115 int start_pid; 116 void *start_site; 117 char start_comm[16]; 118#endif 119}; 120 121/** 122 * struct hrtimer_sleeper - simple sleeper structure 123 * @timer: embedded timer structure 124 * @task: task to wake up 125 * 126 * task is set to NULL, when the timer expires. 127 */ 128struct hrtimer_sleeper { 129 struct hrtimer timer; 130 struct task_struct *task; 131}; 132 133/** 134 * struct hrtimer_clock_base - the timer base for a specific clock 135 * @cpu_base: per cpu clock base 136 * @index: clock type index for per_cpu support when moving a 137 * timer to a base on another cpu. 138 * @clockid: clock id for per_cpu support 139 * @active: red black tree root node for the active timers 140 * @resolution: the resolution of the clock, in nanoseconds 141 * @get_time: function to retrieve the current time of the clock 142 * @softirq_time: the time when running the hrtimer queue in the softirq 143 * @offset: offset of this clock to the monotonic base 144 */ 145struct hrtimer_clock_base { 146 struct hrtimer_cpu_base *cpu_base; 147 int index; 148 clockid_t clockid; 149 struct timerqueue_head active; 150 ktime_t resolution; 151 ktime_t (*get_time)(void); 152 ktime_t softirq_time; 153 ktime_t offset; 154}; 155 156enum hrtimer_base_type { 157 HRTIMER_BASE_MONOTONIC, 158 HRTIMER_BASE_REALTIME, 159 HRTIMER_BASE_BOOTTIME, 160 HRTIMER_BASE_TAI, 161 HRTIMER_MAX_CLOCK_BASES, 162}; 163 164/* 165 * struct hrtimer_cpu_base - the per cpu clock bases 166 * @lock: lock protecting the base and associated clock bases 167 * and timers 168 * @cpu: cpu number 169 * @active_bases: Bitfield to mark bases with active timers 170 * @clock_was_set: Indicates that clock was set from irq context. 171 * @expires_next: absolute time of the next event which was scheduled 172 * via clock_set_next_event() 173 * @in_hrtirq: hrtimer_interrupt() is currently executing 174 * @hres_active: State of high resolution mode 175 * @hang_detected: The last hrtimer interrupt detected a hang 176 * @nr_events: Total number of hrtimer interrupt events 177 * @nr_retries: Total number of hrtimer interrupt retries 178 * @nr_hangs: Total number of hrtimer interrupt hangs 179 * @max_hang_time: Maximum time spent in hrtimer_interrupt 180 * @clock_base: array of clock bases for this cpu 181 */ 182struct hrtimer_cpu_base { 183 raw_spinlock_t lock; 184 unsigned int cpu; 185 unsigned int active_bases; 186 unsigned int clock_was_set; 187#ifdef CONFIG_HIGH_RES_TIMERS 188 ktime_t expires_next; 189 int in_hrtirq; 190 int hres_active; 191 int hang_detected; 192 unsigned long nr_events; 193 unsigned long nr_retries; 194 unsigned long nr_hangs; 195 ktime_t max_hang_time; 196#endif 197 struct hrtimer_clock_base clock_base[HRTIMER_MAX_CLOCK_BASES]; 198}; 199 200static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time) 201{ 202 timer->node.expires = time; 203 timer->_softexpires = time; 204} 205 206static inline void hrtimer_set_expires_range(struct hrtimer *timer, ktime_t time, ktime_t delta) 207{ 208 timer->_softexpires = time; 209 timer->node.expires = ktime_add_safe(time, delta); 210} 211 212static inline void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, unsigned long delta) 213{ 214 timer->_softexpires = time; 215 timer->node.expires = ktime_add_safe(time, ns_to_ktime(delta)); 216} 217 218static inline void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64) 219{ 220 timer->node.expires.tv64 = tv64; 221 timer->_softexpires.tv64 = tv64; 222} 223 224static inline void hrtimer_add_expires(struct hrtimer *timer, ktime_t time) 225{ 226 timer->node.expires = ktime_add_safe(timer->node.expires, time); 227 timer->_softexpires = ktime_add_safe(timer->_softexpires, time); 228} 229 230static inline void hrtimer_add_expires_ns(struct hrtimer *timer, u64 ns) 231{ 232 timer->node.expires = ktime_add_ns(timer->node.expires, ns); 233 timer->_softexpires = ktime_add_ns(timer->_softexpires, ns); 234} 235 236static inline ktime_t hrtimer_get_expires(const struct hrtimer *timer) 237{ 238 return timer->node.expires; 239} 240 241static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer) 242{ 243 return timer->_softexpires; 244} 245 246static inline s64 hrtimer_get_expires_tv64(const struct hrtimer *timer) 247{ 248 return timer->node.expires.tv64; 249} 250static inline s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer) 251{ 252 return timer->_softexpires.tv64; 253} 254 255static inline s64 hrtimer_get_expires_ns(const struct hrtimer *timer) 256{ 257 return ktime_to_ns(timer->node.expires); 258} 259 260static inline ktime_t hrtimer_expires_remaining(const struct hrtimer *timer) 261{ 262 return ktime_sub(timer->node.expires, timer->base->get_time()); 263} 264 265#ifdef CONFIG_HIGH_RES_TIMERS 266struct clock_event_device; 267 268extern void hrtimer_interrupt(struct clock_event_device *dev); 269 270/* 271 * In high resolution mode the time reference must be read accurate 272 */ 273static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer) 274{ 275 return timer->base->get_time(); 276} 277 278static inline int hrtimer_is_hres_active(struct hrtimer *timer) 279{ 280 return timer->base->cpu_base->hres_active; 281} 282 283extern void hrtimer_peek_ahead_timers(void); 284 285/* 286 * The resolution of the clocks. The resolution value is returned in 287 * the clock_getres() system call to give application programmers an 288 * idea of the (in)accuracy of timers. Timer values are rounded up to 289 * this resolution values. 290 */ 291# define HIGH_RES_NSEC 1 292# define KTIME_HIGH_RES (ktime_t) { .tv64 = HIGH_RES_NSEC } 293# define MONOTONIC_RES_NSEC HIGH_RES_NSEC 294# define KTIME_MONOTONIC_RES KTIME_HIGH_RES 295 296extern void clock_was_set_delayed(void); 297 298#else 299 300# define MONOTONIC_RES_NSEC LOW_RES_NSEC 301# define KTIME_MONOTONIC_RES KTIME_LOW_RES 302 303static inline void hrtimer_peek_ahead_timers(void) { } 304 305/* 306 * In non high resolution mode the time reference is taken from 307 * the base softirq time variable. 308 */ 309static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer) 310{ 311 return timer->base->softirq_time; 312} 313 314static inline int hrtimer_is_hres_active(struct hrtimer *timer) 315{ 316 return 0; 317} 318 319static inline void clock_was_set_delayed(void) { } 320 321#endif 322 323extern void clock_was_set(void); 324#ifdef CONFIG_TIMERFD 325extern void timerfd_clock_was_set(void); 326#else 327static inline void timerfd_clock_was_set(void) { } 328#endif 329extern void hrtimers_resume(void); 330 331DECLARE_PER_CPU(struct tick_device, tick_cpu_device); 332 333 334/* Exported timer functions: */ 335 336/* Initialize timers: */ 337extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock, 338 enum hrtimer_mode mode); 339 340#ifdef CONFIG_DEBUG_OBJECTS_TIMERS 341extern void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t which_clock, 342 enum hrtimer_mode mode); 343 344extern void destroy_hrtimer_on_stack(struct hrtimer *timer); 345#else 346static inline void hrtimer_init_on_stack(struct hrtimer *timer, 347 clockid_t which_clock, 348 enum hrtimer_mode mode) 349{ 350 hrtimer_init(timer, which_clock, mode); 351} 352static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { } 353#endif 354 355/* Basic timer operations: */ 356extern int hrtimer_start(struct hrtimer *timer, ktime_t tim, 357 const enum hrtimer_mode mode); 358extern int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, 359 unsigned long range_ns, const enum hrtimer_mode mode); 360extern int 361__hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, 362 unsigned long delta_ns, 363 const enum hrtimer_mode mode, int wakeup); 364 365extern int hrtimer_cancel(struct hrtimer *timer); 366extern int hrtimer_try_to_cancel(struct hrtimer *timer); 367 368static inline int hrtimer_start_expires(struct hrtimer *timer, 369 enum hrtimer_mode mode) 370{ 371 unsigned long delta; 372 ktime_t soft, hard; 373 soft = hrtimer_get_softexpires(timer); 374 hard = hrtimer_get_expires(timer); 375 delta = ktime_to_ns(ktime_sub(hard, soft)); 376 return hrtimer_start_range_ns(timer, soft, delta, mode); 377} 378 379static inline int hrtimer_restart(struct hrtimer *timer) 380{ 381 return hrtimer_start_expires(timer, HRTIMER_MODE_ABS); 382} 383 384/* Query timers: */ 385extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer); 386extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp); 387 388extern ktime_t hrtimer_get_next_event(void); 389 390/* 391 * A timer is active, when it is enqueued into the rbtree or the 392 * callback function is running or it's in the state of being migrated 393 * to another cpu. 394 */ 395static inline int hrtimer_active(const struct hrtimer *timer) 396{ 397 return timer->state != HRTIMER_STATE_INACTIVE; 398} 399 400/* 401 * Helper function to check, whether the timer is on one of the queues 402 */ 403static inline int hrtimer_is_queued(struct hrtimer *timer) 404{ 405 return timer->state & HRTIMER_STATE_ENQUEUED; 406} 407 408/* 409 * Helper function to check, whether the timer is running the callback 410 * function 411 */ 412static inline int hrtimer_callback_running(struct hrtimer *timer) 413{ 414 return timer->state & HRTIMER_STATE_CALLBACK; 415} 416 417/* Forward a hrtimer so it expires after now: */ 418extern u64 419hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval); 420 421/* Forward a hrtimer so it expires after the hrtimer's current now */ 422static inline u64 hrtimer_forward_now(struct hrtimer *timer, 423 ktime_t interval) 424{ 425 return hrtimer_forward(timer, timer->base->get_time(), interval); 426} 427 428/* Precise sleep: */ 429extern long hrtimer_nanosleep(struct timespec *rqtp, 430 struct timespec __user *rmtp, 431 const enum hrtimer_mode mode, 432 const clockid_t clockid); 433extern long hrtimer_nanosleep_restart(struct restart_block *restart_block); 434 435extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, 436 struct task_struct *tsk); 437 438extern int schedule_hrtimeout_range(ktime_t *expires, unsigned long delta, 439 const enum hrtimer_mode mode); 440extern int schedule_hrtimeout_range_clock(ktime_t *expires, 441 unsigned long delta, const enum hrtimer_mode mode, int clock); 442extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode); 443 444/* Soft interrupt function to run the hrtimer queues: */ 445extern void hrtimer_run_queues(void); 446extern void hrtimer_run_pending(void); 447 448/* Bootup initialization: */ 449extern void __init hrtimers_init(void); 450 451/* Show pending timers: */ 452extern void sysrq_timer_list_show(void); 453 454#endif 455