Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 592a438f authored by Thomas Gleixner's avatar Thomas Gleixner Committed by Ingo Molnar
Browse files

clockevents: Provide explicit broadcast control functions 



clockevents_notify() is a leftover from the early design of the
clockevents facility. It's really not a notification mechanism,
it's a multiplex call. We are way better off to have explicit
calls instead of this monstrosity.

Split out the broadcast control into a separate function and
provide inline helpers. Switch clockevents_notify() over. This
will go away once all callers are converted.

This also gets rid of the nested locking of clockevents_lock and
broadcast_lock. The broadcast control functions do not require
clockevents_lock. Only the managing functions
(setup/shutdown/suspend/resume of the broadcast device require
clockevents_lock.

Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
Cc: Daniel Lezcano <daniel.lezcano@linaro.org>
Cc: Len Brown <lenb@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tony Lindgren <tony@atomide.com>
Link: http://lkml.kernel.org/r/8086559.ttsuS0n1Xr@vostro.rjw.lan


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent 3ff70551

include/linux/tick.h

+25 −0
Original line number Original line Diff line number Diff line
@@ -42,6 +42,31 @@ extern void hotplug_cpu__broadcast_tick_pull(int dead_cpu); 
static inline void hotplug_cpu__broadcast_tick_pull(int dead_cpu) { }

static inline void hotplug_cpu__broadcast_tick_pull(int dead_cpu) { }

#endif

#endif





enum tick_broadcast_mode {

	TICK_BROADCAST_OFF,

	TICK_BROADCAST_ON,

	TICK_BROADCAST_FORCE,

};



#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST

extern void tick_broadcast_control(enum tick_broadcast_mode mode);

#else

static inline void tick_broadcast_control(enum tick_broadcast_mode mode) { }

#endif /* BROADCAST */



static inline void tick_broadcast_enable(void)

{

	tick_broadcast_control(TICK_BROADCAST_ON);

}

static inline void tick_broadcast_disable(void)

{

	tick_broadcast_control(TICK_BROADCAST_OFF);

}

static inline void tick_broadcast_force(void)

{

	tick_broadcast_control(TICK_BROADCAST_FORCE);

}



#ifdef CONFIG_NO_HZ_COMMON

#ifdef CONFIG_NO_HZ_COMMON

extern int tick_nohz_tick_stopped(void);

extern int tick_nohz_tick_stopped(void);

extern void tick_nohz_idle_enter(void);

extern void tick_nohz_idle_enter(void);

kernel/time/clockevents.c

+5 −1
Original line number Original line Diff line number Diff line
@@ -656,9 +656,13 @@ int clockevents_notify(unsigned long reason, void *arg) 




	switch (reason) {

	switch (reason) {

	case CLOCK_EVT_NOTIFY_BROADCAST_ON:

	case CLOCK_EVT_NOTIFY_BROADCAST_ON:

		tick_broadcast_enable();

		break;

	case CLOCK_EVT_NOTIFY_BROADCAST_OFF:

	case CLOCK_EVT_NOTIFY_BROADCAST_OFF:

		tick_broadcast_disable();

		break;

	case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:

	case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:

		tick_broadcast_on_off(reason, arg);

		tick_broadcast_force();

		break;

		break;





	case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:

	case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:

kernel/time/tick-broadcast.c

+27 −35
Original line number Original line Diff line number Diff line
@@ -33,7 +33,7 @@ static cpumask_var_t tick_broadcast_mask; 
static cpumask_var_t tick_broadcast_on;

static cpumask_var_t tick_broadcast_on;

static cpumask_var_t tmpmask;

static cpumask_var_t tmpmask;

static DEFINE_RAW_SPINLOCK(tick_broadcast_lock);

static DEFINE_RAW_SPINLOCK(tick_broadcast_lock);

static int tick_broadcast_force;

static int tick_broadcast_forced;





#ifdef CONFIG_TICK_ONESHOT

#ifdef CONFIG_TICK_ONESHOT

static void tick_broadcast_clear_oneshot(int cpu);

static void tick_broadcast_clear_oneshot(int cpu);
@@ -326,49 +326,54 @@ static void tick_handle_periodic_broadcast(struct clock_event_device *dev) 
	raw_spin_unlock(&tick_broadcast_lock);

	raw_spin_unlock(&tick_broadcast_lock);

}

}





/*

/**

 * Powerstate information: The system enters/leaves a state, where

 * tick_broadcast_control - Enable/disable or force broadcast mode

 * affected devices might stop

 * @mode:	The selected broadcast mode

 *

 * Called when the system enters a state where affected tick devices

 * might stop. Note: TICK_BROADCAST_FORCE cannot be undone.

 *

 * Called with interrupts disabled, so clockevents_lock is not

 * required here because the local clock event device cannot go away

 * under us.

 */

 */

static void tick_do_broadcast_on_off(unsigned long *reason)

void tick_broadcast_control(enum tick_broadcast_mode mode)

{

{

	struct clock_event_device *bc, *dev;

	struct clock_event_device *bc, *dev;

	struct tick_device *td;

	struct tick_device *td;

	unsigned long flags;

	int cpu, bc_stopped;

	int cpu, bc_stopped;





	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);

	td = this_cpu_ptr(&tick_cpu_device);



	cpu = smp_processor_id();

	td = &per_cpu(tick_cpu_device, cpu);

	dev = td->evtdev;

	dev = td->evtdev;

	bc = tick_broadcast_device.evtdev;





	/*

	/*

	 * Is the device not affected by the powerstate ?

	 * Is the device not affected by the powerstate ?

	 */

	 */

	if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))

	if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))

		goto out;

		return;





	if (!tick_device_is_functional(dev))

	if (!tick_device_is_functional(dev))

		goto out;

		return;





	raw_spin_lock(&tick_broadcast_lock);

	cpu = smp_processor_id();

	bc = tick_broadcast_device.evtdev;

	bc_stopped = cpumask_empty(tick_broadcast_mask);

	bc_stopped = cpumask_empty(tick_broadcast_mask);





	switch (*reason) {

	switch (mode) {

	case CLOCK_EVT_NOTIFY_BROADCAST_ON:

	case TICK_BROADCAST_FORCE:

	case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:

		tick_broadcast_forced = 1;

	case TICK_BROADCAST_ON:

		cpumask_set_cpu(cpu, tick_broadcast_on);

		cpumask_set_cpu(cpu, tick_broadcast_on);

		if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_mask)) {

		if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_mask)) {

			if (tick_broadcast_device.mode ==

			if (tick_broadcast_device.mode ==

			    TICKDEV_MODE_PERIODIC)

			    TICKDEV_MODE_PERIODIC)

				clockevents_shutdown(dev);

				clockevents_shutdown(dev);

		}

		}

		if (*reason == CLOCK_EVT_NOTIFY_BROADCAST_FORCE)

			tick_broadcast_force = 1;

		break;

		break;

	case CLOCK_EVT_NOTIFY_BROADCAST_OFF:



		if (tick_broadcast_force)

	case TICK_BROADCAST_OFF:

		if (tick_broadcast_forced)

			break;

			break;

		cpumask_clear_cpu(cpu, tick_broadcast_on);

		cpumask_clear_cpu(cpu, tick_broadcast_on);

		if (!tick_device_is_functional(dev))

		if (!tick_device_is_functional(dev))
