LCOV - code coverage report
Current view: top level - include/linux - tick.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 9 28 32.1 %
Date: 2022-03-28 16:04:14 Functions: 0 0 -
Branches: 0 2 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * Tick related global functions
       4                 :            :  */
       5                 :            : #ifndef _LINUX_TICK_H
       6                 :            : #define _LINUX_TICK_H
       7                 :            : 
       8                 :            : #include <linux/clockchips.h>
       9                 :            : #include <linux/irqflags.h>
      10                 :            : #include <linux/percpu.h>
      11                 :            : #include <linux/context_tracking_state.h>
      12                 :            : #include <linux/cpumask.h>
      13                 :            : #include <linux/sched.h>
      14                 :            : 
      15                 :            : #ifdef CONFIG_GENERIC_CLOCKEVENTS
      16                 :            : extern void __init tick_init(void);
      17                 :            : /* Should be core only, but ARM BL switcher requires it */
      18                 :            : extern void tick_suspend_local(void);
      19                 :            : /* Should be core only, but XEN resume magic and ARM BL switcher require it */
      20                 :            : extern void tick_resume_local(void);
      21                 :            : extern void tick_handover_do_timer(void);
      22                 :            : extern void tick_cleanup_dead_cpu(int cpu);
      23                 :            : #else /* CONFIG_GENERIC_CLOCKEVENTS */
      24                 :            : static inline void tick_init(void) { }
      25                 :            : static inline void tick_suspend_local(void) { }
      26                 :            : static inline void tick_resume_local(void) { }
      27                 :            : static inline void tick_handover_do_timer(void) { }
      28                 :            : static inline void tick_cleanup_dead_cpu(int cpu) { }
      29                 :            : #endif /* !CONFIG_GENERIC_CLOCKEVENTS */
      30                 :            : 
      31                 :            : #if defined(CONFIG_GENERIC_CLOCKEVENTS) && defined(CONFIG_SUSPEND)
      32                 :            : extern void tick_freeze(void);
      33                 :            : extern void tick_unfreeze(void);
      34                 :            : #else
      35                 :            : static inline void tick_freeze(void) { }
      36                 :            : static inline void tick_unfreeze(void) { }
      37                 :            : #endif
      38                 :            : 
      39                 :            : #ifdef CONFIG_TICK_ONESHOT
      40                 :            : extern void tick_irq_enter(void);
      41                 :            : #  ifndef arch_needs_cpu
      42                 :            : #   define arch_needs_cpu() (0)
      43                 :            : #  endif
      44                 :            : # else
      45                 :            : static inline void tick_irq_enter(void) { }
      46                 :            : #endif
      47                 :            : 
      48                 :            : #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
      49                 :            : extern void hotplug_cpu__broadcast_tick_pull(int dead_cpu);
      50                 :            : #else
      51                 :            : static inline void hotplug_cpu__broadcast_tick_pull(int dead_cpu) { }
      52                 :            : #endif
      53                 :            : 
      54                 :            : enum tick_broadcast_mode {
      55                 :            :         TICK_BROADCAST_OFF,
      56                 :            :         TICK_BROADCAST_ON,
      57                 :            :         TICK_BROADCAST_FORCE,
      58                 :            : };
      59                 :            : 
      60                 :            : enum tick_broadcast_state {
      61                 :            :         TICK_BROADCAST_EXIT,
      62                 :            :         TICK_BROADCAST_ENTER,
      63                 :            : };
      64                 :            : 
      65                 :            : #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
      66                 :            : extern void tick_broadcast_control(enum tick_broadcast_mode mode);
      67                 :            : #else
      68                 :            : static inline void tick_broadcast_control(enum tick_broadcast_mode mode) { }
      69                 :            : #endif /* BROADCAST */
      70                 :            : 
      71                 :            : #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_HOTPLUG_CPU)
      72                 :            : extern void tick_offline_cpu(unsigned int cpu);
      73                 :            : #else
      74                 :            : static inline void tick_offline_cpu(unsigned int cpu) { }
      75                 :            : #endif
      76                 :            : 
      77                 :            : #ifdef CONFIG_GENERIC_CLOCKEVENTS
      78                 :            : extern int tick_broadcast_oneshot_control(enum tick_broadcast_state state);
      79                 :            : #else
      80                 :            : static inline int tick_broadcast_oneshot_control(enum tick_broadcast_state state)
      81                 :            : {
      82                 :            :         return 0;
      83                 :            : }
      84                 :            : #endif
      85                 :            : 
      86                 :          0 : static inline void tick_broadcast_enable(void)
      87                 :            : {
      88                 :          0 :         tick_broadcast_control(TICK_BROADCAST_ON);
      89                 :          0 : }
      90                 :          0 : static inline void tick_broadcast_disable(void)
      91                 :            : {
      92                 :          0 :         tick_broadcast_control(TICK_BROADCAST_OFF);
      93                 :          0 : }
      94                 :          0 : static inline void tick_broadcast_force(void)
      95                 :            : {
      96                 :          0 :         tick_broadcast_control(TICK_BROADCAST_FORCE);
      97                 :            : }
      98                 :          0 : static inline int tick_broadcast_enter(void)
      99                 :            : {
     100                 :          0 :         return tick_broadcast_oneshot_control(TICK_BROADCAST_ENTER);
     101                 :            : }
     102                 :          0 : static inline void tick_broadcast_exit(void)
     103                 :            : {
     104                 :          0 :         tick_broadcast_oneshot_control(TICK_BROADCAST_EXIT);
     105                 :          0 : }
     106                 :            : 
     107                 :            : enum tick_dep_bits {
     108                 :            :         TICK_DEP_BIT_POSIX_TIMER        = 0,
     109                 :            :         TICK_DEP_BIT_PERF_EVENTS        = 1,
     110                 :            :         TICK_DEP_BIT_SCHED              = 2,
     111                 :            :         TICK_DEP_BIT_CLOCK_UNSTABLE     = 3,
     112                 :            :         TICK_DEP_BIT_RCU                = 4,
     113                 :            :         TICK_DEP_BIT_RCU_EXP            = 5
     114                 :            : };
     115                 :            : #define TICK_DEP_BIT_MAX TICK_DEP_BIT_RCU_EXP
     116                 :            : 
     117                 :            : #define TICK_DEP_MASK_NONE              0
     118                 :            : #define TICK_DEP_MASK_POSIX_TIMER       (1 << TICK_DEP_BIT_POSIX_TIMER)
     119                 :            : #define TICK_DEP_MASK_PERF_EVENTS       (1 << TICK_DEP_BIT_PERF_EVENTS)
     120                 :            : #define TICK_DEP_MASK_SCHED             (1 << TICK_DEP_BIT_SCHED)
     121                 :            : #define TICK_DEP_MASK_CLOCK_UNSTABLE    (1 << TICK_DEP_BIT_CLOCK_UNSTABLE)
     122                 :            : #define TICK_DEP_MASK_RCU               (1 << TICK_DEP_BIT_RCU)
     123                 :            : #define TICK_DEP_MASK_RCU_EXP           (1 << TICK_DEP_BIT_RCU_EXP)
     124                 :            : 
     125                 :            : #ifdef CONFIG_NO_HZ_COMMON
     126                 :            : extern bool tick_nohz_enabled;
     127                 :            : extern bool tick_nohz_tick_stopped(void);
     128                 :            : extern bool tick_nohz_tick_stopped_cpu(int cpu);
     129                 :            : extern void tick_nohz_idle_stop_tick(void);
     130                 :            : extern void tick_nohz_idle_retain_tick(void);
     131                 :            : extern void tick_nohz_idle_restart_tick(void);
     132                 :            : extern void tick_nohz_idle_enter(void);
     133                 :            : extern void tick_nohz_idle_exit(void);
     134                 :            : extern void tick_nohz_irq_exit(void);
     135                 :            : extern bool tick_nohz_idle_got_tick(void);
     136                 :            : extern ktime_t tick_nohz_get_next_hrtimer(void);
     137                 :            : extern ktime_t tick_nohz_get_sleep_length(ktime_t *delta_next);
     138                 :            : extern unsigned long tick_nohz_get_idle_calls(void);
     139                 :            : extern unsigned long tick_nohz_get_idle_calls_cpu(int cpu);
     140                 :            : extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time);
     141                 :            : extern u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time);
     142                 :            : 
     143                 :            : static inline void tick_nohz_idle_stop_tick_protected(void)
     144                 :            : {
     145                 :            :         local_irq_disable();
     146                 :            :         tick_nohz_idle_stop_tick();
     147                 :            :         local_irq_enable();
     148                 :            : }
     149                 :            : 
     150                 :            : #else /* !CONFIG_NO_HZ_COMMON */
     151                 :            : #define tick_nohz_enabled (0)
     152                 :            : static inline int tick_nohz_tick_stopped(void) { return 0; }
     153                 :            : static inline int tick_nohz_tick_stopped_cpu(int cpu) { return 0; }
     154                 :            : static inline void tick_nohz_idle_stop_tick(void) { }
     155                 :            : static inline void tick_nohz_idle_retain_tick(void) { }
     156                 :            : static inline void tick_nohz_idle_restart_tick(void) { }
     157                 :            : static inline void tick_nohz_idle_enter(void) { }
     158                 :            : static inline void tick_nohz_idle_exit(void) { }
     159                 :            : static inline bool tick_nohz_idle_got_tick(void) { return false; }
     160                 :            : static inline ktime_t tick_nohz_get_next_hrtimer(void)
     161                 :            : {
     162                 :            :         /* Next wake up is the tick period, assume it starts now */
     163                 :            :         return ktime_add(ktime_get(), TICK_NSEC);
     164                 :            : }
     165                 :            : static inline ktime_t tick_nohz_get_sleep_length(ktime_t *delta_next)
     166                 :            : {
     167                 :            :         *delta_next = TICK_NSEC;
     168                 :            :         return *delta_next;
     169                 :            : }
     170                 :            : static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; }
     171                 :            : static inline u64 get_cpu_iowait_time_us(int cpu, u64 *unused) { return -1; }
     172                 :            : 
     173                 :            : static inline void tick_nohz_idle_stop_tick_protected(void) { }
     174                 :            : #endif /* !CONFIG_NO_HZ_COMMON */
     175                 :            : 
     176                 :            : #ifdef CONFIG_NO_HZ_FULL
     177                 :            : extern bool tick_nohz_full_running;
     178                 :            : extern cpumask_var_t tick_nohz_full_mask;
     179                 :            : 
     180                 :            : static inline bool tick_nohz_full_enabled(void)
     181                 :            : {
     182                 :            :         if (!context_tracking_enabled())
     183                 :            :                 return false;
     184                 :            : 
     185                 :            :         return tick_nohz_full_running;
     186                 :            : }
     187                 :            : 
     188                 :            : static inline bool tick_nohz_full_cpu(int cpu)
     189                 :            : {
     190                 :            :         if (!tick_nohz_full_enabled())
     191                 :            :                 return false;
     192                 :            : 
     193                 :            :         return cpumask_test_cpu(cpu, tick_nohz_full_mask);
     194                 :            : }
     195                 :            : 
     196                 :            : static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask)
     197                 :            : {
     198                 :            :         if (tick_nohz_full_enabled())
     199                 :            :                 cpumask_or(mask, mask, tick_nohz_full_mask);
     200                 :            : }
     201                 :            : 
     202                 :            : extern void tick_nohz_dep_set(enum tick_dep_bits bit);
     203                 :            : extern void tick_nohz_dep_clear(enum tick_dep_bits bit);
     204                 :            : extern void tick_nohz_dep_set_cpu(int cpu, enum tick_dep_bits bit);
     205                 :            : extern void tick_nohz_dep_clear_cpu(int cpu, enum tick_dep_bits bit);
     206                 :            : extern void tick_nohz_dep_set_task(struct task_struct *tsk,
     207                 :            :                                    enum tick_dep_bits bit);
     208                 :            : extern void tick_nohz_dep_clear_task(struct task_struct *tsk,
     209                 :            :                                      enum tick_dep_bits bit);
     210                 :            : extern void tick_nohz_dep_set_signal(struct signal_struct *signal,
     211                 :            :                                      enum tick_dep_bits bit);
     212                 :            : extern void tick_nohz_dep_clear_signal(struct signal_struct *signal,
     213                 :            :                                        enum tick_dep_bits bit);
     214                 :            : 
     215                 :            : /*
     216                 :            :  * The below are tick_nohz_[set,clear]_dep() wrappers that optimize off-cases
     217                 :            :  * on top of static keys.
     218                 :            :  */
     219                 :            : static inline void tick_dep_set(enum tick_dep_bits bit)
     220                 :            : {
     221                 :            :         if (tick_nohz_full_enabled())
     222                 :            :                 tick_nohz_dep_set(bit);
     223                 :            : }
     224                 :            : 
     225                 :            : static inline void tick_dep_clear(enum tick_dep_bits bit)
     226                 :            : {
     227                 :            :         if (tick_nohz_full_enabled())
     228                 :            :                 tick_nohz_dep_clear(bit);
     229                 :            : }
     230                 :            : 
     231                 :            : static inline void tick_dep_set_cpu(int cpu, enum tick_dep_bits bit)
     232                 :            : {
     233                 :            :         if (tick_nohz_full_cpu(cpu))
     234                 :            :                 tick_nohz_dep_set_cpu(cpu, bit);
     235                 :            : }
     236                 :            : 
     237                 :            : static inline void tick_dep_clear_cpu(int cpu, enum tick_dep_bits bit)
     238                 :            : {
     239                 :            :         if (tick_nohz_full_cpu(cpu))
     240                 :            :                 tick_nohz_dep_clear_cpu(cpu, bit);
     241                 :            : }
     242                 :            : 
     243                 :            : static inline void tick_dep_set_task(struct task_struct *tsk,
     244                 :            :                                      enum tick_dep_bits bit)
     245                 :            : {
     246                 :            :         if (tick_nohz_full_enabled())
     247                 :            :                 tick_nohz_dep_set_task(tsk, bit);
     248                 :            : }
     249                 :            : static inline void tick_dep_clear_task(struct task_struct *tsk,
     250                 :            :                                        enum tick_dep_bits bit)
     251                 :            : {
     252                 :            :         if (tick_nohz_full_enabled())
     253                 :            :                 tick_nohz_dep_clear_task(tsk, bit);
     254                 :            : }
     255                 :            : static inline void tick_dep_set_signal(struct signal_struct *signal,
     256                 :            :                                        enum tick_dep_bits bit)
     257                 :            : {
     258                 :            :         if (tick_nohz_full_enabled())
     259                 :            :                 tick_nohz_dep_set_signal(signal, bit);
     260                 :            : }
     261                 :            : static inline void tick_dep_clear_signal(struct signal_struct *signal,
     262                 :            :                                          enum tick_dep_bits bit)
     263                 :            : {
     264                 :            :         if (tick_nohz_full_enabled())
     265                 :            :                 tick_nohz_dep_clear_signal(signal, bit);
     266                 :            : }
     267                 :            : 
     268                 :            : extern void tick_nohz_full_kick_cpu(int cpu);
     269                 :            : extern void __tick_nohz_task_switch(void);
     270                 :            : extern void __init tick_nohz_full_setup(cpumask_var_t cpumask);
     271                 :            : #else
     272                 :     125453 : static inline bool tick_nohz_full_enabled(void) { return false; }
     273         [ #  # ]:          0 : static inline bool tick_nohz_full_cpu(int cpu) { return false; }
     274                 :            : static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask) { }
     275                 :            : 
     276                 :            : static inline void tick_nohz_dep_set_cpu(int cpu, enum tick_dep_bits bit) { }
     277                 :            : static inline void tick_nohz_dep_clear_cpu(int cpu, enum tick_dep_bits bit) { }
     278                 :            : 
     279                 :          0 : static inline void tick_dep_set(enum tick_dep_bits bit) { }
     280                 :         13 : static inline void tick_dep_clear(enum tick_dep_bits bit) { }
     281                 :          0 : static inline void tick_dep_set_cpu(int cpu, enum tick_dep_bits bit) { }
     282                 :      34686 : static inline void tick_dep_clear_cpu(int cpu, enum tick_dep_bits bit) { }
     283                 :     102892 : static inline void tick_dep_set_task(struct task_struct *tsk,
     284                 :     102892 :                                      enum tick_dep_bits bit) { }
     285                 :     102892 : static inline void tick_dep_clear_task(struct task_struct *tsk,
     286                 :     102892 :                                        enum tick_dep_bits bit) { }
     287                 :          0 : static inline void tick_dep_set_signal(struct signal_struct *signal,
     288                 :            :                                        enum tick_dep_bits bit) { }
     289                 :          0 : static inline void tick_dep_clear_signal(struct signal_struct *signal,
     290                 :          0 :                                          enum tick_dep_bits bit) { }
     291                 :            : 
     292                 :            : static inline void tick_nohz_full_kick_cpu(int cpu) { }
     293                 :            : static inline void __tick_nohz_task_switch(void) { }
     294                 :            : static inline void tick_nohz_full_setup(cpumask_var_t cpumask) { }
     295                 :            : #endif
     296                 :            : 
     297                 :     125440 : static inline void tick_nohz_task_switch(void)
     298                 :            : {
     299                 :     125440 :         if (tick_nohz_full_enabled())
     300                 :            :                 __tick_nohz_task_switch();
     301                 :            : }
     302                 :            : 
     303                 :            : #endif

Generated by: LCOV version 1.14