自学教程：C++ tick_program_event函数代码示例

static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now){	hrtimer_forward(&ts->sched_timer, now, tick_period);	return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);}

/* * High resolution timer interrupt * Called with interrupts disabled */void hrtimer_interrupt(struct clock_event_device *dev){	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	struct hrtimer_clock_base *base;	ktime_t expires_next, now, entry_time, delta;	int i, retries = 0;	BUG_ON(!cpu_base->hres_active);	cpu_base->nr_events++;	dev->next_event.tv64 = KTIME_MAX;	spin_lock(&cpu_base->lock);	entry_time = now = hrtimer_update_base(cpu_base);retry:	expires_next.tv64 = KTIME_MAX;	/*	 * We set expires_next to KTIME_MAX here with cpu_base->lock	 * held to prevent that a timer is enqueued in our queue via	 * the migration code. This does not affect enqueueing of	 * timers which run their callback and need to be requeued on	 * this CPU.	 */	cpu_base->expires_next.tv64 = KTIME_MAX;	base = cpu_base->clock_base;	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		ktime_t basenow;		struct rb_node *node;		basenow = ktime_add(now, base->offset);		while ((node = base->first)) {			struct hrtimer *timer;			timer = rb_entry(node, struct hrtimer, node);			/*			 * The immediate goal for using the softexpires is			 * minimizing wakeups, not running timers at the			 * earliest interrupt after their soft expiration.			 * This allows us to avoid using a Priority Search			 * Tree, which can answer a stabbing querry for			 * overlapping intervals and instead use the simple			 * BST we already have.			 * We don't add extra wakeups by delaying timers that			 * are right-of a not yet expired timer, because that			 * timer will have to trigger a wakeup anyway.			 */			if (basenow.tv64 < hrtimer_get_softexpires_tv64(timer)) {				ktime_t expires;				expires = ktime_sub(hrtimer_get_expires(timer),						    base->offset);				if (expires.tv64 < 0)					expires.tv64 = KTIME_MAX;				if (expires.tv64 < expires_next.tv64)					expires_next = expires;				break;			}			__run_hrtimer(timer, &basenow);		}		base++;	}	/*	 * Store the new expiry value so the migration code can verify	 * against it.	 */	cpu_base->expires_next = expires_next;	spin_unlock(&cpu_base->lock);	/* Reprogramming necessary ? */	if (expires_next.tv64 == KTIME_MAX ||	    !tick_program_event(expires_next, 0)) {		cpu_base->hang_detected = 0;		return;	}	/*	 * The next timer was already expired due to:	 * - tracing	 * - long lasting callbacks	 * - being scheduled away when running in a VM	 *	 * We need to prevent that we loop forever in the hrtimer	 * interrupt routine. We give it 3 attempts to avoid	 * overreacting on some spurious event.	 *	 * Acquire base lock for updating the offsets and retrieving	 * the current time.	 */	spin_lock(&cpu_base->lock);	now = hrtimer_update_base(cpu_base);//.........这里部分代码省略.........

