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

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

tick: Move core only declarations and functions to core 



No point to expose everything to the world. People just believe
such functions can be abused for whatever purposes. Sigh.

Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
[ Rebased on top of 4.0-rc5 ]
Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
Cc: Nicolas Pitre <nico@linaro.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/28017337.VbCUc39Gme@vostro.rjw.lan


[ Merged to latest timers/core ]
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent b7475eb5

include/linux/clockchips.h

+6 −9
Original line number Diff line number Diff line
@@ -193,15 +193,6 @@ extern void clockevents_config_and_register(struct clock_event_device *dev, 


extern int clockevents_update_freq(struct clock_event_device *ce, u32 freq);



extern void clockevents_exchange_device(struct clock_event_device *old,

					struct clock_event_device *new);

extern void clockevents_set_state(struct clock_event_device *dev,

				  enum clock_event_state state);

extern int clockevents_program_event(struct clock_event_device *dev,

				     ktime_t expires, bool force);



extern void clockevents_handle_noop(struct clock_event_device *dev);



static inline void

clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec)

{
@@ -209,6 +200,12 @@ clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec) 
				      freq, minsec);

}



/* Should be core only, but is abused by arm bl_switcher */

extern void clockevents_set_state(struct clock_event_device *dev,

				 enum clock_event_state state);

extern int clockevents_program_event(struct clock_event_device *dev,

				     ktime_t expires, bool force);



extern void clockevents_suspend(void);

extern void clockevents_resume(void);

include/linux/tick.h

+18 −116
Original line number Diff line number Diff line 
/*  linux/include/linux/tick.h

 *

 *  This file contains the structure definitions for tick related functions

 *

/*

 * Tick related global functions

 */

#ifndef _LINUX_TICK_H

#define _LINUX_TICK_H
@@ -9,13 +7,12 @@ 
#include <linux/clockchips.h>

#include <linux/irqflags.h>

#include <linux/percpu.h>

#include <linux/hrtimer.h>

#include <linux/context_tracking_state.h>

#include <linux/cpumask.h>

#include <linux/sched.h>



/* ARM BL switcher abuse support */

#ifdef CONFIG_GENERIC_CLOCKEVENTS



enum tick_device_mode {

	TICKDEV_MODE_PERIODIC,

	TICKDEV_MODE_ONESHOT,
@@ -25,133 +22,38 @@ struct tick_device { 
	struct clock_event_device *evtdev;

	enum tick_device_mode mode;

};



enum tick_nohz_mode {

	NOHZ_MODE_INACTIVE,

	NOHZ_MODE_LOWRES,

	NOHZ_MODE_HIGHRES,

};



/**

 * struct tick_sched - sched tick emulation and no idle tick control/stats

 * @sched_timer:	hrtimer to schedule the periodic tick in high

 *			resolution mode

 * @last_tick:		Store the last tick expiry time when the tick

 *			timer is modified for nohz sleeps. This is necessary

 *			to resume the tick timer operation in the timeline

 *			when the CPU returns from nohz sleep.

 * @tick_stopped:	Indicator that the idle tick has been stopped

 * @idle_jiffies:	jiffies at the entry to idle for idle time accounting

 * @idle_calls:		Total number of idle calls

 * @idle_sleeps:	Number of idle calls, where the sched tick was stopped

 * @idle_entrytime:	Time when the idle call was entered

 * @idle_waketime:	Time when the idle was interrupted

 * @idle_exittime:	Time when the idle state was left

 * @idle_sleeptime:	Sum of the time slept in idle with sched tick stopped

 * @iowait_sleeptime:	Sum of the time slept in idle with sched tick stopped, with IO outstanding

 * @sleep_length:	Duration of the current idle sleep

 * @do_timer_lst:	CPU was the last one doing do_timer before going idle

 */

struct tick_sched {

	struct hrtimer			sched_timer;

	unsigned long			check_clocks;

	enum tick_nohz_mode		nohz_mode;

	ktime_t				last_tick;

	int				inidle;

	int				tick_stopped;

	unsigned long			idle_jiffies;

	unsigned long			idle_calls;

	unsigned long			idle_sleeps;

	int				idle_active;

	ktime_t				idle_entrytime;

	ktime_t				idle_waketime;

	ktime_t				idle_exittime;

	ktime_t				idle_sleeptime;

	ktime_t				iowait_sleeptime;

	ktime_t				sleep_length;

	unsigned long			last_jiffies;

	unsigned long			next_jiffies;

	ktime_t				idle_expires;

	int				do_timer_last;

};



extern void __init tick_init(void);

extern int tick_is_oneshot_available(void);

extern struct tick_device *tick_get_device(int cpu);

#endif



#ifdef CONFIG_GENERIC_CLOCKEVENTS

extern void __init tick_init(void);

extern void tick_freeze(void);

extern void tick_unfreeze(void);



# ifdef CONFIG_HIGH_RES_TIMERS

extern int tick_init_highres(void);

extern int tick_program_event(ktime_t expires, int force);

extern void tick_setup_sched_timer(void);

# endif



# if defined CONFIG_NO_HZ_COMMON || defined CONFIG_HIGH_RES_TIMERS

extern void tick_cancel_sched_timer(int cpu);

# else

static inline void tick_cancel_sched_timer(int cpu) { }

# endif



# ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST

extern struct tick_device *tick_get_broadcast_device(void);

extern struct cpumask *tick_get_broadcast_mask(void);



#  ifdef CONFIG_TICK_ONESHOT

extern struct cpumask *tick_get_broadcast_oneshot_mask(void);

#  endif



# endif /* BROADCAST */

#else /* CONFIG_GENERIC_CLOCKEVENTS */

static inline void tick_init(void) { }

static inline void tick_freeze(void) { }

static inline void tick_unfreeze(void) { }

#endif /* !CONFIG_GENERIC_CLOCKEVENTS */



#ifdef CONFIG_TICK_ONESHOT

extern void tick_clock_notify(void);

extern int tick_check_oneshot_change(int allow_nohz);

extern struct tick_sched *tick_get_tick_sched(int cpu);

extern void tick_irq_enter(void);

extern int tick_oneshot_mode_active(void);

#  ifndef arch_needs_cpu

#   define arch_needs_cpu() (0)

#  endif

# else

static inline void tick_clock_notify(void) { }

static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }

