tick-sched.c 23.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 *  linux/kernel/time/tick-sched.c
 *
 *  Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
 *  Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
 *  Copyright(C) 2006-2007  Timesys Corp., Thomas Gleixner
 *
 *  No idle tick implementation for low and high resolution timers
 *
 *  Started by: Thomas Gleixner and Ingo Molnar
 *
P
Pavel Machek 已提交
12
 *  Distribute under GPLv2.
13 14 15 16 17 18 19 20 21
 */
#include <linux/cpu.h>
#include <linux/err.h>
#include <linux/hrtimer.h>
#include <linux/interrupt.h>
#include <linux/kernel_stat.h>
#include <linux/percpu.h>
#include <linux/profile.h>
#include <linux/sched.h>
22
#include <linux/module.h>
23

24 25
#include <asm/irq_regs.h>

26 27 28 29 30 31 32 33 34 35 36 37
#include "tick-internal.h"

/*
 * Per cpu nohz control structure
 */
static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);

/*
 * The time, when the last jiffy update happened. Protected by xtime_lock.
 */
static ktime_t last_jiffies_update;

38 39 40 41 42
struct tick_sched *tick_get_tick_sched(int cpu)
{
	return &per_cpu(tick_cpu_sched, cpu);
}

43 44 45 46 47 48 49 50
/*
 * Must be called with interrupts disabled !
 */
static void tick_do_update_jiffies64(ktime_t now)
{
	unsigned long ticks = 0;
	ktime_t delta;

51 52 53 54 55 56 57
	/*
	 * Do a quick check without holding xtime_lock:
	 */
	delta = ktime_sub(now, last_jiffies_update);
	if (delta.tv64 < tick_period.tv64)
		return;

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
	/* Reevalute with xtime_lock held */
	write_seqlock(&xtime_lock);

	delta = ktime_sub(now, last_jiffies_update);
	if (delta.tv64 >= tick_period.tv64) {

		delta = ktime_sub(delta, tick_period);
		last_jiffies_update = ktime_add(last_jiffies_update,
						tick_period);

		/* Slow path for long timeouts */
		if (unlikely(delta.tv64 >= tick_period.tv64)) {
			s64 incr = ktime_to_ns(tick_period);

			ticks = ktime_divns(delta, incr);

			last_jiffies_update = ktime_add_ns(last_jiffies_update,
							   incr * ticks);
		}
		do_timer(++ticks);
78 79 80

		/* Keep the tick_next_period variable up to date */
		tick_next_period = ktime_add(last_jiffies_update, tick_period);
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
	}
	write_sequnlock(&xtime_lock);
}

/*
 * Initialize and return retrieve the jiffies update.
 */
static ktime_t tick_init_jiffy_update(void)
{
	ktime_t period;

	write_seqlock(&xtime_lock);
	/* Did we start the jiffies update yet ? */
	if (last_jiffies_update.tv64 == 0)
		last_jiffies_update = tick_next_period;
	period = last_jiffies_update;
	write_sequnlock(&xtime_lock);
	return period;
}

/*
 * NOHZ - aka dynamic tick functionality
 */
#ifdef CONFIG_NO_HZ
/*
 * NO HZ enabled ?
 */
static int tick_nohz_enabled __read_mostly  = 1;

/*
 * Enable / Disable tickless mode
 */
static int __init setup_tick_nohz(char *str)
{
	if (!strcmp(str, "off"))
		tick_nohz_enabled = 0;
	else if (!strcmp(str, "on"))
		tick_nohz_enabled = 1;
	else
		return 0;
	return 1;
}

__setup("nohz=", setup_tick_nohz);

/**
 * tick_nohz_update_jiffies - update jiffies when idle was interrupted
 *
 * Called from interrupt entry when the CPU was idle
 *
 * In case the sched_tick was stopped on this CPU, we have to check if jiffies
 * must be updated. Otherwise an interrupt handler could use a stale jiffy
 * value. We do this unconditionally on any cpu, as we don't know whether the
 * cpu, which has the update task assigned is in a long sleep.
 */
