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_INITIALIZER(_function, _expires, _data, _flags) { \ 65 .entry = { .next = TIMER_ENTRY_STATIC }, \ 66 .function = (_function), \ 67 .expires = (_expires), \ 68 .data = (_data), \ 69 .flags = (_flags), \ 70 __TIMER_LOCKDEP_MAP_INITIALIZER( \ 71 __FILE__ ":" __stringify(__LINE__)) \ 72 } 73 74 #define TIMER_INITIALIZER(_function, _expires, _data) \ 75 __TIMER_INITIALIZER((_function), (_expires), (_data), 0) 76 77 #define TIMER_PINNED_INITIALIZER(_function, _expires, _data) \ 78 __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_PINNED) 79 80 #define TIMER_DEFERRED_INITIALIZER(_function, _expires, _data) \ 81 __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE) 82 83 #define TIMER_PINNED_DEFERRED_INITIALIZER(_function, _expires, _data) \ 84 __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE | TIMER_PINNED) 85 86 #define DEFINE_TIMER(_name, _function, _expires, _data) \ 87 struct timer_list _name = \ 88 TIMER_INITIALIZER(_function, _expires, _data) 89 90 void init_timer_key(struct timer_list *timer, unsigned int flags, 91 const char *name, struct lock_class_key *key); 92 93 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS 94 extern void init_timer_on_stack_key(struct timer_list *timer, 95 unsigned int flags, const char *name, 96 struct lock_class_key *key); 97 extern void destroy_timer_on_stack(struct timer_list *timer); 98 #else 99 static inline void destroy_timer_on_stack(struct timer_list *timer) { } 100 static inline void init_timer_on_stack_key(struct timer_list *timer, 101 unsigned int flags, const char *name, 102 struct lock_class_key *key) 103 { 104 init_timer_key(timer, flags, name, key); 105 } 106 #endif 107 108 #ifdef CONFIG_LOCKDEP 109 #define __init_timer(_timer, _flags) \ 110 do { \ 111 static struct lock_class_key __key; \ 112 init_timer_key((_timer), (_flags), #_timer, &__key); \ 113 } while (0) 114 115 #define __init_timer_on_stack(_timer, _flags) \ 116 do { \ 117 static struct lock_class_key __key; \ 118 init_timer_on_stack_key((_timer), (_flags), #_timer, &__key); \ 119 } while (0) 120 #else 121 #define __init_timer(_timer, _flags) \ 122 init_timer_key((_timer), (_flags), NULL, NULL) 123 #define __init_timer_on_stack(_timer, _flags) \ 124 init_timer_on_stack_key((_timer), (_flags), NULL, NULL) 125 #endif 126 127 #define init_timer(timer) \ 128 __init_timer((timer), 0) 129 #define init_timer_pinned(timer) \ 130 __init_timer((timer), TIMER_PINNED) 131 #define init_timer_deferrable(timer) \ 132 __init_timer((timer), TIMER_DEFERRABLE) 133 #define init_timer_pinned_deferrable(timer) \ 134 __init_timer((timer), TIMER_DEFERRABLE | TIMER_PINNED) 135 #define init_timer_on_stack(timer) \ 136 __init_timer_on_stack((timer), 0) 137 138 #define __setup_timer(_timer, _fn, _data, _flags) \ 139 do { \ 140 __init_timer((_timer), (_flags)); \ 141 (_timer)->function = (_fn); \ 142 (_timer)->data = (_data); \ 143 } while (0) 144 145 #define __setup_timer_on_stack(_timer, _fn, _data, _flags) \ 146 do { \ 147 __init_timer_on_stack((_timer), (_flags)); \ 148 (_timer)->function = (_fn); \ 149 (_timer)->data = (_data); \ 150 } while (0) 151 152 #define setup_timer(timer, fn, data) \ 153 __setup_timer((timer), (fn), (data), 0) 154 #define setup_pinned_timer(timer, fn, data) \ 155 __setup_timer((timer), (fn), (data), TIMER_PINNED) 156 #define setup_deferrable_timer(timer, fn, data) \ 157 __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE) 158 #define setup_pinned_deferrable_timer(timer, fn, data) \ 159 __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED) 160 #define setup_timer_on_stack(timer, fn, data) \ 161 __setup_timer_on_stack((timer), (fn), (data), 0) 162 #define setup_pinned_timer_on_stack(timer, fn, data) \ 163 __setup_timer_on_stack((timer), (fn), (data), TIMER_PINNED) 164 #define setup_deferrable_timer_on_stack(timer, fn, data) \ 165 __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE) 166 #define setup_pinned_deferrable_timer_on_stack(timer, fn, data) \ 167 __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED) 168 169 /** 170 * timer_pending - is a timer pending? 171 * @timer: the timer in question 172 * 173 * timer_pending will tell whether a given timer is currently pending, 174 * or not. Callers must ensure serialization wrt. other operations done 175 * to this timer, eg. interrupt contexts, or other CPUs on SMP. 176 * 177 * return value: 1 if the timer is pending, 0 if not. 178 */ 179 static inline int timer_pending(const struct timer_list * timer) 180 { 181 return timer->entry.pprev != NULL; 182 } 183 184 extern void add_timer_on(struct timer_list *timer, int cpu); 185 extern int del_timer(struct timer_list * timer); 186 extern int mod_timer(struct timer_list *timer, unsigned long expires); 187 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires); 188 189 /* 190 * The jiffies value which is added to now, when there is no timer 191 * in the timer wheel: 192 */ 193 #define NEXT_TIMER_MAX_DELTA ((1UL << 30) - 1) 194 195 extern void add_timer(struct timer_list *timer); 196 197 extern int try_to_del_timer_sync(struct timer_list *timer); 198 199 #ifdef CONFIG_SMP 200 extern int del_timer_sync(struct timer_list *timer); 201 #else 202 # define del_timer_sync(t) del_timer(t) 203 #endif 204 205 #define del_singleshot_timer_sync(t) del_timer_sync(t) 206 207 extern void init_timers(void); 208 extern void run_local_timers(void); 209 struct hrtimer; 210 extern enum hrtimer_restart it_real_fn(struct hrtimer *); 211 212 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON) 213 #include <linux/sysctl.h> 214 215 extern unsigned int sysctl_timer_migration; 216 int timer_migration_handler(struct ctl_table *table, int write, 217 void __user *buffer, size_t *lenp, 218 loff_t *ppos); 219 #endif 220 221 unsigned long __round_jiffies(unsigned long j, int cpu); 222 unsigned long __round_jiffies_relative(unsigned long j, int cpu); 223 unsigned long round_jiffies(unsigned long j); 224 unsigned long round_jiffies_relative(unsigned long j); 225 226 unsigned long __round_jiffies_up(unsigned long j, int cpu); 227 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu); 228 unsigned long round_jiffies_up(unsigned long j); 229 unsigned long round_jiffies_up_relative(unsigned long j); 230 231 #ifdef CONFIG_HOTPLUG_CPU 232 int timers_dead_cpu(unsigned int cpu); 233 #else 234 #define timers_dead_cpu NULL 235 #endif 236 237 #endif 238