static inline void tick_irq_enter(void) { }

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

#endif



#else /* CONFIG_GENERIC_CLOCKEVENTS */

static inline void tick_init(void) { }

static inline void tick_freeze(void) { }

static inline void tick_unfreeze(void) { }

static inline void tick_cancel_sched_timer(int cpu) { }

static inline void tick_clock_notify(void) { }

static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }

static inline void tick_irq_enter(void) { }

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

#endif /* !CONFIG_GENERIC_CLOCKEVENTS */



#ifdef CONFIG_NO_HZ_COMMON

DECLARE_PER_CPU(struct tick_sched, tick_cpu_sched);



static inline int tick_nohz_tick_stopped(void)

{

	return __this_cpu_read(tick_cpu_sched.tick_stopped);

}



extern int tick_nohz_tick_stopped(void);

extern void tick_nohz_idle_enter(void);

extern void tick_nohz_idle_exit(void);

extern void tick_nohz_irq_exit(void);

extern ktime_t tick_nohz_get_sleep_length(void);

extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time);

extern u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time);



#else /* !CONFIG_NO_HZ_COMMON */

static inline int tick_nohz_tick_stopped(void)

{

	return 0;

}



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

static inline void tick_nohz_idle_enter(void) { }

static inline void tick_nohz_idle_exit(void) { }

kernel/time/clocksource.c

+1 −1
Original line number Diff line number Diff line
@@ -31,7 +31,7 @@ 
#include <linux/tick.h>

#include <linux/kthread.h>



#include "timekeeping.h"

#include "tick-internal.h"

#include "timekeeping_internal.h"



/**

kernel/time/hrtimer.c

+1 −1
Original line number Diff line number Diff line
@@ -54,7 +54,7 @@ 


#include <trace/events/timer.h>



#include "timekeeping.h"

#include "tick-internal.h"



/*

 * The timer bases:

kernel/time/tick-internal.h

+15 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
#include <linux/tick.h>



#include "timekeeping.h"

#include "tick-sched.h"



#ifdef CONFIG_GENERIC_CLOCKEVENTS
@@ -26,6 +27,7 @@ extern void tick_resume(void); 
extern bool tick_check_replacement(struct clock_event_device *curdev,

				   struct clock_event_device *newdev);

extern void tick_install_replacement(struct clock_event_device *dev);

extern int tick_is_oneshot_available(void);



extern int clockevents_tick_resume(struct clock_event_device *dev);

/* Check, if the device is functional or a dummy for broadcast */
@@ -35,6 +37,9 @@ static inline int tick_device_is_functional(struct clock_event_device *dev) 
}



extern void clockevents_shutdown(struct clock_event_device *dev);

extern void clockevents_exchange_device(struct clock_event_device *old,

					struct clock_event_device *new);

extern void clockevents_handle_noop(struct clock_event_device *dev);

extern int __clockevents_update_freq(struct clock_event_device *dev, u32 freq);

extern ssize_t sysfs_get_uname(const char *buf, char *dst, size_t cnt);

#endif /* GENERIC_CLOCKEVENTS */
@@ -49,6 +54,10 @@ extern void tick_oneshot_notify(void); 
extern int tick_switch_to_oneshot(void (*handler)(struct clock_event_device *));

extern void tick_resume_oneshot(void);

static inline bool tick_oneshot_possible(void) { return true; }

extern int tick_oneshot_mode_active(void);

extern void tick_clock_notify(void);

extern int tick_check_oneshot_change(int allow_nohz);

extern int tick_init_highres(void);

#else /* !ONESHOT */

static inline

void tick_setup_oneshot(struct clock_event_device *newdev,
@@ -58,6 +67,9 @@ static inline void tick_resume_oneshot(void) { BUG(); } 
static inline int tick_program_event(ktime_t expires, int force) { return 0; }

static inline void tick_oneshot_notify(void) { }

static inline bool tick_oneshot_possible(void) { return false; }

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

static inline void tick_clock_notify(void) { }

static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }

#endif /* !TICK_ONESHOT */



/* Broadcasting support */
@@ -72,6 +84,8 @@ extern int tick_resume_broadcast(void); 
extern void tick_broadcast_init(void);

extern void tick_set_periodic_handler(struct clock_event_device *dev, int broadcast);

extern int tick_broadcast_update_freq(struct clock_event_device *dev, u32 freq);

extern struct tick_device *tick_get_broadcast_device(void);

extern struct cpumask *tick_get_broadcast_mask(void);

#else /* !BROADCAST */

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; }
@@ -101,6 +115,7 @@ extern int tick_resume_broadcast_oneshot(struct clock_event_device *bc); 
extern int tick_broadcast_oneshot_active(void);

extern void tick_check_oneshot_broadcast_this_cpu(void);

bool tick_broadcast_oneshot_available(void);

extern struct cpumask *tick_get_broadcast_oneshot_mask(void);

#else /* BROADCAST && ONESHOT */

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