release/src-rt-6.x.4708/linux/linux-2.6.36/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 list_head entry;
  18         unsigned long expires;
  19         struct tvec_base *base;
  20
  21         void (*function)(unsigned long);
  22         unsigned long data;
  23
  24         int slack;
  25
  26 #ifdef CONFIG_TIMER_STATS
  27         void *start_site;
  28         char start_comm[16];
  29         int start_pid;
  30 #endif
  31 #ifdef CONFIG_LOCKDEP
  32         struct lockdep_map lockdep_map;
  33 #endif
  34 };
  35
  36 extern struct tvec_base boot_tvec_bases;
  37
  38 #ifdef CONFIG_LOCKDEP
  39 /*
  40  * NB: because we have to copy the lockdep_map, setting the lockdep_map key
  41  * (second argument) here is required, otherwise it could be initialised to
  42  * the copy of the lockdep_map later! We use the pointer to and the string
  43  * "<file>:<line>" as the key resp. the name of the lockdep_map.
  44  */
  45 #define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn)                            \
  46         .lockdep_map = STATIC_LOCKDEP_MAP_INIT(_kn, &_kn),
  47 #else
  48 #define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn)
  49 #endif
  50
  51 #define TIMER_INITIALIZER(_function, _expires, _data) {         \
  52                 .entry = { .prev = TIMER_ENTRY_STATIC },        \
  53                 .function = (_function),                        \
  54                 .expires = (_expires),                          \
  55                 .data = (_data),                                \
  56                 .base = &boot_tvec_bases,                       \
  57                 __TIMER_LOCKDEP_MAP_INITIALIZER(                \
  58                         __FILE__ ":" __stringify(__LINE__))     \
  59         }
  60
  61 #define DEFINE_TIMER(_name, _function, _expires, _data)         \
  62         struct timer_list _name =                               \
  63                 TIMER_INITIALIZER(_function, _expires, _data)
  64
  65 void init_timer_key(struct timer_list *timer,
  66                     const char *name,
  67                     struct lock_class_key *key);
  68 void init_timer_deferrable_key(struct timer_list *timer,
  69                                const char *name,
  70                                struct lock_class_key *key);
  71
  72 #ifdef CONFIG_LOCKDEP
  73 #define init_timer(timer)                                               \
  74         do {                                                            \
  75                 static struct lock_class_key __key;                     \
  76                 init_timer_key((timer), #timer, &__key);                \
  77         } while (0)
  78
  79 #define init_timer_deferrable(timer)                                    \
  80         do {                                                            \
  81                 static struct lock_class_key __key;                     \
  82                 init_timer_deferrable_key((timer), #timer, &__key);     \
  83         } while (0)
  84
  85 #define init_timer_on_stack(timer)                                      \
  86         do {                                                            \
  87                 static struct lock_class_key __key;                     \
  88                 init_timer_on_stack_key((timer), #timer, &__key);       \
  89         } while (0)
  90
  91 #define setup_timer(timer, fn, data)                                    \
  92         do {                                                            \
  93                 static struct lock_class_key __key;                     \
  94                 setup_timer_key((timer), #timer, &__key, (fn), (data));\
  95         } while (0)
  96
  97 #define setup_timer_on_stack(timer, fn, data)                           \
  98         do {                                                            \
  99                 static struct lock_class_key __key;                     \
 100                 setup_timer_on_stack_key((timer), #timer, &__key,       \
 101                                          (fn), (data));                 \
 102         } while (0)
 103 #define setup_deferrable_timer_on_stack(timer, fn, data)                \
 104         do {                                                            \
 105                 static struct lock_class_key __key;                     \
 106                 setup_deferrable_timer_on_stack_key((timer), #timer,    \
 107                                                     &__key, (fn),       \
 108                                                     (data));            \
 109         } while (0)
 110 #else
 111 #define init_timer(timer)\
 112         init_timer_key((timer), NULL, NULL)
 113 #define init_timer_deferrable(timer)\
 114         init_timer_deferrable_key((timer), NULL, NULL)
 115 #define init_timer_on_stack(timer)\
 116         init_timer_on_stack_key((timer), NULL, NULL)
 117 #define setup_timer(timer, fn, data)\
 118         setup_timer_key((timer), NULL, NULL, (fn), (data))
 119 #define setup_timer_on_stack(timer, fn, data)\
 120         setup_timer_on_stack_key((timer), NULL, NULL, (fn), (data))
 121 #define setup_deferrable_timer_on_stack(timer, fn, data)\
 122         setup_deferrable_timer_on_stack_key((timer), NULL, NULL, (fn), (data))
 123 #endif
 124
 125 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
 126 extern void init_timer_on_stack_key(struct timer_list *timer,
 127                                     const char *name,
 128                                     struct lock_class_key *key);
 129 extern void destroy_timer_on_stack(struct timer_list *timer);
 130 #else
 131 static inline void destroy_timer_on_stack(struct timer_list *timer) { }
 132 static inline void init_timer_on_stack_key(struct timer_list *timer,
 133                                            const char *name,
 134                                            struct lock_class_key *key)
 135 {
 136         init_timer_key(timer, name, key);
 137 }
 138 #endif
 139
 140 static inline void setup_timer_key(struct timer_list * timer,
 141                                 const char *name,
 142                                 struct lock_class_key *key,
 143                                 void (*function)(unsigned long),
 144                                 unsigned long data)
 145 {
 146         timer->function = function;
 147         timer->data = data;
 148         init_timer_key(timer, name, key);
 149 }
 150
 151 static inline void setup_timer_on_stack_key(struct timer_list *timer,
 152                                         const char *name,
 153                                         struct lock_class_key *key,
 154                                         void (*function)(unsigned long),
 155                                         unsigned long data)
 156 {
 157         timer->function = function;
 158         timer->data = data;
 159         init_timer_on_stack_key(timer, name, key);
 160 }
 161
 162 extern void setup_deferrable_timer_on_stack_key(struct timer_list *timer,
 163                                                 const char *name,
 164                                                 struct lock_class_key *key,
 165                                                 void (*function)(unsigned long),
 166                                                 unsigned long data);
 167
 168 /**
 169  * timer_pending - is a timer pending?
 170  * @timer: the timer in question
 171  *
 172  * timer_pending will tell whether a given timer is currently pending,
 173  * or not. Callers must ensure serialization wrt. other operations done
 174  * to this timer, eg. interrupt contexts, or other CPUs on SMP.
 175  *
 176  * return value: 1 if the timer is pending, 0 if not.
 177  */
 178 static inline int timer_pending(const struct timer_list * timer)
 179 {
 180         return timer->entry.next != NULL;
 181 }
 182
 183 extern void add_timer_on(struct timer_list *timer, int cpu);
 184 extern int del_timer(struct timer_list * timer);
 185 extern int mod_timer(struct timer_list *timer, unsigned long expires);
 186 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);
 187 extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires);
 188
 189 extern void set_timer_slack(struct timer_list *time, int slack_hz);
 190
 191 #define TIMER_NOT_PINNED        0
 192 #define TIMER_PINNED            1
 193 /*
 194  * The jiffies value which is added to now, when there is no timer
 195  * in the timer wheel:
 196  */
 197 #define NEXT_TIMER_MAX_DELTA    ((1UL << 30) - 1)
 198
 199 /*
 200  * Return when the next timer-wheel timeout occurs (in absolute jiffies),
 201  * locks the timer base and does the comparison against the given
 202  * jiffie.
 203  */
 204 extern unsigned long get_next_timer_interrupt(unsigned long now);
 205
 206 /*
 207  * Timer-statistics info:
 208  */
 209 #ifdef CONFIG_TIMER_STATS
 210
 211 extern int timer_stats_active;
 212
 213 #define TIMER_STATS_FLAG_DEFERRABLE     0x1
 214
 215 extern void init_timer_stats(void);
 216
 217 extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
 218                                      void *timerf, char *comm,
 219                                      unsigned int timer_flag);
 220
 221 extern void __timer_stats_timer_set_start_info(struct timer_list *timer,
 222                                                void *addr);
 223
 224 static inline void timer_stats_timer_set_start_info(struct timer_list *timer)
 225 {
 226         if (likely(!timer_stats_active))
 227                 return;
 228         __timer_stats_timer_set_start_info(timer, __builtin_return_address(0));
 229 }
 230
 231 static inline void timer_stats_timer_clear_start_info(struct timer_list *timer)
 232 {
 233         timer->start_site = NULL;
 234 }
 235 #else
 236 static inline void init_timer_stats(void)
 237 {
 238 }
 239
 240 static inline void timer_stats_timer_set_start_info(struct timer_list *timer)
 241 {
 242 }
 243
 244 static inline void timer_stats_timer_clear_start_info(struct timer_list *timer)
 245 {
 246 }
 247 #endif
 248
 249 extern void add_timer(struct timer_list *timer);
 250
 251 #ifdef CONFIG_SMP
 252   extern int try_to_del_timer_sync(struct timer_list *timer);
 253   extern int del_timer_sync(struct timer_list *timer);
 254 #else
 255 # define try_to_del_timer_sync(t)       del_timer(t)
 256 # define del_timer_sync(t)              del_timer(t)
 257 #endif
 258
 259 #define del_singleshot_timer_sync(t) del_timer_sync(t)
 260
 261 extern void init_timers(void);
 262 extern void run_local_timers(void);
 263 struct hrtimer;
 264 extern enum hrtimer_restart it_real_fn(struct hrtimer *);
 265
 266 unsigned long __round_jiffies(unsigned long j, int cpu);
 267 unsigned long __round_jiffies_relative(unsigned long j, int cpu);
 268 unsigned long round_jiffies(unsigned long j);
 269 unsigned long round_jiffies_relative(unsigned long j);
 270
 271 unsigned long __round_jiffies_up(unsigned long j, int cpu);
 272 unsigned long __round_jiffies_up_relative(unsigned long j, int cpu);
 273 unsigned long round_jiffies_up(unsigned long j);
 274 unsigned long round_jiffies_up_relative(unsigned long j);
 275
 276 #endif