Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mattst88...
[linux-2.6-microblaze.git] / include / linux / timer.h
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
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
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  */
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