136
static void tick_nohz_update_jiffies(ktime_t now)
137 138 139 140 141
{
	int cpu = smp_processor_id();
	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
	unsigned long flags;

142
	ts->idle_waketime = now;
143 144 145 146

	local_irq_save(flags);
	tick_do_update_jiffies64(now);
	local_irq_restore(flags);
147 148

	touch_softlockup_watchdog();
149 150
}

151 152 153
/*
 * Updates the per cpu time idle statistics counters
 */
154
static void
155
update_ts_time_stats(int cpu, struct tick_sched *ts, ktime_t now, u64 *last_update_time)
156
{
157
	ktime_t delta;
158

159 160
	if (ts->idle_active) {
		delta = ktime_sub(now, ts->idle_entrytime);
161
		if (nr_iowait_cpu(cpu) > 0)
162
			ts->iowait_sleeptime = ktime_add(ts->iowait_sleeptime, delta);
163 164
		else
			ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
165
		ts->idle_entrytime = now;
166
	}
167

168
	if (last_update_time)
169 170
		*last_update_time = ktime_to_us(now);

171 172 173 174 175 176
}

static void tick_nohz_stop_idle(int cpu, ktime_t now)
{
	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);

177
	update_ts_time_stats(cpu, ts, now, NULL);
178
	ts->idle_active = 0;
179

180
	sched_clock_idle_wakeup_event(0);
181 182
}

183
static ktime_t tick_nohz_start_idle(int cpu, struct tick_sched *ts)
184
{
185
	ktime_t now = ktime_get();
186

187 188
	ts->idle_entrytime = now;
	ts->idle_active = 1;
189
	sched_clock_idle_sleep_event();
190 191 192
	return now;
}

193 194 195
/**
 * get_cpu_idle_time_us - get the total idle time of a cpu
 * @cpu: CPU number to query
196 197
 * @last_update_time: variable to store update time in. Do not update
 * counters if NULL.
198 199
 *
 * Return the cummulative idle time (since boot) for a given
200
 * CPU, in microseconds.
201 202 203 204 205 206
 *
 * This time is measured via accounting rather than sampling,
 * and is as accurate as ktime_get() is.
 *
 * This function returns -1 if NOHZ is not enabled.
 */
207 208 209
u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
{
	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
210
	ktime_t now, idle;
211

212 213 214
	if (!tick_nohz_enabled)
		return -1;

215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
	now = ktime_get();
	if (last_update_time) {
		update_ts_time_stats(cpu, ts, now, last_update_time);
		idle = ts->idle_sleeptime;
	} else {
		if (ts->idle_active && !nr_iowait_cpu(cpu)) {
			ktime_t delta = ktime_sub(now, ts->idle_entrytime);

			idle = ktime_add(ts->idle_sleeptime, delta);
		} else {
			idle = ts->idle_sleeptime;
		}
	}

	return ktime_to_us(idle);
230

231
}
232
EXPORT_SYMBOL_GPL(get_cpu_idle_time_us);
233

234
/**
235 236
 * get_cpu_iowait_time_us - get the total iowait time of a cpu
 * @cpu: CPU number to query
237 238
 * @last_update_time: variable to store update time in. Do not update
 * counters if NULL.
239 240 241 242 243 244 245 246 247 248 249 250
 *
 * Return the cummulative iowait time (since boot) for a given
 * CPU, in microseconds.
 *
 * This time is measured via accounting rather than sampling,
 * and is as accurate as ktime_get() is.
 *
 * This function returns -1 if NOHZ is not enabled.
 */
u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time)
{
	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
251
	ktime_t now, iowait;
252 253 254 255

	if (!tick_nohz_enabled)
		return -1;

256 257 258 259 260 261 262
	now = ktime_get();
	if (last_update_time) {
		update_ts_time_stats(cpu, ts, now, last_update_time);
		iowait = ts->iowait_sleeptime;
	} else {
		if (ts->idle_active && nr_iowait_cpu(cpu) > 0) {
			ktime_t delta = ktime_sub(now, ts->idle_entrytime);
263

264 265 266 267 268
			iowait = ktime_add(ts->iowait_sleeptime, delta);
		} else {
			iowait = ts->iowait_sleeptime;
		}
	}
269

270
	return ktime_to_us(iowait);
271 272 273
}
EXPORT_SYMBOL_GPL(get_cpu_iowait_time_us);

