Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit a382bf934449ddeb625167537ae81daa0211b477

Authored by Frederic Weisbecker 2012-12-19 01:24:35 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

nohz: Assign timekeeping duty to a CPU outside the full dynticks range

This way the full nohz CPUs can safely run with the tick
stopped with a guarantee that somebody else is taking
care of the jiffies and GTOD progression.

Once the duty is attributed to a CPU, it won't change. Also that
CPU can't enter into dyntick idle mode or be hot unplugged.

This may later be improved from a power consumption POV. At
least we should be able to share the duty amongst all CPUs
outside the full dynticks range. Then the duty could even be
shared with full dynticks CPUs when those can't stop their
tick for any reason.

But let's start with that very simple approach first.

Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Chris Metcalf <cmetcalf@tilera.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: Geoff Levand <geoff@infradead.org>
Cc: Gilad Ben Yossef <gilad@benyossef.com>
Cc: Hakan Akkan <hakanakkan@gmail.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Kevin Hilman <khilman@linaro.org>
Cc: Li Zhong <zhong@linux.vnet.ibm.com>
Cc: Namhyung Kim <namhyung.kim@lge.com>
Cc: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
[fix have_nohz_full_mask offcase]
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

Showing 3 changed files with 51 additions and 4 deletions Inline Diff

kernel/time/tick-broadcast.c
kernel/time/tick-common.c
kernel/time/tick-sched.c

kernel/time/tick-broadcast.c

