]> git.karo-electronics.de Git - karo-tx-linux.git/blob - include/linux/timer.h
Merge tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
[karo-tx-linux.git] / include / linux / timer.h
1 #ifndef _LINUX_TIMER_H
2 #define _LINUX_TIMER_H
3
4 #include <linux/list.h>
5 #include <linux/ktime.h>
6 #include <linux/stddef.h>
7 #include <linux/debugobjects.h>
8 #include <linux/stringify.h>
9
10 struct tvec_base;
11
12 struct timer_list {
13         /*
14          * All fields that change during normal runtime grouped to the
15          * same cacheline
16          */
17         struct hlist_node       entry;
18         unsigned long           expires;
19         void                    (*function)(unsigned long);
20         unsigned long           data;
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, _expires, _data, _flags) { \
67                 .entry = { .next = TIMER_ENTRY_STATIC },        \
68                 .function = (_function),                        \
69                 .expires = (_expires),                          \
70                 .data = (_data),                                \
71                 .flags = (_flags),                              \
72                 __TIMER_LOCKDEP_MAP_INITIALIZER(                \
73                         __FILE__ ":" __stringify(__LINE__))     \
74         }
75
76 #define TIMER_INITIALIZER(_function, _expires, _data)           \
77         __TIMER_INITIALIZER((_function), (_expires), (_data), 0)
78
79 #define TIMER_PINNED_INITIALIZER(_function, _expires, _data)    \
80         __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_PINNED)
81
82 #define TIMER_DEFERRED_INITIALIZER(_function, _expires, _data)  \
83         __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE)
84
85 #define TIMER_PINNED_DEFERRED_INITIALIZER(_function, _expires, _data)   \
86         __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE | TIMER_PINNED)
87
88 #define DEFINE_TIMER(_name, _function, _expires, _data)         \
89         struct timer_list _name =                               \
90                 TIMER_INITIALIZER(_function, _expires, _data)
91
92 void init_timer_key(struct timer_list *timer, unsigned int flags,
93                     const char *name, struct lock_class_key *key);
94
95 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
96 extern void init_timer_on_stack_key(struct timer_list *timer,
97                                     unsigned int flags, const char *name,
98                                     struct lock_class_key *key);
99 extern void destroy_timer_on_stack(struct timer_list *timer);
100 #else
101 static inline void destroy_timer_on_stack(struct timer_list *timer) { }
102 static inline void init_timer_on_stack_key(struct timer_list *timer,
103                                            unsigned int flags, const char *name,
104                                            struct lock_class_key *key)
105 {
106         init_timer_key(timer, flags, name, key);
107 }
108 #endif
109
110 #ifdef CONFIG_LOCKDEP
111 #define __init_timer(_timer, _flags)                                    \
112         do {                                                            \
113                 static struct lock_class_key __key;                     \
114                 init_timer_key((_timer), (_flags), #_timer, &__key);    \
115         } while (0)
116
117 #define __init_timer_on_stack(_timer, _flags)                           \
118         do {                                                            \
119                 static struct lock_class_key __key;                     \
120                 init_timer_on_stack_key((_timer), (_flags), #_timer, &__key); \
121         } while (0)
122 #else
123 #define __init_timer(_timer, _flags)                                    \
124         init_timer_key((_timer), (_flags), NULL, NULL)
125 #define __init_timer_on_stack(_timer, _flags)                           \
126         init_timer_on_stack_key((_timer), (_flags), NULL, NULL)
127 #endif
128
129 #define init_timer(timer)                                               \
130         __init_timer((timer), 0)
131 #define init_timer_pinned(timer)                                        \
132         __init_timer((timer), TIMER_PINNED)
133 #define init_timer_deferrable(timer)                                    \
134         __init_timer((timer), TIMER_DEFERRABLE)
135 #define init_timer_pinned_deferrable(timer)                             \
136         __init_timer((timer), TIMER_DEFERRABLE | TIMER_PINNED)
137 #define init_timer_on_stack(timer)                                      \
138         __init_timer_on_stack((timer), 0)
139
140 #define __setup_timer(_timer, _fn, _data, _flags)                       \
141         do {                                                            \
142                 __init_timer((_timer), (_flags));                       \
143                 (_timer)->function = (_fn);                             \
144                 (_timer)->data = (_data);                               \
145         } while (0)
146
147 #define __setup_timer_on_stack(_timer, _fn, _data, _flags)              \
148         do {                                                            \
149                 __init_timer_on_stack((_timer), (_flags));              \
150                 (_timer)->function = (_fn);                             \
151                 (_timer)->data = (_data);                               \
152         } while (0)
153
154 #define setup_timer(timer, fn, data)                                    \
155         __setup_timer((timer), (fn), (data), 0)
156 #define setup_pinned_timer(timer, fn, data)                             \
157         __setup_timer((timer), (fn), (data), TIMER_PINNED)
158 #define setup_deferrable_timer(timer, fn, data)                         \
159         __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE)
160 #define setup_pinned_deferrable_timer(timer, fn, data)                  \
161         __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)
162 #define setup_timer_on_stack(timer, fn, data)                           \
163         __setup_timer_on_stack((timer), (fn), (data), 0)
164 #define setup_pinned_timer_on_stack(timer, fn, data)                    \
165         __setup_timer_on_stack((timer), (fn), (data), TIMER_PINNED)
166 #define setup_deferrable_timer_on_stack(timer, fn, data)                \
167         __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE)
168 #define setup_pinned_deferrable_timer_on_stack(timer, fn, data)         \
169         __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)
170
171 /**
172  * timer_pending - is a timer pending?
173  * @timer: the timer in question
174  *
175  * timer_pending will tell whether a given timer is currently pending,
176  * or not. Callers must ensure serialization wrt. other operations done
177  * to this timer, eg. interrupt contexts, or other CPUs on SMP.
178  *
179  * return value: 1 if the timer is pending, 0 if not.
180  */
181 static inline int timer_pending(const struct timer_list * timer)
182 {
183         return timer->entry.pprev != NULL;
184 }
185
186 extern void add_timer_on(struct timer_list *timer, int cpu);
187 extern int del_timer(struct timer_list * timer);
188 extern int mod_timer(struct timer_list *timer, unsigned long expires);
189 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);
190
191 /*
192  * The jiffies value which is added to now, when there is no timer
193  * in the timer wheel:
194  */
195 #define NEXT_TIMER_MAX_DELTA    ((1UL << 30) - 1)
196
197 extern void add_timer(struct timer_list *timer);
198
199 extern int try_to_del_timer_sync(struct timer_list *timer);
200
201 #ifdef CONFIG_SMP
202   extern int del_timer_sync(struct timer_list *timer);
203 #else
204 # define del_timer_sync(t)              del_timer(t)
205 #endif
206
207 #define del_singleshot_timer_sync(t) del_timer_sync(t)
208
209 extern void init_timers(void);
210 extern void run_local_timers(void);
211 struct hrtimer;
212 extern enum hrtimer_restart it_real_fn(struct hrtimer *);
213
214 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
215 struct ctl_table;
216
217 extern unsigned int sysctl_timer_migration;
218 int timer_migration_handler(struct ctl_table *table, int write,
219                             void __user *buffer, size_t *lenp,
220                             loff_t *ppos);
221 #endif
222
223 unsigned long __round_jiffies(unsigned long j, int cpu);
224 unsigned long __round_jiffies_relative(unsigned long j, int cpu);
225 unsigned long round_jiffies(unsigned long j);
226 unsigned long round_jiffies_relative(unsigned long j);
227
228 unsigned long __round_jiffies_up(unsigned long j, int cpu);
229 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu);
230 unsigned long round_jiffies_up(unsigned long j);
231 unsigned long round_jiffies_up_relative(unsigned long j);
232
233 #ifdef CONFIG_HOTPLUG_CPU
234 int timers_dead_cpu(unsigned int cpu);
235 #else
236 #define timers_dead_cpu NULL
237 #endif
238
239 #endif