//.........这里部分代码省略.........		 * cpu which runs the tick timer next, which might be		 * this cpu as well. If we don't drop this here the		 * jiffies might be stale and do_timer() never		 * invoked. Keep track of the fact that it was the one		 * which had the do_timer() duty last. If this cpu is		 * the one which had the do_timer() duty last, we		 * limit the sleep time to the timekeeping		 * max_deferement value which we retrieved		 * above. Otherwise we can sleep as long as we want.		 */		if (cpu == tick_do_timer_cpu) {			tick_do_timer_cpu = TICK_DO_TIMER_NONE;			ts->do_timer_last = 1;		} else if (tick_do_timer_cpu != TICK_DO_TIMER_NONE) {			time_delta = KTIME_MAX;			ts->do_timer_last = 0;		} else if (!ts->do_timer_last) {			time_delta = KTIME_MAX;		}		/*		 * calculate the expiry time for the next timer wheel		 * timer. delta_jiffies >= NEXT_TIMER_MAX_DELTA signals		 * that there is no timer pending or at least extremely		 * far into the future (12 days for HZ=1000). In this		 * case we set the expiry to the end of time.		 */		if (likely(delta_jiffies < NEXT_TIMER_MAX_DELTA)) {			/*			 * Calculate the time delta for the next timer event.			 * If the time delta exceeds the maximum time delta			 * permitted by the current clocksource then adjust			 * the time delta accordingly to ensure the			 * clocksource does not wrap.			 */			time_delta = min_t(u64, time_delta,					   tick_period.tv64 * delta_jiffies);		}		if (time_delta < KTIME_MAX)			expires = ktime_add_ns(last_update, time_delta);		else			expires.tv64 = KTIME_MAX;		/* Skip reprogram of event if its not changed */		if (ts->tick_stopped && ktime_equal(expires, dev->next_event))			goto out;		/*		 * nohz_stop_sched_tick can be called several times before		 * the nohz_restart_sched_tick is called. This happens when		 * interrupts arrive which do not cause a reschedule. In the		 * first call we save the current tick time, so we can restart		 * the scheduler tick in nohz_restart_sched_tick.		 */		if (!ts->tick_stopped) {			select_nohz_load_balancer(1);			calc_load_enter_idle();			ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);			ts->tick_stopped = 1;			ts->idle_jiffies = last_jiffies;		}		ts->idle_sleeps++;		/* Mark expires */		ts->idle_expires = expires;		/*		 * If the expiration time == KTIME_MAX, then		 * in this case we simply stop the tick timer.		 */		 if (unlikely(expires.tv64 == KTIME_MAX)) {			if (ts->nohz_mode == NOHZ_MODE_HIGHRES)				hrtimer_cancel(&ts->sched_timer);			goto out;		}		if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {			hrtimer_start(&ts->sched_timer, expires,				      HRTIMER_MODE_ABS_PINNED);			/* Check, if the timer was already in the past */			if (hrtimer_active(&ts->sched_timer))				goto out;		} else if (!tick_program_event(expires, 0))				goto out;		/*		 * We are past the event already. So we crossed a		 * jiffie boundary. Update jiffies and raise the		 * softirq.		 */		tick_do_update_jiffies64(ktime_get());	}	raise_softirq_irqoff(TIMER_SOFTIRQ);out:	ts->next_jiffies = next_jiffies;	ts->last_jiffies = last_jiffies;	ts->sleep_length = ktime_sub(dev->next_event, now);}

/* * High resolution timer interrupt * Called with interrupts disabled */void hrtimer_interrupt(struct clock_event_device *dev){	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	struct hrtimer_clock_base *base;	ktime_t expires_next, now;	int i, raise = 0;	BUG_ON(!cpu_base->hres_active);	cpu_base->nr_events++;	dev->next_event.tv64 = KTIME_MAX; retry:	now = ktime_get();	expires_next.tv64 = KTIME_MAX;	base = cpu_base->clock_base;	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		ktime_t basenow;		struct rb_node *node;		spin_lock(&cpu_base->lock);		basenow = ktime_add(now, base->offset);		while ((node = base->first)) {			struct hrtimer *timer;			timer = rb_entry(node, struct hrtimer, node);			if (basenow.tv64 < timer->expires.tv64) {				ktime_t expires;				expires = ktime_sub(timer->expires,						    base->offset);				if (expires.tv64 < expires_next.tv64)					expires_next = expires;				break;			}			/* Move softirq callbacks to the pending list */			if (timer->cb_mode == HRTIMER_CB_SOFTIRQ) {				__remove_hrtimer(timer, base,						 HRTIMER_STATE_PENDING, 0);				list_add_tail(&timer->cb_entry,					      &base->cpu_base->cb_pending);				raise = 1;				continue;			}			__run_hrtimer(timer);		}		spin_unlock(&cpu_base->lock);		base++;	}	cpu_base->expires_next = expires_next;	/* Reprogramming necessary ? */	if (expires_next.tv64 != KTIME_MAX) {		if (tick_program_event(expires_next, 0))			goto retry;	}	/* Raise softirq ? */	if (raise)		raise_softirq(HRTIMER_SOFTIRQ);}

