LCOV - code coverage report
Current view: top level - lkbce/include/linux - timer.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 3 100.0 %
Date: 2017-01-25 Functions: 0 0 -

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

Generated by: LCOV version 1.10