274
static void tick_nohz_stop_sched_tick(struct tick_sched *ts, ktime_t now)
275
{
276
	unsigned long seq, last_jiffies, next_jiffies, delta_jiffies;
277
	ktime_t last_update, expires;
278
	struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
279
	u64 time_delta;
280 281 282 283
	int cpu;

	cpu = smp_processor_id();
	ts = &per_cpu(tick_cpu_sched, cpu);
284

285 286 287 288 289 290 291 292 293
	/*
	 * If this cpu is offline and it 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. If we don't drop
	 * this here the jiffies might be stale and do_timer() never
	 * invoked.
	 */
	if (unlikely(!cpu_online(cpu))) {
		if (cpu == tick_do_timer_cpu)
294
			tick_do_timer_cpu = TICK_DO_TIMER_NONE;
295 296
	}

297
	if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))
298
		return;
299 300

	if (need_resched())
301
		return;
302

303
	if (unlikely(local_softirq_pending() && cpu_online(cpu))) {
304 305 306 307
		static int ratelimit;

		if (ratelimit < 10) {
			printk(KERN_ERR "NOHZ: local_softirq_pending %02x\n",
T
Thomas Gleixner 已提交
308
			       (unsigned int) local_softirq_pending());
309 310
			ratelimit++;
		}
311
		return;
312
	}
313 314 315 316 317 318 319

	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;
T
Thomas Gleixner 已提交
320
		time_delta = timekeeping_max_deferment();
321 322
	} while (read_seqretry(&xtime_lock, seq));

323
	if (rcu_needs_cpu(cpu) || printk_needs_cpu(cpu) ||
324
	    arch_needs_cpu(cpu)) {
325
		next_jiffies = last_jiffies + 1;
I
Ingo Molnar 已提交
326
		delta_jiffies = 1;
327 328 329 330 331
	} else {
		/* Get the next timer wheel timer */
		next_jiffies = get_next_timer_interrupt(last_jiffies);
		delta_jiffies = next_jiffies - last_jiffies;
	}
332 333 334 335
	/*
	 * Do not stop the tick, if we are only one off
	 * or if the cpu is required for rcu
	 */
I
Ingo Molnar 已提交
336
	if (!ts->tick_stopped && delta_jiffies == 1)
337 338 339 340 341
		goto out;

	/* Schedule the tick, if we are at least one jiffie off */
	if ((long)delta_jiffies >= 1) {

342 343 344 345 346 347
		/*
		 * 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
T
Thomas Gleixner 已提交
348 349 350 351 352 353
		 * 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.
354
		 */
T
Thomas Gleixner 已提交
355
		if (cpu == tick_do_timer_cpu) {
356
			tick_do_timer_cpu = TICK_DO_TIMER_NONE;
T
Thomas Gleixner 已提交
357 358 359 360 361 362 363 364
			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;
		}

365
		/*
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
		 * 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);
		}
383

T
Thomas Gleixner 已提交
384 385 386 387
		if (time_delta < KTIME_MAX)
			expires = ktime_add_ns(last_update, time_delta);
		else
			expires.tv64 = KTIME_MAX;
388 389 390 391 392

		/* Skip reprogram of event if its not changed */
		if (ts->tick_stopped && ktime_equal(expires, dev->next_event))
			goto out;

393 394 395 396 397 398 399 400
		/*
		 * 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) {
401
			select_nohz_load_balancer(1);
402

403
			ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);
404 405
			ts->tick_stopped = 1;
		}
406

407 408
		ts->idle_sleeps++;

409 410 411
		/* Mark expires */
		ts->idle_expires = expires;

412
		/*
413 414
		 * If the expiration time == KTIME_MAX, then
		 * in this case we simply stop the tick timer.
415
		 */
416
		 if (unlikely(expires.tv64 == KTIME_MAX)) {
417 418 419 420 421
			if (ts->nohz_mode == NOHZ_MODE_HIGHRES)
				hrtimer_cancel(&ts->sched_timer);
			goto out;
		}

422 423
		if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
			hrtimer_start(&ts->sched_timer, expires,
424
				      HRTIMER_MODE_ABS_PINNED);
425 426 427
			/* Check, if the timer was already in the past */
			if (hrtimer_active(&ts->sched_timer))
				goto out;
P
Pavel Machek 已提交
428
		} else if (!tick_program_event(expires, 0))