/* * High resolution timer interrupt * Called with interrupts disabled */void hrtimer_interrupt(struct clock_event_device *dev){	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	struct hrtimer_clock_base *base;	ktime_t expires_next, now;	int i, raise = 0;	BUG_ON(!cpu_base->hres_active);	cpu_base->nr_events++;	dev->next_event.tv64 = KTIME_MAX; retry:	now = ktime_get();	expires_next.tv64 = KTIME_MAX;	base = cpu_base->clock_base;	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		ktime_t basenow;		struct rb_node *node;		spin_lock(&cpu_base->lock);		basenow = ktime_add(now, base->offset);		while ((node = base->first)) {			struct hrtimer *timer;			timer = rb_entry(node, struct hrtimer, node);			if (basenow.tv64 < timer->expires.tv64) {				ktime_t expires;				expires = ktime_sub(timer->expires,						    base->offset);				if (expires.tv64 < expires_next.tv64)					expires_next = expires;				break;			}			/* Move softirq callbacks to the pending list */			if (timer->cb_mode == HRTIMER_CB_SOFTIRQ) {				__remove_hrtimer(timer, base,						 HRTIMER_STATE_PENDING, 0);				list_add_tail(&timer->cb_entry,					      &base->cpu_base->cb_pending);				raise = 1;				continue;			}			__remove_hrtimer(timer, base,					 HRTIMER_STATE_CALLBACK, 0);			timer_stats_account_hrtimer(timer);			/*			 * Note: We clear the CALLBACK bit after			 * enqueue_hrtimer to avoid reprogramming of			 * the event hardware. This happens at the end			 * of this function anyway.			 */			if (timer->function(timer) != HRTIMER_NORESTART) {				BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);				enqueue_hrtimer(timer, base, 0);			}			timer->state &= ~HRTIMER_STATE_CALLBACK;		}		spin_unlock(&cpu_base->lock);		base++;	}	cpu_base->expires_next = expires_next;	/* Reprogramming necessary ? */	if (expires_next.tv64 != KTIME_MAX) {		if (tick_program_event(expires_next, 0))			goto retry;	}	/* Raise softirq ? */	if (raise)		raise_softirq(HRTIMER_SOFTIRQ);}

/* * High resolution timer interrupt * Called with interrupts disabled */void hrtimer_interrupt(struct clock_event_device *dev){	struct hrtimer_cpu_base *cpu_base = this_cpu_ptr(&hrtimer_bases);	ktime_t expires_next, now, entry_time, delta;	int retries = 0;	BUG_ON(!cpu_base->hres_active);	cpu_base->nr_events++;	dev->next_event.tv64 = KTIME_MAX;	raw_spin_lock(&cpu_base->lock);	entry_time = now = hrtimer_update_base(cpu_base);retry:	cpu_base->in_hrtirq = 1;	/*	 * We set expires_next to KTIME_MAX here with cpu_base->lock	 * held to prevent that a timer is enqueued in our queue via	 * the migration code. This does not affect enqueueing of	 * timers which run their callback and need to be requeued on	 * this CPU.	 */	cpu_base->expires_next.tv64 = KTIME_MAX;	__hrtimer_run_queues(cpu_base, now);	/* Reevaluate the clock bases for the next expiry */	expires_next = __hrtimer_get_next_event(cpu_base);	/*	 * Store the new expiry value so the migration code can verify	 * against it.	 */	cpu_base->expires_next = expires_next;	cpu_base->in_hrtirq = 0;	raw_spin_unlock(&cpu_base->lock);	/* Reprogramming necessary ? */	if (!tick_program_event(expires_next, 0)) {		cpu_base->hang_detected = 0;		return;	}	/*	 * The next timer was already expired due to:	 * - tracing	 * - long lasting callbacks	 * - being scheduled away when running in a VM	 *	 * We need to prevent that we loop forever in the hrtimer	 * interrupt routine. We give it 3 attempts to avoid	 * overreacting on some spurious event.	 *	 * Acquire base lock for updating the offsets and retrieving	 * the current time.	 */	raw_spin_lock(&cpu_base->lock);	now = hrtimer_update_base(cpu_base);	cpu_base->nr_retries++;	if (++retries < 3)		goto retry;	/*	 * Give the system a chance to do something else than looping	 * here. We stored the entry time, so we know exactly how long	 * we spent here. We schedule the next event this amount of	 * time away.	 */	cpu_base->nr_hangs++;	cpu_base->hang_detected = 1;	raw_spin_unlock(&cpu_base->lock);	delta = ktime_sub(now, entry_time);	if ((unsigned int)delta.tv64 > cpu_base->max_hang_time)		cpu_base->max_hang_time = (unsigned int) delta.tv64;	/*	 * Limit it to a sensible value as we enforce a longer	 * delay. Give the CPU at least 100ms to catch up.	 */	if (delta.tv64 > 100 * NSEC_PER_MSEC)		expires_next = ktime_add_ns(now, 100 * NSEC_PER_MSEC);	else		expires_next = ktime_add(now, delta);	tick_program_event(expires_next, 1);	printk_once(KERN_WARNING "hrtimer: interrupt took %llu ns/n",		    ktime_to_ns(delta));}

