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 /* 82 * LOCKDEP and DEBUG timer interfaces. 83 */ 84 void init_timer_key(struct timer_list *timer, 85 void (*func)(struct timer_list *), unsigned int flags, 86 const char *name, struct lock_class_key *key); 87 88 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS 89 extern void init_timer_on_stack_key(struct timer_list *timer, 90 void (*func)(struct timer_list *), 91 unsigned int flags, const char *name, 92 struct lock_class_key *key); 93 #else 94 static inline void init_timer_on_stack_key(struct timer_list *timer, 95 void (*func)(struct timer_list *), 96 unsigned int flags, 97 const char *name, 98 struct lock_class_key *key) 99 { 100 init_timer_key(timer, func, flags, name, key); 101 } 102 #endif 103 104 #ifdef CONFIG_LOCKDEP 105 #define __init_timer(_timer, _fn, _flags) \ 106 do { \ 107 static struct lock_class_key __key; \ 108 init_timer_key((_timer), (_fn), (_flags), #_timer, &__key);\ 109 } while (0) 110 111 #define __init_timer_on_stack(_timer, _fn, _flags) \ 112 do { \ 113 static struct lock_class_key __key; \ 114 init_timer_on_stack_key((_timer), (_fn), (_flags), \ 115 #_timer, &__key); \ 116 } while (0) 117 #else 118 #define __init_timer(_timer, _fn, _flags) \ 119 init_timer_key((_timer), (_fn), (_flags), NULL, NULL) 120 #define __init_timer_on_stack(_timer, _fn, _flags) \ 121 init_timer_on_stack_key((_timer), (_fn), (_flags), NULL, NULL) 122 #endif 123 124 /** 125 * timer_setup - prepare a timer for first use 126 * @timer: the timer in question 127 * @callback: the function to call when timer expires 128 * @flags: any TIMER_* flags 129 * 130 * Regular timer initialization should use either DEFINE_TIMER() above, 131 * or timer_setup(). For timers on the stack, timer_setup_on_stack() must 132 * be used and must be balanced with a call to destroy_timer_on_stack(). 133 */ 134 #define timer_setup(timer, callback, flags) \ 135 __init_timer((timer), (callback), (flags)) 136 137 #define timer_setup_on_stack(timer, callback, flags) \ 138 __init_timer_on_stack((timer), (callback), (flags)) 139 140 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS 141 extern void destroy_timer_on_stack(struct timer_list *timer); 142 #else 143 static inline void destroy_timer_on_stack(struct timer_list *timer) { } 144 #endif 145 146 #define from_timer(var, callback_timer, timer_fieldname) \ 147 container_of(callback_timer, typeof(*var), timer_fieldname) 148 149 /** 150 * timer_pending - is a timer pending? 151 * @timer: the timer in question 152 * 153 * timer_pending will tell whether a given timer is currently pending, 154 * or not. Callers must ensure serialization wrt. other operations done 155 * to this timer, eg. interrupt contexts, or other CPUs on SMP. 156 * 157 * return value: 1 if the timer is pending, 0 if not. 158 */ 159 static inline int timer_pending(const struct timer_list * timer) 160 { 161 return timer->entry.pprev != NULL; 162 } 163 164 extern void add_timer_on(struct timer_list *timer, int cpu); 165 extern int del_timer(struct timer_list * timer); 166 extern int mod_timer(struct timer_list *timer, unsigned long expires); 167 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires); 168 extern int timer_reduce(struct timer_list *timer, unsigned long expires); 169 170 /* 171 * The jiffies value which is added to now, when there is no timer 172 * in the timer wheel: 173 */ 174 #define NEXT_TIMER_MAX_DELTA ((1UL << 30) - 1) 175 176 extern void add_timer(struct timer_list *timer); 177 178 extern int try_to_del_timer_sync(struct timer_list *timer); 179 180 #ifdef CONFIG_SMP 181 extern int del_timer_sync(struct timer_list *timer); 182 #else 183 # define del_timer_sync(t) del_timer(t) 184 #endif 185 186 #define del_singleshot_timer_sync(t) del_timer_sync(t) 187 188 extern void init_timers(void); 189 extern void run_local_timers(void); 190 struct hrtimer; 191 extern enum hrtimer_restart it_real_fn(struct hrtimer *); 192 193 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON) 194 struct ctl_table; 195 196 extern unsigned int sysctl_timer_migration; 197 int timer_migration_handler(struct ctl_table *table, int write, 198 void __user *buffer, size_t *lenp, 199 loff_t *ppos); 200 #endif 201 202 unsigned long __round_jiffies(unsigned long j, int cpu); 203 unsigned long __round_jiffies_relative(unsigned long j, int cpu); 204 unsigned long round_jiffies(unsigned long j); 205 unsigned long round_jiffies_relative(unsigned long j); 206 207 unsigned long __round_jiffies_up(unsigned long j, int cpu); 208 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu); 209 unsigned long round_jiffies_up(unsigned long j); 210 unsigned long round_jiffies_up_relative(unsigned long j); 211 212 #ifdef CONFIG_HOTPLUG_CPU 213 int timers_dead_cpu(unsigned int cpu); 214 #else 215 #define timers_dead_cpu NULL 216 #endif 217 218 #endif 219