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