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