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  * A deferrable timer will work normally when the system is busy, but
41  * will not cause a CPU to come out of idle just to service it; instead,
42  * the timer will be serviced when the CPU eventually wakes up with a
43  * subsequent non-deferrable timer.
44  *
45  * An irqsafe timer is executed with IRQ disabled and it's safe to wait for
46  * the completion of the running instance from IRQ handlers, for example,
47  * 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 #define TIMER_CPUMASK		0x0003FFFF
54 #define TIMER_MIGRATING		0x00040000
55 #define TIMER_BASEMASK		(TIMER_CPUMASK | TIMER_MIGRATING)
56 #define TIMER_DEFERRABLE	0x00080000
57 #define TIMER_PINNED		0x00100000
58 #define TIMER_IRQSAFE		0x00200000
59 #define TIMER_ARRAYSHIFT	22
60 #define TIMER_ARRAYMASK		0xFFC00000
61 
62 #define TIMER_TRACE_FLAGMASK	(TIMER_MIGRATING | TIMER_DEFERRABLE | TIMER_PINNED | TIMER_IRQSAFE)
63 
64 #define __TIMER_INITIALIZER(_function, _flags) {		\
65 		.entry = { .next = TIMER_ENTRY_STATIC },	\
66 		.function = (_function),			\
67 		.flags = (_flags),				\
68 		__TIMER_LOCKDEP_MAP_INITIALIZER(		\
69 			__FILE__ ":" __stringify(__LINE__))	\
70 	}
71 
72 #define DEFINE_TIMER(_name, _function)				\
73 	struct timer_list _name =				\
74 		__TIMER_INITIALIZER(_function, 0)
75 
76 /*
77  * LOCKDEP and DEBUG timer interfaces.
78  */
79 void init_timer_key(struct timer_list *timer,
80 		    void (*func)(struct timer_list *), unsigned int flags,
81 		    const char *name, struct lock_class_key *key);
82 
83 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
84 extern void init_timer_on_stack_key(struct timer_list *timer,
85 				    void (*func)(struct timer_list *),
86 				    unsigned int flags, const char *name,
87 				    struct lock_class_key *key);
88 #else
init_timer_on_stack_key(struct timer_list * timer,void (* func)(struct timer_list *),unsigned int flags,const char * name,struct lock_class_key * key)89 static inline void init_timer_on_stack_key(struct timer_list *timer,
90 					   void (*func)(struct timer_list *),
91 					   unsigned int flags,
92 					   const char *name,
93 					   struct lock_class_key *key)
94 {
95 	init_timer_key(timer, func, flags, name, key);
96 }
97 #endif
98 
99 #ifdef CONFIG_LOCKDEP
100 #define __init_timer(_timer, _fn, _flags)				\
101 	do {								\
102 		static struct lock_class_key __key;			\
103 		init_timer_key((_timer), (_fn), (_flags), #_timer, &__key);\
104 	} while (0)
105 
106 #define __init_timer_on_stack(_timer, _fn, _flags)			\
107 	do {								\
108 		static struct lock_class_key __key;			\
109 		init_timer_on_stack_key((_timer), (_fn), (_flags),	\
110 					#_timer, &__key);		 \
111 	} while (0)
112 #else
113 #define __init_timer(_timer, _fn, _flags)				\
114 	init_timer_key((_timer), (_fn), (_flags), NULL, NULL)
115 #define __init_timer_on_stack(_timer, _fn, _flags)			\
116 	init_timer_on_stack_key((_timer), (_fn), (_flags), NULL, NULL)
117 #endif
118 
119 /**
120  * timer_setup - prepare a timer for first use
121  * @timer: the timer in question
122  * @callback: the function to call when timer expires
123  * @flags: any TIMER_* flags
124  *
125  * Regular timer initialization should use either DEFINE_TIMER() above,
126  * or timer_setup(). For timers on the stack, timer_setup_on_stack() must
127  * be used and must be balanced with a call to destroy_timer_on_stack().
128  */
129 #define timer_setup(timer, callback, flags)			\
130 	__init_timer((timer), (callback), (flags))
131 
132 #define timer_setup_on_stack(timer, callback, flags)		\
133 	__init_timer_on_stack((timer), (callback), (flags))
134 
135 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
136 extern void destroy_timer_on_stack(struct timer_list *timer);
137 #else
destroy_timer_on_stack(struct timer_list * timer)138 static inline void destroy_timer_on_stack(struct timer_list *timer) { }
139 #endif
140 
141 #define from_timer(var, callback_timer, timer_fieldname) \
142 	container_of(callback_timer, typeof(*var), timer_fieldname)
143 
144 /**
145  * timer_pending - is a timer pending?
146  * @timer: the timer in question
147  *
148  * timer_pending will tell whether a given timer is currently pending,
149  * or not. Callers must ensure serialization wrt. other operations done
150  * to this timer, eg. interrupt contexts, or other CPUs on SMP.
151  *
152  * return value: 1 if the timer is pending, 0 if not.
153  */
timer_pending(const struct timer_list * timer)154 static inline int timer_pending(const struct timer_list * timer)
155 {
156 	return timer->entry.pprev != NULL;
157 }
158 
159 extern void add_timer_on(struct timer_list *timer, int cpu);
160 extern int del_timer(struct timer_list * timer);
161 extern int mod_timer(struct timer_list *timer, unsigned long expires);
162 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);
163 extern int timer_reduce(struct timer_list *timer, unsigned long expires);
164 
165 /*
166  * The jiffies value which is added to now, when there is no timer
167  * in the timer wheel:
168  */
169 #define NEXT_TIMER_MAX_DELTA	((1UL << 30) - 1)
170 
171 extern void add_timer(struct timer_list *timer);
172 
173 extern int try_to_del_timer_sync(struct timer_list *timer);
174 
175 #ifdef CONFIG_SMP
176   extern int del_timer_sync(struct timer_list *timer);
177 #else
178 # define del_timer_sync(t)		del_timer(t)
179 #endif
180 
181 #define del_singleshot_timer_sync(t) del_timer_sync(t)
182 
183 extern void init_timers(void);
184 extern void run_local_timers(void);
185 struct hrtimer;
186 extern enum hrtimer_restart it_real_fn(struct hrtimer *);
187 
188 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
189 struct ctl_table;
190 
191 extern unsigned int sysctl_timer_migration;
192 int timer_migration_handler(struct ctl_table *table, int write,
193 			    void __user *buffer, size_t *lenp,
194 			    loff_t *ppos);
195 #endif
196 
197 unsigned long __round_jiffies(unsigned long j, int cpu);
198 unsigned long __round_jiffies_relative(unsigned long j, int cpu);
199 unsigned long round_jiffies(unsigned long j);
200 unsigned long round_jiffies_relative(unsigned long j);
201 
202 unsigned long __round_jiffies_up(unsigned long j, int cpu);
203 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu);
204 unsigned long round_jiffies_up(unsigned long j);
205 unsigned long round_jiffies_up_relative(unsigned long j);
206 
207 #ifdef CONFIG_HOTPLUG_CPU
208 int timers_prepare_cpu(unsigned int cpu);
209 int timers_dead_cpu(unsigned int cpu);
210 #else
211 #define timers_prepare_cpu	NULL
212 #define timers_dead_cpu		NULL
213 #endif
214 
215 #endif
216