Diff comments View file @ a382bf9

 /*
  * linux/kernel/time/tick-broadcast.c
  *
  * This file contains functions which emulate a local clock-event
  * device via a broadcast event source.
  *
  * 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
  *
  * This code is licenced under the GPL version 2. For details see
  * kernel-base/COPYING.
  */
 #include <linux/cpu.h>
 #include <linux/err.h>
 #include <linux/hrtimer.h>
 #include <linux/interrupt.h>
 #include <linux/percpu.h>
 #include <linux/profile.h>
 #include <linux/sched.h>
 #include <linux/smp.h>
 #include "tick-internal.h"
 /*
  * Broadcast support for broken x86 hardware, where the local apic
  * timer stops in C3 state.
  */
 static struct tick_device tick_broadcast_device;
 /* FIXME: Use cpumask_var_t. */
 static DECLARE_BITMAP(tick_broadcast_mask, NR_CPUS);
 static DECLARE_BITMAP(tmpmask, NR_CPUS);
 static DEFINE_RAW_SPINLOCK(tick_broadcast_lock);
 static int tick_broadcast_force;
 #ifdef CONFIG_TICK_ONESHOT
 static void tick_broadcast_clear_oneshot(int cpu);
 #else
 static inline void tick_broadcast_clear_oneshot(int cpu) { }
 #endif
 /*
  * Debugging: see timer_list.c
  */
 struct tick_device *tick_get_broadcast_device(void)
 {
 	return &tick_broadcast_device;
 }
 struct cpumask *tick_get_broadcast_mask(void)
 {
 	return to_cpumask(tick_broadcast_mask);
 }
 /*
  * Start the device in periodic mode
  */
 static void tick_broadcast_start_periodic(struct clock_event_device *bc)
 {
 	if (bc)
 		tick_setup_periodic(bc, 1);
 }
 /*
  * Check, if the device can be utilized as broadcast device:
  */
 int tick_check_broadcast_device(struct clock_event_device *dev)
 {
 	if ((tick_broadcast_device.evtdev &&
 	     tick_broadcast_device.evtdev->rating >= dev->rating) ||
 	     (dev->features & CLOCK_EVT_FEAT_C3STOP))
 		return 0;
 	clockevents_exchange_device(tick_broadcast_device.evtdev, dev);
 	tick_broadcast_device.evtdev = dev;
 	if (!cpumask_empty(tick_get_broadcast_mask()))
 		tick_broadcast_start_periodic(dev);
 	return 1;
 }
 /*
  * Check, if the device is the broadcast device
  */
 int tick_is_broadcast_device(struct clock_event_device *dev)
 {
 	return (dev && tick_broadcast_device.evtdev == dev);
 }
 static void err_broadcast(const struct cpumask *mask)
 {
 	pr_crit_once("Failed to broadcast timer tick. Some CPUs may be unresponsive.\n");
 }
 static void tick_device_setup_broadcast_func(struct clock_event_device *dev)
 {
 	if (!dev->broadcast)
 		dev->broadcast = tick_broadcast;
 	if (!dev->broadcast) {
 		pr_warn_once("%s depends on broadcast, but no broadcast function available\n",
 			     dev->name);
 		dev->broadcast = err_broadcast;
 	}
 }
 /*
  * Check, if the device is disfunctional and a place holder, which
  * needs to be handled by the broadcast device.
  */
 int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
 {
 	unsigned long flags;
 	int ret = 0;
 	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
 	/*
 	 * Devices might be registered with both periodic and oneshot
 	 * mode disabled. This signals, that the device needs to be
 	 * operated from the broadcast device and is a placeholder for
 	 * the cpu local device.
 	 */
 	if (!tick_device_is_functional(dev)) {
 		dev->event_handler = tick_handle_periodic;
 		tick_device_setup_broadcast_func(dev);
 		cpumask_set_cpu(cpu, tick_get_broadcast_mask());
 		tick_broadcast_start_periodic(tick_broadcast_device.evtdev);
 		ret = 1;
 	} else {
 		/*
 		 * When the new device is not affected by the stop
 		 * feature and the cpu is marked in the broadcast mask
 		 * then clear the broadcast bit.
 		 */
 		if (!(dev->features & CLOCK_EVT_FEAT_C3STOP)) {
 			int cpu = smp_processor_id();
 			cpumask_clear_cpu(cpu, tick_get_broadcast_mask());
 			tick_broadcast_clear_oneshot(cpu);
 		} else {
 			tick_device_setup_broadcast_func(dev);
 		}
 	}
 	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 	return ret;
 }
 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
 int tick_receive_broadcast(void)
 {
 	struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
 	struct clock_event_device *evt = td->evtdev;
 	if (!evt)
 		return -ENODEV;
 	if (!evt->event_handler)
 		return -EINVAL;
 	evt->event_handler(evt);
 	return 0;
 }
 #endif
 /*
  * Broadcast the event to the cpus, which are set in the mask (mangled).
  */
 static void tick_do_broadcast(struct cpumask *mask)
 {
 	int cpu = smp_processor_id();
 	struct tick_device *td;
 	/*
 	 * Check, if the current cpu is in the mask
 	 */
 	if (cpumask_test_cpu(cpu, mask)) {
 		cpumask_clear_cpu(cpu, mask);
 		td = &per_cpu(tick_cpu_device, cpu);
 		td->evtdev->event_handler(td->evtdev);
 	}
 	if (!cpumask_empty(mask)) {
 		/*
 		 * It might be necessary to actually check whether the devices
 		 * have different broadcast functions. For now, just use the
 		 * one of the first device. This works as long as we have this
 		 * misfeature only on x86 (lapic)
 		 */
 		td = &per_cpu(tick_cpu_device, cpumask_first(mask));
 		td->evtdev->broadcast(mask);
 	}
 }
 /*
  * Periodic broadcast:
  * - invoke the broadcast handlers
  */
 static void tick_do_periodic_broadcast(void)
 {
 	raw_spin_lock(&tick_broadcast_lock);
 	cpumask_and(to_cpumask(tmpmask),
 		    cpu_online_mask, tick_get_broadcast_mask());
 	tick_do_broadcast(to_cpumask(tmpmask));
 	raw_spin_unlock(&tick_broadcast_lock);
 }
 /*
  * Event handler for periodic broadcast ticks
  */
 static void tick_handle_periodic_broadcast(struct clock_event_device *dev)
 {
 	ktime_t next;
 	tick_do_periodic_broadcast();
 	/*
 	 * The device is in periodic mode. No reprogramming necessary:
 	 */
 	if (dev->mode == CLOCK_EVT_MODE_PERIODIC)
 		return;
 	/*
 	 * Setup the next period for devices, which do not have
 	 * periodic mode. We read dev->next_event first and add to it
 	 * when the event already expired. clockevents_program_event()
 	 * sets dev->next_event only when the event is really
 	 * programmed to the device.
 	 */
 	for (next = dev->next_event; ;) {
 		next = ktime_add(next, tick_period);
 		if (!clockevents_program_event(dev, next, false))
 			return;
 		tick_do_periodic_broadcast();
 	}
 }
 /*
  * Powerstate information: The system enters/leaves a state, where
  * affected devices might stop
  */
 static void tick_do_broadcast_on_off(unsigned long *reason)
 {
 	struct clock_event_device *bc, *dev;
 	struct tick_device *td;
 	unsigned long flags;
 	int cpu, bc_stopped;
 	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
 	cpu = smp_processor_id();
 	td = &per_cpu(tick_cpu_device, cpu);
 	dev = td->evtdev;
 	bc = tick_broadcast_device.evtdev;
 	/*
 	 * Is the device not affected by the powerstate ?
 	 */
 	if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))
 		goto out;
 	if (!tick_device_is_functional(dev))
 		goto out;
 	bc_stopped = cpumask_empty(tick_get_broadcast_mask());
 	switch (*reason) {
 	case CLOCK_EVT_NOTIFY_BROADCAST_ON:
 	case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
 		if (!cpumask_test_cpu(cpu, tick_get_broadcast_mask())) {
 			cpumask_set_cpu(cpu, tick_get_broadcast_mask());
 			if (tick_broadcast_device.mode ==
 			    TICKDEV_MODE_PERIODIC)
 				clockevents_shutdown(dev);
 		}
 		if (*reason == CLOCK_EVT_NOTIFY_BROADCAST_FORCE)
 			tick_broadcast_force = 1;
 		break;
 	case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
 		if (!tick_broadcast_force &&
 		    cpumask_test_cpu(cpu, tick_get_broadcast_mask())) {
 			cpumask_clear_cpu(cpu, tick_get_broadcast_mask());
 			if (tick_broadcast_device.mode ==
 			    TICKDEV_MODE_PERIODIC)
 				tick_setup_periodic(dev, 0);
 		}
 		break;
 	}
 	if (cpumask_empty(tick_get_broadcast_mask())) {
 		if (!bc_stopped)
 			clockevents_shutdown(bc);
 	} else if (bc_stopped) {
 		if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
 			tick_broadcast_start_periodic(bc);
 		else
 			tick_broadcast_setup_oneshot(bc);
 	}
 out:
 	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 /*
  * Powerstate information: The system enters/leaves a state, where
  * affected devices might stop.
  */
 void tick_broadcast_on_off(unsigned long reason, int *oncpu)
 {
 	if (!cpumask_test_cpu(*oncpu, cpu_online_mask))
 		printk(KERN_ERR "tick-broadcast: ignoring broadcast for "
 		       "offline CPU #%d\n", *oncpu);
 	else
 		tick_do_broadcast_on_off(&reason);
 }
 /*
  * Set the periodic handler depending on broadcast on/off
  */
 void tick_set_periodic_handler(struct clock_event_device *dev, int broadcast)
 {
 	if (!broadcast)
 		dev->event_handler = tick_handle_periodic;
 	else
 		dev->event_handler = tick_handle_periodic_broadcast;
 }
 /*
  * Remove a CPU from broadcasting
  */
 void tick_shutdown_broadcast(unsigned int *cpup)
 {
 	struct clock_event_device *bc;
 	unsigned long flags;
 	unsigned int cpu = *cpup;
 	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
 	bc = tick_broadcast_device.evtdev;
 	cpumask_clear_cpu(cpu, tick_get_broadcast_mask());
 	if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC) {
 		if (bc && cpumask_empty(tick_get_broadcast_mask()))
 			clockevents_shutdown(bc);
 	}
 	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 void tick_suspend_broadcast(void)
 {
 	struct clock_event_device *bc;
 	unsigned long flags;
 	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
 	bc = tick_broadcast_device.evtdev;
 	if (bc)
 		clockevents_shutdown(bc);
 	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 int tick_resume_broadcast(void)
 {
 	struct clock_event_device *bc;
 	unsigned long flags;
 	int broadcast = 0;
 	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
 	bc = tick_broadcast_device.evtdev;
 	if (bc) {
 		clockevents_set_mode(bc, CLOCK_EVT_MODE_RESUME);
 		switch (tick_broadcast_device.mode) {
 		case TICKDEV_MODE_PERIODIC:
 			if (!cpumask_empty(tick_get_broadcast_mask()))
 				tick_broadcast_start_periodic(bc);
 			broadcast = cpumask_test_cpu(smp_processor_id(),
 						     tick_get_broadcast_mask());
 			break;
 		case TICKDEV_MODE_ONESHOT:
 			if (!cpumask_empty(tick_get_broadcast_mask()))
 				broadcast = tick_resume_broadcast_oneshot(bc);
 			break;
 		}
 	}
 	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 	return broadcast;
 }
 #ifdef CONFIG_TICK_ONESHOT
 /* FIXME: use cpumask_var_t. */
 static DECLARE_BITMAP(tick_broadcast_oneshot_mask, NR_CPUS);
 /*
  * Exposed for debugging: see timer_list.c
  */
 struct cpumask *tick_get_broadcast_oneshot_mask(void)
 {
 	return to_cpumask(tick_broadcast_oneshot_mask);
 }
 static int tick_broadcast_set_event(ktime_t expires, int force)
 {
 	struct clock_event_device *bc = tick_broadcast_device.evtdev;
 	if (bc->mode != CLOCK_EVT_MODE_ONESHOT)
 		clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
 	return clockevents_program_event(bc, expires, force);
 }
 int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
 {
 	clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
 	return 0;
 }
 /*
  * Called from irq_enter() when idle was interrupted to reenable the
  * per cpu device.
  */
 void tick_check_oneshot_broadcast(int cpu)
 {
 	if (cpumask_test_cpu(cpu, to_cpumask(tick_broadcast_oneshot_mask))) {
 		struct tick_device *td = &per_cpu(tick_cpu_device, cpu);
 		clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_ONESHOT);
 	}
 }
 /*
  * Handle oneshot mode broadcasting
  */
 static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
 {
 	struct tick_device *td;
 	ktime_t now, next_event;
 	int cpu;
 	raw_spin_lock(&tick_broadcast_lock);
 again:
 	dev->next_event.tv64 = KTIME_MAX;
 	next_event.tv64 = KTIME_MAX;
 	cpumask_clear(to_cpumask(tmpmask));
 	now = ktime_get();
 	/* Find all expired events */
 	for_each_cpu(cpu, tick_get_broadcast_oneshot_mask()) {
 		td = &per_cpu(tick_cpu_device, cpu);
 		if (td->evtdev->next_event.tv64 <= now.tv64)
 			cpumask_set_cpu(cpu, to_cpumask(tmpmask));
 		else if (td->evtdev->next_event.tv64 < next_event.tv64)
 			next_event.tv64 = td->evtdev->next_event.tv64;
 	}
 	/*
 	 * Wakeup the cpus which have an expired event.
 	 */
 	tick_do_broadcast(to_cpumask(tmpmask));
 	/*
 	 * Two reasons for reprogram:
 	 *
 	 * - The global event did not expire any CPU local
 	 * events. This happens in dyntick mode, as the maximum PIT
 	 * delta is quite small.
 	 *
 	 * - There are pending events on sleeping CPUs which were not
 	 * in the event mask
 	 */
 	if (next_event.tv64 != KTIME_MAX) {
 		/*
 		 * Rearm the broadcast device. If event expired,
 		 * repeat the above
 		 */
 		if (tick_broadcast_set_event(next_event, 0))
 			goto again;
 	}
 	raw_spin_unlock(&tick_broadcast_lock);
 }
 /*
  * Powerstate information: The system enters/leaves a state, where
  * affected devices might stop
  */
 void tick_broadcast_oneshot_control(unsigned long reason)
 {
 	struct clock_event_device *bc, *dev;
 	struct tick_device *td;
 	unsigned long flags;
 	int cpu;
 	/*
 	 * Periodic mode does not care about the enter/exit of power
 	 * states
 	 */
 	if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
 		return;
 	/*
 	 * We are called with preemtion disabled from the depth of the
 	 * idle code, so we can't be moved away.
 	 */
 	cpu = smp_processor_id();
 	td = &per_cpu(tick_cpu_device, cpu);
 	dev = td->evtdev;
 	if (!(dev->features & CLOCK_EVT_FEAT_C3STOP))
 		return;
 	bc = tick_broadcast_device.evtdev;
 	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
 	if (reason == CLOCK_EVT_NOTIFY_BROADCAST_ENTER) {
 		if (!cpumask_test_cpu(cpu, tick_get_broadcast_oneshot_mask())) {
 			cpumask_set_cpu(cpu, tick_get_broadcast_oneshot_mask());
 			clockevents_set_mode(dev, CLOCK_EVT_MODE_SHUTDOWN);
 			if (dev->next_event.tv64 < bc->next_event.tv64)
 				tick_broadcast_set_event(dev->next_event, 1);
 		}
 	} else {
 		if (cpumask_test_cpu(cpu, tick_get_broadcast_oneshot_mask())) {
 			cpumask_clear_cpu(cpu,
 					  tick_get_broadcast_oneshot_mask());
 			clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);
 			if (dev->next_event.tv64 != KTIME_MAX)
 				tick_program_event(dev->next_event, 1);
 		}
 	}
 	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 /*
  * Reset the one shot broadcast for a cpu
  *
  * Called with tick_broadcast_lock held
  */
 static void tick_broadcast_clear_oneshot(int cpu)
 {
 	cpumask_clear_cpu(cpu, tick_get_broadcast_oneshot_mask());
 }
 static void tick_broadcast_init_next_event(struct cpumask *mask,
 					   ktime_t expires)
 {
 	struct tick_device *td;
 	int cpu;
 	for_each_cpu(cpu, mask) {
 		td = &per_cpu(tick_cpu_device, cpu);
 		if (td->evtdev)
 			td->evtdev->next_event = expires;
 	}
 }
 /**
  * tick_broadcast_setup_oneshot - setup the broadcast device
  */
 void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
 {
 	int cpu = smp_processor_id();
 	/* Set it up only once ! */
 	if (bc->event_handler != tick_handle_oneshot_broadcast) {
 		int was_periodic = bc->mode == CLOCK_EVT_MODE_PERIODIC;
 		bc->event_handler = tick_handle_oneshot_broadcast;
 		/* Take the do_timer update */
-		tick_do_timer_cpu = cpu;
+		if (!tick_nohz_extended_cpu(cpu))
+			tick_do_timer_cpu = cpu;
 		/*
 		 * We must be careful here. There might be other CPUs
 		 * waiting for periodic broadcast. We need to set the
 		 * oneshot_mask bits for those and program the
 		 * broadcast device to fire.
 		 */
 		cpumask_copy(to_cpumask(tmpmask), tick_get_broadcast_mask());
 		cpumask_clear_cpu(cpu, to_cpumask(tmpmask));
 		cpumask_or(tick_get_broadcast_oneshot_mask(),
 			   tick_get_broadcast_oneshot_mask(),
 			   to_cpumask(tmpmask));
 		if (was_periodic && !cpumask_empty(to_cpumask(tmpmask))) {
 			clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
 			tick_broadcast_init_next_event(to_cpumask(tmpmask),
 						       tick_next_period);
 			tick_broadcast_set_event(tick_next_period, 1);
 		} else
 			bc->next_event.tv64 = KTIME_MAX;
 	} else {
 		/*
 		 * The first cpu which switches to oneshot mode sets
 		 * the bit for all other cpus which are in the general
 		 * (periodic) broadcast mask. So the bit is set and
 		 * would prevent the first broadcast enter after this
 		 * to program the bc device.
 		 */
 		tick_broadcast_clear_oneshot(cpu);
 	}
 }
 /*
  * Select oneshot operating mode for the broadcast device
  */
 void tick_broadcast_switch_to_oneshot(void)
 {
 	struct clock_event_device *bc;
 	unsigned long flags;
 	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
 	tick_broadcast_device.mode = TICKDEV_MODE_ONESHOT;
 	bc = tick_broadcast_device.evtdev;
 	if (bc)
 		tick_broadcast_setup_oneshot(bc);
 	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 /*
  * Remove a dead CPU from broadcasting
  */
 void tick_shutdown_broadcast_oneshot(unsigned int *cpup)
 {
 	unsigned long flags;
 	unsigned int cpu = *cpup;
 	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
 	/*
 	 * Clear the broadcast mask flag for the dead cpu, but do not
 	 * stop the broadcast device!
 	 */
 	cpumask_clear_cpu(cpu, tick_get_broadcast_oneshot_mask());
 	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 /*
  * Check, whether the broadcast device is in one shot mode
  */
 int tick_broadcast_oneshot_active(void)
 {
 	return tick_broadcast_device.mode == TICKDEV_MODE_ONESHOT;
 }
 /*
  * Check whether the broadcast device supports oneshot.
  */
 bool tick_broadcast_oneshot_available(void)
 {
 	struct clock_event_device *bc = tick_broadcast_device.evtdev;
 	return bc ? bc->features & CLOCK_EVT_FEAT_ONESHOT : false;
 }
 #endif

kernel/time/tick-common.c

Diff comments View file @ a382bf9

 /*
  * linux/kernel/time/tick-common.c
  *
  * This file contains the base functions to manage periodic tick
  * related events.
  *
  * 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
  *
  * This code is licenced under the GPL version 2. For details see
  * kernel-base/COPYING.
  */
 #include <linux/cpu.h>
 #include <linux/err.h>
 #include <linux/hrtimer.h>
 #include <linux/interrupt.h>
 #include <linux/percpu.h>
 #include <linux/profile.h>
 #include <linux/sched.h>
 #include <asm/irq_regs.h>
 #include "tick-internal.h"
 /*
  * Tick devices
  */
 DEFINE_PER_CPU(struct tick_device, tick_cpu_device);
 /*
  * Tick next event: keeps track of the tick time
  */
 ktime_t tick_next_period;
 ktime_t tick_period;
 int tick_do_timer_cpu __read_mostly = TICK_DO_TIMER_BOOT;
 static DEFINE_RAW_SPINLOCK(tick_device_lock);
 /*
  * Debugging: see timer_list.c
  */
 struct tick_device *tick_get_device(int cpu)
 {
 	return &per_cpu(tick_cpu_device, cpu);
 }
 /**
  * tick_is_oneshot_available - check for a oneshot capable event device
  */
 int tick_is_oneshot_available(void)
 {
 	struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev);
 	if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT))
 		return 0;
 	if (!(dev->features & CLOCK_EVT_FEAT_C3STOP))
 		return 1;
 	return tick_broadcast_oneshot_available();
 }
 /*
  * Periodic tick
  */
 static void tick_periodic(int cpu)
 {
 	if (tick_do_timer_cpu == cpu) {
 		write_seqlock(&jiffies_lock);
 		/* Keep track of the next tick event */
 		tick_next_period = ktime_add(tick_next_period, tick_period);
 		do_timer(1);
 		write_sequnlock(&jiffies_lock);
 	}
 	update_process_times(user_mode(get_irq_regs()));
 	profile_tick(CPU_PROFILING);
 }
 /*
  * Event handler for periodic ticks
  */
 void tick_handle_periodic(struct clock_event_device *dev)
 {
 	int cpu = smp_processor_id();
 	ktime_t next;
 	tick_periodic(cpu);
 	if (dev->mode != CLOCK_EVT_MODE_ONESHOT)
 		return;
 	/*
 	 * Setup the next period for devices, which do not have
 	 * periodic mode:
 	 */
 	next = ktime_add(dev->next_event, tick_period);
 	for (;;) {
 		if (!clockevents_program_event(dev, next, false))
 			return;
 		/*
 		 * Have to be careful here. If we're in oneshot mode,
 		 * before we call tick_periodic() in a loop, we need
 		 * to be sure we're using a real hardware clocksource.
 		 * Otherwise we could get trapped in an infinite
 		 * loop, as the tick_periodic() increments jiffies,
 		 * when then will increment time, posibly causing
 		 * the loop to trigger again and again.
 		 */
 		if (timekeeping_valid_for_hres())
 			tick_periodic(cpu);
 		next = ktime_add(next, tick_period);
 	}
 }
 /*
  * Setup the device for a periodic tick
  */
 void tick_setup_periodic(struct clock_event_device *dev, int broadcast)
 {
 	tick_set_periodic_handler(dev, broadcast);
 	/* Broadcast setup ? */
 	if (!tick_device_is_functional(dev))
 		return;
 	if ((dev->features & CLOCK_EVT_FEAT_PERIODIC) &&
 	    !tick_broadcast_oneshot_active()) {
 		clockevents_set_mode(dev, CLOCK_EVT_MODE_PERIODIC);
 	} else {
 		unsigned long seq;
 		ktime_t next;
 		do {
 			seq = read_seqbegin(&jiffies_lock);
 			next = tick_next_period;
 		} while (read_seqretry(&jiffies_lock, seq));
 		clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);
 		for (;;) {
 			if (!clockevents_program_event(dev, next, false))
 				return;
 			next = ktime_add(next, tick_period);
 		}
 	}
 }
 /*
  * Setup the tick device
  */
 static void tick_setup_device(struct tick_device *td,
 			      struct clock_event_device *newdev, int cpu,
 			      const struct cpumask *cpumask)
 {
 	ktime_t next_event;
 	void (*handler)(struct clock_event_device *) = NULL;
 	/*
 	 * First device setup ?
 	 */
 	if (!td->evtdev) {
 		/*
 		 * If no cpu took the do_timer update, assign it to
 		 * this cpu:
 		 */
 		if (tick_do_timer_cpu == TICK_DO_TIMER_BOOT) {
-			tick_do_timer_cpu = cpu;
+			if (!tick_nohz_extended_cpu(cpu))
+				tick_do_timer_cpu = cpu;
+			else
+				tick_do_timer_cpu = TICK_DO_TIMER_NONE;
 			tick_next_period = ktime_get();
 			tick_period = ktime_set(0, NSEC_PER_SEC / HZ);
 		}
 		/*
 		 * Startup in periodic mode first.
 		 */
 		td->mode = TICKDEV_MODE_PERIODIC;
 	} else {
 		handler = td->evtdev->event_handler;
 		next_event = td->evtdev->next_event;
 		td->evtdev->event_handler = clockevents_handle_noop;
 	}
 	td->evtdev = newdev;
 	/*
 	 * When the device is not per cpu, pin the interrupt to the
 	 * current cpu:
 	 */
 	if (!cpumask_equal(newdev->cpumask, cpumask))
 		irq_set_affinity(newdev->irq, cpumask);
 	/*
 	 * When global broadcasting is active, check if the current
 	 * device is registered as a placeholder for broadcast mode.
 	 * This allows us to handle this x86 misfeature in a generic
 	 * way.
 	 */
 	if (tick_device_uses_broadcast(newdev, cpu))
 		return;
 	if (td->mode == TICKDEV_MODE_PERIODIC)
 		tick_setup_periodic(newdev, 0);
 	else
 		tick_setup_oneshot(newdev, handler, next_event);
 }
 /*
  * Check, if the new registered device should be used.
  */
 static int tick_check_new_device(struct clock_event_device *newdev)
 {
 	struct clock_event_device *curdev;
 	struct tick_device *td;
 	int cpu, ret = NOTIFY_OK;
 	unsigned long flags;
 	raw_spin_lock_irqsave(&tick_device_lock, flags);
 	cpu = smp_processor_id();
 	if (!cpumask_test_cpu(cpu, newdev->cpumask))
 		goto out_bc;
 	td = &per_cpu(tick_cpu_device, cpu);
 	curdev = td->evtdev;
 	/* cpu local device ? */
 	if (!cpumask_equal(newdev->cpumask, cpumask_of(cpu))) {
 		/*
 		 * If the cpu affinity of the device interrupt can not
 		 * be set, ignore it.
 		 */
 		if (!irq_can_set_affinity(newdev->irq))
 			goto out_bc;
 		/*
 		 * If we have a cpu local device already, do not replace it
 		 * by a non cpu local device
 		 */
 		if (curdev && cpumask_equal(curdev->cpumask, cpumask_of(cpu)))
 			goto out_bc;
 	}
 	/*
 	 * If we have an active device, then check the rating and the oneshot
 	 * feature.
 	 */
 	if (curdev) {
 		/*
 		 * Prefer one shot capable devices !
 		 */
 		if ((curdev->features & CLOCK_EVT_FEAT_ONESHOT) &&
 		    !(newdev->features & CLOCK_EVT_FEAT_ONESHOT))
 			goto out_bc;
 		/*
 		 * Check the rating
 		 */
 		if (curdev->rating >= newdev->rating)
 			goto out_bc;
 	}
 	/*
 	 * Replace the eventually existing device by the new
 	 * device. If the current device is the broadcast device, do
 	 * not give it back to the clockevents layer !
 	 */
 	if (tick_is_broadcast_device(curdev)) {
 		clockevents_shutdown(curdev);
 		curdev = NULL;
 	}
 	clockevents_exchange_device(curdev, newdev);
 	tick_setup_device(td, newdev, cpu, cpumask_of(cpu));
 	if (newdev->features & CLOCK_EVT_FEAT_ONESHOT)
 		tick_oneshot_notify();
 	raw_spin_unlock_irqrestore(&tick_device_lock, flags);
 	return NOTIFY_STOP;
 out_bc:
 	/*
 	 * Can the new device be used as a broadcast device ?
 	 */
 	if (tick_check_broadcast_device(newdev))
 		ret = NOTIFY_STOP;
 	raw_spin_unlock_irqrestore(&tick_device_lock, flags);
 	return ret;
 }
 /*
  * Transfer the do_timer job away from a dying cpu.
  *
  * Called with interrupts disabled.
  */
 static void tick_handover_do_timer(int *cpup)
 {
 	if (*cpup == tick_do_timer_cpu) {
 		int cpu = cpumask_first(cpu_online_mask);
 		tick_do_timer_cpu = (cpu < nr_cpu_ids) ? cpu :
 			TICK_DO_TIMER_NONE;
 	}
 }
 /*
  * Shutdown an event device on a given cpu:
  *
  * This is called on a life CPU, when a CPU is dead. So we cannot
  * access the hardware device itself.
  * We just set the mode and remove it from the lists.
  */
 static void tick_shutdown(unsigned int *cpup)
 {
 	struct tick_device *td = &per_cpu(tick_cpu_device, *cpup);
 	struct clock_event_device *dev = td->evtdev;
 	unsigned long flags;
 	raw_spin_lock_irqsave(&tick_device_lock, flags);
 	td->mode = TICKDEV_MODE_PERIODIC;
 	if (dev) {
 		/*
 		 * Prevent that the clock events layer tries to call
 		 * the set mode function!
 		 */
 		dev->mode = CLOCK_EVT_MODE_UNUSED;
 		clockevents_exchange_device(dev, NULL);
 		td->evtdev = NULL;
 	}
 	raw_spin_unlock_irqrestore(&tick_device_lock, flags);
 }
 static void tick_suspend(void)
 {
 	struct tick_device *td = &__get_cpu_var(tick_cpu_device);
 	unsigned long flags;
 	raw_spin_lock_irqsave(&tick_device_lock, flags);
 	clockevents_shutdown(td->evtdev);
 	raw_spin_unlock_irqrestore(&tick_device_lock, flags);
 }
 static void tick_resume(void)
 {
 	struct tick_device *td = &__get_cpu_var(tick_cpu_device);
 	unsigned long flags;
 	int broadcast = tick_resume_broadcast();
 	raw_spin_lock_irqsave(&tick_device_lock, flags);
 	clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_RESUME);
 	if (!broadcast) {
 		if (td->mode == TICKDEV_MODE_PERIODIC)
 			tick_setup_periodic(td->evtdev, 0);
 		else
 			tick_resume_oneshot();
 	}
 	raw_spin_unlock_irqrestore(&tick_device_lock, flags);
 }
 /*
  * Notification about clock event devices
  */
 static int tick_notify(struct notifier_block *nb, unsigned long reason,
 			       void *dev)
 {
 	switch (reason) {
 	case CLOCK_EVT_NOTIFY_ADD:
 		return tick_check_new_device(dev);
 	case CLOCK_EVT_NOTIFY_BROADCAST_ON:
 	case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
 	case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
 		tick_broadcast_on_off(reason, dev);
 		break;
 	case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:
 	case CLOCK_EVT_NOTIFY_BROADCAST_EXIT:
 		tick_broadcast_oneshot_control(reason);
 		break;
 	case CLOCK_EVT_NOTIFY_CPU_DYING:
 		tick_handover_do_timer(dev);
 		break;
 	case CLOCK_EVT_NOTIFY_CPU_DEAD:
 		tick_shutdown_broadcast_oneshot(dev);
 		tick_shutdown_broadcast(dev);
 		tick_shutdown(dev);
 		break;
 	case CLOCK_EVT_NOTIFY_SUSPEND:
 		tick_suspend();
 		tick_suspend_broadcast();
 		break;
 	case CLOCK_EVT_NOTIFY_RESUME:
 		tick_resume();
 		break;
 	default:
 		break;
 	}
 	return NOTIFY_OK;
 }
 static struct notifier_block tick_notifier = {
 	.notifier_call = tick_notify,
 };
 /**
  * tick_init - initialize the tick control
  *
  * Register the notifier with the clockevents framework
  */
 void __init tick_init(void)
 {
 	clockevents_register_notifier(&tick_notifier);
 }

