1#ifndef _LINUX_TIMER_H 2#define _LINUX_TIMER_H 3 4#include <linux/list.h> 5#include <linux/ktime.h> 6#include <linux/stddef.h> 7#include <linux/debugobjects.h> 8#include <linux/stringify.h> 9 10struct tvec_base; 11 12struct timer_list { 13 /* 14 * All fields that change during normal runtime grouped to the 15 * same cacheline 16 */ 17 struct hlist_node entry; 18 unsigned long expires; 19 void (*function)(unsigned long); 20 unsigned long data; 21 u32 flags; 22 int slack; 23 24#ifdef CONFIG_TIMER_STATS 25 int start_pid; 26 void *start_site; 27 char start_comm[16]; 28#endif 29#ifdef CONFIG_LOCKDEP 30 struct lockdep_map lockdep_map; 31#endif 32}; 33 34#ifdef CONFIG_LOCKDEP 35/* 36 * NB: because we have to copy the lockdep_map, setting the lockdep_map key 37 * (second argument) here is required, otherwise it could be initialised to 38 * the copy of the lockdep_map later! We use the pointer to and the string 39 * "<file>:<line>" as the key resp. the name of the lockdep_map. 40 */ 41#define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn) \ 42 .lockdep_map = STATIC_LOCKDEP_MAP_INIT(_kn, &_kn), 43#else 44#define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn) 45#endif 46 47/* 48 * A deferrable timer will work normally when the system is busy, but 49 * will not cause a CPU to come out of idle just to service it; instead, 50 * the timer will be serviced when the CPU eventually wakes up with a 51 * subsequent non-deferrable timer. 52 * 53 * An irqsafe timer is executed with IRQ disabled and it's safe to wait for 54 * the completion of the running instance from IRQ handlers, for example, 55 * by calling del_timer_sync(). 56 * 57 * Note: The irq disabled callback execution is a special case for 58 * workqueue locking issues. It's not meant for executing random crap 59 * with interrupts disabled. Abuse is monitored! 60 */ 61#define TIMER_CPUMASK 0x0007FFFF 62#define TIMER_MIGRATING 0x00080000 63#define TIMER_BASEMASK (TIMER_CPUMASK | TIMER_MIGRATING) 64#define TIMER_DEFERRABLE 0x00100000 65#define TIMER_IRQSAFE 0x00200000 66 67#define __TIMER_INITIALIZER(_function, _expires, _data, _flags) { \ 68 .entry = { .next = TIMER_ENTRY_STATIC }, \ 69 .function = (_function), \ 70 .expires = (_expires), \ 71 .data = (_data), \ 72 .flags = (_flags), \ 73 .slack = -1, \ 74 __TIMER_LOCKDEP_MAP_INITIALIZER( \ 75 __FILE__ ":" __stringify(__LINE__)) \ 76 } 77 78#define TIMER_INITIALIZER(_function, _expires, _data) \ 79 __TIMER_INITIALIZER((_function), (_expires), (_data), 0) 80 81#define TIMER_DEFERRED_INITIALIZER(_function, _expires, _data) \ 82 __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE) 83 84#define DEFINE_TIMER(_name, _function, _expires, _data) \ 85 struct timer_list _name = \ 86 TIMER_INITIALIZER(_function, _expires, _data) 87 88void init_timer_key(struct timer_list *timer, unsigned int flags, 89 const char *name, struct lock_class_key *key); 90 91#ifdef CONFIG_DEBUG_OBJECTS_TIMERS 92extern void init_timer_on_stack_key(struct timer_list *timer, 93 unsigned int flags, const char *name, 94 struct lock_class_key *key); 95extern void destroy_timer_on_stack(struct timer_list *timer); 96#else 97static inline void destroy_timer_on_stack(struct timer_list *timer) { } 98static inline void init_timer_on_stack_key(struct timer_list *timer, 99 unsigned int flags, const char *name, 100 struct lock_class_key *key) 101{ 102 init_timer_key(timer, flags, name, key); 103} 104#endif 105 106#ifdef CONFIG_LOCKDEP 107#define __init_timer(_timer, _flags) \ 108 do { \ 109 static struct lock_class_key __key; \ 110 init_timer_key((_timer), (_flags), #_timer, &__key); \ 111 } while (0) 112 113#define __init_timer_on_stack(_timer, _flags) \ 114 do { \ 115 static struct lock_class_key __key; \ 116 init_timer_on_stack_key((_timer), (_flags), #_timer, &__key); \ 117 } while (0) 118#else 119#define __init_timer(_timer, _flags) \ 120 init_timer_key((_timer), (_flags), NULL, NULL) 121#define __init_timer_on_stack(_timer, _flags) \ 122 init_timer_on_stack_key((_timer), (_flags), NULL, NULL) 123#endif 124 125#define init_timer(timer) \ 126 __init_timer((timer), 0) 127#define init_timer_deferrable(timer) \ 128 __init_timer((timer), TIMER_DEFERRABLE) 129#define init_timer_on_stack(timer) \ 130 __init_timer_on_stack((timer), 0) 131 132#define __setup_timer(_timer, _fn, _data, _flags) \ 133 do { \ 134 __init_timer((_timer), (_flags)); \ 135 (_timer)->function = (_fn); \ 136 (_timer)->data = (_data); \ 137 } while (0) 138 139#define __setup_timer_on_stack(_timer, _fn, _data, _flags) \ 140 do { \ 141 __init_timer_on_stack((_timer), (_flags)); \ 142 (_timer)->function = (_fn); \ 143 (_timer)->data = (_data); \ 144 } while (0) 145 146#define setup_timer(timer, fn, data) \ 147 __setup_timer((timer), (fn), (data), 0) 148#define setup_timer_on_stack(timer, fn, data) \ 149 __setup_timer_on_stack((timer), (fn), (data), 0) 150#define setup_deferrable_timer_on_stack(timer, fn, data) \ 151 __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE) 152 153/** 154 * timer_pending - is a timer pending? 155 * @timer: the timer in question 156 * 157 * timer_pending will tell whether a given timer is currently pending, 158 * or not. Callers must ensure serialization wrt. other operations done 159 * to this timer, eg. interrupt contexts, or other CPUs on SMP. 160 * 161 * return value: 1 if the timer is pending, 0 if not. 162 */ 163static inline int timer_pending(const struct timer_list * timer) 164{ 165 return timer->entry.pprev != NULL; 166} 167 168extern void add_timer_on(struct timer_list *timer, int cpu); 169extern int del_timer(struct timer_list * timer); 170extern int mod_timer(struct timer_list *timer, unsigned long expires); 171extern int mod_timer_pending(struct timer_list *timer, unsigned long expires); 172extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires); 173 174extern void set_timer_slack(struct timer_list *time, int slack_hz); 175 176#define TIMER_NOT_PINNED 0 177#define TIMER_PINNED 1 178/* 179 * The jiffies value which is added to now, when there is no timer 180 * in the timer wheel: 181 */ 182#define NEXT_TIMER_MAX_DELTA ((1UL << 30) - 1) 183 184/* 185 * Timer-statistics info: 186 */ 187#ifdef CONFIG_TIMER_STATS 188 189extern int timer_stats_active; 190 191extern void init_timer_stats(void); 192 193extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf, 194 void *timerf, char *comm, u32 flags); 195 196extern void __timer_stats_timer_set_start_info(struct timer_list *timer, 197 void *addr); 198 199static inline void timer_stats_timer_set_start_info(struct timer_list *timer) 200{ 201 if (likely(!timer_stats_active)) 202 return; 203 __timer_stats_timer_set_start_info(timer, __builtin_return_address(0)); 204} 205 206static inline void timer_stats_timer_clear_start_info(struct timer_list *timer) 207{ 208 timer->start_site = NULL; 209} 210#else 211static inline void init_timer_stats(void) 212{ 213} 214 215static inline void timer_stats_timer_set_start_info(struct timer_list *timer) 216{ 217} 218 219static inline void timer_stats_timer_clear_start_info(struct timer_list *timer) 220{ 221} 222#endif 223 224extern void add_timer(struct timer_list *timer); 225 226extern int try_to_del_timer_sync(struct timer_list *timer); 227 228#ifdef CONFIG_SMP 229 extern int del_timer_sync(struct timer_list *timer); 230#else 231# define del_timer_sync(t) del_timer(t) 232#endif 233 234#define del_singleshot_timer_sync(t) del_timer_sync(t) 235 236extern void init_timers(void); 237extern void run_local_timers(void); 238struct hrtimer; 239extern enum hrtimer_restart it_real_fn(struct hrtimer *); 240 241#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON) 242#include <linux/sysctl.h> 243 244extern unsigned int sysctl_timer_migration; 245int timer_migration_handler(struct ctl_table *table, int write, 246 void __user *buffer, size_t *lenp, 247 loff_t *ppos); 248#endif 249 250unsigned long __round_jiffies(unsigned long j, int cpu); 251unsigned long __round_jiffies_relative(unsigned long j, int cpu); 252unsigned long round_jiffies(unsigned long j); 253unsigned long round_jiffies_relative(unsigned long j); 254 255unsigned long __round_jiffies_up(unsigned long j, int cpu); 256unsigned long __round_jiffies_up_relative(unsigned long j, int cpu); 257unsigned long round_jiffies_up(unsigned long j); 258unsigned long round_jiffies_up_relative(unsigned long j); 259 260#endif 261