LCOV - code coverage report
Current view: top level - kernel/sched - sched.h (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 89 144 61.8 %
Date: 2020-09-30 20:25:40 Functions: 8 14 57.1 %
Branches: 63 170 37.1 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * Scheduler internal types and methods:
       4                 :            :  */
       5                 :            : #include <linux/sched.h>
       6                 :            : 
       7                 :            : #include <linux/sched/autogroup.h>
       8                 :            : #include <linux/sched/clock.h>
       9                 :            : #include <linux/sched/coredump.h>
      10                 :            : #include <linux/sched/cpufreq.h>
      11                 :            : #include <linux/sched/cputime.h>
      12                 :            : #include <linux/sched/deadline.h>
      13                 :            : #include <linux/sched/debug.h>
      14                 :            : #include <linux/sched/hotplug.h>
      15                 :            : #include <linux/sched/idle.h>
      16                 :            : #include <linux/sched/init.h>
      17                 :            : #include <linux/sched/isolation.h>
      18                 :            : #include <linux/sched/jobctl.h>
      19                 :            : #include <linux/sched/loadavg.h>
      20                 :            : #include <linux/sched/mm.h>
      21                 :            : #include <linux/sched/nohz.h>
      22                 :            : #include <linux/sched/numa_balancing.h>
      23                 :            : #include <linux/sched/prio.h>
      24                 :            : #include <linux/sched/rt.h>
      25                 :            : #include <linux/sched/signal.h>
      26                 :            : #include <linux/sched/smt.h>
      27                 :            : #include <linux/sched/stat.h>
      28                 :            : #include <linux/sched/sysctl.h>
      29                 :            : #include <linux/sched/task.h>
      30                 :            : #include <linux/sched/task_stack.h>
      31                 :            : #include <linux/sched/topology.h>
      32                 :            : #include <linux/sched/user.h>
      33                 :            : #include <linux/sched/wake_q.h>
      34                 :            : #include <linux/sched/xacct.h>
      35                 :            : 
      36                 :            : #include <uapi/linux/sched/types.h>
      37                 :            : 
      38                 :            : #include <linux/binfmts.h>
      39                 :            : #include <linux/blkdev.h>
      40                 :            : #include <linux/compat.h>
      41                 :            : #include <linux/context_tracking.h>
      42                 :            : #include <linux/cpufreq.h>
      43                 :            : #include <linux/cpuidle.h>
      44                 :            : #include <linux/cpuset.h>
      45                 :            : #include <linux/ctype.h>
      46                 :            : #include <linux/debugfs.h>
      47                 :            : #include <linux/delayacct.h>
      48                 :            : #include <linux/energy_model.h>
      49                 :            : #include <linux/init_task.h>
      50                 :            : #include <linux/kprobes.h>
      51                 :            : #include <linux/kthread.h>
      52                 :            : #include <linux/membarrier.h>
      53                 :            : #include <linux/migrate.h>
      54                 :            : #include <linux/mmu_context.h>
      55                 :            : #include <linux/nmi.h>
      56                 :            : #include <linux/proc_fs.h>
      57                 :            : #include <linux/prefetch.h>
      58                 :            : #include <linux/profile.h>
      59                 :            : #include <linux/psi.h>
      60                 :            : #include <linux/rcupdate_wait.h>
      61                 :            : #include <linux/security.h>
      62                 :            : #include <linux/stop_machine.h>
      63                 :            : #include <linux/suspend.h>
      64                 :            : #include <linux/swait.h>
      65                 :            : #include <linux/syscalls.h>
      66                 :            : #include <linux/task_work.h>
      67                 :            : #include <linux/tsacct_kern.h>
      68                 :            : 
      69                 :            : #include <asm/tlb.h>
      70                 :            : 
      71                 :            : #ifdef CONFIG_PARAVIRT
      72                 :            : # include <asm/paravirt.h>
      73                 :            : #endif
      74                 :            : 
      75                 :            : #include "cpupri.h"
      76                 :            : #include "cpudeadline.h"
      77                 :            : 
      78                 :            : #ifdef CONFIG_SCHED_DEBUG
      79                 :            : # define SCHED_WARN_ON(x)       WARN_ONCE(x, #x)
      80                 :            : #else
      81                 :            : # define SCHED_WARN_ON(x)       ({ (void)(x), 0; })
      82                 :            : #endif
      83                 :            : 
      84                 :            : struct rq;
      85                 :            : struct cpuidle_state;
      86                 :            : 
      87                 :            : /* task_struct::on_rq states: */
      88                 :            : #define TASK_ON_RQ_QUEUED       1
      89                 :            : #define TASK_ON_RQ_MIGRATING    2
      90                 :            : 
      91                 :            : extern __read_mostly int scheduler_running;
      92                 :            : 
      93                 :            : extern unsigned long calc_load_update;
      94                 :            : extern atomic_long_t calc_load_tasks;
      95                 :            : 
      96                 :            : extern void calc_global_load_tick(struct rq *this_rq);
      97                 :            : extern long calc_load_fold_active(struct rq *this_rq, long adjust);
      98                 :            : 
      99                 :            : /*
     100                 :            :  * Helpers for converting nanosecond timing to jiffy resolution
     101                 :            :  */
     102                 :            : #define NS_TO_JIFFIES(TIME)     ((unsigned long)(TIME) / (NSEC_PER_SEC / HZ))
     103                 :            : 
     104                 :            : /*
     105                 :            :  * Increase resolution of nice-level calculations for 64-bit architectures.
     106                 :            :  * The extra resolution improves shares distribution and load balancing of
     107                 :            :  * low-weight task groups (eg. nice +19 on an autogroup), deeper taskgroup
     108                 :            :  * hierarchies, especially on larger systems. This is not a user-visible change
     109                 :            :  * and does not change the user-interface for setting shares/weights.
     110                 :            :  *
     111                 :            :  * We increase resolution only if we have enough bits to allow this increased
     112                 :            :  * resolution (i.e. 64-bit). The costs for increasing resolution when 32-bit
     113                 :            :  * are pretty high and the returns do not justify the increased costs.
     114                 :            :  *
     115                 :            :  * Really only required when CONFIG_FAIR_GROUP_SCHED=y is also set, but to
     116                 :            :  * increase coverage and consistency always enable it on 64-bit platforms.
     117                 :            :  */
     118                 :            : #ifdef CONFIG_64BIT
     119                 :            : # define NICE_0_LOAD_SHIFT      (SCHED_FIXEDPOINT_SHIFT + SCHED_FIXEDPOINT_SHIFT)
     120                 :            : # define scale_load(w)          ((w) << SCHED_FIXEDPOINT_SHIFT)
     121                 :            : # define scale_load_down(w) \
     122                 :            : ({ \
     123                 :            :         unsigned long __w = (w); \
     124                 :            :         if (__w) \
     125                 :            :                 __w = max(2UL, __w >> SCHED_FIXEDPOINT_SHIFT); \
     126                 :            :         __w; \
     127                 :            : })
     128                 :            : #else
     129                 :            : # define NICE_0_LOAD_SHIFT      (SCHED_FIXEDPOINT_SHIFT)
     130                 :            : # define scale_load(w)          (w)
     131                 :            : # define scale_load_down(w)     (w)
     132                 :            : #endif
     133                 :            : 
     134                 :            : /*
     135                 :            :  * Task weight (visible to users) and its load (invisible to users) have
     136                 :            :  * independent resolution, but they should be well calibrated. We use
     137                 :            :  * scale_load() and scale_load_down(w) to convert between them. The
     138                 :            :  * following must be true:
     139                 :            :  *
     140                 :            :  *  scale_load(sched_prio_to_weight[USER_PRIO(NICE_TO_PRIO(0))]) == NICE_0_LOAD
     141                 :            :  *
     142                 :            :  */
     143                 :            : #define NICE_0_LOAD             (1L << NICE_0_LOAD_SHIFT)
     144                 :            : 
     145                 :            : /*
     146                 :            :  * Single value that decides SCHED_DEADLINE internal math precision.
     147                 :            :  * 10 -> just above 1us
     148                 :            :  * 9  -> just above 0.5us
     149                 :            :  */
     150                 :            : #define DL_SCALE                10
     151                 :            : 
     152                 :            : /*
     153                 :            :  * Single value that denotes runtime == period, ie unlimited time.
     154                 :            :  */
     155                 :            : #define RUNTIME_INF             ((u64)~0ULL)
     156                 :            : 
     157                 :            : static inline int idle_policy(int policy)
     158                 :            : {
     159                 :   21236031 :         return policy == SCHED_IDLE;
     160                 :            : }
     161                 :            : static inline int fair_policy(int policy)
     162                 :            : {
     163                 :      45221 :         return policy == SCHED_NORMAL || policy == SCHED_BATCH;
     164                 :            : }
     165                 :            : 
     166                 :            : static inline int rt_policy(int policy)
     167                 :            : {
     168                 :      43844 :         return policy == SCHED_FIFO || policy == SCHED_RR;
     169                 :            : }
     170                 :            : 
     171                 :            : static inline int dl_policy(int policy)
     172                 :            : {
     173                 :            :         return policy == SCHED_DEADLINE;
     174                 :            : }
     175                 :            : static inline bool valid_policy(int policy)
     176                 :            : {
     177   [ +  +  -  + ]:      46670 :         return idle_policy(policy) || fair_policy(policy) ||
     178   [ +  -  #  # ]:      22714 :                 rt_policy(policy) || dl_policy(policy);
     179                 :            : }
     180                 :            : 
     181                 :            : static inline int task_has_idle_policy(struct task_struct *p)
     182                 :            : {
     183                 :   21245768 :         return idle_policy(p->policy);
     184                 :            : }
     185                 :            : 
     186                 :            : static inline int task_has_rt_policy(struct task_struct *p)
     187                 :            : {
     188                 :        828 :         return rt_policy(p->policy);
     189                 :            : }
     190                 :            : 
     191                 :            : static inline int task_has_dl_policy(struct task_struct *p)
     192                 :            : {
     193                 :      26934 :         return dl_policy(p->policy);
     194                 :            : }
     195                 :            : 
     196                 :            : #define cap_scale(v, s) ((v)*(s) >> SCHED_CAPACITY_SHIFT)
     197                 :            : 
     198                 :            : /*
     199                 :            :  * !! For sched_setattr_nocheck() (kernel) only !!
     200                 :            :  *
     201                 :            :  * This is actually gross. :(
     202                 :            :  *
     203                 :            :  * It is used to make schedutil kworker(s) higher priority than SCHED_DEADLINE
     204                 :            :  * tasks, but still be able to sleep. We need this on platforms that cannot
     205                 :            :  * atomically change clock frequency. Remove once fast switching will be
     206                 :            :  * available on such platforms.
     207                 :            :  *
     208                 :            :  * SUGOV stands for SchedUtil GOVernor.
     209                 :            :  */
     210                 :            : #define SCHED_FLAG_SUGOV        0x10000000
     211                 :            : 
     212                 :            : static inline bool dl_entity_is_special(struct sched_dl_entity *dl_se)
     213                 :            : {
     214                 :            : #ifdef CONFIG_CPU_FREQ_GOV_SCHEDUTIL
     215                 :          0 :         return unlikely(dl_se->flags & SCHED_FLAG_SUGOV);
     216                 :            : #else
     217                 :            :         return false;
     218                 :            : #endif
     219                 :            : }
     220                 :            : 
     221                 :            : /*
     222                 :            :  * Tells if entity @a should preempt entity @b.
     223                 :            :  */
     224                 :            : static inline bool
     225                 :            : dl_entity_preempt(struct sched_dl_entity *a, struct sched_dl_entity *b)
     226                 :            : {
     227   [ #  #  #  #  :          0 :         return dl_entity_is_special(a) ||
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     228                 :          0 :                dl_time_before(a->deadline, b->deadline);
     229                 :            : }
     230                 :            : 
     231                 :            : /*
     232                 :            :  * This is the priority-queue data structure of the RT scheduling class:
     233                 :            :  */
     234                 :            : struct rt_prio_array {
     235                 :            :         DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); /* include 1 bit for delimiter */
     236                 :            :         struct list_head queue[MAX_RT_PRIO];
     237                 :            : };
     238                 :            : 
     239                 :            : struct rt_bandwidth {
     240                 :            :         /* nests inside the rq lock: */
     241                 :            :         raw_spinlock_t          rt_runtime_lock;
     242                 :            :         ktime_t                 rt_period;
     243                 :            :         u64                     rt_runtime;
     244                 :            :         struct hrtimer          rt_period_timer;
     245                 :            :         unsigned int            rt_period_active;
     246                 :            : };
     247                 :            : 
     248                 :            : void __dl_clear_params(struct task_struct *p);
     249                 :            : 
     250                 :            : /*
     251                 :            :  * To keep the bandwidth of -deadline tasks and groups under control
     252                 :            :  * we need some place where:
     253                 :            :  *  - store the maximum -deadline bandwidth of the system (the group);
     254                 :            :  *  - cache the fraction of that bandwidth that is currently allocated.
     255                 :            :  *
     256                 :            :  * This is all done in the data structure below. It is similar to the
     257                 :            :  * one used for RT-throttling (rt_bandwidth), with the main difference
     258                 :            :  * that, since here we are only interested in admission control, we
     259                 :            :  * do not decrease any runtime while the group "executes", neither we
     260                 :            :  * need a timer to replenish it.
     261                 :            :  *
     262                 :            :  * With respect to SMP, the bandwidth is given on a per-CPU basis,
     263                 :            :  * meaning that:
     264                 :            :  *  - dl_bw (< 100%) is the bandwidth of the system (group) on each CPU;
     265                 :            :  *  - dl_total_bw array contains, in the i-eth element, the currently
     266                 :            :  *    allocated bandwidth on the i-eth CPU.
     267                 :            :  * Moreover, groups consume bandwidth on each CPU, while tasks only
     268                 :            :  * consume bandwidth on the CPU they're running on.
     269                 :            :  * Finally, dl_total_bw_cpu is used to cache the index of dl_total_bw
     270                 :            :  * that will be shown the next time the proc or cgroup controls will
     271                 :            :  * be red. It on its turn can be changed by writing on its own
     272                 :            :  * control.
     273                 :            :  */
     274                 :            : struct dl_bandwidth {
     275                 :            :         raw_spinlock_t          dl_runtime_lock;
     276                 :            :         u64                     dl_runtime;
     277                 :            :         u64                     dl_period;
     278                 :            : };
     279                 :            : 
     280                 :            : static inline int dl_bandwidth_enabled(void)
     281                 :            : {
     282                 :        207 :         return sysctl_sched_rt_runtime >= 0;
     283                 :            : }
     284                 :            : 
     285                 :            : struct dl_bw {
     286                 :            :         raw_spinlock_t          lock;
     287                 :            :         u64                     bw;
     288                 :            :         u64                     total_bw;
     289                 :            : };
     290                 :            : 
     291                 :            : static inline void __dl_update(struct dl_bw *dl_b, s64 bw);
     292                 :            : 
     293                 :            : static inline
     294                 :            : void __dl_sub(struct dl_bw *dl_b, u64 tsk_bw, int cpus)
     295                 :            : {
     296                 :          0 :         dl_b->total_bw -= tsk_bw;
     297                 :          0 :         __dl_update(dl_b, (s32)tsk_bw / cpus);
     298                 :            : }
     299                 :            : 
     300                 :            : static inline
     301                 :            : void __dl_add(struct dl_bw *dl_b, u64 tsk_bw, int cpus)
     302                 :            : {
     303                 :          0 :         dl_b->total_bw += tsk_bw;
     304                 :          0 :         __dl_update(dl_b, -((s32)tsk_bw / cpus));
     305                 :            : }
     306                 :            : 
     307                 :            : static inline
     308                 :            : bool __dl_overflow(struct dl_bw *dl_b, int cpus, u64 old_bw, u64 new_bw)
     309                 :            : {
     310   [ #  #  #  #  :          0 :         return dl_b->bw != -1 &&
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     311                 :          0 :                dl_b->bw * cpus < dl_b->total_bw - old_bw + new_bw;
     312                 :            : }
     313                 :            : 
     314                 :            : extern void dl_change_utilization(struct task_struct *p, u64 new_bw);
     315                 :            : extern void init_dl_bw(struct dl_bw *dl_b);
     316                 :            : extern int  sched_dl_global_validate(void);
     317                 :            : extern void sched_dl_do_global(void);
     318                 :            : extern int  sched_dl_overflow(struct task_struct *p, int policy, const struct sched_attr *attr);
     319                 :            : extern void __setparam_dl(struct task_struct *p, const struct sched_attr *attr);
     320                 :            : extern void __getparam_dl(struct task_struct *p, struct sched_attr *attr);
     321                 :            : extern bool __checkparam_dl(const struct sched_attr *attr);
     322                 :            : extern bool dl_param_changed(struct task_struct *p, const struct sched_attr *attr);
     323                 :            : extern int  dl_task_can_attach(struct task_struct *p, const struct cpumask *cs_cpus_allowed);
     324                 :            : extern int  dl_cpuset_cpumask_can_shrink(const struct cpumask *cur, const struct cpumask *trial);
     325                 :            : extern bool dl_cpu_busy(unsigned int cpu);
     326                 :            : 
     327                 :            : #ifdef CONFIG_CGROUP_SCHED
     328                 :            : 
     329                 :            : #include <linux/cgroup.h>
     330                 :            : #include <linux/psi.h>
     331                 :            : 
     332                 :            : struct cfs_rq;
     333                 :            : struct rt_rq;
     334                 :            : 
     335                 :            : extern struct list_head task_groups;
     336                 :            : 
     337                 :            : struct cfs_bandwidth {
     338                 :            : #ifdef CONFIG_CFS_BANDWIDTH
     339                 :            :         raw_spinlock_t          lock;
     340                 :            :         ktime_t                 period;
     341                 :            :         u64                     quota;
     342                 :            :         u64                     runtime;
     343                 :            :         s64                     hierarchical_quota;
     344                 :            : 
     345                 :            :         u8                      idle;
     346                 :            :         u8                      period_active;
     347                 :            :         u8                      distribute_running;
     348                 :            :         u8                      slack_started;
     349                 :            :         struct hrtimer          period_timer;
     350                 :            :         struct hrtimer          slack_timer;
     351                 :            :         struct list_head        throttled_cfs_rq;
     352                 :            : 
     353                 :            :         /* Statistics: */
     354                 :            :         int                     nr_periods;
     355                 :            :         int                     nr_throttled;
     356                 :            :         u64                     throttled_time;
     357                 :            : #endif
     358                 :            : };
     359                 :            : 
     360                 :            : /* Task group related information */
     361                 :            : struct task_group {
     362                 :            :         struct cgroup_subsys_state css;
     363                 :            : 
     364                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
     365                 :            :         /* schedulable entities of this group on each CPU */
     366                 :            :         struct sched_entity     **se;
     367                 :            :         /* runqueue "owned" by this group on each CPU */
     368                 :            :         struct cfs_rq           **cfs_rq;
     369                 :            :         unsigned long           shares;
     370                 :            : 
     371                 :            : #ifdef  CONFIG_SMP
     372                 :            :         /*
     373                 :            :          * load_avg can be heavily contended at clock tick time, so put
     374                 :            :          * it in its own cacheline separated from the fields above which
     375                 :            :          * will also be accessed at each tick.
     376                 :            :          */
     377                 :            :         atomic_long_t           load_avg ____cacheline_aligned;
     378                 :            : #endif
     379                 :            : #endif
     380                 :            : 
     381                 :            : #ifdef CONFIG_RT_GROUP_SCHED
     382                 :            :         struct sched_rt_entity  **rt_se;
     383                 :            :         struct rt_rq            **rt_rq;
     384                 :            : 
     385                 :            :         struct rt_bandwidth     rt_bandwidth;
     386                 :            : #endif
     387                 :            : 
     388                 :            :         struct rcu_head         rcu;
     389                 :            :         struct list_head        list;
     390                 :            : 
     391                 :            :         struct task_group       *parent;
     392                 :            :         struct list_head        siblings;
     393                 :            :         struct list_head        children;
     394                 :            : 
     395                 :            : #ifdef CONFIG_SCHED_AUTOGROUP
     396                 :            :         struct autogroup        *autogroup;
     397                 :            : #endif
     398                 :            : 
     399                 :            :         struct cfs_bandwidth    cfs_bandwidth;
     400                 :            : 
     401                 :            : #ifdef CONFIG_UCLAMP_TASK_GROUP
     402                 :            :         /* The two decimal precision [%] value requested from user-space */
     403                 :            :         unsigned int            uclamp_pct[UCLAMP_CNT];
     404                 :            :         /* Clamp values requested for a task group */
     405                 :            :         struct uclamp_se        uclamp_req[UCLAMP_CNT];
     406                 :            :         /* Effective clamp values used for a task group */
     407                 :            :         struct uclamp_se        uclamp[UCLAMP_CNT];
     408                 :            : #endif
     409                 :            : 
     410                 :            : };
     411                 :            : 
     412                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
     413                 :            : #define ROOT_TASK_GROUP_LOAD    NICE_0_LOAD
     414                 :            : 
     415                 :            : /*
     416                 :            :  * A weight of 0 or 1 can cause arithmetics problems.
     417                 :            :  * A weight of a cfs_rq is the sum of weights of which entities
     418                 :            :  * are queued on this cfs_rq, so a weight of a entity should not be
     419                 :            :  * too large, so as the shares value of a task group.
     420                 :            :  * (The default weight is 1024 - so there's no practical
     421                 :            :  *  limitation from this.)
     422                 :            :  */
     423                 :            : #define MIN_SHARES              (1UL <<  1)
     424                 :            : #define MAX_SHARES              (1UL << 18)
     425                 :            : #endif
     426                 :            : 
     427                 :            : typedef int (*tg_visitor)(struct task_group *, void *);
     428                 :            : 
     429                 :            : extern int walk_tg_tree_from(struct task_group *from,
     430                 :            :                              tg_visitor down, tg_visitor up, void *data);
     431                 :            : 
     432                 :            : /*
     433                 :            :  * Iterate the full tree, calling @down when first entering a node and @up when
     434                 :            :  * leaving it for the final time.
     435                 :            :  *
     436                 :            :  * Caller must hold rcu_lock or sufficient equivalent.
     437                 :            :  */
     438                 :            : static inline int walk_tg_tree(tg_visitor down, tg_visitor up, void *data)
     439                 :            : {
     440                 :          0 :         return walk_tg_tree_from(&root_task_group, down, up, data);
     441                 :            : }
     442                 :            : 
     443                 :            : extern int tg_nop(struct task_group *tg, void *data);
     444                 :            : 
     445                 :            : extern void free_fair_sched_group(struct task_group *tg);
     446                 :            : extern int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent);
     447                 :            : extern void online_fair_sched_group(struct task_group *tg);
     448                 :            : extern void unregister_fair_sched_group(struct task_group *tg);
     449                 :            : extern void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
     450                 :            :                         struct sched_entity *se, int cpu,
     451                 :            :                         struct sched_entity *parent);
     452                 :            : extern void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b);
     453                 :            : 
     454                 :            : extern void __refill_cfs_bandwidth_runtime(struct cfs_bandwidth *cfs_b);
     455                 :            : extern void start_cfs_bandwidth(struct cfs_bandwidth *cfs_b);
     456                 :            : extern void unthrottle_cfs_rq(struct cfs_rq *cfs_rq);
     457                 :            : 
     458                 :            : extern void free_rt_sched_group(struct task_group *tg);
     459                 :            : extern int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent);
     460                 :            : extern void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
     461                 :            :                 struct sched_rt_entity *rt_se, int cpu,
     462                 :            :                 struct sched_rt_entity *parent);
     463                 :            : extern int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us);
     464                 :            : extern int sched_group_set_rt_period(struct task_group *tg, u64 rt_period_us);
     465                 :            : extern long sched_group_rt_runtime(struct task_group *tg);
     466                 :            : extern long sched_group_rt_period(struct task_group *tg);
     467                 :            : extern int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk);
     468                 :            : 
     469                 :            : extern struct task_group *sched_create_group(struct task_group *parent);
     470                 :            : extern void sched_online_group(struct task_group *tg,
     471                 :            :                                struct task_group *parent);
     472                 :            : extern void sched_destroy_group(struct task_group *tg);
     473                 :            : extern void sched_offline_group(struct task_group *tg);
     474                 :            : 
     475                 :            : extern void sched_move_task(struct task_struct *tsk);
     476                 :            : 
     477                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
     478                 :            : extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
     479                 :            : 
     480                 :            : #ifdef CONFIG_SMP
     481                 :            : extern void set_task_rq_fair(struct sched_entity *se,
     482                 :            :                              struct cfs_rq *prev, struct cfs_rq *next);
     483                 :            : #else /* !CONFIG_SMP */
     484                 :            : static inline void set_task_rq_fair(struct sched_entity *se,
     485                 :            :                              struct cfs_rq *prev, struct cfs_rq *next) { }
     486                 :            : #endif /* CONFIG_SMP */
     487                 :            : #endif /* CONFIG_FAIR_GROUP_SCHED */
     488                 :            : 
     489                 :            : #else /* CONFIG_CGROUP_SCHED */
     490                 :            : 
     491                 :            : struct cfs_bandwidth { };
     492                 :            : 
     493                 :            : #endif  /* CONFIG_CGROUP_SCHED */
     494                 :            : 
     495                 :            : /* CFS-related fields in a runqueue */
     496                 :            : struct cfs_rq {
     497                 :            :         struct load_weight      load;
     498                 :            :         unsigned long           runnable_weight;
     499                 :            :         unsigned int            nr_running;
     500                 :            :         unsigned int            h_nr_running;      /* SCHED_{NORMAL,BATCH,IDLE} */
     501                 :            :         unsigned int            idle_h_nr_running; /* SCHED_IDLE */
     502                 :            : 
     503                 :            :         u64                     exec_clock;
     504                 :            :         u64                     min_vruntime;
     505                 :            : #ifndef CONFIG_64BIT
     506                 :            :         u64                     min_vruntime_copy;
     507                 :            : #endif
     508                 :            : 
     509                 :            :         struct rb_root_cached   tasks_timeline;
     510                 :            : 
     511                 :            :         /*
     512                 :            :          * 'curr' points to currently running entity on this cfs_rq.
     513                 :            :          * It is set to NULL otherwise (i.e when none are currently running).
     514                 :            :          */
     515                 :            :         struct sched_entity     *curr;
     516                 :            :         struct sched_entity     *next;
     517                 :            :         struct sched_entity     *last;
     518                 :            :         struct sched_entity     *skip;
     519                 :            : 
     520                 :            : #ifdef  CONFIG_SCHED_DEBUG
     521                 :            :         unsigned int            nr_spread_over;
     522                 :            : #endif
     523                 :            : 
     524                 :            : #ifdef CONFIG_SMP
     525                 :            :         /*
     526                 :            :          * CFS load tracking
     527                 :            :          */
     528                 :            :         struct sched_avg        avg;
     529                 :            : #ifndef CONFIG_64BIT
     530                 :            :         u64                     load_last_update_time_copy;
     531                 :            : #endif
     532                 :            :         struct {
     533                 :            :                 raw_spinlock_t  lock ____cacheline_aligned;
     534                 :            :                 int             nr;
     535                 :            :                 unsigned long   load_avg;
     536                 :            :                 unsigned long   util_avg;
     537                 :            :                 unsigned long   runnable_sum;
     538                 :            :         } removed;
     539                 :            : 
     540                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
     541                 :            :         unsigned long           tg_load_avg_contrib;
     542                 :            :         long                    propagate;
     543                 :            :         long                    prop_runnable_sum;
     544                 :            : 
     545                 :            :         /*
     546                 :            :          *   h_load = weight * f(tg)
     547                 :            :          *
     548                 :            :          * Where f(tg) is the recursive weight fraction assigned to
     549                 :            :          * this group.
     550                 :            :          */
     551                 :            :         unsigned long           h_load;
     552                 :            :         u64                     last_h_load_update;
     553                 :            :         struct sched_entity     *h_load_next;
     554                 :            : #endif /* CONFIG_FAIR_GROUP_SCHED */
     555                 :            : #endif /* CONFIG_SMP */
     556                 :            : 
     557                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
     558                 :            :         struct rq               *rq;    /* CPU runqueue to which this cfs_rq is attached */
     559                 :            : 
     560                 :            :         /*
     561                 :            :          * leaf cfs_rqs are those that hold tasks (lowest schedulable entity in
     562                 :            :          * a hierarchy). Non-leaf lrqs hold other higher schedulable entities
     563                 :            :          * (like users, containers etc.)
     564                 :            :          *
     565                 :            :          * leaf_cfs_rq_list ties together list of leaf cfs_rq's in a CPU.
     566                 :            :          * This list is used during load balance.
     567                 :            :          */
     568                 :            :         int                     on_list;
     569                 :            :         struct list_head        leaf_cfs_rq_list;
     570                 :            :         struct task_group       *tg;    /* group that "owns" this runqueue */
     571                 :            : 
     572                 :            : #ifdef CONFIG_CFS_BANDWIDTH
     573                 :            :         int                     runtime_enabled;
     574                 :            :         s64                     runtime_remaining;
     575                 :            : 
     576                 :            :         u64                     throttled_clock;
     577                 :            :         u64                     throttled_clock_task;
     578                 :            :         u64                     throttled_clock_task_time;
     579                 :            :         int                     throttled;
     580                 :            :         int                     throttle_count;
     581                 :            :         struct list_head        throttled_list;
     582                 :            : #endif /* CONFIG_CFS_BANDWIDTH */
     583                 :            : #endif /* CONFIG_FAIR_GROUP_SCHED */
     584                 :            : };
     585                 :            : 
     586                 :            : static inline int rt_bandwidth_enabled(void)
     587                 :            : {
     588                 :        622 :         return sysctl_sched_rt_runtime >= 0;
     589                 :            : }
     590                 :            : 
     591                 :            : /* RT IPI pull logic requires IRQ_WORK */
     592                 :            : #if defined(CONFIG_IRQ_WORK) && defined(CONFIG_SMP)
     593                 :            : # define HAVE_RT_PUSH_IPI
     594                 :            : #endif
     595                 :            : 
     596                 :            : /* Real-Time classes' related field in a runqueue: */
     597                 :            : struct rt_rq {
     598                 :            :         struct rt_prio_array    active;
     599                 :            :         unsigned int            rt_nr_running;
     600                 :            :         unsigned int            rr_nr_running;
     601                 :            : #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
     602                 :            :         struct {
     603                 :            :                 int             curr; /* highest queued rt task prio */
     604                 :            : #ifdef CONFIG_SMP
     605                 :            :                 int             next; /* next highest */
     606                 :            : #endif
     607                 :            :         } highest_prio;
     608                 :            : #endif
     609                 :            : #ifdef CONFIG_SMP
     610                 :            :         unsigned long           rt_nr_migratory;
     611                 :            :         unsigned long           rt_nr_total;
     612                 :            :         int                     overloaded;
     613                 :            :         struct plist_head       pushable_tasks;
     614                 :            : 
     615                 :            : #endif /* CONFIG_SMP */
     616                 :            :         int                     rt_queued;
     617                 :            : 
     618                 :            :         int                     rt_throttled;
     619                 :            :         u64                     rt_time;
     620                 :            :         u64                     rt_runtime;
     621                 :            :         /* Nests inside the rq lock: */
     622                 :            :         raw_spinlock_t          rt_runtime_lock;
     623                 :            : 
     624                 :            : #ifdef CONFIG_RT_GROUP_SCHED
     625                 :            :         unsigned long           rt_nr_boosted;
     626                 :            : 
     627                 :            :         struct rq               *rq;
     628                 :            :         struct task_group       *tg;
     629                 :            : #endif
     630                 :            : };
     631                 :            : 
     632                 :            : static inline bool rt_rq_is_runnable(struct rt_rq *rt_rq)
     633                 :            : {
     634   [ #  #  #  # ]:          0 :         return rt_rq->rt_queued && rt_rq->rt_nr_running;
     635                 :            : }
     636                 :            : 
     637                 :            : /* Deadline class' related fields in a runqueue */
     638                 :            : struct dl_rq {
     639                 :            :         /* runqueue is an rbtree, ordered by deadline */
     640                 :            :         struct rb_root_cached   root;
     641                 :            : 
     642                 :            :         unsigned long           dl_nr_running;
     643                 :            : 
     644                 :            : #ifdef CONFIG_SMP
     645                 :            :         /*
     646                 :            :          * Deadline values of the currently executing and the
     647                 :            :          * earliest ready task on this rq. Caching these facilitates
     648                 :            :          * the decision whether or not a ready but not running task
     649                 :            :          * should migrate somewhere else.
     650                 :            :          */
     651                 :            :         struct {
     652                 :            :                 u64             curr;
     653                 :            :                 u64             next;
     654                 :            :         } earliest_dl;
     655                 :            : 
     656                 :            :         unsigned long           dl_nr_migratory;
     657                 :            :         int                     overloaded;
     658                 :            : 
     659                 :            :         /*
     660                 :            :          * Tasks on this rq that can be pushed away. They are kept in
     661                 :            :          * an rb-tree, ordered by tasks' deadlines, with caching
     662                 :            :          * of the leftmost (earliest deadline) element.
     663                 :            :          */
     664                 :            :         struct rb_root_cached   pushable_dl_tasks_root;
     665                 :            : #else
     666                 :            :         struct dl_bw            dl_bw;
     667                 :            : #endif
     668                 :            :         /*
     669                 :            :          * "Active utilization" for this runqueue: increased when a
     670                 :            :          * task wakes up (becomes TASK_RUNNING) and decreased when a
     671                 :            :          * task blocks
     672                 :            :          */
     673                 :            :         u64                     running_bw;
     674                 :            : 
     675                 :            :         /*
     676                 :            :          * Utilization of the tasks "assigned" to this runqueue (including
     677                 :            :          * the tasks that are in runqueue and the tasks that executed on this
     678                 :            :          * CPU and blocked). Increased when a task moves to this runqueue, and
     679                 :            :          * decreased when the task moves away (migrates, changes scheduling
     680                 :            :          * policy, or terminates).
     681                 :            :          * This is needed to compute the "inactive utilization" for the
     682                 :            :          * runqueue (inactive utilization = this_bw - running_bw).
     683                 :            :          */
     684                 :            :         u64                     this_bw;
     685                 :            :         u64                     extra_bw;
     686                 :            : 
     687                 :            :         /*
     688                 :            :          * Inverse of the fraction of CPU utilization that can be reclaimed
     689                 :            :          * by the GRUB algorithm.
     690                 :            :          */
     691                 :            :         u64                     bw_ratio;
     692                 :            : };
     693                 :            : 
     694                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
     695                 :            : /* An entity is a task if it doesn't "own" a runqueue */
     696                 :            : #define entity_is_task(se)      (!se->my_q)
     697                 :            : #else
     698                 :            : #define entity_is_task(se)      1
     699                 :            : #endif
     700                 :            : 
     701                 :            : #ifdef CONFIG_SMP
     702                 :            : /*
     703                 :            :  * XXX we want to get rid of these helpers and use the full load resolution.
     704                 :            :  */
     705                 :            : static inline long se_weight(struct sched_entity *se)
     706                 :            : {
     707                 :   50940745 :         return scale_load_down(se->load.weight);
     708                 :            : }
     709                 :            : 
     710                 :            : static inline long se_runnable(struct sched_entity *se)
     711                 :            : {
     712                 :   56252189 :         return scale_load_down(se->runnable_weight);
     713                 :            : }
     714                 :            : 
     715                 :            : static inline bool sched_asym_prefer(int a, int b)
     716                 :            : {
     717                 :          0 :         return arch_asym_cpu_priority(a) > arch_asym_cpu_priority(b);
     718                 :            : }
     719                 :            : 
     720                 :            : struct perf_domain {
     721                 :            :         struct em_perf_domain *em_pd;
     722                 :            :         struct perf_domain *next;
     723                 :            :         struct rcu_head rcu;
     724                 :            : };
     725                 :            : 
     726                 :            : /* Scheduling group status flags */
     727                 :            : #define SG_OVERLOAD             0x1 /* More than one runnable task on a CPU. */
     728                 :            : #define SG_OVERUTILIZED         0x2 /* One or more CPUs are over-utilized. */
     729                 :            : 
     730                 :            : /*
     731                 :            :  * We add the notion of a root-domain which will be used to define per-domain
     732                 :            :  * variables. Each exclusive cpuset essentially defines an island domain by
     733                 :            :  * fully partitioning the member CPUs from any other cpuset. Whenever a new
     734                 :            :  * exclusive cpuset is created, we also create and attach a new root-domain
     735                 :            :  * object.
     736                 :            :  *
     737                 :            :  */
     738                 :            : struct root_domain {
     739                 :            :         atomic_t                refcount;
     740                 :            :         atomic_t                rto_count;
     741                 :            :         struct rcu_head         rcu;
     742                 :            :         cpumask_var_t           span;
     743                 :            :         cpumask_var_t           online;
     744                 :            : 
     745                 :            :         /*
     746                 :            :          * Indicate pullable load on at least one CPU, e.g:
     747                 :            :          * - More than one runnable task
     748                 :            :          * - Running task is misfit
     749                 :            :          */
     750                 :            :         int                     overload;
     751                 :            : 
     752                 :            :         /* Indicate one or more cpus over-utilized (tipping point) */
     753                 :            :         int                     overutilized;
     754                 :            : 
     755                 :            :         /*
     756                 :            :          * The bit corresponding to a CPU gets set here if such CPU has more
     757                 :            :          * than one runnable -deadline task (as it is below for RT tasks).
     758                 :            :          */
     759                 :            :         cpumask_var_t           dlo_mask;
     760                 :            :         atomic_t                dlo_count;
     761                 :            :         struct dl_bw            dl_bw;
     762                 :            :         struct cpudl            cpudl;
     763                 :            : 
     764                 :            : #ifdef HAVE_RT_PUSH_IPI
     765                 :            :         /*
     766                 :            :          * For IPI pull requests, loop across the rto_mask.
     767                 :            :          */
     768                 :            :         struct irq_work         rto_push_work;
     769                 :            :         raw_spinlock_t          rto_lock;
     770                 :            :         /* These are only updated and read within rto_lock */
     771                 :            :         int                     rto_loop;
     772                 :            :         int                     rto_cpu;
     773                 :            :         /* These atomics are updated outside of a lock */
     774                 :            :         atomic_t                rto_loop_next;
     775                 :            :         atomic_t                rto_loop_start;
     776                 :            : #endif
     777                 :            :         /*
     778                 :            :          * The "RT overload" flag: it gets set if a CPU has more than
     779                 :            :          * one runnable RT task.
     780                 :            :          */
     781                 :            :         cpumask_var_t           rto_mask;
     782                 :            :         struct cpupri           cpupri;
     783                 :            : 
     784                 :            :         unsigned long           max_cpu_capacity;
     785                 :            : 
     786                 :            :         /*
     787                 :            :          * NULL-terminated list of performance domains intersecting with the
     788                 :            :          * CPUs of the rd. Protected by RCU.
     789                 :            :          */
     790                 :            :         struct perf_domain __rcu *pd;
     791                 :            : };
     792                 :            : 
     793                 :            : extern void init_defrootdomain(void);
     794                 :            : extern int sched_init_domains(const struct cpumask *cpu_map);
     795                 :            : extern void rq_attach_root(struct rq *rq, struct root_domain *rd);
     796                 :            : extern void sched_get_rd(struct root_domain *rd);
     797                 :            : extern void sched_put_rd(struct root_domain *rd);
     798                 :            : 
     799                 :            : #ifdef HAVE_RT_PUSH_IPI
     800                 :            : extern void rto_push_irq_work_func(struct irq_work *work);
     801                 :            : #endif
     802                 :            : #endif /* CONFIG_SMP */
     803                 :            : 
     804                 :            : #ifdef CONFIG_UCLAMP_TASK
     805                 :            : /*
     806                 :            :  * struct uclamp_bucket - Utilization clamp bucket
     807                 :            :  * @value: utilization clamp value for tasks on this clamp bucket
     808                 :            :  * @tasks: number of RUNNABLE tasks on this clamp bucket
     809                 :            :  *
     810                 :            :  * Keep track of how many tasks are RUNNABLE for a given utilization
     811                 :            :  * clamp value.
     812                 :            :  */
     813                 :            : struct uclamp_bucket {
     814                 :            :         unsigned long value : bits_per(SCHED_CAPACITY_SCALE);
     815                 :            :         unsigned long tasks : BITS_PER_LONG - bits_per(SCHED_CAPACITY_SCALE);
     816                 :            : };
     817                 :            : 
     818                 :            : /*
     819                 :            :  * struct uclamp_rq - rq's utilization clamp
     820                 :            :  * @value: currently active clamp values for a rq
     821                 :            :  * @bucket: utilization clamp buckets affecting a rq
     822                 :            :  *
     823                 :            :  * Keep track of RUNNABLE tasks on a rq to aggregate their clamp values.
     824                 :            :  * A clamp value is affecting a rq when there is at least one task RUNNABLE
     825                 :            :  * (or actually running) with that value.
     826                 :            :  *
     827                 :            :  * There are up to UCLAMP_CNT possible different clamp values, currently there
     828                 :            :  * are only two: minimum utilization and maximum utilization.
     829                 :            :  *
     830                 :            :  * All utilization clamping values are MAX aggregated, since:
     831                 :            :  * - for util_min: we want to run the CPU at least at the max of the minimum
     832                 :            :  *   utilization required by its currently RUNNABLE tasks.
     833                 :            :  * - for util_max: we want to allow the CPU to run up to the max of the
     834                 :            :  *   maximum utilization allowed by its currently RUNNABLE tasks.
     835                 :            :  *
     836                 :            :  * Since on each system we expect only a limited number of different
     837                 :            :  * utilization clamp values (UCLAMP_BUCKETS), use a simple array to track
     838                 :            :  * the metrics required to compute all the per-rq utilization clamp values.
     839                 :            :  */
     840                 :            : struct uclamp_rq {
     841                 :            :         unsigned int value;
     842                 :            :         struct uclamp_bucket bucket[UCLAMP_BUCKETS];
     843                 :            : };
     844                 :            : #endif /* CONFIG_UCLAMP_TASK */
     845                 :            : 
     846                 :            : /*
     847                 :            :  * This is the main, per-CPU runqueue data structure.
     848                 :            :  *
     849                 :            :  * Locking rule: those places that want to lock multiple runqueues
     850                 :            :  * (such as the load balancing or the thread migration code), lock
     851                 :            :  * acquire operations must be ordered by ascending &runqueue.
     852                 :            :  */
     853                 :            : struct rq {
     854                 :            :         /* runqueue lock: */
     855                 :            :         raw_spinlock_t          lock;
     856                 :            : 
     857                 :            :         /*
     858                 :            :          * nr_running and cpu_load should be in the same cacheline because
     859                 :            :          * remote CPUs use both these fields when doing load calculation.
     860                 :            :          */
     861                 :            :         unsigned int            nr_running;
     862                 :            : #ifdef CONFIG_NUMA_BALANCING
     863                 :            :         unsigned int            nr_numa_running;
     864                 :            :         unsigned int            nr_preferred_running;
     865                 :            :         unsigned int            numa_migrate_on;
     866                 :            : #endif
     867                 :            : #ifdef CONFIG_NO_HZ_COMMON
     868                 :            : #ifdef CONFIG_SMP
     869                 :            :         unsigned long           last_load_update_tick;
     870                 :            :         unsigned long           last_blocked_load_update_tick;
     871                 :            :         unsigned int            has_blocked_load;
     872                 :            : #endif /* CONFIG_SMP */
     873                 :            :         unsigned int            nohz_tick_stopped;
     874                 :            :         atomic_t nohz_flags;
     875                 :            : #endif /* CONFIG_NO_HZ_COMMON */
     876                 :            : 
     877                 :            :         unsigned long           nr_load_updates;
     878                 :            :         u64                     nr_switches;
     879                 :            : 
     880                 :            : #ifdef CONFIG_UCLAMP_TASK
     881                 :            :         /* Utilization clamp values based on CPU's RUNNABLE tasks */
     882                 :            :         struct uclamp_rq        uclamp[UCLAMP_CNT] ____cacheline_aligned;
     883                 :            :         unsigned int            uclamp_flags;
     884                 :            : #define UCLAMP_FLAG_IDLE 0x01
     885                 :            : #endif
     886                 :            : 
     887                 :            :         struct cfs_rq           cfs;
     888                 :            :         struct rt_rq            rt;
     889                 :            :         struct dl_rq            dl;
     890                 :            : 
     891                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
     892                 :            :         /* list of leaf cfs_rq on this CPU: */
     893                 :            :         struct list_head        leaf_cfs_rq_list;
     894                 :            :         struct list_head        *tmp_alone_branch;
     895                 :            : #endif /* CONFIG_FAIR_GROUP_SCHED */
     896                 :            : 
     897                 :            :         /*
     898                 :            :          * This is part of a global counter where only the total sum
     899                 :            :          * over all CPUs matters. A task can increase this counter on
     900                 :            :          * one CPU and if it got migrated afterwards it may decrease
     901                 :            :          * it on another CPU. Always updated under the runqueue lock:
     902                 :            :          */
     903                 :            :         unsigned long           nr_uninterruptible;
     904                 :            : 
     905                 :            :         struct task_struct      *curr;
     906                 :            :         struct task_struct      *idle;
     907                 :            :         struct task_struct      *stop;
     908                 :            :         unsigned long           next_balance;
     909                 :            :         struct mm_struct        *prev_mm;
     910                 :            : 
     911                 :            :         unsigned int            clock_update_flags;
     912                 :            :         u64                     clock;
     913                 :            :         /* Ensure that all clocks are in the same cache line */
     914                 :            :         u64                     clock_task ____cacheline_aligned;
     915                 :            :         u64                     clock_pelt;
     916                 :            :         unsigned long           lost_idle_time;
     917                 :            : 
     918                 :            :         atomic_t                nr_iowait;
     919                 :            : 
     920                 :            : #ifdef CONFIG_MEMBARRIER
     921                 :            :         int membarrier_state;
     922                 :            : #endif
     923                 :            : 
     924                 :            : #ifdef CONFIG_SMP
     925                 :            :         struct root_domain              *rd;
     926                 :            :         struct sched_domain __rcu       *sd;
     927                 :            : 
     928                 :            :         unsigned long           cpu_capacity;
     929                 :            :         unsigned long           cpu_capacity_orig;
     930                 :            : 
     931                 :            :         struct callback_head    *balance_callback;
     932                 :            : 
     933                 :            :         unsigned char           idle_balance;
     934                 :            : 
     935                 :            :         unsigned long           misfit_task_load;
     936                 :            : 
     937                 :            :         /* For active balancing */
     938                 :            :         int                     active_balance;
     939                 :            :         int                     push_cpu;
     940                 :            :         struct cpu_stop_work    active_balance_work;
     941                 :            : 
     942                 :            :         /* CPU of this runqueue: */
     943                 :            :         int                     cpu;
     944                 :            :         int                     online;
     945                 :            : 
     946                 :            :         struct list_head cfs_tasks;
     947                 :            : 
     948                 :            :         struct sched_avg        avg_rt;
     949                 :            :         struct sched_avg        avg_dl;
     950                 :            : #ifdef CONFIG_HAVE_SCHED_AVG_IRQ
     951                 :            :         struct sched_avg        avg_irq;
     952                 :            : #endif
     953                 :            :         u64                     idle_stamp;
     954                 :            :         u64                     avg_idle;
     955                 :            : 
     956                 :            :         /* This is used to determine avg_idle's max value */
     957                 :            :         u64                     max_idle_balance_cost;
     958                 :            : #endif
     959                 :            : 
     960                 :            : #ifdef CONFIG_IRQ_TIME_ACCOUNTING
     961                 :            :         u64                     prev_irq_time;
     962                 :            : #endif
     963                 :            : #ifdef CONFIG_PARAVIRT
     964                 :            :         u64                     prev_steal_time;
     965                 :            : #endif
     966                 :            : #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
     967                 :            :         u64                     prev_steal_time_rq;
     968                 :            : #endif
     969                 :            : 
     970                 :            :         /* calc_load related fields */
     971                 :            :         unsigned long           calc_load_update;
     972                 :            :         long                    calc_load_active;
     973                 :            : 
     974                 :            : #ifdef CONFIG_SCHED_HRTICK
     975                 :            : #ifdef CONFIG_SMP
     976                 :            :         int                     hrtick_csd_pending;
     977                 :            :         call_single_data_t      hrtick_csd;
     978                 :            : #endif
     979                 :            :         struct hrtimer          hrtick_timer;
     980                 :            : #endif
     981                 :            : 
     982                 :            : #ifdef CONFIG_SCHEDSTATS
     983                 :            :         /* latency stats */
     984                 :            :         struct sched_info       rq_sched_info;
     985                 :            :         unsigned long long      rq_cpu_time;
     986                 :            :         /* could above be rq->cfs_rq.exec_clock + rq->rt_rq.rt_runtime ? */
     987                 :            : 
     988                 :            :         /* sys_sched_yield() stats */
     989                 :            :         unsigned int            yld_count;
     990                 :            : 
     991                 :            :         /* schedule() stats */
     992                 :            :         unsigned int            sched_count;
     993                 :            :         unsigned int            sched_goidle;
     994                 :            : 
     995                 :            :         /* try_to_wake_up() stats */
     996                 :            :         unsigned int            ttwu_count;
     997                 :            :         unsigned int            ttwu_local;
     998                 :            : #endif
     999                 :            : 
    1000                 :            : #ifdef CONFIG_SMP
    1001                 :            :         struct llist_head       wake_list;
    1002                 :            : #endif
    1003                 :            : 
    1004                 :            : #ifdef CONFIG_CPU_IDLE
    1005                 :            :         /* Must be inspected within a rcu lock section */
    1006                 :            :         struct cpuidle_state    *idle_state;
    1007                 :            : #endif
    1008                 :            : };
    1009                 :            : 
    1010                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
    1011                 :            : 
    1012                 :            : /* CPU runqueue to which this cfs_rq is attached */
    1013                 :            : static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
    1014                 :            : {
    1015                 :  150562102 :         return cfs_rq->rq;
    1016                 :            : }
    1017                 :            : 
    1018                 :            : #else
    1019                 :            : 
    1020                 :            : static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
    1021                 :            : {
    1022                 :            :         return container_of(cfs_rq, struct rq, cfs);
    1023                 :            : }
    1024                 :            : #endif
    1025                 :            : 
    1026                 :            : static inline int cpu_of(struct rq *rq)
    1027                 :            : {
    1028                 :            : #ifdef CONFIG_SMP
    1029                 :   69688764 :         return rq->cpu;
    1030                 :            : #else
    1031                 :            :         return 0;
    1032                 :            : #endif
    1033                 :            : }
    1034                 :            : 
    1035                 :            : 
    1036                 :            : #ifdef CONFIG_SCHED_SMT
    1037                 :            : extern void __update_idle_core(struct rq *rq);
    1038                 :            : 
    1039                 :            : static inline void update_idle_core(struct rq *rq)
    1040                 :            : {
    1041                 :            :         if (static_branch_unlikely(&sched_smt_present))
    1042                 :            :                 __update_idle_core(rq);
    1043                 :            : }
    1044                 :            : 
    1045                 :            : #else
    1046                 :            : static inline void update_idle_core(struct rq *rq) { }
    1047                 :            : #endif
    1048                 :            : 
    1049                 :            : DECLARE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
    1050                 :            : 
    1051                 :            : #define cpu_rq(cpu)             (&per_cpu(runqueues, (cpu)))
    1052                 :            : #define this_rq()               this_cpu_ptr(&runqueues)
    1053                 :            : #define task_rq(p)              cpu_rq(task_cpu(p))
    1054                 :            : #define cpu_curr(cpu)           (cpu_rq(cpu)->curr)
    1055                 :            : #define raw_rq()                raw_cpu_ptr(&runqueues)
    1056                 :            : 
    1057                 :            : extern void update_rq_clock(struct rq *rq);
    1058                 :            : 
    1059                 :            : static inline u64 __rq_clock_broken(struct rq *rq)
    1060                 :            : {
    1061                 :            :         return READ_ONCE(rq->clock);
    1062                 :            : }
    1063                 :            : 
    1064                 :            : /*
    1065                 :            :  * rq::clock_update_flags bits
    1066                 :            :  *
    1067                 :            :  * %RQCF_REQ_SKIP - will request skipping of clock update on the next
    1068                 :            :  *  call to __schedule(). This is an optimisation to avoid
    1069                 :            :  *  neighbouring rq clock updates.
    1070                 :            :  *
    1071                 :            :  * %RQCF_ACT_SKIP - is set from inside of __schedule() when skipping is
    1072                 :            :  *  in effect and calls to update_rq_clock() are being ignored.
    1073                 :            :  *
    1074                 :            :  * %RQCF_UPDATED - is a debug flag that indicates whether a call has been
    1075                 :            :  *  made to update_rq_clock() since the last time rq::lock was pinned.
    1076                 :            :  *
    1077                 :            :  * If inside of __schedule(), clock_update_flags will have been
    1078                 :            :  * shifted left (a left shift is a cheap operation for the fast path
    1079                 :            :  * to promote %RQCF_REQ_SKIP to %RQCF_ACT_SKIP), so you must use,
    1080                 :            :  *
    1081                 :            :  *      if (rq-clock_update_flags >= RQCF_UPDATED)
    1082                 :            :  *
    1083                 :            :  * to check if %RQCF_UPADTED is set. It'll never be shifted more than
    1084                 :            :  * one position though, because the next rq_unpin_lock() will shift it
    1085                 :            :  * back.
    1086                 :            :  */
    1087                 :            : #define RQCF_REQ_SKIP           0x01
    1088                 :            : #define RQCF_ACT_SKIP           0x02
    1089                 :            : #define RQCF_UPDATED            0x04
    1090                 :            : 
    1091                 :  171780797 : static inline void assert_clock_updated(struct rq *rq)
    1092                 :            : {
    1093                 :            :         /*
    1094                 :            :          * The only reason for not seeing a clock update since the
    1095                 :            :          * last rq_pin_lock() is if we're currently skipping updates.
    1096                 :            :          */
    1097   [ -  +  #  # ]:  171780797 :         SCHED_WARN_ON(rq->clock_update_flags < RQCF_ACT_SKIP);
    1098                 :  171780797 : }
    1099                 :            : 
    1100                 :            : static inline u64 rq_clock(struct rq *rq)
    1101                 :            : {
    1102                 :            :         lockdep_assert_held(&rq->lock);
    1103                 :   47802516 :         assert_clock_updated(rq);
    1104                 :            : 
    1105                 :   47808028 :         return rq->clock;
    1106                 :            : }
    1107                 :            : 
    1108                 :            : static inline u64 rq_clock_task(struct rq *rq)
    1109                 :            : {
    1110                 :            :         lockdep_assert_held(&rq->lock);
    1111                 :   56170775 :         assert_clock_updated(rq);
    1112                 :            : 
    1113                 :   56370202 :         return rq->clock_task;
    1114                 :            : }
    1115                 :            : 
    1116                 :            : static inline void rq_clock_skip_update(struct rq *rq)
    1117                 :            : {
    1118                 :            :         lockdep_assert_held(&rq->lock);
    1119                 :    5618151 :         rq->clock_update_flags |= RQCF_REQ_SKIP;
    1120                 :            : }
    1121                 :            : 
    1122                 :            : /*
    1123                 :            :  * See rt task throttling, which is the only time a skip
    1124                 :            :  * request is cancelled.
    1125                 :            :  */
    1126                 :            : static inline void rq_clock_cancel_skipupdate(struct rq *rq)
    1127                 :            : {
    1128                 :            :         lockdep_assert_held(&rq->lock);
    1129                 :          0 :         rq->clock_update_flags &= ~RQCF_REQ_SKIP;
    1130                 :            : }
    1131                 :            : 
    1132                 :            : struct rq_flags {
    1133                 :            :         unsigned long flags;
    1134                 :            :         struct pin_cookie cookie;
    1135                 :            : #ifdef CONFIG_SCHED_DEBUG
    1136                 :            :         /*
    1137                 :            :          * A copy of (rq::clock_update_flags & RQCF_UPDATED) for the
    1138                 :            :          * current pin context is stashed here in case it needs to be
    1139                 :            :          * restored in rq_repin_lock().
    1140                 :            :          */
    1141                 :            :         unsigned int clock_update_flags;
    1142                 :            : #endif
    1143                 :            : };
    1144                 :            : 
    1145                 :            : static inline void rq_pin_lock(struct rq *rq, struct rq_flags *rf)
    1146                 :            : {
    1147                 :            :         rf->cookie = lockdep_pin_lock(&rq->lock);
    1148                 :            : 
    1149                 :            : #ifdef CONFIG_SCHED_DEBUG
    1150                 :   27243016 :         rq->clock_update_flags &= (RQCF_REQ_SKIP|RQCF_ACT_SKIP);
    1151                 :   19442661 :         rf->clock_update_flags = 0;
    1152                 :            : #endif
    1153                 :            : }
    1154                 :            : 
    1155                 :            : static inline void rq_unpin_lock(struct rq *rq, struct rq_flags *rf)
    1156                 :            : {
    1157                 :            : #ifdef CONFIG_SCHED_DEBUG
    1158   [ +  +  #  #  :   22321565 :         if (rq->clock_update_flags > RQCF_ACT_SKIP)
          +  +  +  +  #  
          #  +  +  +  +  
          +  +  +  -  +  
             +  +  +  +  
                      + ]
    1159                 :   16737404 :                 rf->clock_update_flags = RQCF_UPDATED;
    1160                 :            : #endif
    1161                 :            : 
    1162                 :            :         lockdep_unpin_lock(&rq->lock, rf->cookie);
    1163                 :            : }
    1164                 :            : 
    1165                 :            : static inline void rq_repin_lock(struct rq *rq, struct rq_flags *rf)
    1166                 :            : {
    1167                 :            :         lockdep_repin_lock(&rq->lock, rf->cookie);
    1168                 :            : 
    1169                 :            : #ifdef CONFIG_SCHED_DEBUG
    1170                 :            :         /*
    1171                 :            :          * Restore the value we stashed in @rf for this pin context.
    1172                 :            :          */
    1173                 :    2901461 :         rq->clock_update_flags |= rf->clock_update_flags;
    1174                 :            : #endif
    1175                 :            : }
    1176                 :            : 
    1177                 :            : struct rq *__task_rq_lock(struct task_struct *p, struct rq_flags *rf)
    1178                 :            :         __acquires(rq->lock);
    1179                 :            : 
    1180                 :            : struct rq *task_rq_lock(struct task_struct *p, struct rq_flags *rf)
    1181                 :            :         __acquires(p->pi_lock)
    1182                 :            :         __acquires(rq->lock);
    1183                 :            : 
    1184                 :            : static inline void __task_rq_unlock(struct rq *rq, struct rq_flags *rf)
    1185                 :            :         __releases(rq->lock)
    1186                 :            : {
    1187                 :            :         rq_unpin_lock(rq, rf);
    1188                 :            :         raw_spin_unlock(&rq->lock);
    1189                 :            : }
    1190                 :            : 
    1191                 :            : static inline void
    1192                 :     916485 : task_rq_unlock(struct rq *rq, struct task_struct *p, struct rq_flags *rf)
    1193                 :            :         __releases(rq->lock)
    1194                 :            :         __releases(p->pi_lock)
    1195                 :            : {
    1196                 :            :         rq_unpin_lock(rq, rf);
    1197                 :            :         raw_spin_unlock(&rq->lock);
    1198                 :     916530 :         raw_spin_unlock_irqrestore(&p->pi_lock, rf->flags);
    1199                 :     916889 : }
    1200                 :            : 
    1201                 :            : static inline void
    1202                 :            : rq_lock_irqsave(struct rq *rq, struct rq_flags *rf)
    1203                 :            :         __acquires(rq->lock)
    1204                 :            : {
    1205                 :    6408609 :         raw_spin_lock_irqsave(&rq->lock, rf->flags);
    1206                 :            :         rq_pin_lock(rq, rf);
    1207                 :            : }
    1208                 :            : 
    1209                 :            : static inline void
    1210                 :            : rq_lock_irq(struct rq *rq, struct rq_flags *rf)
    1211                 :            :         __acquires(rq->lock)
    1212                 :            : {
    1213                 :      59382 :         raw_spin_lock_irq(&rq->lock);
    1214                 :            :         rq_pin_lock(rq, rf);
    1215                 :            : }
    1216                 :            : 
    1217                 :            : static inline void
    1218                 :            : rq_lock(struct rq *rq, struct rq_flags *rf)
    1219                 :            :         __acquires(rq->lock)
    1220                 :            : {
    1221                 :   19607807 :         raw_spin_lock(&rq->lock);
    1222                 :            :         rq_pin_lock(rq, rf);
    1223                 :            : }
    1224                 :            : 
    1225                 :            : static inline void
    1226                 :            : rq_relock(struct rq *rq, struct rq_flags *rf)
    1227                 :            :         __acquires(rq->lock)
    1228                 :            : {
    1229                 :            :         raw_spin_lock(&rq->lock);
    1230                 :            :         rq_repin_lock(rq, rf);
    1231                 :            : }
    1232                 :            : 
    1233                 :            : static inline void
    1234                 :            : rq_unlock_irqrestore(struct rq *rq, struct rq_flags *rf)
    1235                 :            :         __releases(rq->lock)
    1236                 :            : {
    1237                 :            :         rq_unpin_lock(rq, rf);
    1238                 :    5895186 :         raw_spin_unlock_irqrestore(&rq->lock, rf->flags);
    1239                 :            : }
    1240                 :            : 
    1241                 :            : static inline void
    1242                 :            : rq_unlock_irq(struct rq *rq, struct rq_flags *rf)
    1243                 :            :         __releases(rq->lock)
    1244                 :            : {
    1245                 :            :         rq_unpin_lock(rq, rf);
    1246                 :     190740 :         raw_spin_unlock_irq(&rq->lock);
    1247                 :            : }
    1248                 :            : 
    1249                 :            : static inline void
    1250                 :            : rq_unlock(struct rq *rq, struct rq_flags *rf)
    1251                 :            :         __releases(rq->lock)
    1252                 :            : {
    1253                 :            :         rq_unpin_lock(rq, rf);
    1254                 :            :         raw_spin_unlock(&rq->lock);
    1255                 :            : }
    1256                 :            : 
    1257                 :            : static inline struct rq *
    1258                 :          0 : this_rq_lock_irq(struct rq_flags *rf)
    1259                 :            :         __acquires(rq->lock)
    1260                 :            : {
    1261                 :            :         struct rq *rq;
    1262                 :            : 
    1263                 :          0 :         local_irq_disable();
    1264                 :          0 :         rq = this_rq();
    1265                 :            :         rq_lock(rq, rf);
    1266                 :          0 :         return rq;
    1267                 :            : }
    1268                 :            : 
    1269                 :            : #ifdef CONFIG_NUMA
    1270                 :            : enum numa_topology_type {
    1271                 :            :         NUMA_DIRECT,
    1272                 :            :         NUMA_GLUELESS_MESH,
    1273                 :            :         NUMA_BACKPLANE,
    1274                 :            : };
    1275                 :            : extern enum numa_topology_type sched_numa_topology_type;
    1276                 :            : extern int sched_max_numa_distance;
    1277                 :            : extern bool find_numa_distance(int distance);
    1278                 :            : extern void sched_init_numa(void);
    1279                 :            : extern void sched_domains_numa_masks_set(unsigned int cpu);
    1280                 :            : extern void sched_domains_numa_masks_clear(unsigned int cpu);
    1281                 :            : extern int sched_numa_find_closest(const struct cpumask *cpus, int cpu);
    1282                 :            : #else
    1283                 :            : static inline void sched_init_numa(void) { }
    1284                 :            : static inline void sched_domains_numa_masks_set(unsigned int cpu) { }
    1285                 :            : static inline void sched_domains_numa_masks_clear(unsigned int cpu) { }
    1286                 :            : static inline int sched_numa_find_closest(const struct cpumask *cpus, int cpu)
    1287                 :            : {
    1288                 :            :         return nr_cpu_ids;
    1289                 :            : }
    1290                 :            : #endif
    1291                 :            : 
    1292                 :            : #ifdef CONFIG_NUMA_BALANCING
    1293                 :            : /* The regions in numa_faults array from task_struct */
    1294                 :            : enum numa_faults_stats {
    1295                 :            :         NUMA_MEM = 0,
    1296                 :            :         NUMA_CPU,
    1297                 :            :         NUMA_MEMBUF,
    1298                 :            :         NUMA_CPUBUF
    1299                 :            : };
    1300                 :            : extern void sched_setnuma(struct task_struct *p, int node);
    1301                 :            : extern int migrate_task_to(struct task_struct *p, int cpu);
    1302                 :            : extern int migrate_swap(struct task_struct *p, struct task_struct *t,
    1303                 :            :                         int cpu, int scpu);
    1304                 :            : extern void init_numa_balancing(unsigned long clone_flags, struct task_struct *p);
    1305                 :            : #else
    1306                 :            : static inline void
    1307                 :            : init_numa_balancing(unsigned long clone_flags, struct task_struct *p)
    1308                 :            : {
    1309                 :            : }
    1310                 :            : #endif /* CONFIG_NUMA_BALANCING */
    1311                 :            : 
    1312                 :            : #ifdef CONFIG_SMP
    1313                 :            : 
    1314                 :            : static inline void
    1315                 :            : queue_balance_callback(struct rq *rq,
    1316                 :            :                        struct callback_head *head,
    1317                 :            :                        void (*func)(struct rq *rq))
    1318                 :            : {
    1319                 :            :         lockdep_assert_held(&rq->lock);
    1320                 :            : 
    1321   [ #  #  #  #  :          0 :         if (unlikely(head->next))
             #  #  #  # ]
    1322                 :            :                 return;
    1323                 :            : 
    1324                 :          0 :         head->func = (void (*)(struct callback_head *))func;
    1325                 :          0 :         head->next = rq->balance_callback;
    1326                 :          0 :         rq->balance_callback = head;
    1327                 :            : }
    1328                 :            : 
    1329                 :            : extern void sched_ttwu_pending(void);
    1330                 :            : 
    1331                 :            : #define rcu_dereference_check_sched_domain(p) \
    1332                 :            :         rcu_dereference_check((p), \
    1333                 :            :                               lockdep_is_held(&sched_domains_mutex))
    1334                 :            : 
    1335                 :            : /*
    1336                 :            :  * The domain tree (rq->sd) is protected by RCU's quiescent state transition.
    1337                 :            :  * See destroy_sched_domains: call_rcu for details.
    1338                 :            :  *
    1339                 :            :  * The domain tree of any CPU may only be accessed from within
    1340                 :            :  * preempt-disabled sections.
    1341                 :            :  */
    1342                 :            : #define for_each_domain(cpu, __sd) \
    1343                 :            :         for (__sd = rcu_dereference_check_sched_domain(cpu_rq(cpu)->sd); \
    1344                 :            :                         __sd; __sd = __sd->parent)
    1345                 :            : 
    1346                 :            : #define for_each_lower_domain(sd) for (; sd; sd = sd->child)
    1347                 :            : 
    1348                 :            : /**
    1349                 :            :  * highest_flag_domain - Return highest sched_domain containing flag.
    1350                 :            :  * @cpu:        The CPU whose highest level of sched domain is to
    1351                 :            :  *              be returned.
    1352                 :            :  * @flag:       The flag to check for the highest sched_domain
    1353                 :            :  *              for the given CPU.
    1354                 :            :  *
    1355                 :            :  * Returns the highest sched_domain of a CPU which contains the given flag.
    1356                 :            :  */
    1357                 :            : static inline struct sched_domain *highest_flag_domain(int cpu, int flag)
    1358                 :            : {
    1359                 :            :         struct sched_domain *sd, *hsd = NULL;
    1360                 :            : 
    1361   [ +  -  +  - ]:       3312 :         for_each_domain(cpu, sd) {
    1362   [ -  +  -  + ]:       1656 :                 if (!(sd->flags & flag))
    1363                 :            :                         break;
    1364                 :            :                 hsd = sd;
    1365                 :            :         }
    1366                 :            : 
    1367                 :       1656 :         return hsd;
    1368                 :            : }
    1369                 :            : 
    1370                 :            : static inline struct sched_domain *lowest_flag_domain(int cpu, int flag)
    1371                 :            : {
    1372                 :            :         struct sched_domain *sd;
    1373                 :            : 
    1374   [ +  +  +  + ]:       4968 :         for_each_domain(cpu, sd) {
    1375   [ +  -  +  - ]:       1656 :                 if (sd->flags & flag)
    1376                 :            :                         break;
    1377                 :            :         }
    1378                 :            : 
    1379                 :       1656 :         return sd;
    1380                 :            : }
    1381                 :            : 
    1382                 :            : DECLARE_PER_CPU(struct sched_domain __rcu *, sd_llc);
    1383                 :            : DECLARE_PER_CPU(int, sd_llc_size);
    1384                 :            : DECLARE_PER_CPU(int, sd_llc_id);
    1385                 :            : DECLARE_PER_CPU(struct sched_domain_shared __rcu *, sd_llc_shared);
    1386                 :            : DECLARE_PER_CPU(struct sched_domain __rcu *, sd_numa);
    1387                 :            : DECLARE_PER_CPU(struct sched_domain __rcu *, sd_asym_packing);
    1388                 :            : DECLARE_PER_CPU(struct sched_domain __rcu *, sd_asym_cpucapacity);
    1389                 :            : extern struct static_key_false sched_asym_cpucapacity;
    1390                 :            : 
    1391                 :            : struct sched_group_capacity {
    1392                 :            :         atomic_t                ref;
    1393                 :            :         /*
    1394                 :            :          * CPU capacity of this group, SCHED_CAPACITY_SCALE being max capacity
    1395                 :            :          * for a single CPU.
    1396                 :            :          */
    1397                 :            :         unsigned long           capacity;
    1398                 :            :         unsigned long           min_capacity;           /* Min per-CPU capacity in group */
    1399                 :            :         unsigned long           max_capacity;           /* Max per-CPU capacity in group */
    1400                 :            :         unsigned long           next_update;
    1401                 :            :         int                     imbalance;              /* XXX unrelated to capacity but shared group state */
    1402                 :            : 
    1403                 :            : #ifdef CONFIG_SCHED_DEBUG
    1404                 :            :         int                     id;
    1405                 :            : #endif
    1406                 :            : 
    1407                 :            :         unsigned long           cpumask[0];             /* Balance mask */
    1408                 :            : };
    1409                 :            : 
    1410                 :            : struct sched_group {
    1411                 :            :         struct sched_group      *next;                  /* Must be a circular list */
    1412                 :            :         atomic_t                ref;
    1413                 :            : 
    1414                 :            :         unsigned int            group_weight;
    1415                 :            :         struct sched_group_capacity *sgc;
    1416                 :            :         int                     asym_prefer_cpu;        /* CPU of highest priority in group */
    1417                 :            : 
    1418                 :            :         /*
    1419                 :            :          * The CPUs this group covers.
    1420                 :            :          *
    1421                 :            :          * NOTE: this field is variable length. (Allocated dynamically
    1422                 :            :          * by attaching extra space to the end of the structure,
    1423                 :            :          * depending on how many CPUs the kernel has booted up with)
    1424                 :            :          */
    1425                 :            :         unsigned long           cpumask[0];
    1426                 :            : };
    1427                 :            : 
    1428                 :            : static inline struct cpumask *sched_group_span(struct sched_group *sg)
    1429                 :            : {
    1430                 :   29134788 :         return to_cpumask(sg->cpumask);
    1431                 :            : }
    1432                 :            : 
    1433                 :            : /*
    1434                 :            :  * See build_balance_mask().
    1435                 :            :  */
    1436                 :            : static inline struct cpumask *group_balance_mask(struct sched_group *sg)
    1437                 :            : {
    1438                 :    1903283 :         return to_cpumask(sg->sgc->cpumask);
    1439                 :            : }
    1440                 :            : 
    1441                 :            : /**
    1442                 :            :  * group_first_cpu - Returns the first CPU in the cpumask of a sched_group.
    1443                 :            :  * @group: The group whose first CPU is to be returned.
    1444                 :            :  */
    1445                 :            : static inline unsigned int group_first_cpu(struct sched_group *group)
    1446                 :            : {
    1447                 :            :         return cpumask_first(sched_group_span(group));
    1448                 :            : }
    1449                 :            : 
    1450                 :            : extern int group_balance_cpu(struct sched_group *sg);
    1451                 :            : 
    1452                 :            : #if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_SYSCTL)
    1453                 :            : void register_sched_domain_sysctl(void);
    1454                 :            : void dirty_sched_domain_sysctl(int cpu);
    1455                 :            : void unregister_sched_domain_sysctl(void);
    1456                 :            : #else
    1457                 :            : static inline void register_sched_domain_sysctl(void)
    1458                 :            : {
    1459                 :            : }
    1460                 :            : static inline void dirty_sched_domain_sysctl(int cpu)
    1461                 :            : {
    1462                 :            : }
    1463                 :            : static inline void unregister_sched_domain_sysctl(void)
    1464                 :            : {
    1465                 :            : }
    1466                 :            : #endif
    1467                 :            : 
    1468                 :            : extern int newidle_balance(struct rq *this_rq, struct rq_flags *rf);
    1469                 :            : 
    1470                 :            : #else
    1471                 :            : 
    1472                 :            : static inline void sched_ttwu_pending(void) { }
    1473                 :            : 
    1474                 :            : static inline int newidle_balance(struct rq *this_rq, struct rq_flags *rf) { return 0; }
    1475                 :            : 
    1476                 :            : #endif /* CONFIG_SMP */
    1477                 :            : 
    1478                 :            : #include "stats.h"
    1479                 :            : #include "autogroup.h"
    1480                 :            : 
    1481                 :            : #ifdef CONFIG_CGROUP_SCHED
    1482                 :            : 
    1483                 :            : /*
    1484                 :            :  * Return the group to which this tasks belongs.
    1485                 :            :  *
    1486                 :            :  * We cannot use task_css() and friends because the cgroup subsystem
    1487                 :            :  * changes that value before the cgroup_subsys::attach() method is called,
    1488                 :            :  * therefore we cannot pin it and might observe the wrong value.
    1489                 :            :  *
    1490                 :            :  * The same is true for autogroup's p->signal->autogroup->tg, the autogroup
    1491                 :            :  * core changes this before calling sched_move_task().
    1492                 :            :  *
    1493                 :            :  * Instead we use a 'copy' which is updated from sched_move_task() while
    1494                 :            :  * holding both task_struct::pi_lock and rq::lock.
    1495                 :            :  */
    1496                 :            : static inline struct task_group *task_group(struct task_struct *p)
    1497                 :            : {
    1498                 :    2361083 :         return p->sched_task_group;
    1499                 :            : }
    1500                 :            : 
    1501                 :            : /* Change a task's cfs_rq and parent entity if it moves across CPUs/groups */
    1502                 :    1157664 : static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
    1503                 :            : {
    1504                 :            : #if defined(CONFIG_FAIR_GROUP_SCHED) || defined(CONFIG_RT_GROUP_SCHED)
    1505                 :            :         struct task_group *tg = task_group(p);
    1506                 :            : #endif
    1507                 :            : 
    1508                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
    1509                 :    1157664 :         set_task_rq_fair(&p->se, p->se.cfs_rq, tg->cfs_rq[cpu]);
    1510                 :    1157397 :         p->se.cfs_rq = tg->cfs_rq[cpu];
    1511                 :    1157397 :         p->se.parent = tg->se[cpu];
    1512                 :            : #endif
    1513                 :            : 
    1514                 :            : #ifdef CONFIG_RT_GROUP_SCHED
    1515                 :            :         p->rt.rt_rq  = tg->rt_rq[cpu];
    1516                 :            :         p->rt.parent = tg->rt_se[cpu];
    1517                 :            : #endif
    1518                 :    1157397 : }
    1519                 :            : 
    1520                 :            : #else /* CONFIG_CGROUP_SCHED */
    1521                 :            : 
    1522                 :            : static inline void set_task_rq(struct task_struct *p, unsigned int cpu) { }
    1523                 :            : static inline struct task_group *task_group(struct task_struct *p)
    1524                 :            : {
    1525                 :            :         return NULL;
    1526                 :            : }
    1527                 :            : 
    1528                 :            : #endif /* CONFIG_CGROUP_SCHED */
    1529                 :            : 
    1530                 :            : static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
    1531                 :            : {
    1532                 :     747852 :         set_task_rq(p, cpu);
    1533                 :            : #ifdef CONFIG_SMP
    1534                 :            :         /*
    1535                 :            :          * After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
    1536                 :            :          * successfully executed on another CPU. We must ensure that updates of
    1537                 :            :          * per-task data have been completed by this moment.
    1538                 :            :          */
    1539                 :     748106 :         smp_wmb();
    1540                 :            : #ifdef CONFIG_THREAD_INFO_IN_TASK
    1541                 :            :         WRITE_ONCE(p->cpu, cpu);
    1542                 :            : #else
    1543                 :     747901 :         WRITE_ONCE(task_thread_info(p)->cpu, cpu);
    1544                 :            : #endif
    1545                 :     747901 :         p->wake_cpu = cpu;
    1546                 :            : #endif
    1547                 :            : }
    1548                 :            : 
    1549                 :            : /*
    1550                 :            :  * Tunables that become constants when CONFIG_SCHED_DEBUG is off:
    1551                 :            :  */
    1552                 :            : #ifdef CONFIG_SCHED_DEBUG
    1553                 :            : # include <linux/static_key.h>
    1554                 :            : # define const_debug __read_mostly
    1555                 :            : #else
    1556                 :            : # define const_debug const
    1557                 :            : #endif
    1558                 :            : 
    1559                 :            : #define SCHED_FEAT(name, enabled)       \
    1560                 :            :         __SCHED_FEAT_##name ,
    1561                 :            : 
    1562                 :            : enum {
    1563                 :            : #include "features.h"
    1564                 :            :         __SCHED_FEAT_NR,
    1565                 :            : };
    1566                 :            : 
    1567                 :            : #undef SCHED_FEAT
    1568                 :            : 
    1569                 :            : #if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_JUMP_LABEL)
    1570                 :            : 
    1571                 :            : /*
    1572                 :            :  * To support run-time toggling of sched features, all the translation units
    1573                 :            :  * (but core.c) reference the sysctl_sched_features defined in core.c.
    1574                 :            :  */
    1575                 :            : extern const_debug unsigned int sysctl_sched_features;
    1576                 :            : 
    1577                 :            : #define SCHED_FEAT(name, enabled)                                       \
    1578                 :            : static __always_inline bool static_branch_##name(struct static_key *key) \
    1579                 :            : {                                                                       \
    1580                 :            :         return static_key_##enabled(key);                               \
    1581                 :            : }
    1582                 :            : 
    1583                 :            : #include "features.h"
    1584                 :            : #undef SCHED_FEAT
    1585                 :            : 
    1586                 :            : extern struct static_key sched_feat_keys[__SCHED_FEAT_NR];
    1587                 :            : #define sched_feat(x) (static_branch_##x(&sched_feat_keys[__SCHED_FEAT_##x]))
    1588                 :            : 
    1589                 :            : #else /* !(SCHED_DEBUG && CONFIG_JUMP_LABEL) */
    1590                 :            : 
    1591                 :            : /*
    1592                 :            :  * Each translation unit has its own copy of sysctl_sched_features to allow
    1593                 :            :  * constants propagation at compile time and compiler optimization based on
    1594                 :            :  * features default.
    1595                 :            :  */
    1596                 :            : #define SCHED_FEAT(name, enabled)       \
    1597                 :            :         (1UL << __SCHED_FEAT_##name) * enabled |
    1598                 :            : static const_debug __maybe_unused unsigned int sysctl_sched_features =
    1599                 :            : #include "features.h"
    1600                 :            :         0;
    1601                 :            : #undef SCHED_FEAT
    1602                 :            : 
    1603                 :            : #define sched_feat(x) !!(sysctl_sched_features & (1UL << __SCHED_FEAT_##x))
    1604                 :            : 
    1605                 :            : #endif /* SCHED_DEBUG && CONFIG_JUMP_LABEL */
    1606                 :            : 
    1607                 :            : extern struct static_key_false sched_numa_balancing;
    1608                 :            : extern struct static_key_false sched_schedstats;
    1609                 :            : 
    1610                 :            : static inline u64 global_rt_period(void)
    1611                 :            : {
    1612                 :       2484 :         return (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
    1613                 :            : }
    1614                 :            : 
    1615                 :            : static inline u64 global_rt_runtime(void)
    1616                 :            : {
    1617   [ +  -  +  -  :       3726 :         if (sysctl_sched_rt_runtime < 0)
          #  #  +  -  +  
          -  +  -  #  #  
             +  -  +  - ]
    1618                 :            :                 return RUNTIME_INF;
    1619                 :            : 
    1620                 :       3726 :         return (u64)sysctl_sched_rt_runtime * NSEC_PER_USEC;
    1621                 :            : }
    1622                 :            : 
    1623                 :            : static inline int task_current(struct rq *rq, struct task_struct *p)
    1624                 :            : {
    1625                 :     230635 :         return rq->curr == p;
    1626                 :            : }
    1627                 :            : 
    1628                 :            : static inline int task_running(struct rq *rq, struct task_struct *p)
    1629                 :            : {
    1630                 :            : #ifdef CONFIG_SMP
    1631                 :    1109243 :         return p->on_cpu;
    1632                 :            : #else
    1633                 :            :         return task_current(rq, p);
    1634                 :            : #endif
    1635                 :            : }
    1636                 :            : 
    1637                 :            : static inline int task_on_rq_queued(struct task_struct *p)
    1638                 :            : {
    1639                 :    8359569 :         return p->on_rq == TASK_ON_RQ_QUEUED;
    1640                 :            : }
    1641                 :            : 
    1642                 :            : static inline int task_on_rq_migrating(struct task_struct *p)
    1643                 :            : {
    1644                 :     960220 :         return READ_ONCE(p->on_rq) == TASK_ON_RQ_MIGRATING;
    1645                 :            : }
    1646                 :            : 
    1647                 :            : /*
    1648                 :            :  * wake flags
    1649                 :            :  */
    1650                 :            : #define WF_SYNC                 0x01            /* Waker goes to sleep after wakeup */
    1651                 :            : #define WF_FORK                 0x02            /* Child wakeup after fork */
    1652                 :            : #define WF_MIGRATED             0x4             /* Internal use, task got migrated */
    1653                 :            : 
    1654                 :            : /*
    1655                 :            :  * To aid in avoiding the subversion of "niceness" due to uneven distribution
    1656                 :            :  * of tasks with abnormal "nice" values across CPUs the contribution that
    1657                 :            :  * each task makes to its run queue's load is weighted according to its
    1658                 :            :  * scheduling class and "nice" value. For SCHED_NORMAL tasks this is just a
    1659                 :            :  * scaled version of the new time slice allocation that they receive on time
    1660                 :            :  * slice expiry etc.
    1661                 :            :  */
    1662                 :            : 
    1663                 :            : #define WEIGHT_IDLEPRIO         3
    1664                 :            : #define WMULT_IDLEPRIO          1431655765
    1665                 :            : 
    1666                 :            : extern const int                sched_prio_to_weight[40];
    1667                 :            : extern const u32                sched_prio_to_wmult[40];
    1668                 :            : 
    1669                 :            : /*
    1670                 :            :  * {de,en}queue flags:
    1671                 :            :  *
    1672                 :            :  * DEQUEUE_SLEEP  - task is no longer runnable
    1673                 :            :  * ENQUEUE_WAKEUP - task just became runnable
    1674                 :            :  *
    1675                 :            :  * SAVE/RESTORE - an otherwise spurious dequeue/enqueue, done to ensure tasks
    1676                 :            :  *                are in a known state which allows modification. Such pairs
    1677                 :            :  *                should preserve as much state as possible.
    1678                 :            :  *
    1679                 :            :  * MOVE - paired with SAVE/RESTORE, explicitly does not preserve the location
    1680                 :            :  *        in the runqueue.
    1681                 :            :  *
    1682                 :            :  * ENQUEUE_HEAD      - place at front of runqueue (tail if not specified)
    1683                 :            :  * ENQUEUE_REPLENISH - CBS (replenish runtime and postpone deadline)
    1684                 :            :  * ENQUEUE_MIGRATED  - the task was migrated during wakeup
    1685                 :            :  *
    1686                 :            :  */
    1687                 :            : 
    1688                 :            : #define DEQUEUE_SLEEP           0x01
    1689                 :            : #define DEQUEUE_SAVE            0x02 /* Matches ENQUEUE_RESTORE */
    1690                 :            : #define DEQUEUE_MOVE            0x04 /* Matches ENQUEUE_MOVE */
    1691                 :            : #define DEQUEUE_NOCLOCK         0x08 /* Matches ENQUEUE_NOCLOCK */
    1692                 :            : 
    1693                 :            : #define ENQUEUE_WAKEUP          0x01
    1694                 :            : #define ENQUEUE_RESTORE         0x02
    1695                 :            : #define ENQUEUE_MOVE            0x04
    1696                 :            : #define ENQUEUE_NOCLOCK         0x08
    1697                 :            : 
    1698                 :            : #define ENQUEUE_HEAD            0x10
    1699                 :            : #define ENQUEUE_REPLENISH       0x20
    1700                 :            : #ifdef CONFIG_SMP
    1701                 :            : #define ENQUEUE_MIGRATED        0x40
    1702                 :            : #else
    1703                 :            : #define ENQUEUE_MIGRATED        0x00
    1704                 :            : #endif
    1705                 :            : 
    1706                 :            : #define RETRY_TASK              ((void *)-1UL)
    1707                 :            : 
    1708                 :            : struct sched_class {
    1709                 :            :         const struct sched_class *next;
    1710                 :            : 
    1711                 :            : #ifdef CONFIG_UCLAMP_TASK
    1712                 :            :         int uclamp_enabled;
    1713                 :            : #endif
    1714                 :            : 
    1715                 :            :         void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
    1716                 :            :         void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
    1717                 :            :         void (*yield_task)   (struct rq *rq);
    1718                 :            :         bool (*yield_to_task)(struct rq *rq, struct task_struct *p, bool preempt);
    1719                 :            : 
    1720                 :            :         void (*check_preempt_curr)(struct rq *rq, struct task_struct *p, int flags);
    1721                 :            : 
    1722                 :            :         /*
    1723                 :            :          * Both @prev and @rf are optional and may be NULL, in which case the
    1724                 :            :          * caller must already have invoked put_prev_task(rq, prev, rf).
    1725                 :            :          *
    1726                 :            :          * Otherwise it is the responsibility of the pick_next_task() to call
    1727                 :            :          * put_prev_task() on the @prev task or something equivalent, IFF it
    1728                 :            :          * returns a next task.
    1729                 :            :          *
    1730                 :            :          * In that case (@rf != NULL) it may return RETRY_TASK when it finds a
    1731                 :            :          * higher prio class has runnable tasks.
    1732                 :            :          */
    1733                 :            :         struct task_struct * (*pick_next_task)(struct rq *rq,
    1734                 :            :                                                struct task_struct *prev,
    1735                 :            :                                                struct rq_flags *rf);
    1736                 :            :         void (*put_prev_task)(struct rq *rq, struct task_struct *p);
    1737                 :            :         void (*set_next_task)(struct rq *rq, struct task_struct *p, bool first);
    1738                 :            : 
    1739                 :            : #ifdef CONFIG_SMP
    1740                 :            :         int (*balance)(struct rq *rq, struct task_struct *prev, struct rq_flags *rf);
    1741                 :            :         int  (*select_task_rq)(struct task_struct *p, int task_cpu, int sd_flag, int flags);
    1742                 :            :         void (*migrate_task_rq)(struct task_struct *p, int new_cpu);
    1743                 :            : 
    1744                 :            :         void (*task_woken)(struct rq *this_rq, struct task_struct *task);
    1745                 :            : 
    1746                 :            :         void (*set_cpus_allowed)(struct task_struct *p,
    1747                 :            :                                  const struct cpumask *newmask);
    1748                 :            : 
    1749                 :            :         void (*rq_online)(struct rq *rq);
    1750                 :            :         void (*rq_offline)(struct rq *rq);
    1751                 :            : #endif
    1752                 :            : 
    1753                 :            :         void (*task_tick)(struct rq *rq, struct task_struct *p, int queued);
    1754                 :            :         void (*task_fork)(struct task_struct *p);
    1755                 :            :         void (*task_dead)(struct task_struct *p);
    1756                 :            : 
    1757                 :            :         /*
    1758                 :            :          * The switched_from() call is allowed to drop rq->lock, therefore we
    1759                 :            :          * cannot assume the switched_from/switched_to pair is serliazed by
    1760                 :            :          * rq->lock. They are however serialized by p->pi_lock.
    1761                 :            :          */
    1762                 :            :         void (*switched_from)(struct rq *this_rq, struct task_struct *task);
    1763                 :            :         void (*switched_to)  (struct rq *this_rq, struct task_struct *task);
    1764                 :            :         void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
    1765                 :            :                               int oldprio);
    1766                 :            : 
    1767                 :            :         unsigned int (*get_rr_interval)(struct rq *rq,
    1768                 :            :                                         struct task_struct *task);
    1769                 :            : 
    1770                 :            :         void (*update_curr)(struct rq *rq);
    1771                 :            : 
    1772                 :            : #define TASK_SET_GROUP          0
    1773                 :            : #define TASK_MOVE_GROUP         1
    1774                 :            : 
    1775                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
    1776                 :            :         void (*task_change_group)(struct task_struct *p, int type);
    1777                 :            : #endif
    1778                 :            : };
    1779                 :            : 
    1780                 :    5547420 : static inline void put_prev_task(struct rq *rq, struct task_struct *prev)
    1781                 :            : {
    1782   [ -  +  #  # ]:    5547420 :         WARN_ON_ONCE(rq->curr != prev);
    1783                 :    5547420 :         prev->sched_class->put_prev_task(rq, prev);
    1784                 :    5552338 : }
    1785                 :            : 
    1786                 :     195786 : static inline void set_next_task(struct rq *rq, struct task_struct *next)
    1787                 :            : {
    1788   [ -  +  #  # ]:     195786 :         WARN_ON_ONCE(rq->curr != next);
    1789                 :     195786 :         next->sched_class->set_next_task(rq, next, false);
    1790                 :     196417 : }
    1791                 :            : 
    1792                 :            : #ifdef CONFIG_SMP
    1793                 :            : #define sched_class_highest (&stop_sched_class)
    1794                 :            : #else
    1795                 :            : #define sched_class_highest (&dl_sched_class)
    1796                 :            : #endif
    1797                 :            : 
    1798                 :            : #define for_class_range(class, _from, _to) \
    1799                 :            :         for (class = (_from); class != (_to); class = class->next)
    1800                 :            : 
    1801                 :            : #define for_each_class(class) \
    1802                 :            :         for_class_range(class, sched_class_highest, NULL)
    1803                 :            : 
    1804                 :            : extern const struct sched_class stop_sched_class;
    1805                 :            : extern const struct sched_class dl_sched_class;
    1806                 :            : extern const struct sched_class rt_sched_class;
    1807                 :            : extern const struct sched_class fair_sched_class;
    1808                 :            : extern const struct sched_class idle_sched_class;
    1809                 :            : 
    1810                 :            : static inline bool sched_stop_runnable(struct rq *rq)
    1811                 :            : {
    1812   [ +  +  +  +  :    1130211 :         return rq->stop && task_on_rq_queued(rq->stop);
             +  +  +  + ]
    1813                 :            : }
    1814                 :            : 
    1815                 :            : static inline bool sched_dl_runnable(struct rq *rq)
    1816                 :            : {
    1817                 :     334271 :         return rq->dl.dl_nr_running > 0;
    1818                 :            : }
    1819                 :            : 
    1820                 :            : static inline bool sched_rt_runnable(struct rq *rq)
    1821                 :            : {
    1822                 :     220869 :         return rq->rt.rt_queued > 0;
    1823                 :            : }
    1824                 :            : 
    1825                 :            : static inline bool sched_fair_runnable(struct rq *rq)
    1826                 :            : {
    1827                 :   11906548 :         return rq->cfs.nr_running > 0;
    1828                 :            : }
    1829                 :            : 
    1830                 :            : #ifdef CONFIG_SMP
    1831                 :            : 
    1832                 :            : extern void update_group_capacity(struct sched_domain *sd, int cpu);
    1833                 :            : 
    1834                 :            : extern void trigger_load_balance(struct rq *rq);
    1835                 :            : 
    1836                 :            : extern void set_cpus_allowed_common(struct task_struct *p, const struct cpumask *new_mask);
    1837                 :            : 
    1838                 :            : #endif
    1839                 :            : 
    1840                 :            : #ifdef CONFIG_CPU_IDLE
    1841                 :            : static inline void idle_set_state(struct rq *rq,
    1842                 :            :                                   struct cpuidle_state *idle_state)
    1843                 :            : {
    1844                 :            :         rq->idle_state = idle_state;
    1845                 :            : }
    1846                 :            : 
    1847                 :            : static inline struct cpuidle_state *idle_get_state(struct rq *rq)
    1848                 :            : {
    1849                 :            :         SCHED_WARN_ON(!rcu_read_lock_held());
    1850                 :            : 
    1851                 :            :         return rq->idle_state;
    1852                 :            : }
    1853                 :            : #else
    1854                 :            : static inline void idle_set_state(struct rq *rq,
    1855                 :            :                                   struct cpuidle_state *idle_state)
    1856                 :            : {
    1857                 :            : }
    1858                 :            : 
    1859                 :            : static inline struct cpuidle_state *idle_get_state(struct rq *rq)
    1860                 :            : {
    1861                 :            :         return NULL;
    1862                 :            : }
    1863                 :            : #endif
    1864                 :            : 
    1865                 :            : extern void schedule_idle(void);
    1866                 :            : 
    1867                 :            : extern void sysrq_sched_debug_show(void);
    1868                 :            : extern void sched_init_granularity(void);
    1869                 :            : extern void update_max_interval(void);
    1870                 :            : 
    1871                 :            : extern void init_sched_dl_class(void);
    1872                 :            : extern void init_sched_rt_class(void);
    1873                 :            : extern void init_sched_fair_class(void);
    1874                 :            : 
    1875                 :            : extern void reweight_task(struct task_struct *p, int prio);
    1876                 :            : 
    1877                 :            : extern void resched_curr(struct rq *rq);
    1878                 :            : extern void resched_cpu(int cpu);
    1879                 :            : 
    1880                 :            : extern struct rt_bandwidth def_rt_bandwidth;
    1881                 :            : extern void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime);
    1882                 :            : 
    1883                 :            : extern struct dl_bandwidth def_dl_bandwidth;
    1884                 :            : extern void init_dl_bandwidth(struct dl_bandwidth *dl_b, u64 period, u64 runtime);
    1885                 :            : extern void init_dl_task_timer(struct sched_dl_entity *dl_se);
    1886                 :            : extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);
    1887                 :            : extern void init_dl_rq_bw_ratio(struct dl_rq *dl_rq);
    1888                 :            : 
    1889                 :            : #define BW_SHIFT                20
    1890                 :            : #define BW_UNIT                 (1 << BW_SHIFT)
    1891                 :            : #define RATIO_SHIFT             8
    1892                 :            : #define MAX_BW_BITS             (64 - BW_SHIFT)
    1893                 :            : #define MAX_BW                  ((1ULL << MAX_BW_BITS) - 1)
    1894                 :            : unsigned long to_ratio(u64 period, u64 runtime);
    1895                 :            : 
    1896                 :            : extern void init_entity_runnable_average(struct sched_entity *se);
    1897                 :            : extern void post_init_entity_util_avg(struct task_struct *p);
    1898                 :            : 
    1899                 :            : #ifdef CONFIG_NO_HZ_FULL
    1900                 :            : extern bool sched_can_stop_tick(struct rq *rq);
    1901                 :            : extern int __init sched_tick_offload_init(void);
    1902                 :            : 
    1903                 :            : /*
    1904                 :            :  * Tick may be needed by tasks in the runqueue depending on their policy and
    1905                 :            :  * requirements. If tick is needed, lets send the target an IPI to kick it out of
    1906                 :            :  * nohz mode if necessary.
    1907                 :            :  */
    1908                 :            : static inline void sched_update_tick_dependency(struct rq *rq)
    1909                 :            : {
    1910                 :            :         int cpu;
    1911                 :            : 
    1912                 :            :         if (!tick_nohz_full_enabled())
    1913                 :            :                 return;
    1914                 :            : 
    1915                 :            :         cpu = cpu_of(rq);
    1916                 :            : 
    1917                 :            :         if (!tick_nohz_full_cpu(cpu))
    1918                 :            :                 return;
    1919                 :            : 
    1920                 :            :         if (sched_can_stop_tick(rq))
    1921                 :            :                 tick_nohz_dep_clear_cpu(cpu, TICK_DEP_BIT_SCHED);
    1922                 :            :         else
    1923                 :            :                 tick_nohz_dep_set_cpu(cpu, TICK_DEP_BIT_SCHED);
    1924                 :            : }
    1925                 :            : #else
    1926                 :            : static inline int sched_tick_offload_init(void) { return 0; }
    1927                 :            : static inline void sched_update_tick_dependency(struct rq *rq) { }
    1928                 :            : #endif
    1929                 :            : 
    1930                 :            : static inline void add_nr_running(struct rq *rq, unsigned count)
    1931                 :            : {
    1932                 :    7353213 :         unsigned prev_nr = rq->nr_running;
    1933                 :            : 
    1934                 :    7353213 :         rq->nr_running = prev_nr + count;
    1935                 :            : 
    1936                 :            : #ifdef CONFIG_SMP
    1937   [ +  +  +  +  :    7353213 :         if (prev_nr < 2 && rq->nr_running >= 2) {
             #  #  #  # ]
    1938   [ +  +  #  # ]:    5913794 :                 if (!READ_ONCE(rq->rd->overload))
    1939                 :            :                         WRITE_ONCE(rq->rd->overload, 1);
    1940                 :            :         }
    1941                 :            : #endif
    1942                 :            : 
    1943                 :            :         sched_update_tick_dependency(rq);
    1944                 :            : }
    1945                 :            : 
    1946                 :            : static inline void sub_nr_running(struct rq *rq, unsigned count)
    1947                 :            : {
    1948                 :    7351434 :         rq->nr_running -= count;
    1949                 :            :         /* Check if we still need preemption */
    1950                 :            :         sched_update_tick_dependency(rq);
    1951                 :            : }
    1952                 :            : 
    1953                 :            : extern void activate_task(struct rq *rq, struct task_struct *p, int flags);
    1954                 :            : extern void deactivate_task(struct rq *rq, struct task_struct *p, int flags);
    1955                 :            : 
    1956                 :            : extern void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags);
    1957                 :            : 
    1958                 :            : extern const_debug unsigned int sysctl_sched_nr_migrate;
    1959                 :            : extern const_debug unsigned int sysctl_sched_migration_cost;
    1960                 :            : 
    1961                 :            : #ifdef CONFIG_SCHED_HRTICK
    1962                 :            : 
    1963                 :            : /*
    1964                 :            :  * Use hrtick when:
    1965                 :            :  *  - enabled by features
    1966                 :            :  *  - hrtimer is actually high res
    1967                 :            :  */
    1968                 :   23586196 : static inline int hrtick_enabled(struct rq *rq)
    1969                 :            : {
    1970         [ -  + ]:   23565562 :         if (!sched_feat(HRTICK))
    1971                 :            :                 return 0;
    1972         [ #  # ]:          0 :         if (!cpu_active(cpu_of(rq)))
    1973                 :            :                 return 0;
    1974                 :          0 :         return hrtimer_is_hres_active(&rq->hrtick_timer);
    1975                 :            : }
    1976                 :            : 
    1977                 :            : void hrtick_start(struct rq *rq, u64 delay);
    1978                 :            : 
    1979                 :            : #else
    1980                 :            : 
    1981                 :            : static inline int hrtick_enabled(struct rq *rq)
    1982                 :            : {
    1983                 :            :         return 0;
    1984                 :            : }
    1985                 :            : 
    1986                 :            : #endif /* CONFIG_SCHED_HRTICK */
    1987                 :            : 
    1988                 :            : #ifndef arch_scale_freq_capacity
    1989                 :            : static __always_inline
    1990                 :            : unsigned long arch_scale_freq_capacity(int cpu)
    1991                 :            : {
    1992                 :            :         return SCHED_CAPACITY_SCALE;
    1993                 :            : }
    1994                 :            : #endif
    1995                 :            : 
    1996                 :            : #ifdef CONFIG_SMP
    1997                 :            : #ifdef CONFIG_PREEMPTION
    1998                 :            : 
    1999                 :            : static inline void double_rq_lock(struct rq *rq1, struct rq *rq2);
    2000                 :            : 
    2001                 :            : /*
    2002                 :            :  * fair double_lock_balance: Safely acquires both rq->locks in a fair
    2003                 :            :  * way at the expense of forcing extra atomic operations in all
    2004                 :            :  * invocations.  This assures that the double_lock is acquired using the
    2005                 :            :  * same underlying policy as the spinlock_t on this architecture, which
    2006                 :            :  * reduces latency compared to the unfair variant below.  However, it
    2007                 :            :  * also adds more overhead and therefore may reduce throughput.
    2008                 :            :  */
    2009                 :            : static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
    2010                 :            :         __releases(this_rq->lock)
    2011                 :            :         __acquires(busiest->lock)
    2012                 :            :         __acquires(this_rq->lock)
    2013                 :            : {
    2014                 :            :         raw_spin_unlock(&this_rq->lock);
    2015                 :            :         double_rq_lock(this_rq, busiest);
    2016                 :            : 
    2017                 :            :         return 1;
    2018                 :            : }
    2019                 :            : 
    2020                 :            : #else
    2021                 :            : /*
    2022                 :            :  * Unfair double_lock_balance: Optimizes throughput at the expense of
    2023                 :            :  * latency by eliminating extra atomic operations when the locks are
    2024                 :            :  * already in proper order on entry.  This favors lower CPU-ids and will
    2025                 :            :  * grant the double lock to lower CPUs over higher ids under contention,
    2026                 :            :  * regardless of entry order into the function.
    2027                 :            :  */
    2028                 :          0 : static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
    2029                 :            :         __releases(this_rq->lock)
    2030                 :            :         __acquires(busiest->lock)
    2031                 :            :         __acquires(this_rq->lock)
    2032                 :            : {
    2033                 :            :         int ret = 0;
    2034                 :            : 
    2035         [ #  # ]:          0 :         if (unlikely(!raw_spin_trylock(&busiest->lock))) {
    2036         [ #  # ]:          0 :                 if (busiest < this_rq) {
    2037                 :            :                         raw_spin_unlock(&this_rq->lock);
    2038                 :          0 :                         raw_spin_lock(&busiest->lock);
    2039                 :          0 :                         raw_spin_lock_nested(&this_rq->lock,
    2040                 :            :                                               SINGLE_DEPTH_NESTING);
    2041                 :            :                         ret = 1;
    2042                 :            :                 } else
    2043                 :          0 :                         raw_spin_lock_nested(&busiest->lock,
    2044                 :            :                                               SINGLE_DEPTH_NESTING);
    2045                 :            :         }
    2046                 :          0 :         return ret;
    2047                 :            : }
    2048                 :            : 
    2049                 :            : #endif /* CONFIG_PREEMPTION */
    2050                 :            : 
    2051                 :            : /*
    2052                 :            :  * double_lock_balance - lock the busiest runqueue, this_rq is locked already.
    2053                 :            :  */
    2054                 :          0 : static inline int double_lock_balance(struct rq *this_rq, struct rq *busiest)
    2055                 :            : {
    2056         [ #  # ]:          0 :         if (unlikely(!irqs_disabled())) {
    2057                 :            :                 /* printk() doesn't work well under rq->lock */
    2058                 :            :                 raw_spin_unlock(&this_rq->lock);
    2059                 :          0 :                 BUG_ON(1);
    2060                 :            :         }
    2061                 :            : 
    2062                 :          0 :         return _double_lock_balance(this_rq, busiest);
    2063                 :            : }
    2064                 :            : 
    2065                 :            : static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
    2066                 :            :         __releases(busiest->lock)
    2067                 :            : {
    2068                 :            :         raw_spin_unlock(&busiest->lock);
    2069                 :            :         lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
    2070                 :            : }
    2071                 :            : 
    2072                 :            : static inline void double_lock(spinlock_t *l1, spinlock_t *l2)
    2073                 :            : {
    2074                 :            :         if (l1 > l2)
    2075                 :            :                 swap(l1, l2);
    2076                 :            : 
    2077                 :            :         spin_lock(l1);
    2078                 :            :         spin_lock_nested(l2, SINGLE_DEPTH_NESTING);
    2079                 :            : }
    2080                 :            : 
    2081                 :            : static inline void double_lock_irq(spinlock_t *l1, spinlock_t *l2)
    2082                 :            : {
    2083                 :            :         if (l1 > l2)
    2084                 :            :                 swap(l1, l2);
    2085                 :            : 
    2086                 :            :         spin_lock_irq(l1);
    2087                 :            :         spin_lock_nested(l2, SINGLE_DEPTH_NESTING);
    2088                 :            : }
    2089                 :            : 
    2090                 :            : static inline void double_raw_lock(raw_spinlock_t *l1, raw_spinlock_t *l2)
    2091                 :            : {
    2092                 :            :         if (l1 > l2)
    2093                 :            :                 swap(l1, l2);
    2094                 :            : 
    2095                 :            :         raw_spin_lock(l1);
    2096                 :            :         raw_spin_lock_nested(l2, SINGLE_DEPTH_NESTING);
    2097                 :            : }
    2098                 :            : 
    2099                 :            : /*
    2100                 :            :  * double_rq_lock - safely lock two runqueues
    2101                 :            :  *
    2102                 :            :  * Note this does not disable interrupts like task_rq_lock,
    2103                 :            :  * you need to do so manually before calling.
    2104                 :            :  */
    2105                 :          0 : static inline void double_rq_lock(struct rq *rq1, struct rq *rq2)
    2106                 :            :         __acquires(rq1->lock)
    2107                 :            :         __acquires(rq2->lock)
    2108                 :            : {
    2109         [ #  # ]:          0 :         BUG_ON(!irqs_disabled());
    2110         [ #  # ]:          0 :         if (rq1 == rq2) {
    2111                 :          0 :                 raw_spin_lock(&rq1->lock);
    2112                 :            :                 __acquire(rq2->lock);        /* Fake it out ;) */
    2113                 :            :         } else {
    2114         [ #  # ]:          0 :                 if (rq1 < rq2) {
    2115                 :          0 :                         raw_spin_lock(&rq1->lock);
    2116                 :          0 :                         raw_spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
    2117                 :            :                 } else {
    2118                 :          0 :                         raw_spin_lock(&rq2->lock);
    2119                 :          0 :                         raw_spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
    2120                 :            :                 }
    2121                 :            :         }
    2122                 :          0 : }
    2123                 :            : 
    2124                 :            : /*
    2125                 :            :  * double_rq_unlock - safely unlock two runqueues
    2126                 :            :  *
    2127                 :            :  * Note this does not restore interrupts like task_rq_unlock,
    2128                 :            :  * you need to do so manually after calling.
    2129                 :            :  */
    2130                 :          0 : static inline void double_rq_unlock(struct rq *rq1, struct rq *rq2)
    2131                 :            :         __releases(rq1->lock)
    2132                 :            :         __releases(rq2->lock)
    2133                 :            : {
    2134                 :            :         raw_spin_unlock(&rq1->lock);
    2135         [ #  # ]:          0 :         if (rq1 != rq2)
    2136                 :            :                 raw_spin_unlock(&rq2->lock);
    2137                 :            :         else
    2138                 :            :                 __release(rq2->lock);
    2139                 :          0 : }
    2140                 :            : 
    2141                 :            : extern void set_rq_online (struct rq *rq);
    2142                 :            : extern void set_rq_offline(struct rq *rq);
    2143                 :            : extern bool sched_smp_initialized;
    2144                 :            : 
    2145                 :            : #else /* CONFIG_SMP */
    2146                 :            : 
    2147                 :            : /*
    2148                 :            :  * double_rq_lock - safely lock two runqueues
    2149                 :            :  *
    2150                 :            :  * Note this does not disable interrupts like task_rq_lock,
    2151                 :            :  * you need to do so manually before calling.
    2152                 :            :  */
    2153                 :            : static inline void double_rq_lock(struct rq *rq1, struct rq *rq2)
    2154                 :            :         __acquires(rq1->lock)
    2155                 :            :         __acquires(rq2->lock)
    2156                 :            : {
    2157                 :            :         BUG_ON(!irqs_disabled());
    2158                 :            :         BUG_ON(rq1 != rq2);
    2159                 :            :         raw_spin_lock(&rq1->lock);
    2160                 :            :         __acquire(rq2->lock);        /* Fake it out ;) */
    2161                 :            : }
    2162                 :            : 
    2163                 :            : /*
    2164                 :            :  * double_rq_unlock - safely unlock two runqueues
    2165                 :            :  *
    2166                 :            :  * Note this does not restore interrupts like task_rq_unlock,
    2167                 :            :  * you need to do so manually after calling.
    2168                 :            :  */
    2169                 :            : static inline void double_rq_unlock(struct rq *rq1, struct rq *rq2)
    2170                 :            :         __releases(rq1->lock)
    2171                 :            :         __releases(rq2->lock)
    2172                 :            : {
    2173                 :            :         BUG_ON(rq1 != rq2);
    2174                 :            :         raw_spin_unlock(&rq1->lock);
    2175                 :            :         __release(rq2->lock);
    2176                 :            : }
    2177                 :            : 
    2178                 :            : #endif
    2179                 :            : 
    2180                 :            : extern struct sched_entity *__pick_first_entity(struct cfs_rq *cfs_rq);
    2181                 :            : extern struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq);
    2182                 :            : 
    2183                 :            : #ifdef  CONFIG_SCHED_DEBUG
    2184                 :            : extern bool sched_debug_enabled;
    2185                 :            : 
    2186                 :            : extern void print_cfs_stats(struct seq_file *m, int cpu);
    2187                 :            : extern void print_rt_stats(struct seq_file *m, int cpu);
    2188                 :            : extern void print_dl_stats(struct seq_file *m, int cpu);
    2189                 :            : extern void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
    2190                 :            : extern void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq);
    2191                 :            : extern void print_dl_rq(struct seq_file *m, int cpu, struct dl_rq *dl_rq);
    2192                 :            : #ifdef CONFIG_NUMA_BALANCING
    2193                 :            : extern void
    2194                 :            : show_numa_stats(struct task_struct *p, struct seq_file *m);
    2195                 :            : extern void
    2196                 :            : print_numa_stats(struct seq_file *m, int node, unsigned long tsf,
    2197                 :            :         unsigned long tpf, unsigned long gsf, unsigned long gpf);
    2198                 :            : #endif /* CONFIG_NUMA_BALANCING */
    2199                 :            : #endif /* CONFIG_SCHED_DEBUG */
    2200                 :            : 
    2201                 :            : extern void init_cfs_rq(struct cfs_rq *cfs_rq);
    2202                 :            : extern void init_rt_rq(struct rt_rq *rt_rq);
    2203                 :            : extern void init_dl_rq(struct dl_rq *dl_rq);
    2204                 :            : 
    2205                 :            : extern void cfs_bandwidth_usage_inc(void);
    2206                 :            : extern void cfs_bandwidth_usage_dec(void);
    2207                 :            : 
    2208                 :            : #ifdef CONFIG_NO_HZ_COMMON
    2209                 :            : #define NOHZ_BALANCE_KICK_BIT   0
    2210                 :            : #define NOHZ_STATS_KICK_BIT     1
    2211                 :            : 
    2212                 :            : #define NOHZ_BALANCE_KICK       BIT(NOHZ_BALANCE_KICK_BIT)
    2213                 :            : #define NOHZ_STATS_KICK         BIT(NOHZ_STATS_KICK_BIT)
    2214                 :            : 
    2215                 :            : #define NOHZ_KICK_MASK  (NOHZ_BALANCE_KICK | NOHZ_STATS_KICK)
    2216                 :            : 
    2217                 :            : #define nohz_flags(cpu) (&cpu_rq(cpu)->nohz_flags)
    2218                 :            : 
    2219                 :            : extern void nohz_balance_exit_idle(struct rq *rq);
    2220                 :            : #else
    2221                 :            : static inline void nohz_balance_exit_idle(struct rq *rq) { }
    2222                 :            : #endif
    2223                 :            : 
    2224                 :            : 
    2225                 :            : #ifdef CONFIG_SMP
    2226                 :            : static inline
    2227                 :          0 : void __dl_update(struct dl_bw *dl_b, s64 bw)
    2228                 :            : {
    2229                 :            :         struct root_domain *rd = container_of(dl_b, struct root_domain, dl_bw);
    2230                 :            :         int i;
    2231                 :            : 
    2232                 :            :         RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held(),
    2233                 :            :                          "sched RCU must be held");
    2234         [ #  # ]:          0 :         for_each_cpu_and(i, rd->span, cpu_active_mask) {
    2235                 :          0 :                 struct rq *rq = cpu_rq(i);
    2236                 :            : 
    2237                 :          0 :                 rq->dl.extra_bw += bw;
    2238                 :            :         }
    2239                 :          0 : }
    2240                 :            : #else
    2241                 :            : static inline
    2242                 :            : void __dl_update(struct dl_bw *dl_b, s64 bw)
    2243                 :            : {
    2244                 :            :         struct dl_rq *dl = container_of(dl_b, struct dl_rq, dl_bw);
    2245                 :            : 
    2246                 :            :         dl->extra_bw += bw;
    2247                 :            : }
    2248                 :            : #endif
    2249                 :            : 
    2250                 :            : 
    2251                 :            : #ifdef CONFIG_IRQ_TIME_ACCOUNTING
    2252                 :            : struct irqtime {
    2253                 :            :         u64                     total;
    2254                 :            :         u64                     tick_delta;
    2255                 :            :         u64                     irq_start_time;
    2256                 :            :         struct u64_stats_sync   sync;
    2257                 :            : };
    2258                 :            : 
    2259                 :            : DECLARE_PER_CPU(struct irqtime, cpu_irqtime);
    2260                 :            : 
    2261                 :            : /*
    2262                 :            :  * Returns the irqtime minus the softirq time computed by ksoftirqd.
    2263                 :            :  * Otherwise ksoftirqd's sum_exec_runtime is substracted its own runtime
    2264                 :            :  * and never move forward.
    2265                 :            :  */
    2266                 :            : static inline u64 irq_time_read(int cpu)
    2267                 :            : {
    2268                 :            :         struct irqtime *irqtime = &per_cpu(cpu_irqtime, cpu);
    2269                 :            :         unsigned int seq;
    2270                 :            :         u64 total;
    2271                 :            : 
    2272                 :            :         do {
    2273                 :            :                 seq = __u64_stats_fetch_begin(&irqtime->sync);
    2274                 :            :                 total = irqtime->total;
    2275                 :            :         } while (__u64_stats_fetch_retry(&irqtime->sync, seq));
    2276                 :            : 
    2277                 :            :         return total;
    2278                 :            : }
    2279                 :            : #endif /* CONFIG_IRQ_TIME_ACCOUNTING */
    2280                 :            : 
    2281                 :            : #ifdef CONFIG_CPU_FREQ
    2282                 :            : DECLARE_PER_CPU(struct update_util_data __rcu *, cpufreq_update_util_data);
    2283                 :            : 
    2284                 :            : /**
    2285                 :            :  * cpufreq_update_util - Take a note about CPU utilization changes.
    2286                 :            :  * @rq: Runqueue to carry out the update for.
    2287                 :            :  * @flags: Update reason flags.
    2288                 :            :  *
    2289                 :            :  * This function is called by the scheduler on the CPU whose utilization is
    2290                 :            :  * being updated.
    2291                 :            :  *
    2292                 :            :  * It can only be called from RCU-sched read-side critical sections.
    2293                 :            :  *
    2294                 :            :  * The way cpufreq is currently arranged requires it to evaluate the CPU
    2295                 :            :  * performance state (frequency/voltage) on a regular basis to prevent it from
    2296                 :            :  * being stuck in a completely inadequate performance level for too long.
    2297                 :            :  * That is not guaranteed to happen if the updates are only triggered from CFS
    2298                 :            :  * and DL, though, because they may not be coming in if only RT tasks are
    2299                 :            :  * active all the time (or there are RT tasks only).
    2300                 :            :  *
    2301                 :            :  * As a workaround for that issue, this function is called periodically by the
    2302                 :            :  * RT sched class to trigger extra cpufreq updates to prevent it from stalling,
    2303                 :            :  * but that really is a band-aid.  Going forward it should be replaced with
    2304                 :            :  * solutions targeted more specifically at RT tasks.
    2305                 :            :  */
    2306                 :   14075511 : static inline void cpufreq_update_util(struct rq *rq, unsigned int flags)
    2307                 :            : {
    2308                 :            :         struct update_util_data *data;
    2309                 :            : 
    2310                 :   42226533 :         data = rcu_dereference_sched(*per_cpu_ptr(&cpufreq_update_util_data,
    2311                 :            :                                                   cpu_of(rq)));
    2312         [ +  + ]:   14075511 :         if (data)
    2313                 :   15701434 :                 data->func(data, rq_clock(rq), flags);
    2314                 :   14085501 : }
    2315                 :            : #else
    2316                 :            : static inline void cpufreq_update_util(struct rq *rq, unsigned int flags) {}
    2317                 :            : #endif /* CONFIG_CPU_FREQ */
    2318                 :            : 
    2319                 :            : #ifdef CONFIG_UCLAMP_TASK
    2320                 :            : unsigned int uclamp_eff_value(struct task_struct *p, enum uclamp_id clamp_id);
    2321                 :            : 
    2322                 :            : static __always_inline
    2323                 :            : unsigned int uclamp_util_with(struct rq *rq, unsigned int util,
    2324                 :            :                               struct task_struct *p)
    2325                 :            : {
    2326                 :            :         unsigned int min_util = READ_ONCE(rq->uclamp[UCLAMP_MIN].value);
    2327                 :            :         unsigned int max_util = READ_ONCE(rq->uclamp[UCLAMP_MAX].value);
    2328                 :            : 
    2329                 :            :         if (p) {
    2330                 :            :                 min_util = max(min_util, uclamp_eff_value(p, UCLAMP_MIN));
    2331                 :            :                 max_util = max(max_util, uclamp_eff_value(p, UCLAMP_MAX));
    2332                 :            :         }
    2333                 :            : 
    2334                 :            :         /*
    2335                 :            :          * Since CPU's {min,max}_util clamps are MAX aggregated considering
    2336                 :            :          * RUNNABLE tasks with _different_ clamps, we can end up with an
    2337                 :            :          * inversion. Fix it now when the clamps are applied.
    2338                 :            :          */
    2339                 :            :         if (unlikely(min_util >= max_util))
    2340                 :            :                 return min_util;
    2341                 :            : 
    2342                 :            :         return clamp(util, min_util, max_util);
    2343                 :            : }
    2344                 :            : 
    2345                 :            : static inline unsigned int uclamp_util(struct rq *rq, unsigned int util)
    2346                 :            : {
    2347                 :            :         return uclamp_util_with(rq, util, NULL);
    2348                 :            : }
    2349                 :            : #else /* CONFIG_UCLAMP_TASK */
    2350                 :            : static inline unsigned int uclamp_util_with(struct rq *rq, unsigned int util,
    2351                 :            :                                             struct task_struct *p)
    2352                 :            : {
    2353                 :            :         return util;
    2354                 :            : }
    2355                 :            : static inline unsigned int uclamp_util(struct rq *rq, unsigned int util)
    2356                 :            : {
    2357                 :            :         return util;
    2358                 :            : }
    2359                 :            : #endif /* CONFIG_UCLAMP_TASK */
    2360                 :            : 
    2361                 :            : #ifdef arch_scale_freq_capacity
    2362                 :            : # ifndef arch_scale_freq_invariant
    2363                 :            : #  define arch_scale_freq_invariant()   true
    2364                 :            : # endif
    2365                 :            : #else
    2366                 :            : # define arch_scale_freq_invariant()    false
    2367                 :            : #endif
    2368                 :            : 
    2369                 :            : #ifdef CONFIG_SMP
    2370                 :            : static inline unsigned long capacity_orig_of(int cpu)
    2371                 :            : {
    2372                 :   28605889 :         return cpu_rq(cpu)->cpu_capacity_orig;
    2373                 :            : }
    2374                 :            : #endif
    2375                 :            : 
    2376                 :            : /**
    2377                 :            :  * enum schedutil_type - CPU utilization type
    2378                 :            :  * @FREQUENCY_UTIL:     Utilization used to select frequency
    2379                 :            :  * @ENERGY_UTIL:        Utilization used during energy calculation
    2380                 :            :  *
    2381                 :            :  * The utilization signals of all scheduling classes (CFS/RT/DL) and IRQ time
    2382                 :            :  * need to be aggregated differently depending on the usage made of them. This
    2383                 :            :  * enum is used within schedutil_freq_util() to differentiate the types of
    2384                 :            :  * utilization expected by the callers, and adjust the aggregation accordingly.
    2385                 :            :  */
    2386                 :            : enum schedutil_type {
    2387                 :            :         FREQUENCY_UTIL,
    2388                 :            :         ENERGY_UTIL,
    2389                 :            : };
    2390                 :            : 
    2391                 :            : #ifdef CONFIG_CPU_FREQ_GOV_SCHEDUTIL
    2392                 :            : 
    2393                 :            : unsigned long schedutil_cpu_util(int cpu, unsigned long util_cfs,
    2394                 :            :                                  unsigned long max, enum schedutil_type type,
    2395                 :            :                                  struct task_struct *p);
    2396                 :            : 
    2397                 :            : static inline unsigned long cpu_bw_dl(struct rq *rq)
    2398                 :            : {
    2399                 :          0 :         return (rq->dl.running_bw * SCHED_CAPACITY_SCALE) >> BW_SHIFT;
    2400                 :            : }
    2401                 :            : 
    2402                 :            : static inline unsigned long cpu_util_dl(struct rq *rq)
    2403                 :            : {
    2404                 :            :         return READ_ONCE(rq->avg_dl.util_avg);
    2405                 :            : }
    2406                 :            : 
    2407                 :            : static inline unsigned long cpu_util_cfs(struct rq *rq)
    2408                 :            : {
    2409                 :            :         unsigned long util = READ_ONCE(rq->cfs.avg.util_avg);
    2410                 :            : 
    2411         [ #  # ]:          0 :         if (sched_feat(UTIL_EST)) {
    2412                 :          0 :                 util = max_t(unsigned long, util,
    2413                 :            :                              READ_ONCE(rq->cfs.avg.util_est.enqueued));
    2414                 :            :         }
    2415                 :            : 
    2416                 :            :         return util;
    2417                 :            : }
    2418                 :            : 
    2419                 :            : static inline unsigned long cpu_util_rt(struct rq *rq)
    2420                 :            : {
    2421                 :            :         return READ_ONCE(rq->avg_rt.util_avg);
    2422                 :            : }
    2423                 :            : #else /* CONFIG_CPU_FREQ_GOV_SCHEDUTIL */
    2424                 :            : static inline unsigned long schedutil_cpu_util(int cpu, unsigned long util_cfs,
    2425                 :            :                                  unsigned long max, enum schedutil_type type,
    2426                 :            :                                  struct task_struct *p)
    2427                 :            : {
    2428                 :            :         return 0;
    2429                 :            : }
    2430                 :            : #endif /* CONFIG_CPU_FREQ_GOV_SCHEDUTIL */
    2431                 :            : 
    2432                 :            : #ifdef CONFIG_HAVE_SCHED_AVG_IRQ
    2433                 :            : static inline unsigned long cpu_util_irq(struct rq *rq)
    2434                 :            : {
    2435                 :            :         return rq->avg_irq.util_avg;
    2436                 :            : }
    2437                 :            : 
    2438                 :            : static inline
    2439                 :            : unsigned long scale_irq_capacity(unsigned long util, unsigned long irq, unsigned long max)
    2440                 :            : {
    2441                 :            :         util *= (max - irq);
    2442                 :            :         util /= max;
    2443                 :            : 
    2444                 :            :         return util;
    2445                 :            : 
    2446                 :            : }
    2447                 :            : #else
    2448                 :            : static inline unsigned long cpu_util_irq(struct rq *rq)
    2449                 :            : {
    2450                 :            :         return 0;
    2451                 :            : }
    2452                 :            : 
    2453                 :            : static inline
    2454                 :            : unsigned long scale_irq_capacity(unsigned long util, unsigned long irq, unsigned long max)
    2455                 :            : {
    2456                 :            :         return util;
    2457                 :            : }
    2458                 :            : #endif
    2459                 :            : 
    2460                 :            : #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
    2461                 :            : 
    2462                 :            : #define perf_domain_span(pd) (to_cpumask(((pd)->em_pd->cpus)))
    2463                 :            : 
    2464                 :            : DECLARE_STATIC_KEY_FALSE(sched_energy_present);
    2465                 :            : 
    2466                 :            : static inline bool sched_energy_enabled(void)
    2467                 :            : {
    2468                 :            :         return static_branch_unlikely(&sched_energy_present);
    2469                 :            : }
    2470                 :            : 
    2471                 :            : #else /* ! (CONFIG_ENERGY_MODEL && CONFIG_CPU_FREQ_GOV_SCHEDUTIL) */
    2472                 :            : 
    2473                 :            : #define perf_domain_span(pd) NULL
    2474                 :            : static inline bool sched_energy_enabled(void) { return false; }
    2475                 :            : 
    2476                 :            : #endif /* CONFIG_ENERGY_MODEL && CONFIG_CPU_FREQ_GOV_SCHEDUTIL */
    2477                 :            : 
    2478                 :            : #ifdef CONFIG_MEMBARRIER
    2479                 :            : /*
    2480                 :            :  * The scheduler provides memory barriers required by membarrier between:
    2481                 :            :  * - prior user-space memory accesses and store to rq->membarrier_state,
    2482                 :            :  * - store to rq->membarrier_state and following user-space memory accesses.
    2483                 :            :  * In the same way it provides those guarantees around store to rq->curr.
    2484                 :            :  */
    2485                 :    4860557 : static inline void membarrier_switch_mm(struct rq *rq,
    2486                 :            :                                         struct mm_struct *prev_mm,
    2487                 :            :                                         struct mm_struct *next_mm)
    2488                 :            : {
    2489                 :            :         int membarrier_state;
    2490                 :            : 
    2491         [ +  + ]:    4860557 :         if (prev_mm == next_mm)
    2492                 :            :                 return;
    2493                 :            : 
    2494                 :    2293027 :         membarrier_state = atomic_read(&next_mm->membarrier_state);
    2495         [ -  + ]:    2293027 :         if (READ_ONCE(rq->membarrier_state) == membarrier_state)
    2496                 :            :                 return;
    2497                 :            : 
    2498                 :            :         WRITE_ONCE(rq->membarrier_state, membarrier_state);
    2499                 :            : }
    2500                 :            : #else
    2501                 :            : static inline void membarrier_switch_mm(struct rq *rq,
    2502                 :            :                                         struct mm_struct *prev_mm,
    2503                 :            :                                         struct mm_struct *next_mm)
    2504                 :            : {
    2505                 :            : }
    2506                 :            : #endif

Generated by: LCOV version 1.14