/* * High resolution timer interrupt * Called with interrupts disabled */void hrtimer_interrupt(struct clock_event_device *dev){	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	struct hrtimer_clock_base *base;	ktime_t expires_next, now;	int i, raise = 0;	BUG_ON(!cpu_base->hres_active);	cpu_base->nr_events++;	dev->next_event.tv64 = KTIME_MAX; retry:	now = ktime_get();	expires_next.tv64 = KTIME_MAX;	base = cpu_base->clock_base;	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		ktime_t basenow;		struct rb_node *node;		spin_lock(&cpu_base->lock);		basenow = ktime_add(now, base->offset);		while ((node = base->first)) {			struct hrtimer *timer;			timer = rb_entry(node, struct hrtimer, node);			/*			 * The immediate goal for using the softexpires is			 * minimizing wakeups, not running timers at the			 * earliest interrupt after their soft expiration.			 * This allows us to avoid using a Priority Search			 * Tree, which can answer a stabbing querry for			 * overlapping intervals and instead use the simple			 * BST we already have.			 * We don't add extra wakeups by delaying timers that			 * are right-of a not yet expired timer, because that			 * timer will have to trigger a wakeup anyway.			 */			if (basenow.tv64 < hrtimer_get_softexpires_tv64(timer)) {				ktime_t expires;				expires = ktime_sub(hrtimer_get_expires(timer),						    base->offset);				if (expires.tv64 < expires_next.tv64)					expires_next = expires;				break;			}			/* Move softirq callbacks to the pending list */			if (timer->cb_mode == HRTIMER_CB_SOFTIRQ) {				__remove_hrtimer(timer, base,						 HRTIMER_STATE_PENDING, 0);				list_add_tail(&timer->cb_entry,					      &base->cpu_base->cb_pending);				raise = 1;				continue;			}			__run_hrtimer(timer);		}		spin_unlock(&cpu_base->lock);		base++;	}	cpu_base->expires_next = expires_next;	/* Reprogramming necessary ? */	if (expires_next.tv64 != KTIME_MAX) {		if (tick_program_event(expires_next, 0))			goto retry;	}	/* Raise softirq ? */	if (raise)		raise_softirq(HRTIMER_SOFTIRQ);}

//.........这里部分代码省略.........		return;	if (need_resched())		return;	if (unlikely(local_softirq_pending() && cpu_online(cpu))) {		static int ratelimit;		if (ratelimit < 10) {			printk(KERN_ERR "NOHZ: local_softirq_pending %02x/n",			       (unsigned int) local_softirq_pending());			ratelimit++;		}		return;	}	ts->idle_calls++;		do {		seq = read_seqbegin(&xtime_lock);		last_update = last_jiffies_update;		last_jiffies = jiffies;		time_delta = timekeeping_max_deferment();	} while (read_seqretry(&xtime_lock, seq));	if (rcu_needs_cpu(cpu) || printk_needs_cpu(cpu) ||	    arch_needs_cpu(cpu)) {		next_jiffies = last_jiffies + 1;		delta_jiffies = 1;	} else {				next_jiffies = get_next_timer_interrupt(last_jiffies);		delta_jiffies = next_jiffies - last_jiffies;	}	if (!ts->tick_stopped && delta_jiffies == 1)		goto out;		if ((long)delta_jiffies >= 1) {		if (cpu == tick_do_timer_cpu) {			tick_do_timer_cpu = TICK_DO_TIMER_NONE;			ts->do_timer_last = 1;		} else if (tick_do_timer_cpu != TICK_DO_TIMER_NONE) {			time_delta = KTIME_MAX;			ts->do_timer_last = 0;		} else if (!ts->do_timer_last) {			time_delta = KTIME_MAX;		}		if (likely(delta_jiffies < NEXT_TIMER_MAX_DELTA)) {			time_delta = min_t(u64, time_delta,					   tick_period.tv64 * delta_jiffies);		}		if (time_delta < KTIME_MAX)			expires = ktime_add_ns(last_update, time_delta);		else			expires.tv64 = KTIME_MAX;				if (ts->tick_stopped && ktime_equal(expires, dev->next_event))			goto out;		if (!ts->tick_stopped) {			select_nohz_load_balancer(1);			calc_load_enter_idle();			ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);			ts->tick_stopped = 1;			ts->idle_jiffies = last_jiffies;		}		ts->idle_sleeps++;				ts->idle_expires = expires;		 if (unlikely(expires.tv64 == KTIME_MAX)) {			if (ts->nohz_mode == NOHZ_MODE_HIGHRES)				hrtimer_cancel(&ts->sched_timer);			goto out;		}		if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {			hrtimer_start(&ts->sched_timer, expires,				      HRTIMER_MODE_ABS_PINNED);						if (hrtimer_active(&ts->sched_timer))				goto out;		} else if (!tick_program_event(expires, 0))				goto out;		tick_do_update_jiffies64(ktime_get());	}	raise_softirq_irqoff(TIMER_SOFTIRQ);out:	ts->next_jiffies = next_jiffies;	ts->last_jiffies = last_jiffies;	ts->sleep_length = ktime_sub(dev->next_event, now);}