429 430 431 432 433 434 435 436 437 438 439 440
				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;
441
	ts->sleep_length = ktime_sub(dev->next_event, now);
442 443
}

444 445 446
static void __tick_nohz_idle_enter(struct tick_sched *ts)
{
	ktime_t now;
447
	int was_stopped = ts->tick_stopped;
448 449 450

	now = tick_nohz_start_idle(smp_processor_id(), ts);
	tick_nohz_stop_sched_tick(ts, now);
451 452 453

	if (!was_stopped && ts->tick_stopped)
		ts->idle_jiffies = ts->last_jiffies;
454 455
}

456 457 458 459 460
/**
 * tick_nohz_idle_enter - stop the idle tick from the idle task
 *
 * When the next event is more than a tick into the future, stop the idle tick
 * Called when we start the idle loop.
461
 *
462
 * The arch is responsible of calling:
463 464 465 466
 *
 * - rcu_idle_enter() after its last use of RCU before the CPU is put
 *  to sleep.
 * - rcu_idle_exit() before the first use of RCU after the CPU is woken up.
467
 */
468
void tick_nohz_idle_enter(void)
469 470 471
{
	struct tick_sched *ts;

472 473
	WARN_ON_ONCE(irqs_disabled());

474 475 476 477 478 479 480 481
	/*
 	 * Update the idle state in the scheduler domain hierarchy
 	 * when tick_nohz_stop_sched_tick() is called from the idle loop.
 	 * State will be updated to busy during the first busy tick after
 	 * exiting idle.
 	 */
	set_cpu_sd_state_idle();

482 483
	local_irq_disable();

484 485 486 487 488 489 490
	ts = &__get_cpu_var(tick_cpu_sched);
	/*
	 * set ts->inidle unconditionally. even if the system did not
	 * switch to nohz mode the cpu frequency governers rely on the
	 * update of the idle time accounting in tick_nohz_start_idle().
	 */
	ts->inidle = 1;
491
	__tick_nohz_idle_enter(ts);
492 493

	local_irq_enable();
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
}

/**
 * tick_nohz_irq_exit - update next tick event from interrupt exit
 *
 * When an interrupt fires while we are idle and it doesn't cause
 * a reschedule, it may still add, modify or delete a timer, enqueue
 * an RCU callback, etc...
 * So we need to re-calculate and reprogram the next tick event.
 */
void tick_nohz_irq_exit(void)
{
	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);

	if (!ts->inidle)
		return;

511
	__tick_nohz_idle_enter(ts);
512 513
}

514 515 516 517 518 519 520 521 522 523 524 525
/**
 * tick_nohz_get_sleep_length - return the length of the current sleep
 *
 * Called from power state control code with interrupts disabled
 */
ktime_t tick_nohz_get_sleep_length(void)
{
	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);

	return ts->sleep_length;
}

526 527 528
static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
{
	hrtimer_cancel(&ts->sched_timer);
529
	hrtimer_set_expires(&ts->sched_timer, ts->idle_tick);
530 531 532 533 534 535

	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) {
536
			hrtimer_start_expires(&ts->sched_timer,
537
					      HRTIMER_MODE_ABS_PINNED);
538 539 540 541
			/* Check, if the timer was already in the past */
			if (hrtimer_active(&ts->sched_timer))
				break;
		} else {
542 543
			if (!tick_program_event(
				hrtimer_get_expires(&ts->sched_timer), 0))
544 545
				break;
		}
