Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
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: int start_pid; 28: void *start_site; 29: char start_comm[16]; 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: /* 52: * Note that all tvec_bases are at least 4 byte aligned and lower two bits 53: * of base in timer_list is guaranteed to be zero. Use them for flags. 54: * 55: * A deferrable timer will work normally when the system is busy, but 56: * will not cause a CPU to come out of idle just to service it; instead, 57: * the timer will be serviced when the CPU eventually wakes up with a 58: * subsequent non-deferrable timer. 59: * 60: * An irqsafe timer is executed with IRQ disabled and it's safe to wait for 61: * the completion of the running instance from IRQ handlers, for example, 62: * by calling del_timer_sync(). 63: * 64: * Note: The irq disabled callback execution is a special case for 65: * workqueue locking issues. It's not meant for executing random crap 66: * with interrupts disabled. Abuse is monitored! 67: */ 68: #define TIMER_DEFERRABLE 0x1LU 69: #define TIMER_IRQSAFE 0x2LU 70: 71: #define TIMER_FLAG_MASK 0x3LU 72: 73: #define __TIMER_INITIALIZER(_function, _expires, _data, _flags) { \ 74: .entry = { .prev = TIMER_ENTRY_STATIC }, \ 75: .function = (_function), \ 76: .expires = (_expires), \ 77: .data = (_data), \ 78: .base = (void *)((unsigned long)&boot_tvec_bases + (_flags)), \ 79: .slack = -1, \ 80: __TIMER_LOCKDEP_MAP_INITIALIZER( \ 81: __FILE__ ":" __stringify(__LINE__)) \ 82: } 83: 84: #define TIMER_INITIALIZER(_function, _expires, _data) \ 85: __TIMER_INITIALIZER((_function), (_expires), (_data), 0) 86: 87: #define TIMER_DEFERRED_INITIALIZER(_function, _expires, _data) \ 88: __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE) 89: 90: #define DEFINE_TIMER(_name, _function, _expires, _data) \ 91: struct timer_list _name = \ 92: TIMER_INITIALIZER(_function, _expires, _data) 93: 94: void init_timer_key(struct timer_list *timer, unsigned int flags, 95: const char *name, struct lock_class_key *key); 96: 97: #ifdef CONFIG_DEBUG_OBJECTS_TIMERS 98: extern void init_timer_on_stack_key(struct timer_list *timer, 99: unsigned int flags, const char *name, 100: struct lock_class_key *key); 101: extern void destroy_timer_on_stack(struct timer_list *timer); 102: #else 103: static inline void destroy_timer_on_stack(struct timer_list *timer) { } 104: static inline void init_timer_on_stack_key(struct timer_list *timer, 105: unsigned int flags, const char *name, 106: struct lock_class_key *key) 107: { 108: init_timer_key(timer, flags, name, key); 109: } 110: #endif 111: 112: #ifdef CONFIG_LOCKDEP 113: #define __init_timer(_timer, _flags) \ 114: do { \ 115: static struct lock_class_key __key; \ 116: init_timer_key((_timer), (_flags), #_timer, &__key); \ 117: } while (0) 118: 119: #define __init_timer_on_stack(_timer, _flags) \ 120: do { \ 121: static struct lock_class_key __key; \ 122: init_timer_on_stack_key((_timer), (_flags), #_timer, &__key); \ 123: } while (0) 124: #else 125: #define __init_timer(_timer, _flags) \ 126: init_timer_key((_timer), (_flags), NULL, NULL) 127: #define __init_timer_on_stack(_timer, _flags) \ 128: init_timer_on_stack_key((_timer), (_flags), NULL, NULL) 129: #endif 130: 131: #define init_timer(timer) \ 132: __init_timer((timer), 0) 133: #define init_timer_deferrable(timer) \ 134: __init_timer((timer), TIMER_DEFERRABLE) 135: #define init_timer_on_stack(timer) \ 136: __init_timer_on_stack((timer), 0) 137: 138: #define __setup_timer(_timer, _fn, _data, _flags) \ 139: do { \ 140: __init_timer((_timer), (_flags)); \ 141: (_timer)->function = (_fn); \ 142: (_timer)->data = (_data); \ 143: } while (0) 144: 145: #define __setup_timer_on_stack(_timer, _fn, _data, _flags) \ 146: do { \ 147: __init_timer_on_stack((_timer), (_flags)); \ 148: (_timer)->function = (_fn); \ 149: (_timer)->data = (_data); \ 150: } while (0) 151: 152: #define setup_timer(timer, fn, data) \ 153: __setup_timer((timer), (fn), (data), 0) 154: #define setup_timer_on_stack(timer, fn, data) \ 155: __setup_timer_on_stack((timer), (fn), (data), 0) 156: #define setup_deferrable_timer_on_stack(timer, fn, data) \ 157: __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE) 158: 159: /** 160: * timer_pending - is a timer pending? 161: * @timer: the timer in question 162: * 163: * timer_pending will tell whether a given timer is currently pending, 164: * or not. Callers must ensure serialization wrt. other operations done 165: * to this timer, eg. interrupt contexts, or other CPUs on SMP. 166: * 167: * return value: 1 if the timer is pending, 0 if not. 168: */ 169: static inline int timer_pending(const struct timer_list * timer) 170: { 171: return timer->entry.next != NULL; 172: } 173: 174: extern void add_timer_on(struct timer_list *timer, int cpu); 175: extern int del_timer(struct timer_list * timer); 176: extern int mod_timer(struct timer_list *timer, unsigned long expires); 177: extern int mod_timer_pending(struct timer_list *timer, unsigned long expires); 178: extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires); 179: 180: extern void set_timer_slack(struct timer_list *time, int slack_hz); 181: 182: #define TIMER_NOT_PINNED 0 183: #define TIMER_PINNED 1 184: /* 185: * The jiffies value which is added to now, when there is no timer 186: * in the timer wheel: 187: */ 188: #define NEXT_TIMER_MAX_DELTA ((1UL << 30) - 1) 189: 190: /* 191: * Return when the next timer-wheel timeout occurs (in absolute jiffies), 192: * locks the timer base and does the comparison against the given 193: * jiffie. 194: */ 195: extern unsigned long get_next_timer_interrupt(unsigned long now); 196: 197: /* 198: * Timer-statistics info: 199: */ 200: #ifdef CONFIG_TIMER_STATS 201: 202: extern int timer_stats_active; 203: 204: #define TIMER_STATS_FLAG_DEFERRABLE 0x1 205: 206: extern void init_timer_stats(void); 207: 208: extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf, 209: void *timerf, char *comm, 210: unsigned int timer_flag); 211: 212: extern void __timer_stats_timer_set_start_info(struct timer_list *timer, 213: void *addr); 214: 215: static inline void timer_stats_timer_set_start_info(struct timer_list *timer) 216: { 217: if (likely(!timer_stats_active)) 218: return; 219: __timer_stats_timer_set_start_info(timer, __builtin_return_address(0)); 220: } 221: 222: static inline void timer_stats_timer_clear_start_info(struct timer_list *timer) 223: { 224: timer->start_site = NULL; 225: } 226: #else 227: static inline void init_timer_stats(void) 228: { 229: } 230: 231: static inline void timer_stats_timer_set_start_info(struct timer_list *timer) 232: { 233: } 234: 235: static inline void timer_stats_timer_clear_start_info(struct timer_list *timer) 236: { 237: } 238: #endif 239: 240: extern void add_timer(struct timer_list *timer); 241: 242: extern int try_to_del_timer_sync(struct timer_list *timer); 243: 244: #ifdef CONFIG_SMP 245: extern int del_timer_sync(struct timer_list *timer); 246: #else 247: # define del_timer_sync(t) del_timer(t) 248: #endif 249: 250: #define del_singleshot_timer_sync(t) del_timer_sync(t) 251: 252: extern void init_timers(void); 253: extern void run_local_timers(void); 254: struct hrtimer; 255: extern enum hrtimer_restart it_real_fn(struct hrtimer *); 256: 257: unsigned long __round_jiffies(unsigned long j, int cpu); 258: unsigned long __round_jiffies_relative(unsigned long j, int cpu); 259: unsigned long round_jiffies(unsigned long j); 260: unsigned long round_jiffies_relative(unsigned long j); 261: 262: unsigned long __round_jiffies_up(unsigned long j, int cpu); 263: unsigned long __round_jiffies_up_relative(unsigned long j, int cpu); 264: unsigned long round_jiffies_up(unsigned long j); 265: unsigned long round_jiffies_up_relative(unsigned long j); 266: 267: #endif 268: