blob: 09950482309bb0de2003d44d5b3d6b273f23d33c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_TIMER_H
2#define _LINUX_TIMER_H
3
Linus Torvalds1da177e2005-04-16 15:20:36 -07004#include <linux/list.h>
Ingo Molnar82f67cd2007-02-16 01:28:13 -08005#include <linux/ktime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006#include <linux/stddef.h>
Thomas Gleixnerc6f3a972008-04-30 00:55:03 -07007#include <linux/debugobjects.h>
Johannes Berg6f2b9b92009-01-29 16:03:20 +01008#include <linux/stringify.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009
Pavel Macheka6fa8e52008-01-30 13:30:00 +010010struct tvec_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -070011
12struct timer_list {
Arjan van de Ven3bbb9ec2010-03-11 14:04:36 -080013 /*
14 * All fields that change during normal runtime grouped to the
15 * same cacheline
16 */
Thomas Gleixner0eeda712015-05-26 22:50:29 +000017 struct hlist_node entry;
18 unsigned long expires;
19 void (*function)(unsigned long);
20 unsigned long data;
21 u32 flags;
Arjan van de Ven3bbb9ec2010-03-11 14:04:36 -080022
Johannes Berg6f2b9b92009-01-29 16:03:20 +010023#ifdef CONFIG_LOCKDEP
Thomas Gleixner0eeda712015-05-26 22:50:29 +000024 struct lockdep_map lockdep_map;
Johannes Berg6f2b9b92009-01-29 16:03:20 +010025#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070026};
27
Johannes Berg6f2b9b92009-01-29 16:03:20 +010028#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
Phil Carmodydd6414b2010-10-20 15:57:33 -070041/*
Phil Carmodydd6414b2010-10-20 15:57:33 -070042 * 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.
Tejun Heoc5f66e92012-08-08 11:10:28 -070046 *
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!
Phil Carmodydd6414b2010-10-20 15:57:33 -070054 */
Thomas Gleixnerb0d6e2d2016-07-04 09:50:29 +000055#define TIMER_CPUMASK 0x0003FFFF
56#define TIMER_MIGRATING 0x00040000
Thomas Gleixner0eeda712015-05-26 22:50:29 +000057#define TIMER_BASEMASK (TIMER_CPUMASK | TIMER_MIGRATING)
Thomas Gleixnerb0d6e2d2016-07-04 09:50:29 +000058#define TIMER_DEFERRABLE 0x00080000
59#define TIMER_PINNED 0x00100000
60#define TIMER_IRQSAFE 0x00200000
Thomas Gleixner500462a2016-07-04 09:50:30 +000061#define TIMER_ARRAYSHIFT 22
62#define TIMER_ARRAYMASK 0xFFC00000
Phil Carmodydd6414b2010-10-20 15:57:33 -070063
Thomas Gleixner8a58a342017-02-10 16:41:15 +010064#define TIMER_TRACE_FLAGMASK (TIMER_MIGRATING | TIMER_DEFERRABLE | TIMER_PINNED | TIMER_IRQSAFE)
65
Kees Cook8ede3692017-10-04 16:27:05 -070066#define __TIMER_INITIALIZER(_function, _data, _flags) { \
Thomas Gleixner1dabbce2015-05-26 22:50:28 +000067 .entry = { .next = TIMER_ENTRY_STATIC }, \
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 .function = (_function), \
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 .data = (_data), \
Thomas Gleixner0eeda712015-05-26 22:50:29 +000070 .flags = (_flags), \
Johannes Berg6f2b9b92009-01-29 16:03:20 +010071 __TIMER_LOCKDEP_MAP_INITIALIZER( \
72 __FILE__ ":" __stringify(__LINE__)) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 }
74
Kees Cook1d27e3e2017-10-04 16:27:04 -070075#define DEFINE_TIMER(_name, _function) \
Ingo Molnar8d06afa2005-09-09 13:10:40 -070076 struct timer_list _name = \
Kees Cook8ede3692017-10-04 16:27:05 -070077 __TIMER_INITIALIZER(_function, 0, 0)
Ingo Molnar8d06afa2005-09-09 13:10:40 -070078
Tejun Heofc683992012-08-08 11:10:27 -070079void init_timer_key(struct timer_list *timer, unsigned int flags,
80 const char *name, struct lock_class_key *key);
Johannes Berg6f2b9b92009-01-29 16:03:20 +010081
Tejun Heo5a9af382012-08-08 11:10:26 -070082#ifdef CONFIG_DEBUG_OBJECTS_TIMERS
83extern void init_timer_on_stack_key(struct timer_list *timer,
Tejun Heofc683992012-08-08 11:10:27 -070084 unsigned int flags, const char *name,
Tejun Heo5a9af382012-08-08 11:10:26 -070085 struct lock_class_key *key);
86extern void destroy_timer_on_stack(struct timer_list *timer);
87#else
88static inline void destroy_timer_on_stack(struct timer_list *timer) { }
89static inline void init_timer_on_stack_key(struct timer_list *timer,
Tejun Heofc683992012-08-08 11:10:27 -070090 unsigned int flags, const char *name,
Tejun Heo5a9af382012-08-08 11:10:26 -070091 struct lock_class_key *key)
92{
Tejun Heofc683992012-08-08 11:10:27 -070093 init_timer_key(timer, flags, name, key);
Tejun Heo5a9af382012-08-08 11:10:26 -070094}
95#endif
96
Johannes Berg6f2b9b92009-01-29 16:03:20 +010097#ifdef CONFIG_LOCKDEP
Tejun Heofc683992012-08-08 11:10:27 -070098#define __init_timer(_timer, _flags) \
99 do { \
100 static struct lock_class_key __key; \
101 init_timer_key((_timer), (_flags), #_timer, &__key); \
102 } while (0)
103
104#define __init_timer_on_stack(_timer, _flags) \
105 do { \
106 static struct lock_class_key __key; \
107 init_timer_on_stack_key((_timer), (_flags), #_timer, &__key); \
108 } while (0)
109#else
110#define __init_timer(_timer, _flags) \
111 init_timer_key((_timer), (_flags), NULL, NULL)
112#define __init_timer_on_stack(_timer, _flags) \
113 init_timer_on_stack_key((_timer), (_flags), NULL, NULL)
114#endif
115
Johannes Berg6f2b9b92009-01-29 16:03:20 +0100116#define init_timer(timer) \
Tejun Heofc683992012-08-08 11:10:27 -0700117 __init_timer((timer), 0)
Tejun Heofc683992012-08-08 11:10:27 -0700118
119#define __setup_timer(_timer, _fn, _data, _flags) \
Johannes Berg6f2b9b92009-01-29 16:03:20 +0100120 do { \
Tejun Heofc683992012-08-08 11:10:27 -0700121 __init_timer((_timer), (_flags)); \
122 (_timer)->function = (_fn); \
123 (_timer)->data = (_data); \
Johannes Berg6f2b9b92009-01-29 16:03:20 +0100124 } while (0)
125
Tejun Heofc683992012-08-08 11:10:27 -0700126#define __setup_timer_on_stack(_timer, _fn, _data, _flags) \
Johannes Berg6f2b9b92009-01-29 16:03:20 +0100127 do { \
Tejun Heofc683992012-08-08 11:10:27 -0700128 __init_timer_on_stack((_timer), (_flags)); \
129 (_timer)->function = (_fn); \
130 (_timer)->data = (_data); \
Johannes Berg6f2b9b92009-01-29 16:03:20 +0100131 } while (0)
132
133#define setup_timer(timer, fn, data) \
Tejun Heofc683992012-08-08 11:10:27 -0700134 __setup_timer((timer), (fn), (data), 0)
Thomas Gleixnere6754472016-07-04 09:50:15 +0000135#define setup_pinned_timer(timer, fn, data) \
136 __setup_timer((timer), (fn), (data), TIMER_PINNED)
Lucas Stach6f3ffc12016-01-12 18:17:19 +0100137#define setup_deferrable_timer(timer, fn, data) \
138 __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE)
Thomas Gleixnere6754472016-07-04 09:50:15 +0000139#define setup_pinned_deferrable_timer(timer, fn, data) \
140 __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)
Johannes Berg6f2b9b92009-01-29 16:03:20 +0100141#define setup_timer_on_stack(timer, fn, data) \
Tejun Heofc683992012-08-08 11:10:27 -0700142 __setup_timer_on_stack((timer), (fn), (data), 0)
Thomas Gleixnere6754472016-07-04 09:50:15 +0000143#define setup_pinned_timer_on_stack(timer, fn, data) \
144 __setup_timer_on_stack((timer), (fn), (data), TIMER_PINNED)
Jesse Barnes8cadd2832010-05-10 14:26:20 -0700145#define setup_deferrable_timer_on_stack(timer, fn, data) \
Tejun Heofc683992012-08-08 11:10:27 -0700146 __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE)
Thomas Gleixnere6754472016-07-04 09:50:15 +0000147#define setup_pinned_deferrable_timer_on_stack(timer, fn, data) \
148 __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)
Jesse Barnes8cadd2832010-05-10 14:26:20 -0700149
Kees Cook686fef92017-09-28 06:38:17 -0700150#define TIMER_DATA_TYPE unsigned long
151#define TIMER_FUNC_TYPE void (*)(TIMER_DATA_TYPE)
152
Kees Cook52f737c2017-10-19 13:28:38 -0700153#ifndef CONFIG_LOCKDEP
Kees Cook686fef92017-09-28 06:38:17 -0700154static inline void timer_setup(struct timer_list *timer,
155 void (*callback)(struct timer_list *),
156 unsigned int flags)
157{
158 __setup_timer(timer, (TIMER_FUNC_TYPE)callback,
159 (TIMER_DATA_TYPE)timer, flags);
160}
161
Kees Cook58e11772017-10-04 16:26:55 -0700162static inline void timer_setup_on_stack(struct timer_list *timer,
163 void (*callback)(struct timer_list *),
164 unsigned int flags)
165{
166 __setup_timer_on_stack(timer, (TIMER_FUNC_TYPE)callback,
167 (TIMER_DATA_TYPE)timer, flags);
168}
Kees Cook52f737c2017-10-19 13:28:38 -0700169#else
170/*
171 * Under LOCKDEP, the timer lock_class_key (set up in __init_timer) needs
172 * to be tied to the caller's context, so an inline (above) won't work. We
173 * do want to keep the inline for argument type checking, though.
174 */
175# define timer_setup(timer, callback, flags) \
176 __setup_timer(timer, (TIMER_FUNC_TYPE)callback, \
177 (TIMER_DATA_TYPE)timer, flags)
178# define timer_setup_on_stack(timer, callback, flags) \
179 __setup_timer_on_stack(timer, (TIMER_FUNC_TYPE)callback,\
180 (TIMER_DATA_TYPE)timer, flags)
181#endif
Kees Cook58e11772017-10-04 16:26:55 -0700182
Kees Cook686fef92017-09-28 06:38:17 -0700183#define from_timer(var, callback_timer, timer_fieldname) \
184 container_of(callback_timer, typeof(*var), timer_fieldname)
185
Robert P. J. Day45f8bde2007-01-26 00:57:09 -0800186/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 * timer_pending - is a timer pending?
188 * @timer: the timer in question
189 *
190 * timer_pending will tell whether a given timer is currently pending,
191 * or not. Callers must ensure serialization wrt. other operations done
192 * to this timer, eg. interrupt contexts, or other CPUs on SMP.
193 *
194 * return value: 1 if the timer is pending, 0 if not.
195 */
196static inline int timer_pending(const struct timer_list * timer)
197{
Thomas Gleixner1dabbce2015-05-26 22:50:28 +0000198 return timer->entry.pprev != NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199}
200
201extern void add_timer_on(struct timer_list *timer, int cpu);
202extern int del_timer(struct timer_list * timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203extern int mod_timer(struct timer_list *timer, unsigned long expires);
Ingo Molnar74019222009-02-18 12:23:29 +0100204extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Thomas Gleixnerfd064b92007-02-16 01:27:47 -0800206/*
Thomas Gleixnereaad0842007-05-29 23:47:39 +0200207 * The jiffies value which is added to now, when there is no timer
208 * in the timer wheel:
209 */
210#define NEXT_TIMER_MAX_DELTA ((1UL << 30) - 1)
211
Ingo Molnar74019222009-02-18 12:23:29 +0100212extern void add_timer(struct timer_list *timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Yong Zhang6f1bc452010-10-20 15:57:31 -0700214extern int try_to_del_timer_sync(struct timer_list *timer);
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216#ifdef CONFIG_SMP
217 extern int del_timer_sync(struct timer_list *timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218#else
Oleg Nesterovfd450b72005-06-23 00:08:59 -0700219# define del_timer_sync(t) del_timer(t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220#endif
221
Oleg Nesterov55c888d2005-06-23 00:08:56 -0700222#define del_singleshot_timer_sync(t) del_timer_sync(t)
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224extern void init_timers(void);
225extern void run_local_timers(void);
Roman Zippel05cfb612006-03-26 01:38:12 -0800226struct hrtimer;
Thomas Gleixnerc9cb2e32007-02-16 01:27:49 -0800227extern enum hrtimer_restart it_real_fn(struct hrtimer *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Thomas Gleixnerbc7a34b2015-05-26 22:50:33 +0000229#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
Ingo Molnarb2d5bfe2017-02-06 09:56:40 +0100230struct ctl_table;
Thomas Gleixnerbc7a34b2015-05-26 22:50:33 +0000231
232extern unsigned int sysctl_timer_migration;
233int timer_migration_handler(struct ctl_table *table, int write,
234 void __user *buffer, size_t *lenp,
235 loff_t *ppos);
236#endif
237
Arjan van de Ven4c36a5d2006-12-10 02:21:24 -0800238unsigned long __round_jiffies(unsigned long j, int cpu);
239unsigned long __round_jiffies_relative(unsigned long j, int cpu);
240unsigned long round_jiffies(unsigned long j);
241unsigned long round_jiffies_relative(unsigned long j);
242
Alan Stern9c133c42008-11-06 08:42:48 +0100243unsigned long __round_jiffies_up(unsigned long j, int cpu);
244unsigned long __round_jiffies_up_relative(unsigned long j, int cpu);
245unsigned long round_jiffies_up(unsigned long j);
246unsigned long round_jiffies_up_relative(unsigned long j);
247
Richard Cochran24f73b92016-07-13 17:16:59 +0000248#ifdef CONFIG_HOTPLUG_CPU
249int timers_dead_cpu(unsigned int cpu);
250#else
251#define timers_dead_cpu NULL
252#endif
253
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254#endif