kernel/time/tick-sched.c

Diff comments View file @ a382bf9

 /*
  *  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
  *
  *  Distribute under GPLv2.
  */
 #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>
 #include <linux/module.h>
 #include <linux/irq_work.h>
 #include <asm/irq_regs.h>
 #include "tick-internal.h"
 /*
  * Per cpu nohz control structure
  */
 DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);
 /*
  * The time, when the last jiffy update happened. Protected by jiffies_lock.
  */
 static ktime_t last_jiffies_update;
 struct tick_sched *tick_get_tick_sched(int cpu)
 {
 	return &per_cpu(tick_cpu_sched, cpu);
 }
 /*
  * Must be called with interrupts disabled !
  */
 static void tick_do_update_jiffies64(ktime_t now)
 {
 	unsigned long ticks = 0;
 	ktime_t delta;
 	/*
 	 * Do a quick check without holding jiffies_lock:
 	 */
 	delta = ktime_sub(now, last_jiffies_update);
 	if (delta.tv64 < tick_period.tv64)
 		return;
 	/* Reevalute with jiffies_lock held */
 	write_seqlock(&jiffies_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);
 		/* Keep the tick_next_period variable up to date */
 		tick_next_period = ktime_add(last_jiffies_update, tick_period);
 	}
 	write_sequnlock(&jiffies_lock);
 }
 /*
  * Initialize and return retrieve the jiffies update.
  */
 static ktime_t tick_init_jiffy_update(void)
 {
 	ktime_t period;
 	write_seqlock(&jiffies_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(&jiffies_lock);
 	return period;
 }
 static void tick_sched_do_timer(ktime_t now)
 {
 	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
 	 * jiffies_lock.
 	 */
-	if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
+	if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE)
+	    && !tick_nohz_extended_cpu(cpu))
 		tick_do_timer_cpu = cpu;
 #endif
 	/* Check, if the jiffies need an update */
 	if (tick_do_timer_cpu == cpu)
 		tick_do_update_jiffies64(now);
 }
 static void tick_sched_handle(struct tick_sched *ts, struct pt_regs *regs)
 {
 #ifdef CONFIG_NO_HZ
 	/*
 	 * 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();
 		if (is_idle_task(current))
 			ts->idle_jiffies++;
 	}
 #endif
 	update_process_times(user_mode(regs));
 	profile_tick(CPU_PROFILING);
 }
 #ifdef CONFIG_NO_HZ_EXTENDED
 static cpumask_var_t nohz_extended_mask;
 bool have_nohz_extended_mask;
 int tick_nohz_extended_cpu(int cpu)
 {
 	if (!have_nohz_extended_mask)
 		return 0;
 	return cpumask_test_cpu(cpu, nohz_extended_mask);
 }
 /* Parse the boot-time nohz CPU list from the kernel parameters. */
 static int __init tick_nohz_extended_setup(char *str)
 {
 	alloc_bootmem_cpumask_var(&nohz_extended_mask);
 	if (cpulist_parse(str, nohz_extended_mask) < 0)
 		pr_warning("NOHZ: Incorrect nohz_extended cpumask\n");
 	else
 		have_nohz_extended_mask = true;
 	return 1;
 }
 __setup("nohz_extended=", tick_nohz_extended_setup);
+static int __cpuinit tick_nohz_cpu_down_callback(struct notifier_block *nfb,
+						 unsigned long action,
+						 void *hcpu)
+{
+	unsigned int cpu = (unsigned long)hcpu;
+	switch (action & ~CPU_TASKS_FROZEN) {
+	case CPU_DOWN_PREPARE:
+		/*
+		 * If we handle the timekeeping duty for full dynticks CPUs,
+		 * we can't safely shutdown that CPU.
+		 */
+		if (have_nohz_extended_mask && tick_do_timer_cpu == cpu)
+			return -EINVAL;
+		break;
+	}
+	return NOTIFY_OK;
+}
 static int __init init_tick_nohz_extended(void)
 {
 	cpumask_var_t online_nohz;
 	int cpu;
 	if (!have_nohz_extended_mask)
 		return 0;
+	cpu_notifier(tick_nohz_cpu_down_callback, 0);
 	if (!zalloc_cpumask_var(&online_nohz, GFP_KERNEL)) {
 		pr_warning("NO_HZ: Not enough memory to check extended nohz mask\n");
 		return -ENOMEM;
 	}
 	/*
 	 * CPUs can probably not be concurrently offlined on initcall time.
 	 * But we are paranoid, aren't we?
 	 */
 	get_online_cpus();
 	/* Ensure we keep a CPU outside the dynticks range for timekeeping */
 	cpumask_and(online_nohz, cpu_online_mask, nohz_extended_mask);
 	if (cpumask_equal(online_nohz, cpu_online_mask)) {
-		cpu = cpumask_any(cpu_online_mask);
 		pr_warning("NO_HZ: Must keep at least one online CPU "
 			   "out of nohz_extended range\n");
+		/*
+		 * We know the current CPU doesn't have its tick stopped.
+		 * Let's use it for the timekeeping duty.
+		 */
+		preempt_disable();
+		cpu = smp_processor_id();
 		pr_warning("NO_HZ: Clearing %d from nohz_extended range\n", cpu);
 		cpumask_clear_cpu(cpu, nohz_extended_mask);
+		preempt_enable();
 	}
 	put_online_cpus();
 	free_cpumask_var(online_nohz);
 	return 0;
 }
 core_initcall(init_tick_nohz_extended);
 #else
 #define have_nohz_extended_mask (0)
 #endif
 /*
  * NOHZ - aka dynamic tick functionality
  */
 #ifdef CONFIG_NO_HZ
 /*
  * NO HZ enabled ?
  */
 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.
  */
 static void tick_nohz_update_jiffies(ktime_t now)
 {
 	int cpu = smp_processor_id();
 	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 	unsigned long flags;
 	ts->idle_waketime = now;
 	local_irq_save(flags);
 	tick_do_update_jiffies64(now);
 	local_irq_restore(flags);
 	touch_softlockup_watchdog();
 }
 /*
  * Updates the per cpu time idle statistics counters
  */
 static void
 update_ts_time_stats(int cpu, struct tick_sched *ts, ktime_t now, u64 *last_update_time)
 {
 	ktime_t delta;
 	if (ts->idle_active) {
 		delta = ktime_sub(now, ts->idle_entrytime);
 		if (nr_iowait_cpu(cpu) > 0)
 			ts->iowait_sleeptime = ktime_add(ts->iowait_sleeptime, delta);
 		else
 			ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
 		ts->idle_entrytime = now;
 	}
 	if (last_update_time)
 		*last_update_time = ktime_to_us(now);
 }
 static void tick_nohz_stop_idle(int cpu, ktime_t now)
 {
 	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 	update_ts_time_stats(cpu, ts, now, NULL);
 	ts->idle_active = 0;
 	sched_clock_idle_wakeup_event(0);
 }
 static ktime_t tick_nohz_start_idle(int cpu, struct tick_sched *ts)
 {
 	ktime_t now = ktime_get();
 	ts->idle_entrytime = now;
 	ts->idle_active = 1;
 	sched_clock_idle_sleep_event();
 	return now;
 }
 /**
  * get_cpu_idle_time_us - get the total idle time of a cpu
  * @cpu: CPU number to query
  * @last_update_time: variable to store update time in. Do not update
  * counters if NULL.
  *
  * Return the cummulative idle 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_idle_time_us(int cpu, u64 *last_update_time)
 {
 	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 	ktime_t now, idle;
 	if (!tick_nohz_enabled)
 		return -1;
 	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);
 }
 EXPORT_SYMBOL_GPL(get_cpu_idle_time_us);
 /**
  * get_cpu_iowait_time_us - get the total iowait time of a cpu
  * @cpu: CPU number to query
  * @last_update_time: variable to store update time in. Do not update
  * counters if NULL.
  *
  * 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);
 	ktime_t now, iowait;
 	if (!tick_nohz_enabled)
 		return -1;
 	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);
 			iowait = ktime_add(ts->iowait_sleeptime, delta);
 		} else {
 			iowait = ts->iowait_sleeptime;
 		}
 	}
 	return ktime_to_us(iowait);
 }
 EXPORT_SYMBOL_GPL(get_cpu_iowait_time_us);
 static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
 					 ktime_t now, int cpu)
 {
 	unsigned long seq, last_jiffies, next_jiffies, delta_jiffies;
 	ktime_t last_update, expires, ret = { .tv64 = 0 };
 	unsigned long rcu_delta_jiffies;
 	struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
 	u64 time_delta;
 	/* Read jiffies and the time when jiffies were updated last */
 	do {
 		seq = read_seqbegin(&jiffies_lock);
 		last_update = last_jiffies_update;
 		last_jiffies = jiffies;
 		time_delta = timekeeping_max_deferment();
 	} while (read_seqretry(&jiffies_lock, seq));
 	if (rcu_needs_cpu(cpu, &rcu_delta_jiffies) ||
 	    arch_needs_cpu(cpu) || irq_work_needs_cpu()) {
 		next_jiffies = last_jiffies + 1;
 		delta_jiffies = 1;
 	} else {
 		/* Get the next timer wheel timer */
 		next_jiffies = get_next_timer_interrupt(last_jiffies);
 		delta_jiffies = next_jiffies - last_jiffies;
 		if (rcu_delta_jiffies < delta_jiffies) {
 			next_jiffies = last_jiffies + rcu_delta_jiffies;
 			delta_jiffies = rcu_delta_jiffies;
 		}
 	}
 	/*
 	 * 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 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. 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;
 		ret = expires;
 		/*
 		 * 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) {
 			nohz_balance_enter_idle(cpu);
 			calc_load_enter_idle();
 			ts->last_tick = hrtimer_get_expires(&ts->sched_timer);
 			ts->tick_stopped = 1;
 		}
 		/*
 		 * 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);
 	return ret;
 }
 static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
 {
 	/*
 	 * 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)
 			tick_do_timer_cpu = TICK_DO_TIMER_NONE;
 	}
 	if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))
 		return false;
 	if (need_resched())
 		return false;
 	if (unlikely(local_softirq_pending() && cpu_online(cpu))) {
 		static int ratelimit;
 		if (ratelimit < 10 &&
 		    (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) {
 			printk(KERN_ERR "NOHZ: local_softirq_pending %02x\n",
 			       (unsigned int) local_softirq_pending());
 			ratelimit++;
 		}
 		return false;
+	}
+	if (have_nohz_extended_mask) {
+		/*
+		 * Keep the tick alive to guarantee timekeeping progression
+		 * if there are full dynticks CPUs around
+		 */
+		if (tick_do_timer_cpu == cpu)
+			return false;
+		/*
+		 * Boot safety: make sure the timekeeping duty has been
+		 * assigned before entering dyntick-idle mode,
+		 */
+		if (tick_do_timer_cpu == TICK_DO_TIMER_NONE)
+			return false;
 	}
 	return true;
 }
 static void __tick_nohz_idle_enter(struct tick_sched *ts)
 {
 	ktime_t now, expires;
 	int cpu = smp_processor_id();
 	now = tick_nohz_start_idle(cpu, ts);
 	if (can_stop_idle_tick(cpu, ts)) {
 		int was_stopped = ts->tick_stopped;
 		ts->idle_calls++;
 		expires = tick_nohz_stop_sched_tick(ts, now, cpu);
 		if (expires.tv64 > 0LL) {
 			ts->idle_sleeps++;
 			ts->idle_expires = expires;
 		}
 		if (!was_stopped && ts->tick_stopped)
 			ts->idle_jiffies = ts->last_jiffies;
 	}
 }
 /**
  * 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.
  *
  * The arch is responsible of calling:
  *
  * - 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.
  */
 void tick_nohz_idle_enter(void)
 {
 	struct tick_sched *ts;
 	WARN_ON_ONCE(irqs_disabled());
 	/*
  	 * 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();
 	local_irq_disable();
 	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;
 	__tick_nohz_idle_enter(ts);
 	local_irq_enable();
 }
 EXPORT_SYMBOL_GPL(tick_nohz_idle_enter);
 /**
  * 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;
 	/* Cancel the timer because CPU already waken up from the C-states*/
 	menu_hrtimer_cancel();
 	__tick_nohz_idle_enter(ts);
 }
 /**
  * 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;
 }
 static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
 {
 	hrtimer_cancel(&ts->sched_timer);
 	hrtimer_set_expires(&ts->sched_timer, ts->last_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_expires(&ts->sched_timer,
 					      HRTIMER_MODE_ABS_PINNED);
 			/* Check, if the timer was already in the past */
 			if (hrtimer_active(&ts->sched_timer))
 				break;
 		} else {
 			if (!tick_program_event(
 				hrtimer_get_expires(&ts->sched_timer), 0))
 				break;
 		}
 		/* Reread time and update jiffies */
 		now = ktime_get();
 		tick_do_update_jiffies64(now);
 	}
 }
 static void tick_nohz_restart_sched_tick(struct tick_sched *ts, ktime_t now)
 {
 	/* Update jiffies first */
 	tick_do_update_jiffies64(now);
 	update_cpu_load_nohz();
 	calc_load_exit_idle();
 	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)
 {
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 	unsigned long ticks;
 	if (vtime_accounting_enabled())
 		return;
 	/*
 	 * 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)
 		account_idle_ticks(ticks);
 #endif
 }
 /**
  * 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;
 	/* Cancel the timer because CPU already waken up from the C-states*/
 	menu_hrtimer_cancel();
 	if (ts->idle_active || ts->tick_stopped)
 		now = ktime_get();
 	if (ts->idle_active)
 		tick_nohz_stop_idle(cpu, now);
 	if (ts->tick_stopped) {
 		tick_nohz_restart_sched_tick(ts, now);
 		tick_nohz_account_idle_ticks(ts);
 	}
 	local_irq_enable();
 }
 EXPORT_SYMBOL_GPL(tick_nohz_idle_exit);
 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);
 }
 /*
  * 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();
 	ktime_t now = ktime_get();
 	dev->next_event.tv64 = KTIME_MAX;
 	tick_sched_do_timer(now);
 	tick_sched_handle(ts, regs);
 	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 (;;) {
 		hrtimer_set_expires(&ts->sched_timer, next);
 		if (!tick_program_event(next, 0))
 			break;
 		next = ktime_add(next, tick_period);
 	}
 	local_irq_enable();
 }
 /*
  * 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.
  */
 static void tick_nohz_kick_tick(int cpu, ktime_t now)
 {
 #if 0
 	/* Switch back to 2.6.27 behaviour */
 	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 	ktime_t delta;
 	/*
 	 * Do not touch the tick device, when the next expiry is either
 	 * already reached or less/equal than the tick period.
 	 */
 	delta =	ktime_sub(hrtimer_get_expires(&ts->sched_timer), now);
 	if (delta.tv64 <= tick_period.tv64)
 		return;
 	tick_nohz_restart(ts, now);
 #endif
 }
 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);
 	}
 }
 #else
 static inline void tick_nohz_switch_to_nohz(void) { }
 static inline void tick_check_nohz(int cpu) { }
 #endif /* NO_HZ */
 /*
  * Called from irq_enter to notify about the possible interruption of idle()
  */
 void tick_check_idle(int cpu)
 {
 	tick_check_oneshot_broadcast(cpu);
 	tick_check_nohz(cpu);
 }
 /*
  * High resolution timer specific code
  */
 #ifdef CONFIG_HIGH_RES_TIMERS
 /*
  * We rearm the timer until we get disabled by the idle code.
  * Called with interrupts disabled.
  */
 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();
 	tick_sched_do_timer(now);
 	/*
 	 * Do not call, when we are not in irq context and have
 	 * no valid regs pointer
 	 */
 	if (regs)
 		tick_sched_handle(ts, regs);
 	hrtimer_forward(timer, now, tick_period);
 	return HRTIMER_RESTART;
 }
 static int sched_skew_tick;
 static int __init skew_tick(char *str)
 {
 	get_option(&str, &sched_skew_tick);
 	return 0;
 }
 early_param("skew_tick", skew_tick);
 /**
  * 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;
 	/* Get the next period (per cpu) */
 	hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
 	/* Offset the tick to avert jiffies_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);
 	}
 	for (;;) {
 		hrtimer_forward(&ts->sched_timer, now, tick_period);
 		hrtimer_start_expires(&ts->sched_timer,
 				      HRTIMER_MODE_ABS_PINNED);
 		/* Check, if the timer was already in the past */
 		if (hrtimer_active(&ts->sched_timer))
 			break;
 		now = ktime_get();
 	}
 #ifdef CONFIG_NO_HZ
 	if (tick_nohz_enabled)
 		ts->nohz_mode = NOHZ_MODE_HIGHRES;
 #endif
 }
 #endif /* HIGH_RES_TIMERS */
 #if defined CONFIG_NO_HZ || defined CONFIG_HIGH_RES_TIMERS
 void tick_cancel_sched_timer(int cpu)
 {
 	struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 # ifdef CONFIG_HIGH_RES_TIMERS
 	if (ts->sched_timer.base)
 		hrtimer_cancel(&ts->sched_timer);
 # endif
 	ts->nohz_mode = NOHZ_MODE_INACTIVE;
 }
 #endif
 /**
  * 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;
 	if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())
 		return 0;
 	if (!allow_nohz)
 		return 1;
 	tick_nohz_switch_to_nohz();
 	return 0;
 }