546
		/* Reread time and update jiffies */
547
		now = ktime_get();
548
		tick_do_update_jiffies64(now);
549 550 551
	}
}

552
static void tick_nohz_restart_sched_tick(struct tick_sched *ts, ktime_t now)
553 554
{
	/* Update jiffies first */
555
	select_nohz_load_balancer(0);
556
	tick_do_update_jiffies64(now);
557
	update_cpu_load_nohz();
558

559 560 561 562 563 564 565 566 567 568 569 570
	touch_softlockup_watchdog();
	/*
	 * Cancel the scheduled timer and restore the tick
	 */
	ts->tick_stopped  = 0;
	ts->idle_exittime = now;

	tick_nohz_restart(ts, now);
}

static void tick_nohz_account_idle_ticks(struct tick_sched *ts)
{
571
#ifndef CONFIG_VIRT_CPU_ACCOUNTING
572
	unsigned long ticks;
573 574 575 576 577 578 579 580 581
	/*
	 * 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!
	 */
582 583 584
	if (ticks && ticks < LONG_MAX)
		account_idle_ticks(ticks);
#endif
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
}

/**
 * tick_nohz_idle_exit - restart the idle tick from the idle task
 *
 * Restart the idle tick when the CPU is woken up from idle
 * This also exit the RCU extended quiescent state. The CPU
 * can use RCU again after this function is called.
 */
void tick_nohz_idle_exit(void)
{
	int cpu = smp_processor_id();
	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
	ktime_t now;

	local_irq_disable();

	WARN_ON_ONCE(!ts->inidle);

	ts->inidle = 0;

	if (ts->idle_active || ts->tick_stopped)
		now = ktime_get();

	if (ts->idle_active)
		tick_nohz_stop_idle(cpu, now);

612
	if (ts->tick_stopped) {
613
		tick_nohz_restart_sched_tick(ts, now);
614 615
		tick_nohz_account_idle_ticks(ts);
	}
616 617 618 619 620 621 622

	local_irq_enable();
}

static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)
{
	hrtimer_forward(&ts->sched_timer, now, tick_period);
623
	return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);
624 625 626 627 628 629 630 631 632
}

/*
 * The nohz low res interrupt handler
 */
static void tick_nohz_handler(struct clock_event_device *dev)
{
	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
	struct pt_regs *regs = get_irq_regs();
633
	int cpu = smp_processor_id();
634 635 636 637
	ktime_t now = ktime_get();

	dev->next_event.tv64 = KTIME_MAX;

638 639 640 641 642 643 644
	/*
	 * Check if the do_timer duty was dropped. We don't care about
	 * concurrency: This happens only when the cpu in charge went
	 * into a long sleep. If two cpus happen to assign themself to
	 * this duty, then the jiffies update is still serialized by
	 * xtime_lock.
	 */
645
	if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
646 647
		tick_do_timer_cpu = cpu;

648
	/* Check, if the jiffies need an update */
649 650
	if (tick_do_timer_cpu == cpu)
		tick_do_update_jiffies64(now);
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701

	/*
	 * When we are idle and the tick is stopped, we have to touch
	 * the watchdog as we might not schedule for a really long
	 * time. This happens on complete idle SMP systems while
	 * waiting on the login prompt. We also increment the "start
	 * of idle" jiffy stamp so the idle accounting adjustment we
	 * do when we go busy again does not account too much ticks.
	 */
	if (ts->tick_stopped) {
		touch_softlockup_watchdog();
		ts->idle_jiffies++;
	}

	update_process_times(user_mode(regs));
	profile_tick(CPU_PROFILING);

	while (tick_nohz_reprogram(ts, now)) {
		now = ktime_get();
		tick_do_update_jiffies64(now);
	}
}

/**
 * tick_nohz_switch_to_nohz - switch to nohz mode
 */