/** * nohz_restart_sched_tick - restart the idle tick from the idle task * * Restart the idle tick when the CPU is woken up from idle */void tick_nohz_restart_sched_tick(void){	int cpu = smp_processor_id();	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);	unsigned long ticks;	ktime_t now, delta;	if (!ts->tick_stopped)		return;	/* Update jiffies first */	now = ktime_get();	local_irq_disable();	tick_do_update_jiffies64(now);	cpu_clear(cpu, nohz_cpu_mask);	/* Account the idle time */	delta = ktime_sub(now, ts->idle_entrytime);	ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);	/*	 * We stopped the tick in idle. Update process times would miss the	 * time we slept as update_process_times does only a 1 tick	 * accounting. Enforce that this is accounted to idle !	 */	ticks = jiffies - ts->idle_jiffies;	/*	 * We might be one off. Do not randomly account a huge number of ticks!	 */	if (ticks && ticks < LONG_MAX) {		add_preempt_count(HARDIRQ_OFFSET);		account_system_time(current, HARDIRQ_OFFSET,				    jiffies_to_cputime(ticks));		sub_preempt_count(HARDIRQ_OFFSET);	}	/*	 * Cancel the scheduled timer and restore the tick	 */	ts->tick_stopped  = 0;	hrtimer_cancel(&ts->sched_timer);	ts->sched_timer.expires = ts->idle_tick;	while (1) {		/* Forward the time to expire in the future */		hrtimer_forward(&ts->sched_timer, now, tick_period);		if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {			hrtimer_start(&ts->sched_timer,				      ts->sched_timer.expires,				      HRTIMER_MODE_ABS);			/* Check, if the timer was already in the past */			if (hrtimer_active(&ts->sched_timer))				break;		} else {			if (!tick_program_event(ts->sched_timer.expires, 0))				break;		}		/* Update jiffies and reread time */		tick_do_update_jiffies64(now);		now = ktime_get();	}	local_irq_enable();}

