lkml.org 
[lkml]   [2015]   [Mar]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 04/09] tick: Move core only declarations and functions to core
    Date
    From: Thomas Gleixner <tglx@linutronix.de>

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

    Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
    Cc: Nicolas Pitre <nico@linaro.org>
    [ rjw: Rebased on top of 4.0-rc5 ]
    Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
    ---
    include/linux/clockchips.h | 15 +---
    include/linux/tick.h | 134 +++++---------------------------------------
    kernel/time/clocksource.c | 2
    kernel/time/hrtimer.c | 2
    kernel/time/tick-internal.h | 15 ++++
    kernel/time/tick-sched.c | 7 +-
    kernel/time/tick-sched.h | 64 +++++++++++++++++++++
    kernel/time/timer_list.c | 2
    8 files changed, 112 insertions(+), 129 deletions(-)

    Index: linux-pm/include/linux/clockchips.h
    ===================================================================
    --- linux-pm.orig/include/linux/clockchips.h
    +++ linux-pm/include/linux/clockchips.h
    @@ -158,15 +158,6 @@ extern void clockevents_config_and_regis

    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_mode(struct clock_event_device *dev,
    - enum clock_event_mode mode);
    -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)
    {
    @@ -174,6 +165,12 @@ clockevents_calc_mult_shift(struct clock
    freq, minsec);
    }

    +/* Should be core only, but is abused by arm bl_switcher */
    +extern void clockevents_set_mode(struct clock_event_device *dev,
    + enum clock_event_mode mode);
    +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);

    Index: linux-pm/include/linux/tick.h
    ===================================================================
    --- linux-pm.orig/include/linux/tick.h
    +++ linux-pm/include/linux/tick.h
    @@ -1,7 +1,5 @@
    -/* 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);
    +#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_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 */
    -
    -# 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);
    +#ifdef CONFIG_TICK_ONESHOT
    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);
    -}
    +#endif

    +#ifdef CONFIG_NO_HZ_COMMON
    +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;
    -}
    -
    +#else /* !CONFIG_NO_HZ_COMMON */
    +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) { }

    @@ -163,7 +65,7 @@ static inline ktime_t tick_nohz_get_slee
    }
    static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; }
    static inline u64 get_cpu_iowait_time_us(int cpu, u64 *unused) { return -1; }
    -# endif /* !CONFIG_NO_HZ_COMMON */
    +#endif /* !CONFIG_NO_HZ_COMMON */

    #ifdef CONFIG_NO_HZ_FULL
    extern bool tick_nohz_full_running;
    Index: linux-pm/kernel/time/clocksource.c
    ===================================================================
    --- linux-pm.orig/kernel/time/clocksource.c
    +++ linux-pm/kernel/time/clocksource.c
    @@ -31,7 +31,7 @@
    #include <linux/tick.h>
    #include <linux/kthread.h>

    -#include "timekeeping.h"
    +#include "tick-internal.h"
    #include "timekeeping_internal.h"

    /**
    Index: linux-pm/kernel/time/hrtimer.c
    ===================================================================
    --- linux-pm.orig/kernel/time/hrtimer.c
    +++ linux-pm/kernel/time/hrtimer.c
    @@ -54,7 +54,7 @@

    #include <trace/events/timer.h>

    -#include "timekeeping.h"
    +#include "tick-internal.h"

    /*
    * The timer bases:
    Index: linux-pm/kernel/time/tick-internal.h
    ===================================================================
    --- linux-pm.orig/kernel/time/tick-internal.h
    +++ linux-pm/kernel/time/tick-internal.h
    @@ -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);

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

    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 */
    @@ -48,6 +53,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,
    @@ -57,6 +66,9 @@ static inline void tick_resume_oneshot(v
    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 */
    @@ -71,6 +83,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; }
    @@ -100,6 +114,7 @@ extern int tick_resume_broadcast_oneshot
    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; }
    Index: linux-pm/kernel/time/tick-sched.c
    ===================================================================
    --- linux-pm.orig/kernel/time/tick-sched.c
    +++ linux-pm/kernel/time/tick-sched.c
    @@ -34,7 +34,7 @@
    /*
    * Per cpu nohz control structure
    */
    -DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);
    +static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);

    /*
    * The time, when the last jiffy update happened. Protected by jiffies_lock.
    @@ -416,6 +416,11 @@ static int __init setup_tick_nohz(char *

    __setup("nohz=", setup_tick_nohz);

    +int tick_nohz_tick_stopped(void)
    +{
    + return __this_cpu_read(tick_cpu_sched.tick_stopped);
    +}
    +
    /**
    * tick_nohz_update_jiffies - update jiffies when idle was interrupted
    *
    Index: linux-pm/kernel/time/tick-sched.h
    ===================================================================
    --- /dev/null
    +++ linux-pm/kernel/time/tick-sched.h
    @@ -0,0 +1,64 @@
    +#ifndef _TICK_SCHED_H
    +#define _TICK_SCHED_H
    +
    +#include <linux/hrtimer.h>
    +
    +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 struct tick_sched *tick_get_tick_sched(int cpu);
    +
    +extern void tick_setup_sched_timer(void);
    +#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
    +
    +#endif
    Index: linux-pm/kernel/time/timer_list.c
    ===================================================================
    --- linux-pm.orig/kernel/time/timer_list.c
    +++ linux-pm/kernel/time/timer_list.c
    @@ -16,10 +16,10 @@
    #include <linux/sched.h>
    #include <linux/seq_file.h>
    #include <linux/kallsyms.h>
    -#include <linux/tick.h>

    #include <asm/uaccess.h>

    +#include "tick-internal.h"

    struct timer_list_iter {
    int cpu;


    \
     
     \ /
      Last update: 2015-03-25 13:01    [W:4.452 / U:0.108 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site