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