//.........这里部分代码省略.........			printk(KERN_ERR "NOHZ: local_softirq_pending %02x/n",			       local_softirq_pending());			ratelimit++;		}	}	now = ktime_get();	/*	 * When called from irq_exit we need to account the idle sleep time	 * correctly.	 */	if (ts->tick_stopped) {		delta = ktime_sub(now, ts->idle_entrytime);		ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);	}	ts->idle_entrytime = now;	ts->idle_calls++;	/* Read jiffies and the time when jiffies were updated last */	do {		seq = read_seqbegin(&xtime_lock);		last_update = last_jiffies_update;		last_jiffies = jiffies;	} while (read_seqretry(&xtime_lock, seq));	/* Get the next timer wheel timer */	next_jiffies = get_next_timer_interrupt(last_jiffies);	delta_jiffies = next_jiffies - last_jiffies;	if (rcu_needs_cpu(cpu))		delta_jiffies = 1;	/*	 * Do not stop the tick, if we are only one off	 * or if the cpu is required for rcu	 */	if (!ts->tick_stopped && delta_jiffies == 1)		goto out;	/* Schedule the tick, if we are at least one jiffie off */	if ((long)delta_jiffies >= 1) {		if (delta_jiffies > 1)			cpu_set(cpu, nohz_cpu_mask);		/*		 * nohz_stop_sched_tick can be called several times before		 * the nohz_restart_sched_tick is called. This happens when		 * interrupts arrive which do not cause a reschedule. In the		 * first call we save the current tick time, so we can restart		 * the scheduler tick in nohz_restart_sched_tick.		 */		if (!ts->tick_stopped) {			ts->idle_tick = ts->sched_timer.expires;			ts->tick_stopped = 1;			ts->idle_jiffies = last_jiffies;		}		/*		 * If this cpu is the one which updates jiffies, then		 * give up the assignment and let it be taken by the		 * cpu which runs the tick timer next, which might be		 * this cpu as well. If we don't drop this here the		 * jiffies might be stale and do_timer() never		 * invoked.		 */		if (cpu == tick_do_timer_cpu)			tick_do_timer_cpu = -1;		/*		 * calculate the expiry time for the next timer wheel		 * timer		 */		expires = ktime_add_ns(last_update, tick_period.tv64 *				       delta_jiffies);		ts->idle_expires = expires;		ts->idle_sleeps++;		if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {			hrtimer_start(&ts->sched_timer, expires,				      HRTIMER_MODE_ABS);			/* Check, if the timer was already in the past */			if (hrtimer_active(&ts->sched_timer))				goto out;		} else if(!tick_program_event(expires, 0))				goto out;		/*		 * We are past the event already. So we crossed a		 * jiffie boundary. Update jiffies and raise the		 * softirq.		 */		tick_do_update_jiffies64(ktime_get());		cpu_clear(cpu, nohz_cpu_mask);	}	raise_softirq_irqoff(TIMER_SOFTIRQ);out:	ts->next_jiffies = next_jiffies;	ts->last_jiffies = last_jiffies;end:	local_irq_restore(flags);}

void hrtimer_interrupt(struct clock_event_device *dev){	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	ktime_t expires_next, now, entry_time, delta;	int i, retries = 0;	BUG_ON(!cpu_base->hres_active);	cpu_base->nr_events++;	dev->next_event.tv64 = KTIME_MAX;	raw_spin_lock(&cpu_base->lock);	entry_time = now = hrtimer_update_base(cpu_base);retry:	expires_next.tv64 = KTIME_MAX;	cpu_base->expires_next.tv64 = KTIME_MAX;	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		struct hrtimer_clock_base *base;		struct timerqueue_node *node;		ktime_t basenow;		if (!(cpu_base->active_bases & (1 << i)))			continue;		base = cpu_base->clock_base + i;		basenow = ktime_add(now, base->offset);		while ((node = timerqueue_getnext(&base->active))) {			struct hrtimer *timer;			timer = container_of(node, struct hrtimer, node);			if (basenow.tv64 < hrtimer_get_softexpires_tv64(timer)) {				ktime_t expires;				expires = ktime_sub(hrtimer_get_expires(timer),						    base->offset);				if (expires.tv64 < expires_next.tv64)					expires_next = expires;				break;			}			__run_hrtimer(timer, &basenow);		}	}	cpu_base->expires_next = expires_next;	raw_spin_unlock(&cpu_base->lock);		if (expires_next.tv64 == KTIME_MAX ||	    !tick_program_event(expires_next, 0)) {		cpu_base->hang_detected = 0;		return;	}	raw_spin_lock(&cpu_base->lock);	now = hrtimer_update_base(cpu_base);	cpu_base->nr_retries++;	if (++retries < 3)		goto retry;	cpu_base->nr_hangs++;	cpu_base->hang_detected = 1;	raw_spin_unlock(&cpu_base->lock);	delta = ktime_sub(now, entry_time);	if (delta.tv64 > cpu_base->max_hang_time.tv64)		cpu_base->max_hang_time = delta;	if (delta.tv64 > 100 * NSEC_PER_MSEC)		expires_next = ktime_add_ns(now, 100 * NSEC_PER_MSEC);	else		expires_next = ktime_add(now, delta);	tick_program_event(expires_next, 1);	printk_once(KERN_WARNING "hrtimer: interrupt took %llu ns/n",		    ktime_to_ns(delta));}