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

Commit 1fe5d5c3 authored by Thomas Gleixner's avatar Thomas Gleixner Committed by Ingo Molnar
Browse files

clockevents: Provide explicit broadcast oneshot 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 oneshot 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 oneshot 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: Alexandre Courbot <gnurou@gmail.com>
Cc: Daniel Lezcano <daniel.lezcano@linaro.org>
Cc: Len Brown <lenb@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephen Warren <swarren@wwwdotorg.org>
Cc: Thierry Reding <thierry.reding@gmail.com>
Cc: Tony Lindgren <tony@atomide.com>
Link: http://lkml.kernel.org/r/13000649.8qZuEDV0OA@vostro.rjw.lan


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

include/linux/tick.h

+19 −0
Original line number Original line Diff line number Diff line
@@ -48,12 +48,23 @@ enum tick_broadcast_mode { 
	TICK_BROADCAST_FORCE,

	TICK_BROADCAST_FORCE,

};

};





enum tick_broadcast_state {

	TICK_BROADCAST_EXIT,

	TICK_BROADCAST_ENTER,

};



#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST

#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST

extern void tick_broadcast_control(enum tick_broadcast_mode mode);

extern void tick_broadcast_control(enum tick_broadcast_mode mode);

#else

#else

static inline void tick_broadcast_control(enum tick_broadcast_mode mode) { }

static inline void tick_broadcast_control(enum tick_broadcast_mode mode) { }

#endif /* BROADCAST */

#endif /* BROADCAST */





#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)

extern int tick_broadcast_oneshot_control(enum tick_broadcast_state state);

#else

static inline int tick_broadcast_oneshot_control(enum tick_broadcast_state state) { return 0; }

#endif



static inline void tick_broadcast_enable(void)

static inline void tick_broadcast_enable(void)

{

{

	tick_broadcast_control(TICK_BROADCAST_ON);

	tick_broadcast_control(TICK_BROADCAST_ON);
@@ -66,6 +77,14 @@ static inline void tick_broadcast_force(void) 
{

{

	tick_broadcast_control(TICK_BROADCAST_FORCE);

	tick_broadcast_control(TICK_BROADCAST_FORCE);

}

}

static inline int tick_broadcast_enter(void)

{

	return tick_broadcast_oneshot_control(TICK_BROADCAST_ENTER);

}

static inline void tick_broadcast_exit(void)

{

	tick_broadcast_oneshot_control(TICK_BROADCAST_EXIT);

}





#ifdef CONFIG_NO_HZ_COMMON

#ifdef CONFIG_NO_HZ_COMMON

extern int tick_nohz_tick_stopped(void);

extern int tick_nohz_tick_stopped(void);

kernel/time/clockevents.c

+3 −1
Original line number Original line Diff line number Diff line
@@ -656,8 +656,10 @@ int clockevents_notify(unsigned long reason, void *arg) 




	switch (reason) {

	switch (reason) {

	case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:

	case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:

		tick_broadcast_enter();

		break;

	case CLOCK_EVT_NOTIFY_BROADCAST_EXIT:

	case CLOCK_EVT_NOTIFY_BROADCAST_EXIT:

		ret = tick_broadcast_oneshot_control(reason);

		tick_broadcast_exit();

		break;

		break;





	case CLOCK_EVT_NOTIFY_CPU_DYING:

	case CLOCK_EVT_NOTIFY_CPU_DYING:

kernel/time/tick-broadcast.c

+17 −11
Original line number Original line Diff line number Diff line
@@ -687,18 +687,23 @@ void hotplug_cpu__broadcast_tick_pull(int deadcpu) 
	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);

	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);

}

}





/*

/**

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

 * tick_broadcast_oneshot_control - Enter/exit broadcast oneshot mode

 * affected devices might stop

 * @state:	The target state (enter/exit)

 *

 * The system enters/leaves a state, where affected devices might stop

 * Returns 0 on success, -EBUSY if the cpu is used to broadcast wakeups.

 * Returns 0 on success, -EBUSY if the cpu is used to broadcast wakeups.

 *

 * Called with interrupts disabled, so clockevents_lock is not

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

 * under us.

 */

 */

