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_ARRAYSHIFT 22 71 #define TIMER_ARRAYMASK 0xFFC00000 72 73 #define TIMER_TRACE_FLAGMASK (TIMER_MIGRATING | TIMER_DEFERRABLE | TIMER_PINNED | TIMER_IRQSAFE) 74 75 #define __TIMER_INITIALIZER(_function, _flags) { \ 76 .entry = { .next = TIMER_ENTRY_STATIC }, \ 77 .function = (_function), \ 78 .flags = (_flags), \ 79 __TIMER_LOCKDEP_MAP_INITIALIZER( \ 80 __FILE__ ":" __stringify(__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 timer->entry.pprev != NULL; 168 } 169 170 extern void add_timer_on(struct timer_list *timer, int cpu); 171 extern int del_timer(struct timer_list * timer); 172 extern int mod_timer(struct timer_list *timer, unsigned long expires); 173 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires); 174 extern int timer_reduce(struct timer_list *timer, unsigned long expires); 175 176 /* 177 * The jiffies value which is added to now, when there is no timer 178 * in the timer wheel: 179 */ 180 #define NEXT_TIMER_MAX_DELTA ((1UL << 30) - 1) 181 182 extern void add_timer(struct timer_list *timer); 183 184 extern int try_to_del_timer_sync(struct timer_list *timer); 185 186 #if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT_RT) 187 extern int del_timer_sync(struct timer_list *timer); 188 #else 189 # define del_timer_sync(t) del_timer(t) 190 #endif 191 192 #define del_singleshot_timer_sync(t) del_timer_sync(t) 193 194 extern void init_timers(void); 195 extern void run_local_timers(void); 196 struct hrtimer; 197 extern enum hrtimer_restart it_real_fn(struct hrtimer *); 198 199 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON) 200 struct ctl_table; 201 202 extern unsigned int sysctl_timer_migration; 203 int timer_migration_handler(struct ctl_table *table, int write, 204 void __user *buffer, size_t *lenp, 205 loff_t *ppos); 206 #endif 207 208 unsigned long __round_jiffies(unsigned long j, int cpu); 209 unsigned long __round_jiffies_relative(unsigned long j, int cpu); 210 unsigned long round_jiffies(unsigned long j); 211 unsigned long round_jiffies_relative(unsigned long j); 212 213 unsigned long __round_jiffies_up(unsigned long j, int cpu); 214 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu); 215 unsigned long round_jiffies_up(unsigned long j); 216 unsigned long round_jiffies_up_relative(unsigned long j); 217 218 #ifdef CONFIG_HOTPLUG_CPU 219 int timers_prepare_cpu(unsigned int cpu); 220 int timers_dead_cpu(unsigned int cpu); 221 #else 222 #define timers_prepare_cpu NULL 223 #define timers_dead_cpu NULL 224 #endif 225 226 #endif 227