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 timer_list { 12 /* 13 * All fields that change during normal runtime grouped to the 14 * same cacheline 15 */ 16 struct hlist_node entry; 17 unsigned long expires; 18 void (*function)(struct timer_list *); 19 u32 flags; 20 21 #ifdef CONFIG_LOCKDEP 22 struct lockdep_map lockdep_map; 23 #endif 24 }; 25 26 #ifdef CONFIG_LOCKDEP 27 /* 28 * NB: because we have to copy the lockdep_map, setting the lockdep_map key 29 * (second argument) here is required, otherwise it could be initialised to 30 * the copy of the lockdep_map later! We use the pointer to and the string 31 * "<file>:<line>" as the key resp. the name of the lockdep_map. 32 */ 33 #define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn) \ 34 .lockdep_map = STATIC_LOCKDEP_MAP_INIT(_kn, &_kn), 35 #else 36 #define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn) 37 #endif 38 39 /** 40 * @TIMER_DEFERRABLE: A deferrable timer will work normally when the 41 * system is busy, but will not cause a CPU to come out of idle just 42 * to service it; instead, the timer will be serviced when the CPU 43 * eventually wakes up with a subsequent non-deferrable timer. 44 * 45 * @TIMER_IRQSAFE: An irqsafe timer is executed with IRQ disabled and 46 * it's safe to wait for the completion of the running instance from 47 * IRQ handlers, for example, by calling del_timer_sync(). 48 * 49 * Note: The irq disabled callback execution is a special case for 50 * workqueue locking issues. It's not meant for executing random crap 51 * with interrupts disabled. Abuse is monitored! 52 * 53 * @TIMER_PINNED: A pinned timer will not be affected by any timer 54 * placement heuristics (like, NOHZ) and will always expire on the CPU 55 * on which the timer was enqueued. 56 * 57 * Note: Because enqueuing of timers can migrate the timer from one 58 * CPU to another, pinned timers are not guaranteed to stay on the 59 * initialy selected CPU. They move to the CPU on which the enqueue 60 * function is invoked via mod_timer() or add_timer(). If the timer 61 * should be placed on a particular CPU, then add_timer_on() has to be 62 * used. 63 */ 64 #define TIMER_CPUMASK 0x0003FFFF 65 #define TIMER_MIGRATING 0x00040000 66 #define TIMER_BASEMASK (TIMER_CPUMASK | TIMER_MIGRATING) 67 #define TIMER_DEFERRABLE 0x00080000 68 #define TIMER_PINNED 0x00100000 69 #define TIMER_IRQSAFE 0x00200000 70 #define TIMER_INIT_FLAGS (TIMER_DEFERRABLE | TIMER_PINNED | TIMER_IRQSAFE) 71 #define TIMER_ARRAYSHIFT 22 72 #define TIMER_ARRAYMASK 0xFFC00000 73 74 #define TIMER_TRACE_FLAGMASK (TIMER_MIGRATING | TIMER_DEFERRABLE | TIMER_PINNED | TIMER_IRQSAFE) 75 76 #define __TIMER_INITIALIZER(_function, _flags) { \ 77 .entry = { .next = TIMER_ENTRY_STATIC }, \ 78 .function = (_function), \ 79 .flags = (_flags), \ 80 __TIMER_LOCKDEP_MAP_INITIALIZER(FILE_LINE) \ 81 } 82 83 #define DEFINE_TIMER(_name, _function) \ 84 struct timer_list _name = \ 85 __TIMER_INITIALIZER(_function, 0) 86 87 /* 88 * LOCKDEP and DEBUG timer interfaces. 89 */ 90 void init_timer_key(struct timer_list *timer, 91 void (*func)(struct timer_list *), unsigned int flags, 92 const char *name, struct lock_class_key *key); 93 94 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS 95 extern void init_timer_on_stack_key(struct timer_list *timer, 96 void (*func)(struct timer_list *), 97 unsigned int flags, const char *name, 98 struct lock_class_key *key); 99 #else 100 static inline void init_timer_on_stack_key(struct timer_list *timer, 101 void (*func)(struct timer_list *), 102 unsigned int flags, 103 const char *name, 104 struct lock_class_key *key) 105 { 106 init_timer_key(timer, func, flags, name, key); 107 } 108 #endif 109 110 #ifdef CONFIG_LOCKDEP 111 #define __init_timer(_timer, _fn, _flags) \ 112 do { \ 113 static struct lock_class_key __key; \ 114 init_timer_key((_timer), (_fn), (_flags), #_timer, &__key);\ 115 } while (0) 116 117 #define __init_timer_on_stack(_timer, _fn, _flags) \ 118 do { \ 119 static struct lock_class_key __key; \ 120 init_timer_on_stack_key((_timer), (_fn), (_flags), \ 121 #_timer, &__key); \ 122 } while (0) 123 #else 124 #define __init_timer(_timer, _fn, _flags) \ 125 init_timer_key((_timer), (_fn), (_flags), NULL, NULL) 126 #define __init_timer_on_stack(_timer, _fn, _flags) \ 127 init_timer_on_stack_key((_timer), (_fn), (_flags), NULL, NULL) 128 #endif 129 130 /** 131 * timer_setup - prepare a timer for first use 132 * @timer: the timer in question 133 * @callback: the function to call when timer expires 134 * @flags: any TIMER_* flags 135 * 136 * Regular timer initialization should use either DEFINE_TIMER() above, 137 * or timer_setup(). For timers on the stack, timer_setup_on_stack() must 138 * be used and must be balanced with a call to destroy_timer_on_stack(). 139 */ 140 #define timer_setup(timer, callback, flags) \ 141 __init_timer((timer), (callback), (flags)) 142 143 #define timer_setup_on_stack(timer, callback, flags) \ 144 __init_timer_on_stack((timer), (callback), (flags)) 145 146 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS 147 extern void destroy_timer_on_stack(struct timer_list *timer); 148 #else 149 static inline void destroy_timer_on_stack(struct timer_list *timer) { } 150 #endif 151 152 #define from_timer(var, callback_timer, timer_fieldname) \ 153 container_of(callback_timer, typeof(*var), timer_fieldname) 154 155 /** 156 * timer_pending - is a timer pending? 157 * @timer: the timer in question 158 * 159 * timer_pending will tell whether a given timer is currently pending, 160 * or not. Callers must ensure serialization wrt. other operations done 161 * to this timer, eg. interrupt contexts, or other CPUs on SMP. 162 * 163 * return value: 1 if the timer is pending, 0 if not. 164 */ 165 static inline int timer_pending(const struct timer_list * timer) 166 { 167 return !hlist_unhashed_lockless(&timer->entry); 168 } 169 170 extern void add_timer_on(struct timer_list *timer, int cpu); 171 extern int mod_timer(struct timer_list *timer, unsigned long expires); 172 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires); 173 extern int timer_reduce(struct timer_list *timer, unsigned long expires); 174 175 /* 176 * The jiffies value which is added to now, when there is no timer 177 * in the timer wheel: 178 */ 179 #define NEXT_TIMER_MAX_DELTA ((1UL << 30) - 1) 180 181 extern void add_timer(struct timer_list *timer); 182 183 extern int try_to_del_timer_sync(struct timer_list *timer); 184 extern int timer_delete_sync(struct timer_list *timer); 185 extern int timer_delete(struct timer_list *timer); 186 extern int timer_shutdown_sync(struct timer_list *timer); 187 extern int timer_shutdown(struct timer_list *timer); 188 189 /** 190 * del_timer_sync - Delete a pending timer and wait for a running callback 191 * @timer: The timer to be deleted 192 * 193 * See timer_delete_sync() for detailed explanation. 194 * 195 * Do not use in new code. Use timer_delete_sync() instead. 196 */ 197 static inline int del_timer_sync(struct timer_list *timer) 198 { 199 return timer_delete_sync(timer); 200 } 201 202 /** 203 * del_timer - Delete a pending timer 204 * @timer: The timer to be deleted 205 * 206 * See timer_delete() for detailed explanation. 207 * 208 * Do not use in new code. Use timer_delete() instead. 209 */ 210 static inline int del_timer(struct timer_list *timer) 211 { 212 return timer_delete(timer); 213 } 214 215 extern void init_timers(void); 216 struct hrtimer; 217 extern enum hrtimer_restart it_real_fn(struct hrtimer *); 218 219 unsigned long __round_jiffies(unsigned long j, int cpu); 220 unsigned long __round_jiffies_relative(unsigned long j, int cpu); 221 unsigned long round_jiffies(unsigned long j); 222 unsigned long round_jiffies_relative(unsigned long j); 223 224 unsigned long __round_jiffies_up(unsigned long j, int cpu); 225 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu); 226 unsigned long round_jiffies_up(unsigned long j); 227 unsigned long round_jiffies_up_relative(unsigned long j); 228 229 #ifdef CONFIG_HOTPLUG_CPU 230 int timers_prepare_cpu(unsigned int cpu); 231 int timers_dead_cpu(unsigned int cpu); 232 #else 233 #define timers_prepare_cpu NULL 234 #define timers_dead_cpu NULL 235 #endif 236 237 #endif 238