int tick_broadcast_oneshot_control(unsigned long reason)

int tick_broadcast_oneshot_control(enum tick_broadcast_state state)

{

{

	struct clock_event_device *bc, *dev;

	struct clock_event_device *bc, *dev;

	struct tick_device *td;

	struct tick_device *td;

	unsigned long flags;

	ktime_t now;

	int cpu, ret = 0;

	int cpu, ret = 0;

	ktime_t now;





	/*

	/*

	 * Periodic mode does not care about the enter/exit of power

	 * Periodic mode does not care about the enter/exit of power
@@ -711,17 +716,17 @@ int tick_broadcast_oneshot_control(unsigned long reason) 
	 * We are called with preemtion disabled from the depth of the

	 * We are called with preemtion disabled from the depth of the

	 * idle code, so we can't be moved away.

	 * idle code, so we can't be moved away.

	 */

	 */

	cpu = smp_processor_id();

	td = this_cpu_ptr(&tick_cpu_device);

	td = &per_cpu(tick_cpu_device, cpu);

	dev = td->evtdev;

	dev = td->evtdev;





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

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

		return 0;

		return 0;





	raw_spin_lock(&tick_broadcast_lock);

	bc = tick_broadcast_device.evtdev;

	bc = tick_broadcast_device.evtdev;

	cpu = smp_processor_id();





	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);

	if (state == TICK_BROADCAST_ENTER) {

	if (reason == CLOCK_EVT_NOTIFY_BROADCAST_ENTER) {

		if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_oneshot_mask)) {

		if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_oneshot_mask)) {

			WARN_ON_ONCE(cpumask_test_cpu(cpu, tick_broadcast_pending_mask));

			WARN_ON_ONCE(cpumask_test_cpu(cpu, tick_broadcast_pending_mask));

			broadcast_shutdown_local(bc, dev);

			broadcast_shutdown_local(bc, dev);
@@ -813,9 +818,10 @@ int tick_broadcast_oneshot_control(unsigned long reason) 
		}

		}

	}

	}

out:

out:

	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);

	raw_spin_unlock(&tick_broadcast_lock);

	return ret;

	return ret;

}

}

EXPORT_SYMBOL_GPL(tick_broadcast_oneshot_control);





/*

/*

 * Reset the one shot broadcast for a cpu

 * Reset the one shot broadcast for a cpu

kernel/time/tick-internal.h

+0 −2
Original line number Original line Diff line number Diff line
@@ -117,7 +117,6 @@ static inline int tick_check_oneshot_change(int allow_nohz) { return 0; } 
/* Functions related to oneshot broadcasting */

/* Functions related to oneshot broadcasting */

#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)

#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)

extern void tick_broadcast_setup_oneshot(struct clock_event_device *bc);

extern void tick_broadcast_setup_oneshot(struct clock_event_device *bc);

extern int tick_broadcast_oneshot_control(unsigned long reason);

extern void tick_broadcast_switch_to_oneshot(void);

extern void tick_broadcast_switch_to_oneshot(void);

extern void tick_shutdown_broadcast_oneshot(unsigned int *cpup);

extern void tick_shutdown_broadcast_oneshot(unsigned int *cpup);

extern int tick_broadcast_oneshot_active(void);

extern int tick_broadcast_oneshot_active(void);
@@ -126,7 +125,6 @@ bool tick_broadcast_oneshot_available(void); 
extern struct cpumask *tick_get_broadcast_oneshot_mask(void);

extern struct cpumask *tick_get_broadcast_oneshot_mask(void);

#else /* !(BROADCAST && ONESHOT): */

#else /* !(BROADCAST && ONESHOT): */

static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }

static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }

static inline int tick_broadcast_oneshot_control(unsigned long reason) { return 0; }

static inline void tick_broadcast_switch_to_oneshot(void) { }

static inline void tick_broadcast_switch_to_oneshot(void) { }

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

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

static inline int tick_broadcast_oneshot_active(void) { return 0; }

static inline int tick_broadcast_oneshot_active(void) { return 0; }