@@ -390,22 +395,9 @@ static void tick_do_broadcast_on_off(unsigned long *reason) 
		else

		else

			tick_broadcast_setup_oneshot(bc);

			tick_broadcast_setup_oneshot(bc);

	}

	}

out:

	raw_spin_unlock(&tick_broadcast_lock);

	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);

}

}

EXPORT_SYMBOL_GPL(tick_broadcast_control);





/*

/*

 * Set the periodic handler depending on broadcast on/off

 * Set the periodic handler depending on broadcast on/off

kernel/time/tick-internal.h

+0 −2
Original line number Original line Diff line number Diff line
@@ -53,7 +53,6 @@ extern ssize_t sysfs_get_uname(const char *buf, char *dst, size_t cnt); 
extern int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu);

extern int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu);

extern void tick_install_broadcast_device(struct clock_event_device *dev);

extern void tick_install_broadcast_device(struct clock_event_device *dev);

extern int tick_is_broadcast_device(struct clock_event_device *dev);

extern int tick_is_broadcast_device(struct clock_event_device *dev);

extern void tick_broadcast_on_off(unsigned long reason, int *oncpu);

extern void tick_shutdown_broadcast(unsigned int *cpup);

extern void tick_shutdown_broadcast(unsigned int *cpup);

extern void tick_suspend_broadcast(void);

extern void tick_suspend_broadcast(void);

extern void tick_resume_broadcast(void);

extern void tick_resume_broadcast(void);
@@ -68,7 +67,6 @@ static inline void tick_install_broadcast_device(struct clock_event_device *dev) 
static inline int tick_is_broadcast_device(struct clock_event_device *dev) { return 0; }

static inline int tick_is_broadcast_device(struct clock_event_device *dev) { return 0; }

static inline int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu) { return 0; }

static inline int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu) { return 0; }

static inline void tick_do_periodic_broadcast(struct clock_event_device *d) { }

static inline void tick_do_periodic_broadcast(struct clock_event_device *d) { }

static inline void tick_broadcast_on_off(unsigned long reason, int *oncpu) { }

static inline void tick_shutdown_broadcast(unsigned int *cpup) { }

static inline void tick_shutdown_broadcast(unsigned int *cpup) { }

static inline void tick_suspend_broadcast(void) { }

static inline void tick_suspend_broadcast(void) { }

static inline void tick_resume_broadcast(void) { }

static inline void tick_resume_broadcast(void) { }