static void tick_nohz_switch_to_nohz(void)
{
	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
	ktime_t next;

	if (!tick_nohz_enabled)
		return;

	local_irq_disable();
	if (tick_switch_to_oneshot(tick_nohz_handler)) {
		local_irq_enable();
		return;
	}

	ts->nohz_mode = NOHZ_MODE_LOWRES;

	/*
	 * Recycle the hrtimer in ts, so we can share the
	 * hrtimer_forward with the highres code.
	 */
	hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
	/* Get the next period */
	next = tick_init_jiffy_update();

	for (;;) {
702
		hrtimer_set_expires(&ts->sched_timer, next);
703 704 705 706 707 708 709
		if (!tick_program_event(next, 0))
			break;
		next = ktime_add(next, tick_period);
	}
	local_irq_enable();
}

710 711 712 713 714 715 716 717 718 719 720
/*
 * When NOHZ is enabled and the tick is stopped, we need to kick the
 * tick timer from irq_enter() so that the jiffies update is kept
 * alive during long running softirqs. That's ugly as hell, but
 * correctness is key even if we need to fix the offending softirq in
 * the first place.
 *
 * Note, this is different to tick_nohz_restart. We just kick the
 * timer and do not touch the other magic bits which need to be done
 * when idle is left.
 */
721
static void tick_nohz_kick_tick(int cpu, ktime_t now)
722
{
723 724 725
#if 0
	/* Switch back to 2.6.27 behaviour */

726
	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
727
	ktime_t delta;
728

729 730 731 732
	/*
	 * Do not touch the tick device, when the next expiry is either
	 * already reached or less/equal than the tick period.
	 */
733
	delta =	ktime_sub(hrtimer_get_expires(&ts->sched_timer), now);
734 735 736 737
	if (delta.tv64 <= tick_period.tv64)
		return;

	tick_nohz_restart(ts, now);
738
#endif
739 740
}

741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
static inline void tick_check_nohz(int cpu)
{
	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
	ktime_t now;

	if (!ts->idle_active && !ts->tick_stopped)
		return;
	now = ktime_get();
	if (ts->idle_active)
		tick_nohz_stop_idle(cpu, now);
	if (ts->tick_stopped) {
		tick_nohz_update_jiffies(now);
		tick_nohz_kick_tick(cpu, now);
	}
}

757 758 759
#else

static inline void tick_nohz_switch_to_nohz(void) { }
760
static inline void tick_check_nohz(int cpu) { }
761 762 763

#endif /* NO_HZ */

764 765 766 767 768
/*
 * Called from irq_enter to notify about the possible interruption of idle()
 */
void tick_check_idle(int cpu)
{
769
	tick_check_oneshot_broadcast(cpu);
770
	tick_check_nohz(cpu);
771 772
}

773 774 775 776 777
/*
 * High resolution timer specific code
 */
#ifdef CONFIG_HIGH_RES_TIMERS
/*
P
Pavel Machek 已提交
778
 * We rearm the timer until we get disabled by the idle code.
779 780 781 782 783 784 785 786
 * Called with interrupts disabled and timer->base->cpu_base->lock held.
 */
static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
{
	struct tick_sched *ts =
		container_of(timer, struct tick_sched, sched_timer);
	struct pt_regs *regs = get_irq_regs();
	ktime_t now = ktime_get();
787 788 789 790 791 792 793 794 795 796
	int cpu = smp_processor_id();

#ifdef CONFIG_NO_HZ
	/*
	 * Check if the do_timer duty was dropped. We don't care about
	 * concurrency: This happens only when the cpu in charge went
	 * into a long sleep. If two cpus happen to assign themself to
	 * this duty, then the jiffies update is still serialized by
	 * xtime_lock.
	 */
797
	if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
798 799
		tick_do_timer_cpu = cpu;
#endif
800 801

	/* Check, if the jiffies need an update */
802 803
	if (tick_do_timer_cpu == cpu)
		tick_do_update_jiffies64(now);
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819

	/*
	 * Do not call, when we are not in irq context and have
	 * no valid regs pointer
	 */
	if (regs) {
		/*
		 * When we are idle and the tick is stopped, we have to touch
		 * the watchdog as we might not schedule for a really long
		 * time. This happens on complete idle SMP systems while
		 * waiting on the login prompt. We also increment the "start of
		 * idle" jiffy stamp so the idle accounting adjustment we do
		 * when we go busy again does not account too much ticks.
		 */
		if (ts->tick_stopped) {
			touch_softlockup_watchdog();
820 821
			if (idle_cpu(cpu))
				ts->idle_jiffies++;
822 823 824 825 826 827 828 829 830 831
		}
		update_process_times(user_mode(regs));
		profile_tick(CPU_PROFILING);
	}

	hrtimer_forward(timer, now, tick_period);

	return HRTIMER_RESTART;
}

