Lines Matching refs:base
87 * base in timer_list is guaranteed to be zero. Use the LSB for
93 static inline unsigned int tbase_get_deferrable(tvec_base_t *base)
95 return ((unsigned int)(unsigned long)base & TBASE_DEFERRABLE_FLAG);
98 static inline tvec_base_t *tbase_get_base(tvec_base_t *base)
100 return ((tvec_base_t *)((unsigned long)base & ~TBASE_DEFERRABLE_FLAG));
105 timer->base = ((tvec_base_t *)((unsigned long)(timer->base) |
112 timer->base = (tvec_base_t *)((unsigned long)(new_base) |
113 tbase_get_deferrable(timer->base));
248 static inline void set_running_timer(tvec_base_t *base,
252 base->running_timer = timer;
256 static void internal_add_timer(tvec_base_t *base, struct timer_list *timer)
259 unsigned long idx = expires - base->timer_jiffies;
264 vec = base->tv1.vec + i;
267 vec = base->tv2.vec + i;
270 vec = base->tv3.vec + i;
273 vec = base->tv4.vec + i;
279 vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
287 expires = idx + base->timer_jiffies;
290 vec = base->tv5.vec + i;
320 timer->base = __raw_get_cpu_var(tvec_bases);
349 * means that all timers which are tied to this base via timer->base are
350 * locked, and the base itself is locked too.
355 * When the timer's base is locked, and the timer removed from list, it is
356 * possible to set timer->base = NULL and drop the lock: the timer remains
361 __acquires(timer->base->lock)
363 tvec_base_t *base;
366 tvec_base_t *prelock_base = timer->base;
367 base = tbase_get_base(prelock_base);
368 if (likely(base != NULL)) {
369 spin_lock_irqsave(&base->lock, *flags);
370 if (likely(prelock_base == timer->base))
371 return base;
373 spin_unlock_irqrestore(&base->lock, *flags);
381 tvec_base_t *base, *new_base;
388 base = lock_timer_base(timer, &flags);
397 if (base != new_base) {
400 * However we can't change timer's base while it is running,
405 if (likely(base->running_timer != timer)) {
408 spin_unlock(&base->lock);
409 base = new_base;
410 spin_lock(&base->lock);
411 timer_set_base(timer, base);
416 internal_add_timer(base, timer);
417 spin_unlock_irqrestore(&base->lock, flags);
433 tvec_base_t *base = per_cpu(tvec_bases, cpu);
438 spin_lock_irqsave(&base->lock, flags);
439 timer_set_base(timer, base);
440 internal_add_timer(base, timer);
441 spin_unlock_irqrestore(&base->lock, flags);
496 tvec_base_t *base;
502 base = lock_timer_base(timer, &flags);
507 spin_unlock_irqrestore(&base->lock, flags);
527 tvec_base_t *base;
531 base = lock_timer_base(timer, &flags);
533 if (base->running_timer == timer)
542 spin_unlock_irqrestore(&base->lock, flags);
579 static int cascade(tvec_base_t *base, tvec_t *tv, int index)
592 BUG_ON(tbase_get_base(timer->base) != base);
593 internal_add_timer(base, timer);
599 #define INDEX(N) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)
603 * @base: the timer vector to be processed.
608 static inline void __run_timers(tvec_base_t *base)
612 spin_lock_irq(&base->lock);
613 while (time_after_eq(jiffies, base->timer_jiffies)) {
616 int index = base->timer_jiffies & TVR_MASK;
622 (!cascade(base, &base->tv2, INDEX(0))) &&
623 (!cascade(base, &base->tv3, INDEX(1))) &&
624 !cascade(base, &base->tv4, INDEX(2)))
625 cascade(base, &base->tv5, INDEX(3));
626 ++base->timer_jiffies;
627 list_replace_init(base->tv1.vec + index, &work_list);
638 set_running_timer(base, timer);
640 spin_unlock_irq(&base->lock);
653 spin_lock_irq(&base->lock);
656 set_running_timer(base, NULL);
657 spin_unlock_irq(&base->lock);
666 static unsigned long __next_timer_interrupt(tvec_base_t *base)
668 unsigned long timer_jiffies = base->timer_jiffies;
677 list_for_each_entry(nte, base->tv1.vec + slot, entry) {
678 if (tbase_get_deferrable(nte->base))
698 varray[0] = &base->tv2;
699 varray[1] = &base->tv3;
700 varray[2] = &base->tv4;
701 varray[3] = &base->tv5;
783 tvec_base_t *base = __get_cpu_var(tvec_bases);
786 spin_lock(&base->lock);
787 expires = __next_timer_interrupt(base);
788 spin_unlock(&base->lock);
872 tvec_base_t *base = __get_cpu_var(tvec_bases);
876 if (time_after_eq(jiffies, base->timer_jiffies))
877 __run_timers(base);
1190 * lockdep: we want to track each per-CPU base as a separate lock-class,
1199 tvec_base_t *base;
1209 base = kmalloc_node(sizeof(*base), GFP_KERNEL,
1211 if (!base)
1215 if (tbase_get_deferrable(base)) {
1217 kfree(base);
1220 memset(base, 0, sizeof(*base));
1221 per_cpu(tvec_bases, cpu) = base;
1230 base = &boot_tvec_bases;
1234 base = per_cpu(tvec_bases, cpu);
1237 spin_lock_init(&base->lock);
1238 lockdep_set_class(&base->lock, base_lock_keys + cpu);
1241 INIT_LIST_HEAD(base->tv5.vec + j);
1242 INIT_LIST_HEAD(base->tv4.vec + j);
1243 INIT_LIST_HEAD(base->tv3.vec + j);
1244 INIT_LIST_HEAD(base->tv2.vec + j);
1247 INIT_LIST_HEAD(base->tv1.vec + j);
1249 base->timer_jiffies = jiffies;