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 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 88 void 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 92 extern void init_timer_on_stack_key(struct timer_list *timer, 93 unsigned int flags, const char *name, 94 struct lock_class_key *key); 95 extern void destroy_timer_on_stack(struct timer_list *timer); 96 #else 97 static inline void destroy_timer_on_stack(struct timer_list *timer) { } 98 static 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_deferrable_timer(timer, fn, data) \ 149 __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE) 150 #define setup_timer_on_stack(timer, fn, data) \ 151 __setup_timer_on_stack((timer), (fn), (data), 0) 152 #define setup_deferrable_timer_on_stack(timer, fn, data) \ 153 __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE) 154 155 /** 156 * timer_pending - is a timer pending? 157 * @timer: the timer in question 158 * 159 * timer_pending will tell whether a given timer is currently pending, 160 * or not. Callers must ensure serialization wrt. other operations done 161 * to this timer, eg. interrupt contexts, or other CPUs on SMP. 162 * 163 * return value: 1 if the timer is pending, 0 if not. 164 */ 165 static inline int timer_pending(const struct timer_list * timer) 166 { 167 return timer->entry.pprev != NULL; 168 } 169 170 extern void add_timer_on(struct timer_list *timer, int cpu); 171 extern int del_timer(struct timer_list * timer); 172 extern int mod_timer(struct timer_list *timer, unsigned long expires); 173 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires); 174 extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires); 175 176 extern void set_timer_slack(struct timer_list *time, int slack_hz); 177 178 #define TIMER_NOT_PINNED 0 179 #define TIMER_PINNED 1 180 /* 181 * The jiffies value which is added to now, when there is no timer 182 * in the timer wheel: 183 */ 184 #define NEXT_TIMER_MAX_DELTA ((1UL << 30) - 1) 185 186 /* 187 * Timer-statistics info: 188 */ 189 #ifdef CONFIG_TIMER_STATS 190 191 extern int timer_stats_active; 192 193 extern void init_timer_stats(void); 194 195 extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf, 196 void *timerf, char *comm, u32 flags); 197 198 extern void __timer_stats_timer_set_start_info(struct timer_list *timer, 199 void *addr); 200 201 static inline void timer_stats_timer_set_start_info(struct timer_list *timer) 202 { 203 if (likely(!timer_stats_active)) 204 return; 205 __timer_stats_timer_set_start_info(timer, __builtin_return_address(0)); 206 } 207 208 static inline void timer_stats_timer_clear_start_info(struct timer_list *timer) 209 { 210 timer->start_site = NULL; 211 } 212 #else 213 static inline void init_timer_stats(void) 214 { 215 } 216 217 static inline void timer_stats_timer_set_start_info(struct timer_list *timer) 218 { 219 } 220 221 static inline void timer_stats_timer_clear_start_info(struct timer_list *timer) 222 { 223 } 224 #endif 225 226 extern void add_timer(struct timer_list *timer); 227 228 extern int try_to_del_timer_sync(struct timer_list *timer); 229 230 #ifdef CONFIG_SMP 231 extern int del_timer_sync(struct timer_list *timer); 232 #else 233 # define del_timer_sync(t) del_timer(t) 234 #endif 235 236 #define del_singleshot_timer_sync(t) del_timer_sync(t) 237 238 extern void init_timers(void); 239 extern void run_local_timers(void); 240 struct hrtimer; 241 extern enum hrtimer_restart it_real_fn(struct hrtimer *); 242 243 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON) 244 #include <linux/sysctl.h> 245 246 extern unsigned int sysctl_timer_migration; 247 int timer_migration_handler(struct ctl_table *table, int write, 248 void __user *buffer, size_t *lenp, 249 loff_t *ppos); 250 #endif 251 252 unsigned long __round_jiffies(unsigned long j, int cpu); 253 unsigned long __round_jiffies_relative(unsigned long j, int cpu); 254 unsigned long round_jiffies(unsigned long j); 255 unsigned long round_jiffies_relative(unsigned long j); 256 257 unsigned long __round_jiffies_up(unsigned long j, int cpu); 258 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu); 259 unsigned long round_jiffies_up(unsigned long j); 260 unsigned long round_jiffies_up_relative(unsigned long j); 261 262 #endif 263