M
Mike Galbraith 已提交
832 833
static int sched_skew_tick;

834 835 836 837 838 839 840 841
static int __init skew_tick(char *str)
{
	get_option(&str, &sched_skew_tick);

	return 0;
}
early_param("skew_tick", skew_tick);

842 843 844 845 846 847 848 849 850 851 852 853 854 855
/**
 * tick_setup_sched_timer - setup the tick emulation timer
 */
void tick_setup_sched_timer(void)
{
	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
	ktime_t now = ktime_get();

	/*
	 * Emulate tick processing via per-CPU hrtimers:
	 */
	hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
	ts->sched_timer.function = tick_sched_timer;

856
	/* Get the next period (per cpu) */
857
	hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
858

M
Mike Galbraith 已提交
859 860 861 862 863 864 865 866
	/* Offset the tick to avert xtime_lock contention. */
	if (sched_skew_tick) {
		u64 offset = ktime_to_ns(tick_period) >> 1;
		do_div(offset, num_possible_cpus());
		offset *= smp_processor_id();
		hrtimer_add_expires_ns(&ts->sched_timer, offset);
	}

867 868
	for (;;) {
		hrtimer_forward(&ts->sched_timer, now, tick_period);
869 870
		hrtimer_start_expires(&ts->sched_timer,
				      HRTIMER_MODE_ABS_PINNED);
871 872 873 874 875 876 877
		/* Check, if the timer was already in the past */
		if (hrtimer_active(&ts->sched_timer))
			break;
		now = ktime_get();
	}

#ifdef CONFIG_NO_HZ
878
	if (tick_nohz_enabled)
879 880 881
		ts->nohz_mode = NOHZ_MODE_HIGHRES;
#endif
}
882
#endif /* HIGH_RES_TIMERS */
883

884
#if defined CONFIG_NO_HZ || defined CONFIG_HIGH_RES_TIMERS
885 886 887 888
void tick_cancel_sched_timer(int cpu)
{
	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);

889
# ifdef CONFIG_HIGH_RES_TIMERS
890 891
	if (ts->sched_timer.base)
		hrtimer_cancel(&ts->sched_timer);
892
# endif
893

894 895
	ts->nohz_mode = NOHZ_MODE_INACTIVE;
}
896
#endif
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936

/**
 * Async notification about clocksource changes
 */
void tick_clock_notify(void)
{
	int cpu;

	for_each_possible_cpu(cpu)
		set_bit(0, &per_cpu(tick_cpu_sched, cpu).check_clocks);
}

/*
 * Async notification about clock event changes
 */
void tick_oneshot_notify(void)
{
	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);

	set_bit(0, &ts->check_clocks);
}

/**
 * Check, if a change happened, which makes oneshot possible.
 *
 * Called cyclic from the hrtimer softirq (driven by the timer
 * softirq) allow_nohz signals, that we can switch into low-res nohz
 * mode, because high resolution timers are disabled (either compile
 * or runtime).
 */
int tick_check_oneshot_change(int allow_nohz)
{
	struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);

	if (!test_and_clear_bit(0, &ts->check_clocks))
		return 0;

	if (ts->nohz_mode != NOHZ_MODE_INACTIVE)
		return 0;

937
	if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())
938 939 940 941 942 943 944 945
		return 0;

	if (!allow_nohz)
		return 1;

	tick_nohz_switch_to_nohz();
	return 0;
}