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_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 */ 163 static inline int timer_pending(const struct timer_list * timer) 164 { 165 return timer->entry.pprev != NULL; 166 } 167 168 extern void add_timer_on(struct timer_list *timer, int cpu); 169 extern int del_timer(struct timer_list * timer); 170 extern int mod_timer(struct timer_list *timer, unsigned long expires); 171 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires); 172 extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires); 173 174 extern 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 189 extern int timer_stats_active; 190 191 extern void init_timer_stats(void); 192 193 extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf, 194 void *timerf, char *comm, u32 flags); 195 196 extern void __timer_stats_timer_set_start_info(struct timer_list *timer, 197 void *addr); 198 199 static 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 206 static inline void timer_stats_timer_clear_start_info(struct timer_list *timer) 207 { 208 timer->start_site = NULL; 209 } 210 #else 211 static inline void init_timer_stats(void) 212 { 213 } 214 215 static inline void timer_stats_timer_set_start_info(struct timer_list *timer) 216 { 217 } 218 219 static inline void timer_stats_timer_clear_start_info(struct timer_list *timer) 220 { 221 } 222 #endif 223 224 extern void add_timer(struct timer_list *timer); 225 226 extern 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 236 extern void init_timers(void); 237 extern void run_local_timers(void); 238 struct hrtimer; 239 extern 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 244 extern unsigned int sysctl_timer_migration; 245 int timer_migration_handler(struct ctl_table *table, int write, 246 void __user *buffer, size_t *lenp, 247 loff_t *ppos); 248 #endif 249 250 unsigned long __round_jiffies(unsigned long j, int cpu); 251 unsigned long __round_jiffies_relative(unsigned long j, int cpu); 252 unsigned long round_jiffies(unsigned long j); 253 unsigned long round_jiffies_relative(unsigned long j); 254 255 unsigned long __round_jiffies_up(unsigned long j, int cpu); 256 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu); 257 unsigned long round_jiffies_up(unsigned long j); 258 unsigned long round_jiffies_up_relative(unsigned long j); 259 260 #endif 261