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