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