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