LCOV - code coverage report
Current view: top level - kernel/sched - fair.c (source / functions) Hit Total Coverage
Test: Real Lines: 1699 2291 74.2 %
Date: 2020-10-17 15:46:16 Functions: 0 196 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * Completely Fair Scheduling (CFS) Class (SCHED_NORMAL/SCHED_BATCH)
       4                 :            :  *
       5                 :            :  *  Copyright (C) 2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
       6                 :            :  *
       7                 :            :  *  Interactivity improvements by Mike Galbraith
       8                 :            :  *  (C) 2007 Mike Galbraith <efault@gmx.de>
       9                 :            :  *
      10                 :            :  *  Various enhancements by Dmitry Adamushko.
      11                 :            :  *  (C) 2007 Dmitry Adamushko <dmitry.adamushko@gmail.com>
      12                 :            :  *
      13                 :            :  *  Group scheduling enhancements by Srivatsa Vaddagiri
      14                 :            :  *  Copyright IBM Corporation, 2007
      15                 :            :  *  Author: Srivatsa Vaddagiri <vatsa@linux.vnet.ibm.com>
      16                 :            :  *
      17                 :            :  *  Scaled math optimizations by Thomas Gleixner
      18                 :            :  *  Copyright (C) 2007, Thomas Gleixner <tglx@linutronix.de>
      19                 :            :  *
      20                 :            :  *  Adaptive scheduling granularity, math enhancements by Peter Zijlstra
      21                 :            :  *  Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra
      22                 :            :  */
      23                 :            : #include "sched.h"
      24                 :            : 
      25                 :            : #include <trace/events/sched.h>
      26                 :            : 
      27                 :            : /*
      28                 :            :  * Targeted preemption latency for CPU-bound tasks:
      29                 :            :  *
      30                 :            :  * NOTE: this latency value is not the same as the concept of
      31                 :            :  * 'timeslice length' - timeslices in CFS are of variable length
      32                 :            :  * and have no persistent notion like in traditional, time-slice
      33                 :            :  * based scheduling concepts.
      34                 :            :  *
      35                 :            :  * (to see the precise effective timeslice length of your workload,
      36                 :            :  *  run vmstat and monitor the context-switches (cs) field)
      37                 :            :  *
      38                 :            :  * (default: 6ms * (1 + ilog(ncpus)), units: nanoseconds)
      39                 :            :  */
      40                 :            : unsigned int sysctl_sched_latency                       = 6000000ULL;
      41                 :            : static unsigned int normalized_sysctl_sched_latency     = 6000000ULL;
      42                 :            : 
      43                 :            : /*
      44                 :            :  * The initial- and re-scaling of tunables is configurable
      45                 :            :  *
      46                 :            :  * Options are:
      47                 :            :  *
      48                 :            :  *   SCHED_TUNABLESCALING_NONE - unscaled, always *1
      49                 :            :  *   SCHED_TUNABLESCALING_LOG - scaled logarithmical, *1+ilog(ncpus)
      50                 :            :  *   SCHED_TUNABLESCALING_LINEAR - scaled linear, *ncpus
      51                 :            :  *
      52                 :            :  * (default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus))
      53                 :            :  */
      54                 :            : enum sched_tunable_scaling sysctl_sched_tunable_scaling = SCHED_TUNABLESCALING_LOG;
      55                 :            : 
      56                 :            : /*
      57                 :            :  * Minimal preemption granularity for CPU-bound tasks:
      58                 :            :  *
      59                 :            :  * (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds)
      60                 :            :  */
      61                 :            : unsigned int sysctl_sched_min_granularity                       = 750000ULL;
      62                 :            : static unsigned int normalized_sysctl_sched_min_granularity     = 750000ULL;
      63                 :            : 
      64                 :            : /*
      65                 :            :  * This value is kept at sysctl_sched_latency/sysctl_sched_min_granularity
      66                 :            :  */
      67                 :            : static unsigned int sched_nr_latency = 8;
      68                 :            : 
      69                 :            : /*
      70                 :            :  * After fork, child runs first. If set to 0 (default) then
      71                 :            :  * parent will (try to) run first.
      72                 :            :  */
      73                 :            : unsigned int sysctl_sched_child_runs_first __read_mostly;
      74                 :            : 
      75                 :            : /*
      76                 :            :  * SCHED_OTHER wake-up granularity.
      77                 :            :  *
      78                 :            :  * This option delays the preemption effects of decoupled workloads
      79                 :            :  * and reduces their over-scheduling. Synchronous workloads will still
      80                 :            :  * have immediate wakeup/sleep latencies.
      81                 :            :  *
      82                 :            :  * (default: 1 msec * (1 + ilog(ncpus)), units: nanoseconds)
      83                 :            :  */
      84                 :            : unsigned int sysctl_sched_wakeup_granularity                    = 1000000UL;
      85                 :            : static unsigned int normalized_sysctl_sched_wakeup_granularity  = 1000000UL;
      86                 :            : 
      87                 :            : const_debug unsigned int sysctl_sched_migration_cost    = 500000UL;
      88                 :            : 
      89                 :            : #ifdef CONFIG_SMP
      90                 :            : /*
      91                 :            :  * For asym packing, by default the lower numbered CPU has higher priority.
      92                 :            :  */
      93                 :          0 : int __weak arch_asym_cpu_priority(int cpu)
      94                 :            : {
      95                 :          0 :         return -cpu;
      96                 :            : }
      97                 :            : 
      98                 :            : /*
      99                 :            :  * The margin used when comparing utilization with CPU capacity.
     100                 :            :  *
     101                 :            :  * (default: ~20%)
     102                 :            :  */
     103                 :            : #define fits_capacity(cap, max) ((cap) * 1280 < (max) * 1024)
     104                 :            : 
     105                 :            : #endif
     106                 :            : 
     107                 :            : #ifdef CONFIG_CFS_BANDWIDTH
     108                 :            : /*
     109                 :            :  * Amount of runtime to allocate from global (tg) to local (per-cfs_rq) pool
     110                 :            :  * each time a cfs_rq requests quota.
     111                 :            :  *
     112                 :            :  * Note: in the case that the slice exceeds the runtime remaining (either due
     113                 :            :  * to consumption or the quota being specified to be smaller than the slice)
     114                 :            :  * we will always only issue the remaining available time.
     115                 :            :  *
     116                 :            :  * (default: 5 msec, units: microseconds)
     117                 :            :  */
     118                 :            : unsigned int sysctl_sched_cfs_bandwidth_slice           = 5000UL;
     119                 :            : #endif
     120                 :            : 
     121                 :            : static inline void update_load_add(struct load_weight *lw, unsigned long inc)
     122                 :            : {
     123                 :          3 :         lw->weight += inc;
     124                 :          3 :         lw->inv_weight = 0;
     125                 :            : }
     126                 :            : 
     127                 :            : static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
     128                 :            : {
     129                 :          3 :         lw->weight -= dec;
     130                 :          3 :         lw->inv_weight = 0;
     131                 :            : }
     132                 :            : 
     133                 :            : static inline void update_load_set(struct load_weight *lw, unsigned long w)
     134                 :            : {
     135                 :          3 :         lw->weight = w;
     136                 :          3 :         lw->inv_weight = 0;
     137                 :            : }
     138                 :            : 
     139                 :            : /*
     140                 :            :  * Increase the granularity value when there are more CPUs,
     141                 :            :  * because with more CPUs the 'effective latency' as visible
     142                 :            :  * to users decreases. But the relationship is not linear,
     143                 :            :  * so pick a second-best guess by going with the log2 of the
     144                 :            :  * number of CPUs.
     145                 :            :  *
     146                 :            :  * This idea comes from the SD scheduler of Con Kolivas:
     147                 :            :  */
     148                 :          3 : static unsigned int get_update_sysctl_factor(void)
     149                 :            : {
     150                 :          3 :         unsigned int cpus = min_t(unsigned int, num_online_cpus(), 8);
     151                 :            :         unsigned int factor;
     152                 :            : 
     153                 :          3 :         switch (sysctl_sched_tunable_scaling) {
     154                 :            :         case SCHED_TUNABLESCALING_NONE:
     155                 :            :                 factor = 1;
     156                 :            :                 break;
     157                 :            :         case SCHED_TUNABLESCALING_LINEAR:
     158                 :            :                 factor = cpus;
     159                 :          0 :                 break;
     160                 :            :         case SCHED_TUNABLESCALING_LOG:
     161                 :            :         default:
     162                 :          3 :                 factor = 1 + ilog2(cpus);
     163                 :          3 :                 break;
     164                 :            :         }
     165                 :            : 
     166                 :          3 :         return factor;
     167                 :            : }
     168                 :            : 
     169                 :          3 : static void update_sysctl(void)
     170                 :            : {
     171                 :          3 :         unsigned int factor = get_update_sysctl_factor();
     172                 :            : 
     173                 :            : #define SET_SYSCTL(name) \
     174                 :            :         (sysctl_##name = (factor) * normalized_sysctl_##name)
     175                 :          3 :         SET_SYSCTL(sched_min_granularity);
     176                 :          3 :         SET_SYSCTL(sched_latency);
     177                 :          3 :         SET_SYSCTL(sched_wakeup_granularity);
     178                 :            : #undef SET_SYSCTL
     179                 :          3 : }
     180                 :            : 
     181                 :          3 : void sched_init_granularity(void)
     182                 :            : {
     183                 :          3 :         update_sysctl();
     184                 :          3 : }
     185                 :            : 
     186                 :            : #define WMULT_CONST     (~0U)
     187                 :            : #define WMULT_SHIFT     32
     188                 :            : 
     189                 :            : static void __update_inv_weight(struct load_weight *lw)
     190                 :            : {
     191                 :            :         unsigned long w;
     192                 :            : 
     193                 :          3 :         if (likely(lw->inv_weight))
     194                 :            :                 return;
     195                 :            : 
     196                 :          3 :         w = scale_load_down(lw->weight);
     197                 :            : 
     198                 :            :         if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
     199                 :            :                 lw->inv_weight = 1;
     200                 :          3 :         else if (unlikely(!w))
     201                 :          0 :                 lw->inv_weight = WMULT_CONST;
     202                 :            :         else
     203                 :          3 :                 lw->inv_weight = WMULT_CONST / w;
     204                 :            : }
     205                 :            : 
     206                 :            : /*
     207                 :            :  * delta_exec * weight / lw.weight
     208                 :            :  *   OR
     209                 :            :  * (delta_exec * (weight * lw->inv_weight)) >> WMULT_SHIFT
     210                 :            :  *
     211                 :            :  * Either weight := NICE_0_LOAD and lw \e sched_prio_to_wmult[], in which case
     212                 :            :  * we're guaranteed shift stays positive because inv_weight is guaranteed to
     213                 :            :  * fit 32 bits, and NICE_0_LOAD gives another 10 bits; therefore shift >= 22.
     214                 :            :  *
     215                 :            :  * Or, weight =< lw.weight (because lw.weight is the runqueue weight), thus
     216                 :            :  * weight/lw.weight <= 1, and therefore our shift will also be positive.
     217                 :            :  */
     218                 :          3 : static u64 __calc_delta(u64 delta_exec, unsigned long weight, struct load_weight *lw)
     219                 :            : {
     220                 :          3 :         u64 fact = scale_load_down(weight);
     221                 :            :         int shift = WMULT_SHIFT;
     222                 :            : 
     223                 :            :         __update_inv_weight(lw);
     224                 :            : 
     225                 :          3 :         if (unlikely(fact >> 32)) {
     226                 :          0 :                 while (fact >> 32) {
     227                 :          0 :                         fact >>= 1;
     228                 :          0 :                         shift--;
     229                 :            :                 }
     230                 :            :         }
     231                 :            : 
     232                 :            :         /* hint to use a 32x32->64 mul */
     233                 :          3 :         fact = (u64)(u32)fact * lw->inv_weight;
     234                 :            : 
     235                 :          3 :         while (fact >> 32) {
     236                 :          3 :                 fact >>= 1;
     237                 :          3 :                 shift--;
     238                 :            :         }
     239                 :            : 
     240                 :          3 :         return mul_u64_u32_shr(delta_exec, fact, shift);
     241                 :            : }
     242                 :            : 
     243                 :            : 
     244                 :            : const struct sched_class fair_sched_class;
     245                 :            : 
     246                 :            : /**************************************************************
     247                 :            :  * CFS operations on generic schedulable entities:
     248                 :            :  */
     249                 :            : 
     250                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
     251                 :          3 : static inline struct task_struct *task_of(struct sched_entity *se)
     252                 :            : {
     253                 :          3 :         SCHED_WARN_ON(!entity_is_task(se));
     254                 :          3 :         return container_of(se, struct task_struct, se);
     255                 :            : }
     256                 :            : 
     257                 :            : /* Walk up scheduling entities hierarchy */
     258                 :            : #define for_each_sched_entity(se) \
     259                 :            :                 for (; se; se = se->parent)
     260                 :            : 
     261                 :            : static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
     262                 :            : {
     263                 :          3 :         return p->se.cfs_rq;
     264                 :            : }
     265                 :            : 
     266                 :            : /* runqueue on which this entity is (to be) queued */
     267                 :            : static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
     268                 :            : {
     269                 :          3 :         return se->cfs_rq;
     270                 :            : }
     271                 :            : 
     272                 :            : /* runqueue "owned" by this group */
     273                 :            : static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
     274                 :            : {
     275                 :          3 :         return grp->my_q;
     276                 :            : }
     277                 :            : 
     278                 :          0 : static inline void cfs_rq_tg_path(struct cfs_rq *cfs_rq, char *path, int len)
     279                 :            : {
     280                 :          0 :         if (!path)
     281                 :          0 :                 return;
     282                 :            : 
     283                 :          0 :         if (cfs_rq && task_group_is_autogroup(cfs_rq->tg))
     284                 :          0 :                 autogroup_path(cfs_rq->tg, path, len);
     285                 :          0 :         else if (cfs_rq && cfs_rq->tg->css.cgroup)
     286                 :          0 :                 cgroup_path(cfs_rq->tg->css.cgroup, path, len);
     287                 :            :         else
     288                 :          0 :                 strlcpy(path, "(null)", len);
     289                 :            : }
     290                 :            : 
     291                 :          3 : static inline bool list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq)
     292                 :            : {
     293                 :            :         struct rq *rq = rq_of(cfs_rq);
     294                 :            :         int cpu = cpu_of(rq);
     295                 :            : 
     296                 :          3 :         if (cfs_rq->on_list)
     297                 :          3 :                 return rq->tmp_alone_branch == &rq->leaf_cfs_rq_list;
     298                 :            : 
     299                 :          3 :         cfs_rq->on_list = 1;
     300                 :            : 
     301                 :            :         /*
     302                 :            :          * Ensure we either appear before our parent (if already
     303                 :            :          * enqueued) or force our parent to appear after us when it is
     304                 :            :          * enqueued. The fact that we always enqueue bottom-up
     305                 :            :          * reduces this to two cases and a special case for the root
     306                 :            :          * cfs_rq. Furthermore, it also means that we will always reset
     307                 :            :          * tmp_alone_branch either when the branch is connected
     308                 :            :          * to a tree or when we reach the top of the tree
     309                 :            :          */
     310                 :          3 :         if (cfs_rq->tg->parent &&
     311                 :          3 :             cfs_rq->tg->parent->cfs_rq[cpu]->on_list) {
     312                 :            :                 /*
     313                 :            :                  * If parent is already on the list, we add the child
     314                 :            :                  * just before. Thanks to circular linked property of
     315                 :            :                  * the list, this means to put the child at the tail
     316                 :            :                  * of the list that starts by parent.
     317                 :            :                  */
     318                 :          3 :                 list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list,
     319                 :            :                         &(cfs_rq->tg->parent->cfs_rq[cpu]->leaf_cfs_rq_list));
     320                 :            :                 /*
     321                 :            :                  * The branch is now connected to its tree so we can
     322                 :            :                  * reset tmp_alone_branch to the beginning of the
     323                 :            :                  * list.
     324                 :            :                  */
     325                 :          3 :                 rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
     326                 :          3 :                 return true;
     327                 :            :         }
     328                 :            : 
     329                 :          3 :         if (!cfs_rq->tg->parent) {
     330                 :            :                 /*
     331                 :            :                  * cfs rq without parent should be put
     332                 :            :                  * at the tail of the list.
     333                 :            :                  */
     334                 :          3 :                 list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list,
     335                 :            :                         &rq->leaf_cfs_rq_list);
     336                 :            :                 /*
     337                 :            :                  * We have reach the top of a tree so we can reset
     338                 :            :                  * tmp_alone_branch to the beginning of the list.
     339                 :            :                  */
     340                 :          3 :                 rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
     341                 :          3 :                 return true;
     342                 :            :         }
     343                 :            : 
     344                 :            :         /*
     345                 :            :          * The parent has not already been added so we want to
     346                 :            :          * make sure that it will be put after us.
     347                 :            :          * tmp_alone_branch points to the begin of the branch
     348                 :            :          * where we will add parent.
     349                 :            :          */
     350                 :          3 :         list_add_rcu(&cfs_rq->leaf_cfs_rq_list, rq->tmp_alone_branch);
     351                 :            :         /*
     352                 :            :          * update tmp_alone_branch to points to the new begin
     353                 :            :          * of the branch
     354                 :            :          */
     355                 :          3 :         rq->tmp_alone_branch = &cfs_rq->leaf_cfs_rq_list;
     356                 :          3 :         return false;
     357                 :            : }
     358                 :            : 
     359                 :            : static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
     360                 :            : {
     361                 :          3 :         if (cfs_rq->on_list) {
     362                 :            :                 struct rq *rq = rq_of(cfs_rq);
     363                 :            : 
     364                 :            :                 /*
     365                 :            :                  * With cfs_rq being unthrottled/throttled during an enqueue,
     366                 :            :                  * it can happen the tmp_alone_branch points the a leaf that
     367                 :            :                  * we finally want to del. In this case, tmp_alone_branch moves
     368                 :            :                  * to the prev element but it will point to rq->leaf_cfs_rq_list
     369                 :            :                  * at the end of the enqueue.
     370                 :            :                  */
     371                 :          3 :                 if (rq->tmp_alone_branch == &cfs_rq->leaf_cfs_rq_list)
     372                 :          0 :                         rq->tmp_alone_branch = cfs_rq->leaf_cfs_rq_list.prev;
     373                 :            : 
     374                 :            :                 list_del_rcu(&cfs_rq->leaf_cfs_rq_list);
     375                 :          3 :                 cfs_rq->on_list = 0;
     376                 :            :         }
     377                 :            : }
     378                 :            : 
     379                 :          3 : static inline void assert_list_leaf_cfs_rq(struct rq *rq)
     380                 :            : {
     381                 :          3 :         SCHED_WARN_ON(rq->tmp_alone_branch != &rq->leaf_cfs_rq_list);
     382                 :          3 : }
     383                 :            : 
     384                 :            : /* Iterate thr' all leaf cfs_rq's on a runqueue */
     385                 :            : #define for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos)                      \
     386                 :            :         list_for_each_entry_safe(cfs_rq, pos, &rq->leaf_cfs_rq_list,     \
     387                 :            :                                  leaf_cfs_rq_list)
     388                 :            : 
     389                 :            : /* Do the two (enqueued) entities belong to the same group ? */
     390                 :            : static inline struct cfs_rq *
     391                 :            : is_same_group(struct sched_entity *se, struct sched_entity *pse)
     392                 :            : {
     393                 :          3 :         if (se->cfs_rq == pse->cfs_rq)
     394                 :            :                 return se->cfs_rq;
     395                 :            : 
     396                 :            :         return NULL;
     397                 :            : }
     398                 :            : 
     399                 :            : static inline struct sched_entity *parent_entity(struct sched_entity *se)
     400                 :            : {
     401                 :          3 :         return se->parent;
     402                 :            : }
     403                 :            : 
     404                 :            : static void
     405                 :          3 : find_matching_se(struct sched_entity **se, struct sched_entity **pse)
     406                 :            : {
     407                 :            :         int se_depth, pse_depth;
     408                 :            : 
     409                 :            :         /*
     410                 :            :          * preemption test can be made between sibling entities who are in the
     411                 :            :          * same cfs_rq i.e who have a common parent. Walk up the hierarchy of
     412                 :            :          * both tasks until we find their ancestors who are siblings of common
     413                 :            :          * parent.
     414                 :            :          */
     415                 :            : 
     416                 :            :         /* First walk up until both entities are at same depth */
     417                 :          3 :         se_depth = (*se)->depth;
     418                 :          3 :         pse_depth = (*pse)->depth;
     419                 :            : 
     420                 :          3 :         while (se_depth > pse_depth) {
     421                 :          3 :                 se_depth--;
     422                 :          3 :                 *se = parent_entity(*se);
     423                 :            :         }
     424                 :            : 
     425                 :          3 :         while (pse_depth > se_depth) {
     426                 :          3 :                 pse_depth--;
     427                 :          3 :                 *pse = parent_entity(*pse);
     428                 :            :         }
     429                 :            : 
     430                 :          3 :         while (!is_same_group(*se, *pse)) {
     431                 :          3 :                 *se = parent_entity(*se);
     432                 :          3 :                 *pse = parent_entity(*pse);
     433                 :            :         }
     434                 :          3 : }
     435                 :            : 
     436                 :            : #else   /* !CONFIG_FAIR_GROUP_SCHED */
     437                 :            : 
     438                 :            : static inline struct task_struct *task_of(struct sched_entity *se)
     439                 :            : {
     440                 :            :         return container_of(se, struct task_struct, se);
     441                 :            : }
     442                 :            : 
     443                 :            : #define for_each_sched_entity(se) \
     444                 :            :                 for (; se; se = NULL)
     445                 :            : 
     446                 :            : static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
     447                 :            : {
     448                 :            :         return &task_rq(p)->cfs;
     449                 :            : }
     450                 :            : 
     451                 :            : static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
     452                 :            : {
     453                 :            :         struct task_struct *p = task_of(se);
     454                 :            :         struct rq *rq = task_rq(p);
     455                 :            : 
     456                 :            :         return &rq->cfs;
     457                 :            : }
     458                 :            : 
     459                 :            : /* runqueue "owned" by this group */
     460                 :            : static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
     461                 :            : {
     462                 :            :         return NULL;
     463                 :            : }
     464                 :            : 
     465                 :            : static inline void cfs_rq_tg_path(struct cfs_rq *cfs_rq, char *path, int len)
     466                 :            : {
     467                 :            :         if (path)
     468                 :            :                 strlcpy(path, "(null)", len);
     469                 :            : }
     470                 :            : 
     471                 :            : static inline bool list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq)
     472                 :            : {
     473                 :            :         return true;
     474                 :            : }
     475                 :            : 
     476                 :            : static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
     477                 :            : {
     478                 :            : }
     479                 :            : 
     480                 :            : static inline void assert_list_leaf_cfs_rq(struct rq *rq)
     481                 :            : {
     482                 :            : }
     483                 :            : 
     484                 :            : #define for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos)      \
     485                 :            :                 for (cfs_rq = &rq->cfs, pos = NULL; cfs_rq; cfs_rq = pos)
     486                 :            : 
     487                 :            : static inline struct sched_entity *parent_entity(struct sched_entity *se)
     488                 :            : {
     489                 :            :         return NULL;
     490                 :            : }
     491                 :            : 
     492                 :            : static inline void
     493                 :            : find_matching_se(struct sched_entity **se, struct sched_entity **pse)
     494                 :            : {
     495                 :            : }
     496                 :            : 
     497                 :            : #endif  /* CONFIG_FAIR_GROUP_SCHED */
     498                 :            : 
     499                 :            : static __always_inline
     500                 :            : void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec);
     501                 :            : 
     502                 :            : /**************************************************************
     503                 :            :  * Scheduling class tree data structure manipulation methods:
     504                 :            :  */
     505                 :            : 
     506                 :            : static inline u64 max_vruntime(u64 max_vruntime, u64 vruntime)
     507                 :            : {
     508                 :          3 :         s64 delta = (s64)(vruntime - max_vruntime);
     509                 :          3 :         if (delta > 0)
     510                 :            :                 max_vruntime = vruntime;
     511                 :            : 
     512                 :            :         return max_vruntime;
     513                 :            : }
     514                 :            : 
     515                 :            : static inline u64 min_vruntime(u64 min_vruntime, u64 vruntime)
     516                 :            : {
     517                 :          3 :         s64 delta = (s64)(vruntime - min_vruntime);
     518                 :          3 :         if (delta < 0)
     519                 :            :                 min_vruntime = vruntime;
     520                 :            : 
     521                 :            :         return min_vruntime;
     522                 :            : }
     523                 :            : 
     524                 :            : static inline int entity_before(struct sched_entity *a,
     525                 :            :                                 struct sched_entity *b)
     526                 :            : {
     527                 :          3 :         return (s64)(a->vruntime - b->vruntime) < 0;
     528                 :            : }
     529                 :            : 
     530                 :          3 : static void update_min_vruntime(struct cfs_rq *cfs_rq)
     531                 :            : {
     532                 :          3 :         struct sched_entity *curr = cfs_rq->curr;
     533                 :          3 :         struct rb_node *leftmost = rb_first_cached(&cfs_rq->tasks_timeline);
     534                 :            : 
     535                 :          3 :         u64 vruntime = cfs_rq->min_vruntime;
     536                 :            : 
     537                 :          3 :         if (curr) {
     538                 :          3 :                 if (curr->on_rq)
     539                 :          3 :                         vruntime = curr->vruntime;
     540                 :            :                 else
     541                 :            :                         curr = NULL;
     542                 :            :         }
     543                 :            : 
     544                 :          3 :         if (leftmost) { /* non-empty tree */
     545                 :            :                 struct sched_entity *se;
     546                 :            :                 se = rb_entry(leftmost, struct sched_entity, run_node);
     547                 :            : 
     548                 :          3 :                 if (!curr)
     549                 :          3 :                         vruntime = se->vruntime;
     550                 :            :                 else
     551                 :          3 :                         vruntime = min_vruntime(vruntime, se->vruntime);
     552                 :            :         }
     553                 :            : 
     554                 :            :         /* ensure we never gain time by being placed backwards. */
     555                 :          3 :         cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime);
     556                 :            : #ifndef CONFIG_64BIT
     557                 :          3 :         smp_wmb();
     558                 :          3 :         cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;
     559                 :            : #endif
     560                 :          3 : }
     561                 :            : 
     562                 :            : /*
     563                 :            :  * Enqueue an entity into the rb-tree:
     564                 :            :  */
     565                 :          3 : static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
     566                 :            : {
     567                 :          3 :         struct rb_node **link = &cfs_rq->tasks_timeline.rb_root.rb_node;
     568                 :            :         struct rb_node *parent = NULL;
     569                 :            :         struct sched_entity *entry;
     570                 :            :         bool leftmost = true;
     571                 :            : 
     572                 :            :         /*
     573                 :            :          * Find the right place in the rbtree:
     574                 :            :          */
     575                 :          3 :         while (*link) {
     576                 :            :                 parent = *link;
     577                 :            :                 entry = rb_entry(parent, struct sched_entity, run_node);
     578                 :            :                 /*
     579                 :            :                  * We dont care about collisions. Nodes with
     580                 :            :                  * the same key stay together.
     581                 :            :                  */
     582                 :          3 :                 if (entity_before(se, entry)) {
     583                 :          3 :                         link = &parent->rb_left;
     584                 :            :                 } else {
     585                 :          3 :                         link = &parent->rb_right;
     586                 :            :                         leftmost = false;
     587                 :            :                 }
     588                 :            :         }
     589                 :            : 
     590                 :          3 :         rb_link_node(&se->run_node, parent, link);
     591                 :            :         rb_insert_color_cached(&se->run_node,
     592                 :            :                                &cfs_rq->tasks_timeline, leftmost);
     593                 :          3 : }
     594                 :            : 
     595                 :            : static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
     596                 :            : {
     597                 :          3 :         rb_erase_cached(&se->run_node, &cfs_rq->tasks_timeline);
     598                 :            : }
     599                 :            : 
     600                 :          0 : struct sched_entity *__pick_first_entity(struct cfs_rq *cfs_rq)
     601                 :            : {
     602                 :          3 :         struct rb_node *left = rb_first_cached(&cfs_rq->tasks_timeline);
     603                 :            : 
     604                 :          3 :         if (!left)
     605                 :            :                 return NULL;
     606                 :            : 
     607                 :          3 :         return rb_entry(left, struct sched_entity, run_node);
     608                 :            : }
     609                 :            : 
     610                 :            : static struct sched_entity *__pick_next_entity(struct sched_entity *se)
     611                 :            : {
     612                 :          0 :         struct rb_node *next = rb_next(&se->run_node);
     613                 :            : 
     614                 :          0 :         if (!next)
     615                 :            :                 return NULL;
     616                 :            : 
     617                 :          0 :         return rb_entry(next, struct sched_entity, run_node);
     618                 :            : }
     619                 :            : 
     620                 :            : #ifdef CONFIG_SCHED_DEBUG
     621                 :          0 : struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
     622                 :            : {
     623                 :          0 :         struct rb_node *last = rb_last(&cfs_rq->tasks_timeline.rb_root);
     624                 :            : 
     625                 :          0 :         if (!last)
     626                 :            :                 return NULL;
     627                 :            : 
     628                 :          0 :         return rb_entry(last, struct sched_entity, run_node);
     629                 :            : }
     630                 :            : 
     631                 :            : /**************************************************************
     632                 :            :  * Scheduling class statistics methods:
     633                 :            :  */
     634                 :            : 
     635                 :          0 : int sched_proc_update_handler(struct ctl_table *table, int write,
     636                 :            :                 void __user *buffer, size_t *lenp,
     637                 :            :                 loff_t *ppos)
     638                 :            : {
     639                 :          0 :         int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
     640                 :          0 :         unsigned int factor = get_update_sysctl_factor();
     641                 :            : 
     642                 :          0 :         if (ret || !write)
     643                 :            :                 return ret;
     644                 :            : 
     645                 :          0 :         sched_nr_latency = DIV_ROUND_UP(sysctl_sched_latency,
     646                 :            :                                         sysctl_sched_min_granularity);
     647                 :            : 
     648                 :            : #define WRT_SYSCTL(name) \
     649                 :            :         (normalized_sysctl_##name = sysctl_##name / (factor))
     650                 :          0 :         WRT_SYSCTL(sched_min_granularity);
     651                 :          0 :         WRT_SYSCTL(sched_latency);
     652                 :          0 :         WRT_SYSCTL(sched_wakeup_granularity);
     653                 :            : #undef WRT_SYSCTL
     654                 :            : 
     655                 :          0 :         return 0;
     656                 :            : }
     657                 :            : #endif
     658                 :            : 
     659                 :            : /*
     660                 :            :  * delta /= w
     661                 :            :  */
     662                 :            : static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se)
     663                 :            : {
     664                 :          3 :         if (unlikely(se->load.weight != NICE_0_LOAD))
     665                 :          3 :                 delta = __calc_delta(delta, NICE_0_LOAD, &se->load);
     666                 :            : 
     667                 :            :         return delta;
     668                 :            : }
     669                 :            : 
     670                 :            : /*
     671                 :            :  * The idea is to set a period in which each task runs once.
     672                 :            :  *
     673                 :            :  * When there are too many tasks (sched_nr_latency) we have to stretch
     674                 :            :  * this period because otherwise the slices get too small.
     675                 :            :  *
     676                 :            :  * p = (nr <= nl) ? l : l*nr/nl
     677                 :            :  */
     678                 :            : static u64 __sched_period(unsigned long nr_running)
     679                 :            : {
     680                 :          3 :         if (unlikely(nr_running > sched_nr_latency))
     681                 :          1 :                 return nr_running * sysctl_sched_min_granularity;
     682                 :            :         else
     683                 :          3 :                 return sysctl_sched_latency;
     684                 :            : }
     685                 :            : 
     686                 :            : /*
     687                 :            :  * We calculate the wall-time slice from the period by taking a part
     688                 :            :  * proportional to the weight.
     689                 :            :  *
     690                 :            :  * s = p*P[w/rw]
     691                 :            :  */
     692                 :          3 : static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
     693                 :            : {
     694                 :          3 :         u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq);
     695                 :            : 
     696                 :          3 :         for_each_sched_entity(se) {
     697                 :            :                 struct load_weight *load;
     698                 :            :                 struct load_weight lw;
     699                 :            : 
     700                 :            :                 cfs_rq = cfs_rq_of(se);
     701                 :          3 :                 load = &cfs_rq->load;
     702                 :            : 
     703                 :          3 :                 if (unlikely(!se->on_rq)) {
     704                 :          3 :                         lw = cfs_rq->load;
     705                 :            : 
     706                 :          3 :                         update_load_add(&lw, se->load.weight);
     707                 :            :                         load = &lw;
     708                 :            :                 }
     709                 :          3 :                 slice = __calc_delta(slice, se->load.weight, load);
     710                 :            :         }
     711                 :          3 :         return slice;
     712                 :            : }
     713                 :            : 
     714                 :            : /*
     715                 :            :  * We calculate the vruntime slice of a to-be-inserted task.
     716                 :            :  *
     717                 :            :  * vs = s/w
     718                 :            :  */
     719                 :          3 : static u64 sched_vslice(struct cfs_rq *cfs_rq, struct sched_entity *se)
     720                 :            : {
     721                 :          3 :         return calc_delta_fair(sched_slice(cfs_rq, se), se);
     722                 :            : }
     723                 :            : 
     724                 :            : #include "pelt.h"
     725                 :            : #ifdef CONFIG_SMP
     726                 :            : 
     727                 :            : static int select_idle_sibling(struct task_struct *p, int prev_cpu, int cpu);
     728                 :            : static unsigned long task_h_load(struct task_struct *p);
     729                 :            : static unsigned long capacity_of(int cpu);
     730                 :            : 
     731                 :            : /* Give new sched_entity start runnable values to heavy its load in infant time */
     732                 :          3 : void init_entity_runnable_average(struct sched_entity *se)
     733                 :            : {
     734                 :          3 :         struct sched_avg *sa = &se->avg;
     735                 :            : 
     736                 :          3 :         memset(sa, 0, sizeof(*sa));
     737                 :            : 
     738                 :            :         /*
     739                 :            :          * Tasks are initialized with full load to be seen as heavy tasks until
     740                 :            :          * they get a chance to stabilize to their real load level.
     741                 :            :          * Group entities are initialized with zero load to reflect the fact that
     742                 :            :          * nothing has been attached to the task group yet.
     743                 :            :          */
     744                 :          3 :         if (entity_is_task(se))
     745                 :          3 :                 sa->runnable_load_avg = sa->load_avg = scale_load_down(se->load.weight);
     746                 :            : 
     747                 :          3 :         se->runnable_weight = se->load.weight;
     748                 :            : 
     749                 :            :         /* when this task enqueue'ed, it will contribute to its cfs_rq's load_avg */
     750                 :          3 : }
     751                 :            : 
     752                 :            : static void attach_entity_cfs_rq(struct sched_entity *se);
     753                 :            : 
     754                 :            : /*
     755                 :            :  * With new tasks being created, their initial util_avgs are extrapolated
     756                 :            :  * based on the cfs_rq's current util_avg:
     757                 :            :  *
     758                 :            :  *   util_avg = cfs_rq->util_avg / (cfs_rq->load_avg + 1) * se.load.weight
     759                 :            :  *
     760                 :            :  * However, in many cases, the above util_avg does not give a desired
     761                 :            :  * value. Moreover, the sum of the util_avgs may be divergent, such
     762                 :            :  * as when the series is a harmonic series.
     763                 :            :  *
     764                 :            :  * To solve this problem, we also cap the util_avg of successive tasks to
     765                 :            :  * only 1/2 of the left utilization budget:
     766                 :            :  *
     767                 :            :  *   util_avg_cap = (cpu_scale - cfs_rq->avg.util_avg) / 2^n
     768                 :            :  *
     769                 :            :  * where n denotes the nth task and cpu_scale the CPU capacity.
     770                 :            :  *
     771                 :            :  * For example, for a CPU with 1024 of capacity, a simplest series from
     772                 :            :  * the beginning would be like:
     773                 :            :  *
     774                 :            :  *  task  util_avg: 512, 256, 128,  64,  32,   16,    8, ...
     775                 :            :  * cfs_rq util_avg: 512, 768, 896, 960, 992, 1008, 1016, ...
     776                 :            :  *
     777                 :            :  * Finally, that extrapolated util_avg is clamped to the cap (util_avg_cap)
     778                 :            :  * if util_avg > util_avg_cap.
     779                 :            :  */
     780                 :          3 : void post_init_entity_util_avg(struct task_struct *p)
     781                 :            : {
     782                 :          3 :         struct sched_entity *se = &p->se;
     783                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
     784                 :            :         struct sched_avg *sa = &se->avg;
     785                 :            :         long cpu_scale = arch_scale_cpu_capacity(cpu_of(rq_of(cfs_rq)));
     786                 :          3 :         long cap = (long)(cpu_scale - cfs_rq->avg.util_avg) / 2;
     787                 :            : 
     788                 :          3 :         if (cap > 0) {
     789                 :          3 :                 if (cfs_rq->avg.util_avg != 0) {
     790                 :          3 :                         sa->util_avg  = cfs_rq->avg.util_avg * se->load.weight;
     791                 :          3 :                         sa->util_avg /= (cfs_rq->avg.load_avg + 1);
     792                 :            : 
     793                 :          3 :                         if (sa->util_avg > cap)
     794                 :          3 :                                 sa->util_avg = cap;
     795                 :            :                 } else {
     796                 :          3 :                         sa->util_avg = cap;
     797                 :            :                 }
     798                 :            :         }
     799                 :            : 
     800                 :          3 :         if (p->sched_class != &fair_sched_class) {
     801                 :            :                 /*
     802                 :            :                  * For !fair tasks do:
     803                 :            :                  *
     804                 :            :                 update_cfs_rq_load_avg(now, cfs_rq);
     805                 :            :                 attach_entity_load_avg(cfs_rq, se, 0);
     806                 :            :                 switched_from_fair(rq, p);
     807                 :            :                  *
     808                 :            :                  * such that the next switched_to_fair() has the
     809                 :            :                  * expected state.
     810                 :            :                  */
     811                 :          0 :                 se->avg.last_update_time = cfs_rq_clock_pelt(cfs_rq);
     812                 :          3 :                 return;
     813                 :            :         }
     814                 :            : 
     815                 :          3 :         attach_entity_cfs_rq(se);
     816                 :            : }
     817                 :            : 
     818                 :            : #else /* !CONFIG_SMP */
     819                 :            : void init_entity_runnable_average(struct sched_entity *se)
     820                 :            : {
     821                 :            : }
     822                 :            : void post_init_entity_util_avg(struct task_struct *p)
     823                 :            : {
     824                 :            : }
     825                 :            : static void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
     826                 :            : {
     827                 :            : }
     828                 :            : #endif /* CONFIG_SMP */
     829                 :            : 
     830                 :            : /*
     831                 :            :  * Update the current task's runtime statistics.
     832                 :            :  */
     833                 :          3 : static void update_curr(struct cfs_rq *cfs_rq)
     834                 :            : {
     835                 :          3 :         struct sched_entity *curr = cfs_rq->curr;
     836                 :            :         u64 now = rq_clock_task(rq_of(cfs_rq));
     837                 :            :         u64 delta_exec;
     838                 :            : 
     839                 :          3 :         if (unlikely(!curr))
     840                 :            :                 return;
     841                 :            : 
     842                 :          3 :         delta_exec = now - curr->exec_start;
     843                 :          3 :         if (unlikely((s64)delta_exec <= 0))
     844                 :            :                 return;
     845                 :            : 
     846                 :          3 :         curr->exec_start = now;
     847                 :            : 
     848                 :          3 :         schedstat_set(curr->statistics.exec_max,
     849                 :            :                       max(delta_exec, curr->statistics.exec_max));
     850                 :            : 
     851                 :          3 :         curr->sum_exec_runtime += delta_exec;
     852                 :          3 :         schedstat_add(cfs_rq->exec_clock, delta_exec);
     853                 :            : 
     854                 :          3 :         curr->vruntime += calc_delta_fair(delta_exec, curr);
     855                 :          3 :         update_min_vruntime(cfs_rq);
     856                 :            : 
     857                 :          3 :         if (entity_is_task(curr)) {
     858                 :          3 :                 struct task_struct *curtask = task_of(curr);
     859                 :            : 
     860                 :          3 :                 trace_sched_stat_runtime(curtask, delta_exec, curr->vruntime);
     861                 :          3 :                 cgroup_account_cputime(curtask, delta_exec);
     862                 :          3 :                 account_group_exec_runtime(curtask, delta_exec);
     863                 :            :         }
     864                 :            : 
     865                 :            :         account_cfs_rq_runtime(cfs_rq, delta_exec);
     866                 :            : }
     867                 :            : 
     868                 :          3 : static void update_curr_fair(struct rq *rq)
     869                 :            : {
     870                 :          3 :         update_curr(cfs_rq_of(&rq->curr->se));
     871                 :          3 : }
     872                 :            : 
     873                 :            : static inline void
     874                 :          3 : update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
     875                 :            : {
     876                 :            :         u64 wait_start, prev_wait_start;
     877                 :            : 
     878                 :          3 :         if (!schedstat_enabled())
     879                 :          3 :                 return;
     880                 :            : 
     881                 :            :         wait_start = rq_clock(rq_of(cfs_rq));
     882                 :          0 :         prev_wait_start = schedstat_val(se->statistics.wait_start);
     883                 :            : 
     884                 :          0 :         if (entity_is_task(se) && task_on_rq_migrating(task_of(se)) &&
     885                 :          0 :             likely(wait_start > prev_wait_start))
     886                 :          0 :                 wait_start -= prev_wait_start;
     887                 :            : 
     888                 :          0 :         __schedstat_set(se->statistics.wait_start, wait_start);
     889                 :            : }
     890                 :            : 
     891                 :            : static inline void
     892                 :          3 : update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
     893                 :            : {
     894                 :            :         struct task_struct *p;
     895                 :            :         u64 delta;
     896                 :            : 
     897                 :          3 :         if (!schedstat_enabled())
     898                 :            :                 return;
     899                 :            : 
     900                 :          0 :         delta = rq_clock(rq_of(cfs_rq)) - schedstat_val(se->statistics.wait_start);
     901                 :            : 
     902                 :          0 :         if (entity_is_task(se)) {
     903                 :          0 :                 p = task_of(se);
     904                 :          0 :                 if (task_on_rq_migrating(p)) {
     905                 :            :                         /*
     906                 :            :                          * Preserve migrating task's wait time so wait_start
     907                 :            :                          * time stamp can be adjusted to accumulate wait time
     908                 :            :                          * prior to migration.
     909                 :            :                          */
     910                 :          0 :                         __schedstat_set(se->statistics.wait_start, delta);
     911                 :          0 :                         return;
     912                 :            :                 }
     913                 :          0 :                 trace_sched_stat_wait(p, delta);
     914                 :            :         }
     915                 :            : 
     916                 :          0 :         __schedstat_set(se->statistics.wait_max,
     917                 :            :                       max(schedstat_val(se->statistics.wait_max), delta));
     918                 :          0 :         __schedstat_inc(se->statistics.wait_count);
     919                 :          0 :         __schedstat_add(se->statistics.wait_sum, delta);
     920                 :          0 :         __schedstat_set(se->statistics.wait_start, 0);
     921                 :            : }
     922                 :            : 
     923                 :            : static inline void
     924                 :          0 : update_stats_enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
     925                 :            : {
     926                 :            :         struct task_struct *tsk = NULL;
     927                 :            :         u64 sleep_start, block_start;
     928                 :            : 
     929                 :          0 :         if (!schedstat_enabled())
     930                 :          0 :                 return;
     931                 :            : 
     932                 :          0 :         sleep_start = schedstat_val(se->statistics.sleep_start);
     933                 :          0 :         block_start = schedstat_val(se->statistics.block_start);
     934                 :            : 
     935                 :          0 :         if (entity_is_task(se))
     936                 :          0 :                 tsk = task_of(se);
     937                 :            : 
     938                 :          0 :         if (sleep_start) {
     939                 :          0 :                 u64 delta = rq_clock(rq_of(cfs_rq)) - sleep_start;
     940                 :            : 
     941                 :          0 :                 if ((s64)delta < 0)
     942                 :            :                         delta = 0;
     943                 :            : 
     944                 :          0 :                 if (unlikely(delta > schedstat_val(se->statistics.sleep_max)))
     945                 :          0 :                         __schedstat_set(se->statistics.sleep_max, delta);
     946                 :            : 
     947                 :          0 :                 __schedstat_set(se->statistics.sleep_start, 0);
     948                 :          0 :                 __schedstat_add(se->statistics.sum_sleep_runtime, delta);
     949                 :            : 
     950                 :          0 :                 if (tsk) {
     951                 :          0 :                         account_scheduler_latency(tsk, delta >> 10, 1);
     952                 :          0 :                         trace_sched_stat_sleep(tsk, delta);
     953                 :            :                 }
     954                 :            :         }
     955                 :          0 :         if (block_start) {
     956                 :          0 :                 u64 delta = rq_clock(rq_of(cfs_rq)) - block_start;
     957                 :            : 
     958                 :          0 :                 if ((s64)delta < 0)
     959                 :            :                         delta = 0;
     960                 :            : 
     961                 :          0 :                 if (unlikely(delta > schedstat_val(se->statistics.block_max)))
     962                 :          0 :                         __schedstat_set(se->statistics.block_max, delta);
     963                 :            : 
     964                 :          0 :                 __schedstat_set(se->statistics.block_start, 0);
     965                 :          0 :                 __schedstat_add(se->statistics.sum_sleep_runtime, delta);
     966                 :            : 
     967                 :          0 :                 if (tsk) {
     968                 :          0 :                         if (tsk->in_iowait) {
     969                 :          0 :                                 __schedstat_add(se->statistics.iowait_sum, delta);
     970                 :          0 :                                 __schedstat_inc(se->statistics.iowait_count);
     971                 :          0 :                                 trace_sched_stat_iowait(tsk, delta);
     972                 :            :                         }
     973                 :            : 
     974                 :          0 :                         trace_sched_stat_blocked(tsk, delta);
     975                 :            : 
     976                 :            :                         /*
     977                 :            :                          * Blocking time is in units of nanosecs, so shift by
     978                 :            :                          * 20 to get a milliseconds-range estimation of the
     979                 :            :                          * amount of time that the task spent sleeping:
     980                 :            :                          */
     981                 :          0 :                         if (unlikely(prof_on == SLEEP_PROFILING)) {
     982                 :          0 :                                 profile_hits(SLEEP_PROFILING,
     983                 :          0 :                                                 (void *)get_wchan(tsk),
     984                 :          0 :                                                 delta >> 20);
     985                 :            :                         }
     986                 :          0 :                         account_scheduler_latency(tsk, delta >> 10, 0);
     987                 :            :                 }
     988                 :            :         }
     989                 :            : }
     990                 :            : 
     991                 :            : /*
     992                 :            :  * Task is being enqueued - update stats:
     993                 :            :  */
     994                 :            : static inline void
     995                 :          3 : update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
     996                 :            : {
     997                 :          3 :         if (!schedstat_enabled())
     998                 :          3 :                 return;
     999                 :            : 
    1000                 :            :         /*
    1001                 :            :          * Are we enqueueing a waiting task? (for current tasks
    1002                 :            :          * a dequeue/enqueue event is a NOP)
    1003                 :            :          */
    1004                 :          0 :         if (se != cfs_rq->curr)
    1005                 :          0 :                 update_stats_wait_start(cfs_rq, se);
    1006                 :            : 
    1007                 :          0 :         if (flags & ENQUEUE_WAKEUP)
    1008                 :          0 :                 update_stats_enqueue_sleeper(cfs_rq, se);
    1009                 :            : }
    1010                 :            : 
    1011                 :            : static inline void
    1012                 :          3 : update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
    1013                 :            : {
    1014                 :            : 
    1015                 :          3 :         if (!schedstat_enabled())
    1016                 :          3 :                 return;
    1017                 :            : 
    1018                 :            :         /*
    1019                 :            :          * Mark the end of the wait period if dequeueing a
    1020                 :            :          * waiting task:
    1021                 :            :          */
    1022                 :          0 :         if (se != cfs_rq->curr)
    1023                 :          0 :                 update_stats_wait_end(cfs_rq, se);
    1024                 :            : 
    1025                 :          0 :         if ((flags & DEQUEUE_SLEEP) && entity_is_task(se)) {
    1026                 :          0 :                 struct task_struct *tsk = task_of(se);
    1027                 :            : 
    1028                 :          0 :                 if (tsk->state & TASK_INTERRUPTIBLE)
    1029                 :          0 :                         __schedstat_set(se->statistics.sleep_start,
    1030                 :            :                                       rq_clock(rq_of(cfs_rq)));
    1031                 :          0 :                 if (tsk->state & TASK_UNINTERRUPTIBLE)
    1032                 :          0 :                         __schedstat_set(se->statistics.block_start,
    1033                 :            :                                       rq_clock(rq_of(cfs_rq)));
    1034                 :            :         }
    1035                 :            : }
    1036                 :            : 
    1037                 :            : /*
    1038                 :            :  * We are picking a new current task - update its stats:
    1039                 :            :  */
    1040                 :            : static inline void
    1041                 :            : update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
    1042                 :            : {
    1043                 :            :         /*
    1044                 :            :          * We are starting a new run period:
    1045                 :            :          */
    1046                 :          3 :         se->exec_start = rq_clock_task(rq_of(cfs_rq));
    1047                 :            : }
    1048                 :            : 
    1049                 :            : /**************************************************
    1050                 :            :  * Scheduling class queueing methods:
    1051                 :            :  */
    1052                 :            : 
    1053                 :            : #ifdef CONFIG_NUMA_BALANCING
    1054                 :            : /*
    1055                 :            :  * Approximate time to scan a full NUMA task in ms. The task scan period is
    1056                 :            :  * calculated based on the tasks virtual memory size and
    1057                 :            :  * numa_balancing_scan_size.
    1058                 :            :  */
    1059                 :            : unsigned int sysctl_numa_balancing_scan_period_min = 1000;
    1060                 :            : unsigned int sysctl_numa_balancing_scan_period_max = 60000;
    1061                 :            : 
    1062                 :            : /* Portion of address space to scan in MB */
    1063                 :            : unsigned int sysctl_numa_balancing_scan_size = 256;
    1064                 :            : 
    1065                 :            : /* Scan @scan_size MB every @scan_period after an initial @scan_delay in ms */
    1066                 :            : unsigned int sysctl_numa_balancing_scan_delay = 1000;
    1067                 :            : 
    1068                 :            : struct numa_group {
    1069                 :            :         refcount_t refcount;
    1070                 :            : 
    1071                 :            :         spinlock_t lock; /* nr_tasks, tasks */
    1072                 :            :         int nr_tasks;
    1073                 :            :         pid_t gid;
    1074                 :            :         int active_nodes;
    1075                 :            : 
    1076                 :            :         struct rcu_head rcu;
    1077                 :            :         unsigned long total_faults;
    1078                 :            :         unsigned long max_faults_cpu;
    1079                 :            :         /*
    1080                 :            :          * Faults_cpu is used to decide whether memory should move
    1081                 :            :          * towards the CPU. As a consequence, these stats are weighted
    1082                 :            :          * more by CPU use than by memory faults.
    1083                 :            :          */
    1084                 :            :         unsigned long *faults_cpu;
    1085                 :            :         unsigned long faults[0];
    1086                 :            : };
    1087                 :            : 
    1088                 :            : /*
    1089                 :            :  * For functions that can be called in multiple contexts that permit reading
    1090                 :            :  * ->numa_group (see struct task_struct for locking rules).
    1091                 :            :  */
    1092                 :            : static struct numa_group *deref_task_numa_group(struct task_struct *p)
    1093                 :            : {
    1094                 :            :         return rcu_dereference_check(p->numa_group, p == current ||
    1095                 :            :                 (lockdep_is_held(&task_rq(p)->lock) && !READ_ONCE(p->on_cpu)));
    1096                 :            : }
    1097                 :            : 
    1098                 :            : static struct numa_group *deref_curr_numa_group(struct task_struct *p)
    1099                 :            : {
    1100                 :            :         return rcu_dereference_protected(p->numa_group, p == current);
    1101                 :            : }
    1102                 :            : 
    1103                 :            : static inline unsigned long group_faults_priv(struct numa_group *ng);
    1104                 :            : static inline unsigned long group_faults_shared(struct numa_group *ng);
    1105                 :            : 
    1106                 :            : static unsigned int task_nr_scan_windows(struct task_struct *p)
    1107                 :            : {
    1108                 :            :         unsigned long rss = 0;
    1109                 :            :         unsigned long nr_scan_pages;
    1110                 :            : 
    1111                 :            :         /*
    1112                 :            :          * Calculations based on RSS as non-present and empty pages are skipped
    1113                 :            :          * by the PTE scanner and NUMA hinting faults should be trapped based
    1114                 :            :          * on resident pages
    1115                 :            :          */
    1116                 :            :         nr_scan_pages = sysctl_numa_balancing_scan_size << (20 - PAGE_SHIFT);
    1117                 :            :         rss = get_mm_rss(p->mm);
    1118                 :            :         if (!rss)
    1119                 :            :                 rss = nr_scan_pages;
    1120                 :            : 
    1121                 :            :         rss = round_up(rss, nr_scan_pages);
    1122                 :            :         return rss / nr_scan_pages;
    1123                 :            : }
    1124                 :            : 
    1125                 :            : /* For sanitys sake, never scan more PTEs than MAX_SCAN_WINDOW MB/sec. */
    1126                 :            : #define MAX_SCAN_WINDOW 2560
    1127                 :            : 
    1128                 :            : static unsigned int task_scan_min(struct task_struct *p)
    1129                 :            : {
    1130                 :            :         unsigned int scan_size = READ_ONCE(sysctl_numa_balancing_scan_size);
    1131                 :            :         unsigned int scan, floor;
    1132                 :            :         unsigned int windows = 1;
    1133                 :            : 
    1134                 :            :         if (scan_size < MAX_SCAN_WINDOW)
    1135                 :            :                 windows = MAX_SCAN_WINDOW / scan_size;
    1136                 :            :         floor = 1000 / windows;
    1137                 :            : 
    1138                 :            :         scan = sysctl_numa_balancing_scan_period_min / task_nr_scan_windows(p);
    1139                 :            :         return max_t(unsigned int, floor, scan);
    1140                 :            : }
    1141                 :            : 
    1142                 :            : static unsigned int task_scan_start(struct task_struct *p)
    1143                 :            : {
    1144                 :            :         unsigned long smin = task_scan_min(p);
    1145                 :            :         unsigned long period = smin;
    1146                 :            :         struct numa_group *ng;
    1147                 :            : 
    1148                 :            :         /* Scale the maximum scan period with the amount of shared memory. */
    1149                 :            :         rcu_read_lock();
    1150                 :            :         ng = rcu_dereference(p->numa_group);
    1151                 :            :         if (ng) {
    1152                 :            :                 unsigned long shared = group_faults_shared(ng);
    1153                 :            :                 unsigned long private = group_faults_priv(ng);
    1154                 :            : 
    1155                 :            :                 period *= refcount_read(&ng->refcount);
    1156                 :            :                 period *= shared + 1;
    1157                 :            :                 period /= private + shared + 1;
    1158                 :            :         }
    1159                 :            :         rcu_read_unlock();
    1160                 :            : 
    1161                 :            :         return max(smin, period);
    1162                 :            : }
    1163                 :            : 
    1164                 :            : static unsigned int task_scan_max(struct task_struct *p)
    1165                 :            : {
    1166                 :            :         unsigned long smin = task_scan_min(p);
    1167                 :            :         unsigned long smax;
    1168                 :            :         struct numa_group *ng;
    1169                 :            : 
    1170                 :            :         /* Watch for min being lower than max due to floor calculations */
    1171                 :            :         smax = sysctl_numa_balancing_scan_period_max / task_nr_scan_windows(p);
    1172                 :            : 
    1173                 :            :         /* Scale the maximum scan period with the amount of shared memory. */
    1174                 :            :         ng = deref_curr_numa_group(p);
    1175                 :            :         if (ng) {
    1176                 :            :                 unsigned long shared = group_faults_shared(ng);
    1177                 :            :                 unsigned long private = group_faults_priv(ng);
    1178                 :            :                 unsigned long period = smax;
    1179                 :            : 
    1180                 :            :                 period *= refcount_read(&ng->refcount);
    1181                 :            :                 period *= shared + 1;
    1182                 :            :                 period /= private + shared + 1;
    1183                 :            : 
    1184                 :            :                 smax = max(smax, period);
    1185                 :            :         }
    1186                 :            : 
    1187                 :            :         return max(smin, smax);
    1188                 :            : }
    1189                 :            : 
    1190                 :            : static void account_numa_enqueue(struct rq *rq, struct task_struct *p)
    1191                 :            : {
    1192                 :            :         rq->nr_numa_running += (p->numa_preferred_nid != NUMA_NO_NODE);
    1193                 :            :         rq->nr_preferred_running += (p->numa_preferred_nid == task_node(p));
    1194                 :            : }
    1195                 :            : 
    1196                 :            : static void account_numa_dequeue(struct rq *rq, struct task_struct *p)
    1197                 :            : {
    1198                 :            :         rq->nr_numa_running -= (p->numa_preferred_nid != NUMA_NO_NODE);
    1199                 :            :         rq->nr_preferred_running -= (p->numa_preferred_nid == task_node(p));
    1200                 :            : }
    1201                 :            : 
    1202                 :            : /* Shared or private faults. */
    1203                 :            : #define NR_NUMA_HINT_FAULT_TYPES 2
    1204                 :            : 
    1205                 :            : /* Memory and CPU locality */
    1206                 :            : #define NR_NUMA_HINT_FAULT_STATS (NR_NUMA_HINT_FAULT_TYPES * 2)
    1207                 :            : 
    1208                 :            : /* Averaged statistics, and temporary buffers. */
    1209                 :            : #define NR_NUMA_HINT_FAULT_BUCKETS (NR_NUMA_HINT_FAULT_STATS * 2)
    1210                 :            : 
    1211                 :            : pid_t task_numa_group_id(struct task_struct *p)
    1212                 :            : {
    1213                 :            :         struct numa_group *ng;
    1214                 :            :         pid_t gid = 0;
    1215                 :            : 
    1216                 :            :         rcu_read_lock();
    1217                 :            :         ng = rcu_dereference(p->numa_group);
    1218                 :            :         if (ng)
    1219                 :            :                 gid = ng->gid;
    1220                 :            :         rcu_read_unlock();
    1221                 :            : 
    1222                 :            :         return gid;
    1223                 :            : }
    1224                 :            : 
    1225                 :            : /*
    1226                 :            :  * The averaged statistics, shared & private, memory & CPU,
    1227                 :            :  * occupy the first half of the array. The second half of the
    1228                 :            :  * array is for current counters, which are averaged into the
    1229                 :            :  * first set by task_numa_placement.
    1230                 :            :  */
    1231                 :            : static inline int task_faults_idx(enum numa_faults_stats s, int nid, int priv)
    1232                 :            : {
    1233                 :            :         return NR_NUMA_HINT_FAULT_TYPES * (s * nr_node_ids + nid) + priv;
    1234                 :            : }
    1235                 :            : 
    1236                 :            : static inline unsigned long task_faults(struct task_struct *p, int nid)
    1237                 :            : {
    1238                 :            :         if (!p->numa_faults)
    1239                 :            :                 return 0;
    1240                 :            : 
    1241                 :            :         return p->numa_faults[task_faults_idx(NUMA_MEM, nid, 0)] +
    1242                 :            :                 p->numa_faults[task_faults_idx(NUMA_MEM, nid, 1)];
    1243                 :            : }
    1244                 :            : 
    1245                 :            : static inline unsigned long group_faults(struct task_struct *p, int nid)
    1246                 :            : {
    1247                 :            :         struct numa_group *ng = deref_task_numa_group(p);
    1248                 :            : 
    1249                 :            :         if (!ng)
    1250                 :            :                 return 0;
    1251                 :            : 
    1252                 :            :         return ng->faults[task_faults_idx(NUMA_MEM, nid, 0)] +
    1253                 :            :                 ng->faults[task_faults_idx(NUMA_MEM, nid, 1)];
    1254                 :            : }
    1255                 :            : 
    1256                 :            : static inline unsigned long group_faults_cpu(struct numa_group *group, int nid)
    1257                 :            : {
    1258                 :            :         return group->faults_cpu[task_faults_idx(NUMA_MEM, nid, 0)] +
    1259                 :            :                 group->faults_cpu[task_faults_idx(NUMA_MEM, nid, 1)];
    1260                 :            : }
    1261                 :            : 
    1262                 :            : static inline unsigned long group_faults_priv(struct numa_group *ng)
    1263                 :            : {
    1264                 :            :         unsigned long faults = 0;
    1265                 :            :         int node;
    1266                 :            : 
    1267                 :            :         for_each_online_node(node) {
    1268                 :            :                 faults += ng->faults[task_faults_idx(NUMA_MEM, node, 1)];
    1269                 :            :         }
    1270                 :            : 
    1271                 :            :         return faults;
    1272                 :            : }
    1273                 :            : 
    1274                 :            : static inline unsigned long group_faults_shared(struct numa_group *ng)
    1275                 :            : {
    1276                 :            :         unsigned long faults = 0;
    1277                 :            :         int node;
    1278                 :            : 
    1279                 :            :         for_each_online_node(node) {
    1280                 :            :                 faults += ng->faults[task_faults_idx(NUMA_MEM, node, 0)];
    1281                 :            :         }
    1282                 :            : 
    1283                 :            :         return faults;
    1284                 :            : }
    1285                 :            : 
    1286                 :            : /*
    1287                 :            :  * A node triggering more than 1/3 as many NUMA faults as the maximum is
    1288                 :            :  * considered part of a numa group's pseudo-interleaving set. Migrations
    1289                 :            :  * between these nodes are slowed down, to allow things to settle down.
    1290                 :            :  */
    1291                 :            : #define ACTIVE_NODE_FRACTION 3
    1292                 :            : 
    1293                 :            : static bool numa_is_active_node(int nid, struct numa_group *ng)
    1294                 :            : {
    1295                 :            :         return group_faults_cpu(ng, nid) * ACTIVE_NODE_FRACTION > ng->max_faults_cpu;
    1296                 :            : }
    1297                 :            : 
    1298                 :            : /* Handle placement on systems where not all nodes are directly connected. */
    1299                 :            : static unsigned long score_nearby_nodes(struct task_struct *p, int nid,
    1300                 :            :                                         int maxdist, bool task)
    1301                 :            : {
    1302                 :            :         unsigned long score = 0;
    1303                 :            :         int node;
    1304                 :            : 
    1305                 :            :         /*
    1306                 :            :          * All nodes are directly connected, and the same distance
    1307                 :            :          * from each other. No need for fancy placement algorithms.
    1308                 :            :          */
    1309                 :            :         if (sched_numa_topology_type == NUMA_DIRECT)
    1310                 :            :                 return 0;
    1311                 :            : 
    1312                 :            :         /*
    1313                 :            :          * This code is called for each node, introducing N^2 complexity,
    1314                 :            :          * which should be ok given the number of nodes rarely exceeds 8.
    1315                 :            :          */
    1316                 :            :         for_each_online_node(node) {
    1317                 :            :                 unsigned long faults;
    1318                 :            :                 int dist = node_distance(nid, node);
    1319                 :            : 
    1320                 :            :                 /*
    1321                 :            :                  * The furthest away nodes in the system are not interesting
    1322                 :            :                  * for placement; nid was already counted.
    1323                 :            :                  */
    1324                 :            :                 if (dist == sched_max_numa_distance || node == nid)
    1325                 :            :                         continue;
    1326                 :            : 
    1327                 :            :                 /*
    1328                 :            :                  * On systems with a backplane NUMA topology, compare groups
    1329                 :            :                  * of nodes, and move tasks towards the group with the most
    1330                 :            :                  * memory accesses. When comparing two nodes at distance
    1331                 :            :                  * "hoplimit", only nodes closer by than "hoplimit" are part
    1332                 :            :                  * of each group. Skip other nodes.
    1333                 :            :                  */
    1334                 :            :                 if (sched_numa_topology_type == NUMA_BACKPLANE &&
    1335                 :            :                                         dist >= maxdist)
    1336                 :            :                         continue;
    1337                 :            : 
    1338                 :            :                 /* Add up the faults from nearby nodes. */
    1339                 :            :                 if (task)
    1340                 :            :                         faults = task_faults(p, node);
    1341                 :            :                 else
    1342                 :            :                         faults = group_faults(p, node);
    1343                 :            : 
    1344                 :            :                 /*
    1345                 :            :                  * On systems with a glueless mesh NUMA topology, there are
    1346                 :            :                  * no fixed "groups of nodes". Instead, nodes that are not
    1347                 :            :                  * directly connected bounce traffic through intermediate
    1348                 :            :                  * nodes; a numa_group can occupy any set of nodes.
    1349                 :            :                  * The further away a node is, the less the faults count.
    1350                 :            :                  * This seems to result in good task placement.
    1351                 :            :                  */
    1352                 :            :                 if (sched_numa_topology_type == NUMA_GLUELESS_MESH) {
    1353                 :            :                         faults *= (sched_max_numa_distance - dist);
    1354                 :            :                         faults /= (sched_max_numa_distance - LOCAL_DISTANCE);
    1355                 :            :                 }
    1356                 :            : 
    1357                 :            :                 score += faults;
    1358                 :            :         }
    1359                 :            : 
    1360                 :            :         return score;
    1361                 :            : }
    1362                 :            : 
    1363                 :            : /*
    1364                 :            :  * These return the fraction of accesses done by a particular task, or
    1365                 :            :  * task group, on a particular numa node.  The group weight is given a
    1366                 :            :  * larger multiplier, in order to group tasks together that are almost
    1367                 :            :  * evenly spread out between numa nodes.
    1368                 :            :  */
    1369                 :            : static inline unsigned long task_weight(struct task_struct *p, int nid,
    1370                 :            :                                         int dist)
    1371                 :            : {
    1372                 :            :         unsigned long faults, total_faults;
    1373                 :            : 
    1374                 :            :         if (!p->numa_faults)
    1375                 :            :                 return 0;
    1376                 :            : 
    1377                 :            :         total_faults = p->total_numa_faults;
    1378                 :            : 
    1379                 :            :         if (!total_faults)
    1380                 :            :                 return 0;
    1381                 :            : 
    1382                 :            :         faults = task_faults(p, nid);
    1383                 :            :         faults += score_nearby_nodes(p, nid, dist, true);
    1384                 :            : 
    1385                 :            :         return 1000 * faults / total_faults;
    1386                 :            : }
    1387                 :            : 
    1388                 :            : static inline unsigned long group_weight(struct task_struct *p, int nid,
    1389                 :            :                                          int dist)
    1390                 :            : {
    1391                 :            :         struct numa_group *ng = deref_task_numa_group(p);
    1392                 :            :         unsigned long faults, total_faults;
    1393                 :            : 
    1394                 :            :         if (!ng)
    1395                 :            :                 return 0;
    1396                 :            : 
    1397                 :            :         total_faults = ng->total_faults;
    1398                 :            : 
    1399                 :            :         if (!total_faults)
    1400                 :            :                 return 0;
    1401                 :            : 
    1402                 :            :         faults = group_faults(p, nid);
    1403                 :            :         faults += score_nearby_nodes(p, nid, dist, false);
    1404                 :            : 
    1405                 :            :         return 1000 * faults / total_faults;
    1406                 :            : }
    1407                 :            : 
    1408                 :            : bool should_numa_migrate_memory(struct task_struct *p, struct page * page,
    1409                 :            :                                 int src_nid, int dst_cpu)
    1410                 :            : {
    1411                 :            :         struct numa_group *ng = deref_curr_numa_group(p);
    1412                 :            :         int dst_nid = cpu_to_node(dst_cpu);
    1413                 :            :         int last_cpupid, this_cpupid;
    1414                 :            : 
    1415                 :            :         this_cpupid = cpu_pid_to_cpupid(dst_cpu, current->pid);
    1416                 :            :         last_cpupid = page_cpupid_xchg_last(page, this_cpupid);
    1417                 :            : 
    1418                 :            :         /*
    1419                 :            :          * Allow first faults or private faults to migrate immediately early in
    1420                 :            :          * the lifetime of a task. The magic number 4 is based on waiting for
    1421                 :            :          * two full passes of the "multi-stage node selection" test that is
    1422                 :            :          * executed below.
    1423                 :            :          */
    1424                 :            :         if ((p->numa_preferred_nid == NUMA_NO_NODE || p->numa_scan_seq <= 4) &&
    1425                 :            :             (cpupid_pid_unset(last_cpupid) || cpupid_match_pid(p, last_cpupid)))
    1426                 :            :                 return true;
    1427                 :            : 
    1428                 :            :         /*
    1429                 :            :          * Multi-stage node selection is used in conjunction with a periodic
    1430                 :            :          * migration fault to build a temporal task<->page relation. By using
    1431                 :            :          * a two-stage filter we remove short/unlikely relations.
    1432                 :            :          *
    1433                 :            :          * Using P(p) ~ n_p / n_t as per frequentist probability, we can equate
    1434                 :            :          * a task's usage of a particular page (n_p) per total usage of this
    1435                 :            :          * page (n_t) (in a given time-span) to a probability.
    1436                 :            :          *
    1437                 :            :          * Our periodic faults will sample this probability and getting the
    1438                 :            :          * same result twice in a row, given these samples are fully
    1439                 :            :          * independent, is then given by P(n)^2, provided our sample period
    1440                 :            :          * is sufficiently short compared to the usage pattern.
    1441                 :            :          *
    1442                 :            :          * This quadric squishes small probabilities, making it less likely we
    1443                 :            :          * act on an unlikely task<->page relation.
    1444                 :            :          */
    1445                 :            :         if (!cpupid_pid_unset(last_cpupid) &&
    1446                 :            :                                 cpupid_to_nid(last_cpupid) != dst_nid)
    1447                 :            :                 return false;
    1448                 :            : 
    1449                 :            :         /* Always allow migrate on private faults */
    1450                 :            :         if (cpupid_match_pid(p, last_cpupid))
    1451                 :            :                 return true;
    1452                 :            : 
    1453                 :            :         /* A shared fault, but p->numa_group has not been set up yet. */
    1454                 :            :         if (!ng)
    1455                 :            :                 return true;
    1456                 :            : 
    1457                 :            :         /*
    1458                 :            :          * Destination node is much more heavily used than the source
    1459                 :            :          * node? Allow migration.
    1460                 :            :          */
    1461                 :            :         if (group_faults_cpu(ng, dst_nid) > group_faults_cpu(ng, src_nid) *
    1462                 :            :                                         ACTIVE_NODE_FRACTION)
    1463                 :            :                 return true;
    1464                 :            : 
    1465                 :            :         /*
    1466                 :            :          * Distribute memory according to CPU & memory use on each node,
    1467                 :            :          * with 3/4 hysteresis to avoid unnecessary memory migrations:
    1468                 :            :          *
    1469                 :            :          * faults_cpu(dst)   3   faults_cpu(src)
    1470                 :            :          * --------------- * - > ---------------
    1471                 :            :          * faults_mem(dst)   4   faults_mem(src)
    1472                 :            :          */
    1473                 :            :         return group_faults_cpu(ng, dst_nid) * group_faults(p, src_nid) * 3 >
    1474                 :            :                group_faults_cpu(ng, src_nid) * group_faults(p, dst_nid) * 4;
    1475                 :            : }
    1476                 :            : 
    1477                 :            : static unsigned long cpu_runnable_load(struct rq *rq);
    1478                 :            : 
    1479                 :            : /* Cached statistics for all CPUs within a node */
    1480                 :            : struct numa_stats {
    1481                 :            :         unsigned long load;
    1482                 :            : 
    1483                 :            :         /* Total compute capacity of CPUs on a node */
    1484                 :            :         unsigned long compute_capacity;
    1485                 :            : };
    1486                 :            : 
    1487                 :            : /*
    1488                 :            :  * XXX borrowed from update_sg_lb_stats
    1489                 :            :  */
    1490                 :            : static void update_numa_stats(struct numa_stats *ns, int nid)
    1491                 :            : {
    1492                 :            :         int cpu;
    1493                 :            : 
    1494                 :            :         memset(ns, 0, sizeof(*ns));
    1495                 :            :         for_each_cpu(cpu, cpumask_of_node(nid)) {
    1496                 :            :                 struct rq *rq = cpu_rq(cpu);
    1497                 :            : 
    1498                 :            :                 ns->load += cpu_runnable_load(rq);
    1499                 :            :                 ns->compute_capacity += capacity_of(cpu);
    1500                 :            :         }
    1501                 :            : 
    1502                 :            : }
    1503                 :            : 
    1504                 :            : struct task_numa_env {
    1505                 :            :         struct task_struct *p;
    1506                 :            : 
    1507                 :            :         int src_cpu, src_nid;
    1508                 :            :         int dst_cpu, dst_nid;
    1509                 :            : 
    1510                 :            :         struct numa_stats src_stats, dst_stats;
    1511                 :            : 
    1512                 :            :         int imbalance_pct;
    1513                 :            :         int dist;
    1514                 :            : 
    1515                 :            :         struct task_struct *best_task;
    1516                 :            :         long best_imp;
    1517                 :            :         int best_cpu;
    1518                 :            : };
    1519                 :            : 
    1520                 :            : static void task_numa_assign(struct task_numa_env *env,
    1521                 :            :                              struct task_struct *p, long imp)
    1522                 :            : {
    1523                 :            :         struct rq *rq = cpu_rq(env->dst_cpu);
    1524                 :            : 
    1525                 :            :         /* Bail out if run-queue part of active NUMA balance. */
    1526                 :            :         if (xchg(&rq->numa_migrate_on, 1))
    1527                 :            :                 return;
    1528                 :            : 
    1529                 :            :         /*
    1530                 :            :          * Clear previous best_cpu/rq numa-migrate flag, since task now
    1531                 :            :          * found a better CPU to move/swap.
    1532                 :            :          */
    1533                 :            :         if (env->best_cpu != -1) {
    1534                 :            :                 rq = cpu_rq(env->best_cpu);
    1535                 :            :                 WRITE_ONCE(rq->numa_migrate_on, 0);
    1536                 :            :         }
    1537                 :            : 
    1538                 :            :         if (env->best_task)
    1539                 :            :                 put_task_struct(env->best_task);
    1540                 :            :         if (p)
    1541                 :            :                 get_task_struct(p);
    1542                 :            : 
    1543                 :            :         env->best_task = p;
    1544                 :            :         env->best_imp = imp;
    1545                 :            :         env->best_cpu = env->dst_cpu;
    1546                 :            : }
    1547                 :            : 
    1548                 :            : static bool load_too_imbalanced(long src_load, long dst_load,
    1549                 :            :                                 struct task_numa_env *env)
    1550                 :            : {
    1551                 :            :         long imb, old_imb;
    1552                 :            :         long orig_src_load, orig_dst_load;
    1553                 :            :         long src_capacity, dst_capacity;
    1554                 :            : 
    1555                 :            :         /*
    1556                 :            :          * The load is corrected for the CPU capacity available on each node.
    1557                 :            :          *
    1558                 :            :          * src_load        dst_load
    1559                 :            :          * ------------ vs ---------
    1560                 :            :          * src_capacity    dst_capacity
    1561                 :            :          */
    1562                 :            :         src_capacity = env->src_stats.compute_capacity;
    1563                 :            :         dst_capacity = env->dst_stats.compute_capacity;
    1564                 :            : 
    1565                 :            :         imb = abs(dst_load * src_capacity - src_load * dst_capacity);
    1566                 :            : 
    1567                 :            :         orig_src_load = env->src_stats.load;
    1568                 :            :         orig_dst_load = env->dst_stats.load;
    1569                 :            : 
    1570                 :            :         old_imb = abs(orig_dst_load * src_capacity - orig_src_load * dst_capacity);
    1571                 :            : 
    1572                 :            :         /* Would this change make things worse? */
    1573                 :            :         return (imb > old_imb);
    1574                 :            : }
    1575                 :            : 
    1576                 :            : /*
    1577                 :            :  * Maximum NUMA importance can be 1998 (2*999);
    1578                 :            :  * SMALLIMP @ 30 would be close to 1998/64.
    1579                 :            :  * Used to deter task migration.
    1580                 :            :  */
    1581                 :            : #define SMALLIMP        30
    1582                 :            : 
    1583                 :            : /*
    1584                 :            :  * This checks if the overall compute and NUMA accesses of the system would
    1585                 :            :  * be improved if the source tasks was migrated to the target dst_cpu taking
    1586                 :            :  * into account that it might be best if task running on the dst_cpu should
    1587                 :            :  * be exchanged with the source task
    1588                 :            :  */
    1589                 :            : static void task_numa_compare(struct task_numa_env *env,
    1590                 :            :                               long taskimp, long groupimp, bool maymove)
    1591                 :            : {
    1592                 :            :         struct numa_group *cur_ng, *p_ng = deref_curr_numa_group(env->p);
    1593                 :            :         struct rq *dst_rq = cpu_rq(env->dst_cpu);
    1594                 :            :         long imp = p_ng ? groupimp : taskimp;
    1595                 :            :         struct task_struct *cur;
    1596                 :            :         long src_load, dst_load;
    1597                 :            :         int dist = env->dist;
    1598                 :            :         long moveimp = imp;
    1599                 :            :         long load;
    1600                 :            : 
    1601                 :            :         if (READ_ONCE(dst_rq->numa_migrate_on))
    1602                 :            :                 return;
    1603                 :            : 
    1604                 :            :         rcu_read_lock();
    1605                 :            :         cur = rcu_dereference(dst_rq->curr);
    1606                 :            :         if (cur && ((cur->flags & PF_EXITING) || is_idle_task(cur)))
    1607                 :            :                 cur = NULL;
    1608                 :            : 
    1609                 :            :         /*
    1610                 :            :          * Because we have preemption enabled we can get migrated around and
    1611                 :            :          * end try selecting ourselves (current == env->p) as a swap candidate.
    1612                 :            :          */
    1613                 :            :         if (cur == env->p)
    1614                 :            :                 goto unlock;
    1615                 :            : 
    1616                 :            :         if (!cur) {
    1617                 :            :                 if (maymove && moveimp >= env->best_imp)
    1618                 :            :                         goto assign;
    1619                 :            :                 else
    1620                 :            :                         goto unlock;
    1621                 :            :         }
    1622                 :            : 
    1623                 :            :         /*
    1624                 :            :          * "imp" is the fault differential for the source task between the
    1625                 :            :          * source and destination node. Calculate the total differential for
    1626                 :            :          * the source task and potential destination task. The more negative
    1627                 :            :          * the value is, the more remote accesses that would be expected to
    1628                 :            :          * be incurred if the tasks were swapped.
    1629                 :            :          */
    1630                 :            :         /* Skip this swap candidate if cannot move to the source cpu */
    1631                 :            :         if (!cpumask_test_cpu(env->src_cpu, cur->cpus_ptr))
    1632                 :            :                 goto unlock;
    1633                 :            : 
    1634                 :            :         /*
    1635                 :            :          * If dst and source tasks are in the same NUMA group, or not
    1636                 :            :          * in any group then look only at task weights.
    1637                 :            :          */
    1638                 :            :         cur_ng = rcu_dereference(cur->numa_group);
    1639                 :            :         if (cur_ng == p_ng) {
    1640                 :            :                 imp = taskimp + task_weight(cur, env->src_nid, dist) -
    1641                 :            :                       task_weight(cur, env->dst_nid, dist);
    1642                 :            :                 /*
    1643                 :            :                  * Add some hysteresis to prevent swapping the
    1644                 :            :                  * tasks within a group over tiny differences.
    1645                 :            :                  */
    1646                 :            :                 if (cur_ng)
    1647                 :            :                         imp -= imp / 16;
    1648                 :            :         } else {
    1649                 :            :                 /*
    1650                 :            :                  * Compare the group weights. If a task is all by itself
    1651                 :            :                  * (not part of a group), use the task weight instead.
    1652                 :            :                  */
    1653                 :            :                 if (cur_ng && p_ng)
    1654                 :            :                         imp += group_weight(cur, env->src_nid, dist) -
    1655                 :            :                                group_weight(cur, env->dst_nid, dist);
    1656                 :            :                 else
    1657                 :            :                         imp += task_weight(cur, env->src_nid, dist) -
    1658                 :            :                                task_weight(cur, env->dst_nid, dist);
    1659                 :            :         }
    1660                 :            : 
    1661                 :            :         if (maymove && moveimp > imp && moveimp > env->best_imp) {
    1662                 :            :                 imp = moveimp;
    1663                 :            :                 cur = NULL;
    1664                 :            :                 goto assign;
    1665                 :            :         }
    1666                 :            : 
    1667                 :            :         /*
    1668                 :            :          * If the NUMA importance is less than SMALLIMP,
    1669                 :            :          * task migration might only result in ping pong
    1670                 :            :          * of tasks and also hurt performance due to cache
    1671                 :            :          * misses.
    1672                 :            :          */
    1673                 :            :         if (imp < SMALLIMP || imp <= env->best_imp + SMALLIMP / 2)
    1674                 :            :                 goto unlock;
    1675                 :            : 
    1676                 :            :         /*
    1677                 :            :          * In the overloaded case, try and keep the load balanced.
    1678                 :            :          */
    1679                 :            :         load = task_h_load(env->p) - task_h_load(cur);
    1680                 :            :         if (!load)
    1681                 :            :                 goto assign;
    1682                 :            : 
    1683                 :            :         dst_load = env->dst_stats.load + load;
    1684                 :            :         src_load = env->src_stats.load - load;
    1685                 :            : 
    1686                 :            :         if (load_too_imbalanced(src_load, dst_load, env))
    1687                 :            :                 goto unlock;
    1688                 :            : 
    1689                 :            : assign:
    1690                 :            :         /*
    1691                 :            :          * One idle CPU per node is evaluated for a task numa move.
    1692                 :            :          * Call select_idle_sibling to maybe find a better one.
    1693                 :            :          */
    1694                 :            :         if (!cur) {
    1695                 :            :                 /*
    1696                 :            :                  * select_idle_siblings() uses an per-CPU cpumask that
    1697                 :            :                  * can be used from IRQ context.
    1698                 :            :                  */
    1699                 :            :                 local_irq_disable();
    1700                 :            :                 env->dst_cpu = select_idle_sibling(env->p, env->src_cpu,
    1701                 :            :                                                    env->dst_cpu);
    1702                 :            :                 local_irq_enable();
    1703                 :            :         }
    1704                 :            : 
    1705                 :            :         task_numa_assign(env, cur, imp);
    1706                 :            : unlock:
    1707                 :            :         rcu_read_unlock();
    1708                 :            : }
    1709                 :            : 
    1710                 :            : static void task_numa_find_cpu(struct task_numa_env *env,
    1711                 :            :                                 long taskimp, long groupimp)
    1712                 :            : {
    1713                 :            :         long src_load, dst_load, load;
    1714                 :            :         bool maymove = false;
    1715                 :            :         int cpu;
    1716                 :            : 
    1717                 :            :         load = task_h_load(env->p);
    1718                 :            :         dst_load = env->dst_stats.load + load;
    1719                 :            :         src_load = env->src_stats.load - load;
    1720                 :            : 
    1721                 :            :         /*
    1722                 :            :          * If the improvement from just moving env->p direction is better
    1723                 :            :          * than swapping tasks around, check if a move is possible.
    1724                 :            :          */
    1725                 :            :         maymove = !load_too_imbalanced(src_load, dst_load, env);
    1726                 :            : 
    1727                 :            :         for_each_cpu(cpu, cpumask_of_node(env->dst_nid)) {
    1728                 :            :                 /* Skip this CPU if the source task cannot migrate */
    1729                 :            :                 if (!cpumask_test_cpu(cpu, env->p->cpus_ptr))
    1730                 :            :                         continue;
    1731                 :            : 
    1732                 :            :                 env->dst_cpu = cpu;
    1733                 :            :                 task_numa_compare(env, taskimp, groupimp, maymove);
    1734                 :            :         }
    1735                 :            : }
    1736                 :            : 
    1737                 :            : static int task_numa_migrate(struct task_struct *p)
    1738                 :            : {
    1739                 :            :         struct task_numa_env env = {
    1740                 :            :                 .p = p,
    1741                 :            : 
    1742                 :            :                 .src_cpu = task_cpu(p),
    1743                 :            :                 .src_nid = task_node(p),
    1744                 :            : 
    1745                 :            :                 .imbalance_pct = 112,
    1746                 :            : 
    1747                 :            :                 .best_task = NULL,
    1748                 :            :                 .best_imp = 0,
    1749                 :            :                 .best_cpu = -1,
    1750                 :            :         };
    1751                 :            :         unsigned long taskweight, groupweight;
    1752                 :            :         struct sched_domain *sd;
    1753                 :            :         long taskimp, groupimp;
    1754                 :            :         struct numa_group *ng;
    1755                 :            :         struct rq *best_rq;
    1756                 :            :         int nid, ret, dist;
    1757                 :            : 
    1758                 :            :         /*
    1759                 :            :          * Pick the lowest SD_NUMA domain, as that would have the smallest
    1760                 :            :          * imbalance and would be the first to start moving tasks about.
    1761                 :            :          *
    1762                 :            :          * And we want to avoid any moving of tasks about, as that would create
    1763                 :            :          * random movement of tasks -- counter the numa conditions we're trying
    1764                 :            :          * to satisfy here.
    1765                 :            :          */
    1766                 :            :         rcu_read_lock();
    1767                 :            :         sd = rcu_dereference(per_cpu(sd_numa, env.src_cpu));
    1768                 :            :         if (sd)
    1769                 :            :                 env.imbalance_pct = 100 + (sd->imbalance_pct - 100) / 2;
    1770                 :            :         rcu_read_unlock();
    1771                 :            : 
    1772                 :            :         /*
    1773                 :            :          * Cpusets can break the scheduler domain tree into smaller
    1774                 :            :          * balance domains, some of which do not cross NUMA boundaries.
    1775                 :            :          * Tasks that are "trapped" in such domains cannot be migrated
    1776                 :            :          * elsewhere, so there is no point in (re)trying.
    1777                 :            :          */
    1778                 :            :         if (unlikely(!sd)) {
    1779                 :            :                 sched_setnuma(p, task_node(p));
    1780                 :            :                 return -EINVAL;
    1781                 :            :         }
    1782                 :            : 
    1783                 :            :         env.dst_nid = p->numa_preferred_nid;
    1784                 :            :         dist = env.dist = node_distance(env.src_nid, env.dst_nid);
    1785                 :            :         taskweight = task_weight(p, env.src_nid, dist);
    1786                 :            :         groupweight = group_weight(p, env.src_nid, dist);
    1787                 :            :         update_numa_stats(&env.src_stats, env.src_nid);
    1788                 :            :         taskimp = task_weight(p, env.dst_nid, dist) - taskweight;
    1789                 :            :         groupimp = group_weight(p, env.dst_nid, dist) - groupweight;
    1790                 :            :         update_numa_stats(&env.dst_stats, env.dst_nid);
    1791                 :            : 
    1792                 :            :         /* Try to find a spot on the preferred nid. */
    1793                 :            :         task_numa_find_cpu(&env, taskimp, groupimp);
    1794                 :            : 
    1795                 :            :         /*
    1796                 :            :          * Look at other nodes in these cases:
    1797                 :            :          * - there is no space available on the preferred_nid
    1798                 :            :          * - the task is part of a numa_group that is interleaved across
    1799                 :            :          *   multiple NUMA nodes; in order to better consolidate the group,
    1800                 :            :          *   we need to check other locations.
    1801                 :            :          */
    1802                 :            :         ng = deref_curr_numa_group(p);
    1803                 :            :         if (env.best_cpu == -1 || (ng && ng->active_nodes > 1)) {
    1804                 :            :                 for_each_online_node(nid) {
    1805                 :            :                         if (nid == env.src_nid || nid == p->numa_preferred_nid)
    1806                 :            :                                 continue;
    1807                 :            : 
    1808                 :            :                         dist = node_distance(env.src_nid, env.dst_nid);
    1809                 :            :                         if (sched_numa_topology_type == NUMA_BACKPLANE &&
    1810                 :            :                                                 dist != env.dist) {
    1811                 :            :                                 taskweight = task_weight(p, env.src_nid, dist);
    1812                 :            :                                 groupweight = group_weight(p, env.src_nid, dist);
    1813                 :            :                         }
    1814                 :            : 
    1815                 :            :                         /* Only consider nodes where both task and groups benefit */
    1816                 :            :                         taskimp = task_weight(p, nid, dist) - taskweight;
    1817                 :            :                         groupimp = group_weight(p, nid, dist) - groupweight;
    1818                 :            :                         if (taskimp < 0 && groupimp < 0)
    1819                 :            :                                 continue;
    1820                 :            : 
    1821                 :            :                         env.dist = dist;
    1822                 :            :                         env.dst_nid = nid;
    1823                 :            :                         update_numa_stats(&env.dst_stats, env.dst_nid);
    1824                 :            :                         task_numa_find_cpu(&env, taskimp, groupimp);
    1825                 :            :                 }
    1826                 :            :         }
    1827                 :            : 
    1828                 :            :         /*
    1829                 :            :          * If the task is part of a workload that spans multiple NUMA nodes,
    1830                 :            :          * and is migrating into one of the workload's active nodes, remember
    1831                 :            :          * this node as the task's preferred numa node, so the workload can
    1832                 :            :          * settle down.
    1833                 :            :          * A task that migrated to a second choice node will be better off
    1834                 :            :          * trying for a better one later. Do not set the preferred node here.
    1835                 :            :          */
    1836                 :            :         if (ng) {
    1837                 :            :                 if (env.best_cpu == -1)
    1838                 :            :                         nid = env.src_nid;
    1839                 :            :                 else
    1840                 :            :                         nid = cpu_to_node(env.best_cpu);
    1841                 :            : 
    1842                 :            :                 if (nid != p->numa_preferred_nid)
    1843                 :            :                         sched_setnuma(p, nid);
    1844                 :            :         }
    1845                 :            : 
    1846                 :            :         /* No better CPU than the current one was found. */
    1847                 :            :         if (env.best_cpu == -1)
    1848                 :            :                 return -EAGAIN;
    1849                 :            : 
    1850                 :            :         best_rq = cpu_rq(env.best_cpu);
    1851                 :            :         if (env.best_task == NULL) {
    1852                 :            :                 ret = migrate_task_to(p, env.best_cpu);
    1853                 :            :                 WRITE_ONCE(best_rq->numa_migrate_on, 0);
    1854                 :            :                 if (ret != 0)
    1855                 :            :                         trace_sched_stick_numa(p, env.src_cpu, env.best_cpu);
    1856                 :            :                 return ret;
    1857                 :            :         }
    1858                 :            : 
    1859                 :            :         ret = migrate_swap(p, env.best_task, env.best_cpu, env.src_cpu);
    1860                 :            :         WRITE_ONCE(best_rq->numa_migrate_on, 0);
    1861                 :            : 
    1862                 :            :         if (ret != 0)
    1863                 :            :                 trace_sched_stick_numa(p, env.src_cpu, task_cpu(env.best_task));
    1864                 :            :         put_task_struct(env.best_task);
    1865                 :            :         return ret;
    1866                 :            : }
    1867                 :            : 
    1868                 :            : /* Attempt to migrate a task to a CPU on the preferred node. */
    1869                 :            : static void numa_migrate_preferred(struct task_struct *p)
    1870                 :            : {
    1871                 :            :         unsigned long interval = HZ;
    1872                 :            : 
    1873                 :            :         /* This task has no NUMA fault statistics yet */
    1874                 :            :         if (unlikely(p->numa_preferred_nid == NUMA_NO_NODE || !p->numa_faults))
    1875                 :            :                 return;
    1876                 :            : 
    1877                 :            :         /* Periodically retry migrating the task to the preferred node */
    1878                 :            :         interval = min(interval, msecs_to_jiffies(p->numa_scan_period) / 16);
    1879                 :            :         p->numa_migrate_retry = jiffies + interval;
    1880                 :            : 
    1881                 :            :         /* Success if task is already running on preferred CPU */
    1882                 :            :         if (task_node(p) == p->numa_preferred_nid)
    1883                 :            :                 return;
    1884                 :            : 
    1885                 :            :         /* Otherwise, try migrate to a CPU on the preferred node */
    1886                 :            :         task_numa_migrate(p);
    1887                 :            : }
    1888                 :            : 
    1889                 :            : /*
    1890                 :            :  * Find out how many nodes on the workload is actively running on. Do this by
    1891                 :            :  * tracking the nodes from which NUMA hinting faults are triggered. This can
    1892                 :            :  * be different from the set of nodes where the workload's memory is currently
    1893                 :            :  * located.
    1894                 :            :  */
    1895                 :            : static void numa_group_count_active_nodes(struct numa_group *numa_group)
    1896                 :            : {
    1897                 :            :         unsigned long faults, max_faults = 0;
    1898                 :            :         int nid, active_nodes = 0;
    1899                 :            : 
    1900                 :            :         for_each_online_node(nid) {
    1901                 :            :                 faults = group_faults_cpu(numa_group, nid);
    1902                 :            :                 if (faults > max_faults)
    1903                 :            :                         max_faults = faults;
    1904                 :            :         }
    1905                 :            : 
    1906                 :            :         for_each_online_node(nid) {
    1907                 :            :                 faults = group_faults_cpu(numa_group, nid);
    1908                 :            :                 if (faults * ACTIVE_NODE_FRACTION > max_faults)
    1909                 :            :                         active_nodes++;
    1910                 :            :         }
    1911                 :            : 
    1912                 :            :         numa_group->max_faults_cpu = max_faults;
    1913                 :            :         numa_group->active_nodes = active_nodes;
    1914                 :            : }
    1915                 :            : 
    1916                 :            : /*
    1917                 :            :  * When adapting the scan rate, the period is divided into NUMA_PERIOD_SLOTS
    1918                 :            :  * increments. The more local the fault statistics are, the higher the scan
    1919                 :            :  * period will be for the next scan window. If local/(local+remote) ratio is
    1920                 :            :  * below NUMA_PERIOD_THRESHOLD (where range of ratio is 1..NUMA_PERIOD_SLOTS)
    1921                 :            :  * the scan period will decrease. Aim for 70% local accesses.
    1922                 :            :  */
    1923                 :            : #define NUMA_PERIOD_SLOTS 10
    1924                 :            : #define NUMA_PERIOD_THRESHOLD 7
    1925                 :            : 
    1926                 :            : /*
    1927                 :            :  * Increase the scan period (slow down scanning) if the majority of
    1928                 :            :  * our memory is already on our local node, or if the majority of
    1929                 :            :  * the page accesses are shared with other processes.
    1930                 :            :  * Otherwise, decrease the scan period.
    1931                 :            :  */
    1932                 :            : static void update_task_scan_period(struct task_struct *p,
    1933                 :            :                         unsigned long shared, unsigned long private)
    1934                 :            : {
    1935                 :            :         unsigned int period_slot;
    1936                 :            :         int lr_ratio, ps_ratio;
    1937                 :            :         int diff;
    1938                 :            : 
    1939                 :            :         unsigned long remote = p->numa_faults_locality[0];
    1940                 :            :         unsigned long local = p->numa_faults_locality[1];
    1941                 :            : 
    1942                 :            :         /*
    1943                 :            :          * If there were no record hinting faults then either the task is
    1944                 :            :          * completely idle or all activity is areas that are not of interest
    1945                 :            :          * to automatic numa balancing. Related to that, if there were failed
    1946                 :            :          * migration then it implies we are migrating too quickly or the local
    1947                 :            :          * node is overloaded. In either case, scan slower
    1948                 :            :          */
    1949                 :            :         if (local + shared == 0 || p->numa_faults_locality[2]) {
    1950                 :            :                 p->numa_scan_period = min(p->numa_scan_period_max,
    1951                 :            :                         p->numa_scan_period << 1);
    1952                 :            : 
    1953                 :            :                 p->mm->numa_next_scan = jiffies +
    1954                 :            :                         msecs_to_jiffies(p->numa_scan_period);
    1955                 :            : 
    1956                 :            :                 return;
    1957                 :            :         }
    1958                 :            : 
    1959                 :            :         /*
    1960                 :            :          * Prepare to scale scan period relative to the current period.
    1961                 :            :          *       == NUMA_PERIOD_THRESHOLD scan period stays the same
    1962                 :            :          *       <  NUMA_PERIOD_THRESHOLD scan period decreases (scan faster)
    1963                 :            :          *       >= NUMA_PERIOD_THRESHOLD scan period increases (scan slower)
    1964                 :            :          */
    1965                 :            :         period_slot = DIV_ROUND_UP(p->numa_scan_period, NUMA_PERIOD_SLOTS);
    1966                 :            :         lr_ratio = (local * NUMA_PERIOD_SLOTS) / (local + remote);
    1967                 :            :         ps_ratio = (private * NUMA_PERIOD_SLOTS) / (private + shared);
    1968                 :            : 
    1969                 :            :         if (ps_ratio >= NUMA_PERIOD_THRESHOLD) {
    1970                 :            :                 /*
    1971                 :            :                  * Most memory accesses are local. There is no need to
    1972                 :            :                  * do fast NUMA scanning, since memory is already local.
    1973                 :            :                  */
    1974                 :            :                 int slot = ps_ratio - NUMA_PERIOD_THRESHOLD;
    1975                 :            :                 if (!slot)
    1976                 :            :                         slot = 1;
    1977                 :            :                 diff = slot * period_slot;
    1978                 :            :         } else if (lr_ratio >= NUMA_PERIOD_THRESHOLD) {
    1979                 :            :                 /*
    1980                 :            :                  * Most memory accesses are shared with other tasks.
    1981                 :            :                  * There is no point in continuing fast NUMA scanning,
    1982                 :            :                  * since other tasks may just move the memory elsewhere.
    1983                 :            :                  */
    1984                 :            :                 int slot = lr_ratio - NUMA_PERIOD_THRESHOLD;
    1985                 :            :                 if (!slot)
    1986                 :            :                         slot = 1;
    1987                 :            :                 diff = slot * period_slot;
    1988                 :            :         } else {
    1989                 :            :                 /*
    1990                 :            :                  * Private memory faults exceed (SLOTS-THRESHOLD)/SLOTS,
    1991                 :            :                  * yet they are not on the local NUMA node. Speed up
    1992                 :            :                  * NUMA scanning to get the memory moved over.
    1993                 :            :                  */
    1994                 :            :                 int ratio = max(lr_ratio, ps_ratio);
    1995                 :            :                 diff = -(NUMA_PERIOD_THRESHOLD - ratio) * period_slot;
    1996                 :            :         }
    1997                 :            : 
    1998                 :            :         p->numa_scan_period = clamp(p->numa_scan_period + diff,
    1999                 :            :                         task_scan_min(p), task_scan_max(p));
    2000                 :            :         memset(p->numa_faults_locality, 0, sizeof(p->numa_faults_locality));
    2001                 :            : }
    2002                 :            : 
    2003                 :            : /*
    2004                 :            :  * Get the fraction of time the task has been running since the last
    2005                 :            :  * NUMA placement cycle. The scheduler keeps similar statistics, but
    2006                 :            :  * decays those on a 32ms period, which is orders of magnitude off
    2007                 :            :  * from the dozens-of-seconds NUMA balancing period. Use the scheduler
    2008                 :            :  * stats only if the task is so new there are no NUMA statistics yet.
    2009                 :            :  */
    2010                 :            : static u64 numa_get_avg_runtime(struct task_struct *p, u64 *period)
    2011                 :            : {
    2012                 :            :         u64 runtime, delta, now;
    2013                 :            :         /* Use the start of this time slice to avoid calculations. */
    2014                 :            :         now = p->se.exec_start;
    2015                 :            :         runtime = p->se.sum_exec_runtime;
    2016                 :            : 
    2017                 :            :         if (p->last_task_numa_placement) {
    2018                 :            :                 delta = runtime - p->last_sum_exec_runtime;
    2019                 :            :                 *period = now - p->last_task_numa_placement;
    2020                 :            : 
    2021                 :            :                 /* Avoid time going backwards, prevent potential divide error: */
    2022                 :            :                 if (unlikely((s64)*period < 0))
    2023                 :            :                         *period = 0;
    2024                 :            :         } else {
    2025                 :            :                 delta = p->se.avg.load_sum;
    2026                 :            :                 *period = LOAD_AVG_MAX;
    2027                 :            :         }
    2028                 :            : 
    2029                 :            :         p->last_sum_exec_runtime = runtime;
    2030                 :            :         p->last_task_numa_placement = now;
    2031                 :            : 
    2032                 :            :         return delta;
    2033                 :            : }
    2034                 :            : 
    2035                 :            : /*
    2036                 :            :  * Determine the preferred nid for a task in a numa_group. This needs to
    2037                 :            :  * be done in a way that produces consistent results with group_weight,
    2038                 :            :  * otherwise workloads might not converge.
    2039                 :            :  */
    2040                 :            : static int preferred_group_nid(struct task_struct *p, int nid)
    2041                 :            : {
    2042                 :            :         nodemask_t nodes;
    2043                 :            :         int dist;
    2044                 :            : 
    2045                 :            :         /* Direct connections between all NUMA nodes. */
    2046                 :            :         if (sched_numa_topology_type == NUMA_DIRECT)
    2047                 :            :                 return nid;
    2048                 :            : 
    2049                 :            :         /*
    2050                 :            :          * On a system with glueless mesh NUMA topology, group_weight
    2051                 :            :          * scores nodes according to the number of NUMA hinting faults on
    2052                 :            :          * both the node itself, and on nearby nodes.
    2053                 :            :          */
    2054                 :            :         if (sched_numa_topology_type == NUMA_GLUELESS_MESH) {
    2055                 :            :                 unsigned long score, max_score = 0;
    2056                 :            :                 int node, max_node = nid;
    2057                 :            : 
    2058                 :            :                 dist = sched_max_numa_distance;
    2059                 :            : 
    2060                 :            :                 for_each_online_node(node) {
    2061                 :            :                         score = group_weight(p, node, dist);
    2062                 :            :                         if (score > max_score) {
    2063                 :            :                                 max_score = score;
    2064                 :            :                                 max_node = node;
    2065                 :            :                         }
    2066                 :            :                 }
    2067                 :            :                 return max_node;
    2068                 :            :         }
    2069                 :            : 
    2070                 :            :         /*
    2071                 :            :          * Finding the preferred nid in a system with NUMA backplane
    2072                 :            :          * interconnect topology is more involved. The goal is to locate
    2073                 :            :          * tasks from numa_groups near each other in the system, and
    2074                 :            :          * untangle workloads from different sides of the system. This requires
    2075                 :            :          * searching down the hierarchy of node groups, recursively searching
    2076                 :            :          * inside the highest scoring group of nodes. The nodemask tricks
    2077                 :            :          * keep the complexity of the search down.
    2078                 :            :          */
    2079                 :            :         nodes = node_online_map;
    2080                 :            :         for (dist = sched_max_numa_distance; dist > LOCAL_DISTANCE; dist--) {
    2081                 :            :                 unsigned long max_faults = 0;
    2082                 :            :                 nodemask_t max_group = NODE_MASK_NONE;
    2083                 :            :                 int a, b;
    2084                 :            : 
    2085                 :            :                 /* Are there nodes at this distance from each other? */
    2086                 :            :                 if (!find_numa_distance(dist))
    2087                 :            :                         continue;
    2088                 :            : 
    2089                 :            :                 for_each_node_mask(a, nodes) {
    2090                 :            :                         unsigned long faults = 0;
    2091                 :            :                         nodemask_t this_group;
    2092                 :            :                         nodes_clear(this_group);
    2093                 :            : 
    2094                 :            :                         /* Sum group's NUMA faults; includes a==b case. */
    2095                 :            :                         for_each_node_mask(b, nodes) {
    2096                 :            :                                 if (node_distance(a, b) < dist) {
    2097                 :            :                                         faults += group_faults(p, b);
    2098                 :            :                                         node_set(b, this_group);
    2099                 :            :                                         node_clear(b, nodes);
    2100                 :            :                                 }
    2101                 :            :                         }
    2102                 :            : 
    2103                 :            :                         /* Remember the top group. */
    2104                 :            :                         if (faults > max_faults) {
    2105                 :            :                                 max_faults = faults;
    2106                 :            :                                 max_group = this_group;
    2107                 :            :                                 /*
    2108                 :            :                                  * subtle: at the smallest distance there is
    2109                 :            :                                  * just one node left in each "group", the
    2110                 :            :                                  * winner is the preferred nid.
    2111                 :            :                                  */
    2112                 :            :                                 nid = a;
    2113                 :            :                         }
    2114                 :            :                 }
    2115                 :            :                 /* Next round, evaluate the nodes within max_group. */
    2116                 :            :                 if (!max_faults)
    2117                 :            :                         break;
    2118                 :            :                 nodes = max_group;
    2119                 :            :         }
    2120                 :            :         return nid;
    2121                 :            : }
    2122                 :            : 
    2123                 :            : static void task_numa_placement(struct task_struct *p)
    2124                 :            : {
    2125                 :            :         int seq, nid, max_nid = NUMA_NO_NODE;
    2126                 :            :         unsigned long max_faults = 0;
    2127                 :            :         unsigned long fault_types[2] = { 0, 0 };
    2128                 :            :         unsigned long total_faults;
    2129                 :            :         u64 runtime, period;
    2130                 :            :         spinlock_t *group_lock = NULL;
    2131                 :            :         struct numa_group *ng;
    2132                 :            : 
    2133                 :            :         /*
    2134                 :            :          * The p->mm->numa_scan_seq field gets updated without
    2135                 :            :          * exclusive access. Use READ_ONCE() here to ensure
    2136                 :            :          * that the field is read in a single access:
    2137                 :            :          */
    2138                 :            :         seq = READ_ONCE(p->mm->numa_scan_seq);
    2139                 :            :         if (p->numa_scan_seq == seq)
    2140                 :            :                 return;
    2141                 :            :         p->numa_scan_seq = seq;
    2142                 :            :         p->numa_scan_period_max = task_scan_max(p);
    2143                 :            : 
    2144                 :            :         total_faults = p->numa_faults_locality[0] +
    2145                 :            :                        p->numa_faults_locality[1];
    2146                 :            :         runtime = numa_get_avg_runtime(p, &period);
    2147                 :            : 
    2148                 :            :         /* If the task is part of a group prevent parallel updates to group stats */
    2149                 :            :         ng = deref_curr_numa_group(p);
    2150                 :            :         if (ng) {
    2151                 :            :                 group_lock = &ng->lock;
    2152                 :            :                 spin_lock_irq(group_lock);
    2153                 :            :         }
    2154                 :            : 
    2155                 :            :         /* Find the node with the highest number of faults */
    2156                 :            :         for_each_online_node(nid) {
    2157                 :            :                 /* Keep track of the offsets in numa_faults array */
    2158                 :            :                 int mem_idx, membuf_idx, cpu_idx, cpubuf_idx;
    2159                 :            :                 unsigned long faults = 0, group_faults = 0;
    2160                 :            :                 int priv;
    2161                 :            : 
    2162                 :            :                 for (priv = 0; priv < NR_NUMA_HINT_FAULT_TYPES; priv++) {
    2163                 :            :                         long diff, f_diff, f_weight;
    2164                 :            : 
    2165                 :            :                         mem_idx = task_faults_idx(NUMA_MEM, nid, priv);
    2166                 :            :                         membuf_idx = task_faults_idx(NUMA_MEMBUF, nid, priv);
    2167                 :            :                         cpu_idx = task_faults_idx(NUMA_CPU, nid, priv);
    2168                 :            :                         cpubuf_idx = task_faults_idx(NUMA_CPUBUF, nid, priv);
    2169                 :            : 
    2170                 :            :                         /* Decay existing window, copy faults since last scan */
    2171                 :            :                         diff = p->numa_faults[membuf_idx] - p->numa_faults[mem_idx] / 2;
    2172                 :            :                         fault_types[priv] += p->numa_faults[membuf_idx];
    2173                 :            :                         p->numa_faults[membuf_idx] = 0;
    2174                 :            : 
    2175                 :            :                         /*
    2176                 :            :                          * Normalize the faults_from, so all tasks in a group
    2177                 :            :                          * count according to CPU use, instead of by the raw
    2178                 :            :                          * number of faults. Tasks with little runtime have
    2179                 :            :                          * little over-all impact on throughput, and thus their
    2180                 :            :                          * faults are less important.
    2181                 :            :                          */
    2182                 :            :                         f_weight = div64_u64(runtime << 16, period + 1);
    2183                 :            :                         f_weight = (f_weight * p->numa_faults[cpubuf_idx]) /
    2184                 :            :                                    (total_faults + 1);
    2185                 :            :                         f_diff = f_weight - p->numa_faults[cpu_idx] / 2;
    2186                 :            :                         p->numa_faults[cpubuf_idx] = 0;
    2187                 :            : 
    2188                 :            :                         p->numa_faults[mem_idx] += diff;
    2189                 :            :                         p->numa_faults[cpu_idx] += f_diff;
    2190                 :            :                         faults += p->numa_faults[mem_idx];
    2191                 :            :                         p->total_numa_faults += diff;
    2192                 :            :                         if (ng) {
    2193                 :            :                                 /*
    2194                 :            :                                  * safe because we can only change our own group
    2195                 :            :                                  *
    2196                 :            :                                  * mem_idx represents the offset for a given
    2197                 :            :                                  * nid and priv in a specific region because it
    2198                 :            :                                  * is at the beginning of the numa_faults array.
    2199                 :            :                                  */
    2200                 :            :                                 ng->faults[mem_idx] += diff;
    2201                 :            :                                 ng->faults_cpu[mem_idx] += f_diff;
    2202                 :            :                                 ng->total_faults += diff;
    2203                 :            :                                 group_faults += ng->faults[mem_idx];
    2204                 :            :                         }
    2205                 :            :                 }
    2206                 :            : 
    2207                 :            :                 if (!ng) {
    2208                 :            :                         if (faults > max_faults) {
    2209                 :            :                                 max_faults = faults;
    2210                 :            :                                 max_nid = nid;
    2211                 :            :                         }
    2212                 :            :                 } else if (group_faults > max_faults) {
    2213                 :            :                         max_faults = group_faults;
    2214                 :            :                         max_nid = nid;
    2215                 :            :                 }
    2216                 :            :         }
    2217                 :            : 
    2218                 :            :         if (ng) {
    2219                 :            :                 numa_group_count_active_nodes(ng);
    2220                 :            :                 spin_unlock_irq(group_lock);
    2221                 :            :                 max_nid = preferred_group_nid(p, max_nid);
    2222                 :            :         }
    2223                 :            : 
    2224                 :            :         if (max_faults) {
    2225                 :            :                 /* Set the new preferred node */
    2226                 :            :                 if (max_nid != p->numa_preferred_nid)
    2227                 :            :                         sched_setnuma(p, max_nid);
    2228                 :            :         }
    2229                 :            : 
    2230                 :            :         update_task_scan_period(p, fault_types[0], fault_types[1]);
    2231                 :            : }
    2232                 :            : 
    2233                 :            : static inline int get_numa_group(struct numa_group *grp)
    2234                 :            : {
    2235                 :            :         return refcount_inc_not_zero(&grp->refcount);
    2236                 :            : }
    2237                 :            : 
    2238                 :            : static inline void put_numa_group(struct numa_group *grp)
    2239                 :            : {
    2240                 :            :         if (refcount_dec_and_test(&grp->refcount))
    2241                 :            :                 kfree_rcu(grp, rcu);
    2242                 :            : }
    2243                 :            : 
    2244                 :            : static void task_numa_group(struct task_struct *p, int cpupid, int flags,
    2245                 :            :                         int *priv)
    2246                 :            : {
    2247                 :            :         struct numa_group *grp, *my_grp;
    2248                 :            :         struct task_struct *tsk;
    2249                 :            :         bool join = false;
    2250                 :            :         int cpu = cpupid_to_cpu(cpupid);
    2251                 :            :         int i;
    2252                 :            : 
    2253                 :            :         if (unlikely(!deref_curr_numa_group(p))) {
    2254                 :            :                 unsigned int size = sizeof(struct numa_group) +
    2255                 :            :                                     4*nr_node_ids*sizeof(unsigned long);
    2256                 :            : 
    2257                 :            :                 grp = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
    2258                 :            :                 if (!grp)
    2259                 :            :                         return;
    2260                 :            : 
    2261                 :            :                 refcount_set(&grp->refcount, 1);
    2262                 :            :                 grp->active_nodes = 1;
    2263                 :            :                 grp->max_faults_cpu = 0;
    2264                 :            :                 spin_lock_init(&grp->lock);
    2265                 :            :                 grp->gid = p->pid;
    2266                 :            :                 /* Second half of the array tracks nids where faults happen */
    2267                 :            :                 grp->faults_cpu = grp->faults + NR_NUMA_HINT_FAULT_TYPES *
    2268                 :            :                                                 nr_node_ids;
    2269                 :            : 
    2270                 :            :                 for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++)
    2271                 :            :                         grp->faults[i] = p->numa_faults[i];
    2272                 :            : 
    2273                 :            :                 grp->total_faults = p->total_numa_faults;
    2274                 :            : 
    2275                 :            :                 grp->nr_tasks++;
    2276                 :            :                 rcu_assign_pointer(p->numa_group, grp);
    2277                 :            :         }
    2278                 :            : 
    2279                 :            :         rcu_read_lock();
    2280                 :            :         tsk = READ_ONCE(cpu_rq(cpu)->curr);
    2281                 :            : 
    2282                 :            :         if (!cpupid_match_pid(tsk, cpupid))
    2283                 :            :                 goto no_join;
    2284                 :            : 
    2285                 :            :         grp = rcu_dereference(tsk->numa_group);
    2286                 :            :         if (!grp)
    2287                 :            :                 goto no_join;
    2288                 :            : 
    2289                 :            :         my_grp = deref_curr_numa_group(p);
    2290                 :            :         if (grp == my_grp)
    2291                 :            :                 goto no_join;
    2292                 :            : 
    2293                 :            :         /*
    2294                 :            :          * Only join the other group if its bigger; if we're the bigger group,
    2295                 :            :          * the other task will join us.
    2296                 :            :          */
    2297                 :            :         if (my_grp->nr_tasks > grp->nr_tasks)
    2298                 :            :                 goto no_join;
    2299                 :            : 
    2300                 :            :         /*
    2301                 :            :          * Tie-break on the grp address.
    2302                 :            :          */
    2303                 :            :         if (my_grp->nr_tasks == grp->nr_tasks && my_grp > grp)
    2304                 :            :                 goto no_join;
    2305                 :            : 
    2306                 :            :         /* Always join threads in the same process. */
    2307                 :            :         if (tsk->mm == current->mm)
    2308                 :            :                 join = true;
    2309                 :            : 
    2310                 :            :         /* Simple filter to avoid false positives due to PID collisions */
    2311                 :            :         if (flags & TNF_SHARED)
    2312                 :            :                 join = true;
    2313                 :            : 
    2314                 :            :         /* Update priv based on whether false sharing was detected */
    2315                 :            :         *priv = !join;
    2316                 :            : 
    2317                 :            :         if (join && !get_numa_group(grp))
    2318                 :            :                 goto no_join;
    2319                 :            : 
    2320                 :            :         rcu_read_unlock();
    2321                 :            : 
    2322                 :            :         if (!join)
    2323                 :            :                 return;
    2324                 :            : 
    2325                 :            :         BUG_ON(irqs_disabled());
    2326                 :            :         double_lock_irq(&my_grp->lock, &grp->lock);
    2327                 :            : 
    2328                 :            :         for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++) {
    2329                 :            :                 my_grp->faults[i] -= p->numa_faults[i];
    2330                 :            :                 grp->faults[i] += p->numa_faults[i];
    2331                 :            :         }
    2332                 :            :         my_grp->total_faults -= p->total_numa_faults;
    2333                 :            :         grp->total_faults += p->total_numa_faults;
    2334                 :            : 
    2335                 :            :         my_grp->nr_tasks--;
    2336                 :            :         grp->nr_tasks++;
    2337                 :            : 
    2338                 :            :         spin_unlock(&my_grp->lock);
    2339                 :            :         spin_unlock_irq(&grp->lock);
    2340                 :            : 
    2341                 :            :         rcu_assign_pointer(p->numa_group, grp);
    2342                 :            : 
    2343                 :            :         put_numa_group(my_grp);
    2344                 :            :         return;
    2345                 :            : 
    2346                 :            : no_join:
    2347                 :            :         rcu_read_unlock();
    2348                 :            :         return;
    2349                 :            : }
    2350                 :            : 
    2351                 :            : /*
    2352                 :            :  * Get rid of NUMA staticstics associated with a task (either current or dead).
    2353                 :            :  * If @final is set, the task is dead and has reached refcount zero, so we can
    2354                 :            :  * safely free all relevant data structures. Otherwise, there might be
    2355                 :            :  * concurrent reads from places like load balancing and procfs, and we should
    2356                 :            :  * reset the data back to default state without freeing ->numa_faults.
    2357                 :            :  */
    2358                 :            : void task_numa_free(struct task_struct *p, bool final)
    2359                 :            : {
    2360                 :            :         /* safe: p either is current or is being freed by current */
    2361                 :            :         struct numa_group *grp = rcu_dereference_raw(p->numa_group);
    2362                 :            :         unsigned long *numa_faults = p->numa_faults;
    2363                 :            :         unsigned long flags;
    2364                 :            :         int i;
    2365                 :            : 
    2366                 :            :         if (!numa_faults)
    2367                 :            :                 return;
    2368                 :            : 
    2369                 :            :         if (grp) {
    2370                 :            :                 spin_lock_irqsave(&grp->lock, flags);
    2371                 :            :                 for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++)
    2372                 :            :                         grp->faults[i] -= p->numa_faults[i];
    2373                 :            :                 grp->total_faults -= p->total_numa_faults;
    2374                 :            : 
    2375                 :            :                 grp->nr_tasks--;
    2376                 :            :                 spin_unlock_irqrestore(&grp->lock, flags);
    2377                 :            :                 RCU_INIT_POINTER(p->numa_group, NULL);
    2378                 :            :                 put_numa_group(grp);
    2379                 :            :         }
    2380                 :            : 
    2381                 :            :         if (final) {
    2382                 :            :                 p->numa_faults = NULL;
    2383                 :            :                 kfree(numa_faults);
    2384                 :            :         } else {
    2385                 :            :                 p->total_numa_faults = 0;
    2386                 :            :                 for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++)
    2387                 :            :                         numa_faults[i] = 0;
    2388                 :            :         }
    2389                 :            : }
    2390                 :            : 
    2391                 :            : /*
    2392                 :            :  * Got a PROT_NONE fault for a page on @node.
    2393                 :            :  */
    2394                 :            : void task_numa_fault(int last_cpupid, int mem_node, int pages, int flags)
    2395                 :            : {
    2396                 :            :         struct task_struct *p = current;
    2397                 :            :         bool migrated = flags & TNF_MIGRATED;
    2398                 :            :         int cpu_node = task_node(current);
    2399                 :            :         int local = !!(flags & TNF_FAULT_LOCAL);
    2400                 :            :         struct numa_group *ng;
    2401                 :            :         int priv;
    2402                 :            : 
    2403                 :            :         if (!static_branch_likely(&sched_numa_balancing))
    2404                 :            :                 return;
    2405                 :            : 
    2406                 :            :         /* for example, ksmd faulting in a user's mm */
    2407                 :            :         if (!p->mm)
    2408                 :            :                 return;
    2409                 :            : 
    2410                 :            :         /* Allocate buffer to track faults on a per-node basis */
    2411                 :            :         if (unlikely(!p->numa_faults)) {
    2412                 :            :                 int size = sizeof(*p->numa_faults) *
    2413                 :            :                            NR_NUMA_HINT_FAULT_BUCKETS * nr_node_ids;
    2414                 :            : 
    2415                 :            :                 p->numa_faults = kzalloc(size, GFP_KERNEL|__GFP_NOWARN);
    2416                 :            :                 if (!p->numa_faults)
    2417                 :            :                         return;
    2418                 :            : 
    2419                 :            :                 p->total_numa_faults = 0;
    2420                 :            :                 memset(p->numa_faults_locality, 0, sizeof(p->numa_faults_locality));
    2421                 :            :         }
    2422                 :            : 
    2423                 :            :         /*
    2424                 :            :          * First accesses are treated as private, otherwise consider accesses
    2425                 :            :          * to be private if the accessing pid has not changed
    2426                 :            :          */
    2427                 :            :         if (unlikely(last_cpupid == (-1 & LAST_CPUPID_MASK))) {
    2428                 :            :                 priv = 1;
    2429                 :            :         } else {
    2430                 :            :                 priv = cpupid_match_pid(p, last_cpupid);
    2431                 :            :                 if (!priv && !(flags & TNF_NO_GROUP))
    2432                 :            :                         task_numa_group(p, last_cpupid, flags, &priv);
    2433                 :            :         }
    2434                 :            : 
    2435                 :            :         /*
    2436                 :            :          * If a workload spans multiple NUMA nodes, a shared fault that
    2437                 :            :          * occurs wholly within the set of nodes that the workload is
    2438                 :            :          * actively using should be counted as local. This allows the
    2439                 :            :          * scan rate to slow down when a workload has settled down.
    2440                 :            :          */
    2441                 :            :         ng = deref_curr_numa_group(p);
    2442                 :            :         if (!priv && !local && ng && ng->active_nodes > 1 &&
    2443                 :            :                                 numa_is_active_node(cpu_node, ng) &&
    2444                 :            :                                 numa_is_active_node(mem_node, ng))
    2445                 :            :                 local = 1;
    2446                 :            : 
    2447                 :            :         /*
    2448                 :            :          * Retry to migrate task to preferred node periodically, in case it
    2449                 :            :          * previously failed, or the scheduler moved us.
    2450                 :            :          */
    2451                 :            :         if (time_after(jiffies, p->numa_migrate_retry)) {
    2452                 :            :                 task_numa_placement(p);
    2453                 :            :                 numa_migrate_preferred(p);
    2454                 :            :         }
    2455                 :            : 
    2456                 :            :         if (migrated)
    2457                 :            :                 p->numa_pages_migrated += pages;
    2458                 :            :         if (flags & TNF_MIGRATE_FAIL)
    2459                 :            :                 p->numa_faults_locality[2] += pages;
    2460                 :            : 
    2461                 :            :         p->numa_faults[task_faults_idx(NUMA_MEMBUF, mem_node, priv)] += pages;
    2462                 :            :         p->numa_faults[task_faults_idx(NUMA_CPUBUF, cpu_node, priv)] += pages;
    2463                 :            :         p->numa_faults_locality[local] += pages;
    2464                 :            : }
    2465                 :            : 
    2466                 :            : static void reset_ptenuma_scan(struct task_struct *p)
    2467                 :            : {
    2468                 :            :         /*
    2469                 :            :          * We only did a read acquisition of the mmap sem, so
    2470                 :            :          * p->mm->numa_scan_seq is written to without exclusive access
    2471                 :            :          * and the update is not guaranteed to be atomic. That's not
    2472                 :            :          * much of an issue though, since this is just used for
    2473                 :            :          * statistical sampling. Use READ_ONCE/WRITE_ONCE, which are not
    2474                 :            :          * expensive, to avoid any form of compiler optimizations:
    2475                 :            :          */
    2476                 :            :         WRITE_ONCE(p->mm->numa_scan_seq, READ_ONCE(p->mm->numa_scan_seq) + 1);
    2477                 :            :         p->mm->numa_scan_offset = 0;
    2478                 :            : }
    2479                 :            : 
    2480                 :            : /*
    2481                 :            :  * The expensive part of numa migration is done from task_work context.
    2482                 :            :  * Triggered from task_tick_numa().
    2483                 :            :  */
    2484                 :            : static void task_numa_work(struct callback_head *work)
    2485                 :            : {
    2486                 :            :         unsigned long migrate, next_scan, now = jiffies;
    2487                 :            :         struct task_struct *p = current;
    2488                 :            :         struct mm_struct *mm = p->mm;
    2489                 :            :         u64 runtime = p->se.sum_exec_runtime;
    2490                 :            :         struct vm_area_struct *vma;
    2491                 :            :         unsigned long start, end;
    2492                 :            :         unsigned long nr_pte_updates = 0;
    2493                 :            :         long pages, virtpages;
    2494                 :            : 
    2495                 :            :         SCHED_WARN_ON(p != container_of(work, struct task_struct, numa_work));
    2496                 :            : 
    2497                 :            :         work->next = work;
    2498                 :            :         /*
    2499                 :            :          * Who cares about NUMA placement when they're dying.
    2500                 :            :          *
    2501                 :            :          * NOTE: make sure not to dereference p->mm before this check,
    2502                 :            :          * exit_task_work() happens _after_ exit_mm() so we could be called
    2503                 :            :          * without p->mm even though we still had it when we enqueued this
    2504                 :            :          * work.
    2505                 :            :          */
    2506                 :            :         if (p->flags & PF_EXITING)
    2507                 :            :                 return;
    2508                 :            : 
    2509                 :            :         if (!mm->numa_next_scan) {
    2510                 :            :                 mm->numa_next_scan = now +
    2511                 :            :                         msecs_to_jiffies(sysctl_numa_balancing_scan_delay);
    2512                 :            :         }
    2513                 :            : 
    2514                 :            :         /*
    2515                 :            :          * Enforce maximal scan/migration frequency..
    2516                 :            :          */
    2517                 :            :         migrate = mm->numa_next_scan;
    2518                 :            :         if (time_before(now, migrate))
    2519                 :            :                 return;
    2520                 :            : 
    2521                 :            :         if (p->numa_scan_period == 0) {
    2522                 :            :                 p->numa_scan_period_max = task_scan_max(p);
    2523                 :            :                 p->numa_scan_period = task_scan_start(p);
    2524                 :            :         }
    2525                 :            : 
    2526                 :            :         next_scan = now + msecs_to_jiffies(p->numa_scan_period);
    2527                 :            :         if (cmpxchg(&mm->numa_next_scan, migrate, next_scan) != migrate)
    2528                 :            :                 return;
    2529                 :            : 
    2530                 :            :         /*
    2531                 :            :          * Delay this task enough that another task of this mm will likely win
    2532                 :            :          * the next time around.
    2533                 :            :          */
    2534                 :            :         p->node_stamp += 2 * TICK_NSEC;
    2535                 :            : 
    2536                 :            :         start = mm->numa_scan_offset;
    2537                 :            :         pages = sysctl_numa_balancing_scan_size;
    2538                 :            :         pages <<= 20 - PAGE_SHIFT; /* MB in pages */
    2539                 :            :         virtpages = pages * 8;     /* Scan up to this much virtual space */
    2540                 :            :         if (!pages)
    2541                 :            :                 return;
    2542                 :            : 
    2543                 :            : 
    2544                 :            :         if (!down_read_trylock(&mm->mmap_sem))
    2545                 :            :                 return;
    2546                 :            :         vma = find_vma(mm, start);
    2547                 :            :         if (!vma) {
    2548                 :            :                 reset_ptenuma_scan(p);
    2549                 :            :                 start = 0;
    2550                 :            :                 vma = mm->mmap;
    2551                 :            :         }
    2552                 :            :         for (; vma; vma = vma->vm_next) {
    2553                 :            :                 if (!vma_migratable(vma) || !vma_policy_mof(vma) ||
    2554                 :            :                         is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_MIXEDMAP)) {
    2555                 :            :                         continue;
    2556                 :            :                 }
    2557                 :            : 
    2558                 :            :                 /*
    2559                 :            :                  * Shared library pages mapped by multiple processes are not
    2560                 :            :                  * migrated as it is expected they are cache replicated. Avoid
    2561                 :            :                  * hinting faults in read-only file-backed mappings or the vdso
    2562                 :            :                  * as migrating the pages will be of marginal benefit.
    2563                 :            :                  */
    2564                 :            :                 if (!vma->vm_mm ||
    2565                 :            :                     (vma->vm_file && (vma->vm_flags & (VM_READ|VM_WRITE)) == (VM_READ)))
    2566                 :            :                         continue;
    2567                 :            : 
    2568                 :            :                 /*
    2569                 :            :                  * Skip inaccessible VMAs to avoid any confusion between
    2570                 :            :                  * PROT_NONE and NUMA hinting ptes
    2571                 :            :                  */
    2572                 :            :                 if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
    2573                 :            :                         continue;
    2574                 :            : 
    2575                 :            :                 do {
    2576                 :            :                         start = max(start, vma->vm_start);
    2577                 :            :                         end = ALIGN(start + (pages << PAGE_SHIFT), HPAGE_SIZE);
    2578                 :            :                         end = min(end, vma->vm_end);
    2579                 :            :                         nr_pte_updates = change_prot_numa(vma, start, end);
    2580                 :            : 
    2581                 :            :                         /*
    2582                 :            :                          * Try to scan sysctl_numa_balancing_size worth of
    2583                 :            :                          * hpages that have at least one present PTE that
    2584                 :            :                          * is not already pte-numa. If the VMA contains
    2585                 :            :                          * areas that are unused or already full of prot_numa
    2586                 :            :                          * PTEs, scan up to virtpages, to skip through those
    2587                 :            :                          * areas faster.
    2588                 :            :                          */
    2589                 :            :                         if (nr_pte_updates)
    2590                 :            :                                 pages -= (end - start) >> PAGE_SHIFT;
    2591                 :            :                         virtpages -= (end - start) >> PAGE_SHIFT;
    2592                 :            : 
    2593                 :            :                         start = end;
    2594                 :            :                         if (pages <= 0 || virtpages <= 0)
    2595                 :            :                                 goto out;
    2596                 :            : 
    2597                 :            :                         cond_resched();
    2598                 :            :                 } while (end != vma->vm_end);
    2599                 :            :         }
    2600                 :            : 
    2601                 :            : out:
    2602                 :            :         /*
    2603                 :            :          * It is possible to reach the end of the VMA list but the last few
    2604                 :            :          * VMAs are not guaranteed to the vma_migratable. If they are not, we
    2605                 :            :          * would find the !migratable VMA on the next scan but not reset the
    2606                 :            :          * scanner to the start so check it now.
    2607                 :            :          */
    2608                 :            :         if (vma)
    2609                 :            :                 mm->numa_scan_offset = start;
    2610                 :            :         else
    2611                 :            :                 reset_ptenuma_scan(p);
    2612                 :            :         up_read(&mm->mmap_sem);
    2613                 :            : 
    2614                 :            :         /*
    2615                 :            :          * Make sure tasks use at least 32x as much time to run other code
    2616                 :            :          * than they used here, to limit NUMA PTE scanning overhead to 3% max.
    2617                 :            :          * Usually update_task_scan_period slows down scanning enough; on an
    2618                 :            :          * overloaded system we need to limit overhead on a per task basis.
    2619                 :            :          */
    2620                 :            :         if (unlikely(p->se.sum_exec_runtime != runtime)) {
    2621                 :            :                 u64 diff = p->se.sum_exec_runtime - runtime;
    2622                 :            :                 p->node_stamp += 32 * diff;
    2623                 :            :         }
    2624                 :            : }
    2625                 :            : 
    2626                 :            : void init_numa_balancing(unsigned long clone_flags, struct task_struct *p)
    2627                 :            : {
    2628                 :            :         int mm_users = 0;
    2629                 :            :         struct mm_struct *mm = p->mm;
    2630                 :            : 
    2631                 :            :         if (mm) {
    2632                 :            :                 mm_users = atomic_read(&mm->mm_users);
    2633                 :            :                 if (mm_users == 1) {
    2634                 :            :                         mm->numa_next_scan = jiffies + msecs_to_jiffies(sysctl_numa_balancing_scan_delay);
    2635                 :            :                         mm->numa_scan_seq = 0;
    2636                 :            :                 }
    2637                 :            :         }
    2638                 :            :         p->node_stamp                        = 0;
    2639                 :            :         p->numa_scan_seq             = mm ? mm->numa_scan_seq : 0;
    2640                 :            :         p->numa_scan_period          = sysctl_numa_balancing_scan_delay;
    2641                 :            :         /* Protect against double add, see task_tick_numa and task_numa_work */
    2642                 :            :         p->numa_work.next            = &p->numa_work;
    2643                 :            :         p->numa_faults                       = NULL;
    2644                 :            :         RCU_INIT_POINTER(p->numa_group, NULL);
    2645                 :            :         p->last_task_numa_placement  = 0;
    2646                 :            :         p->last_sum_exec_runtime     = 0;
    2647                 :            : 
    2648                 :            :         init_task_work(&p->numa_work, task_numa_work);
    2649                 :            : 
    2650                 :            :         /* New address space, reset the preferred nid */
    2651                 :            :         if (!(clone_flags & CLONE_VM)) {
    2652                 :            :                 p->numa_preferred_nid = NUMA_NO_NODE;
    2653                 :            :                 return;
    2654                 :            :         }
    2655                 :            : 
    2656                 :            :         /*
    2657                 :            :          * New thread, keep existing numa_preferred_nid which should be copied
    2658                 :            :          * already by arch_dup_task_struct but stagger when scans start.
    2659                 :            :          */
    2660                 :            :         if (mm) {
    2661                 :            :                 unsigned int delay;
    2662                 :            : 
    2663                 :            :                 delay = min_t(unsigned int, task_scan_max(current),
    2664                 :            :                         current->numa_scan_period * mm_users * NSEC_PER_MSEC);
    2665                 :            :                 delay += 2 * TICK_NSEC;
    2666                 :            :                 p->node_stamp = delay;
    2667                 :            :         }
    2668                 :            : }
    2669                 :            : 
    2670                 :            : /*
    2671                 :            :  * Drive the periodic memory faults..
    2672                 :            :  */
    2673                 :            : static void task_tick_numa(struct rq *rq, struct task_struct *curr)
    2674                 :            : {
    2675                 :            :         struct callback_head *work = &curr->numa_work;
    2676                 :            :         u64 period, now;
    2677                 :            : 
    2678                 :            :         /*
    2679                 :            :          * We don't care about NUMA placement if we don't have memory.
    2680                 :            :          */
    2681                 :            :         if ((curr->flags & (PF_EXITING | PF_KTHREAD)) || work->next != work)
    2682                 :            :                 return;
    2683                 :            : 
    2684                 :            :         /*
    2685                 :            :          * Using runtime rather than walltime has the dual advantage that
    2686                 :            :          * we (mostly) drive the selection from busy threads and that the
    2687                 :            :          * task needs to have done some actual work before we bother with
    2688                 :            :          * NUMA placement.
    2689                 :            :          */
    2690                 :            :         now = curr->se.sum_exec_runtime;
    2691                 :            :         period = (u64)curr->numa_scan_period * NSEC_PER_MSEC;
    2692                 :            : 
    2693                 :            :         if (now > curr->node_stamp + period) {
    2694                 :            :                 if (!curr->node_stamp)
    2695                 :            :                         curr->numa_scan_period = task_scan_start(curr);
    2696                 :            :                 curr->node_stamp += period;
    2697                 :            : 
    2698                 :            :                 if (!time_before(jiffies, curr->mm->numa_next_scan))
    2699                 :            :                         task_work_add(curr, work, true);
    2700                 :            :         }
    2701                 :            : }
    2702                 :            : 
    2703                 :            : static void update_scan_period(struct task_struct *p, int new_cpu)
    2704                 :            : {
    2705                 :            :         int src_nid = cpu_to_node(task_cpu(p));
    2706                 :            :         int dst_nid = cpu_to_node(new_cpu);
    2707                 :            : 
    2708                 :            :         if (!static_branch_likely(&sched_numa_balancing))
    2709                 :            :                 return;
    2710                 :            : 
    2711                 :            :         if (!p->mm || !p->numa_faults || (p->flags & PF_EXITING))
    2712                 :            :                 return;
    2713                 :            : 
    2714                 :            :         if (src_nid == dst_nid)
    2715                 :            :                 return;
    2716                 :            : 
    2717                 :            :         /*
    2718                 :            :          * Allow resets if faults have been trapped before one scan
    2719                 :            :          * has completed. This is most likely due to a new task that
    2720                 :            :          * is pulled cross-node due to wakeups or load balancing.
    2721                 :            :          */
    2722                 :            :         if (p->numa_scan_seq) {
    2723                 :            :                 /*
    2724                 :            :                  * Avoid scan adjustments if moving to the preferred
    2725                 :            :                  * node or if the task was not previously running on
    2726                 :            :                  * the preferred node.
    2727                 :            :                  */
    2728                 :            :                 if (dst_nid == p->numa_preferred_nid ||
    2729                 :            :                     (p->numa_preferred_nid != NUMA_NO_NODE &&
    2730                 :            :                         src_nid != p->numa_preferred_nid))
    2731                 :            :                         return;
    2732                 :            :         }
    2733                 :            : 
    2734                 :            :         p->numa_scan_period = task_scan_start(p);
    2735                 :            : }
    2736                 :            : 
    2737                 :            : #else
    2738                 :            : static void task_tick_numa(struct rq *rq, struct task_struct *curr)
    2739                 :            : {
    2740                 :            : }
    2741                 :            : 
    2742                 :            : static inline void account_numa_enqueue(struct rq *rq, struct task_struct *p)
    2743                 :            : {
    2744                 :            : }
    2745                 :            : 
    2746                 :            : static inline void account_numa_dequeue(struct rq *rq, struct task_struct *p)
    2747                 :            : {
    2748                 :            : }
    2749                 :            : 
    2750                 :            : static inline void update_scan_period(struct task_struct *p, int new_cpu)
    2751                 :            : {
    2752                 :            : }
    2753                 :            : 
    2754                 :            : #endif /* CONFIG_NUMA_BALANCING */
    2755                 :            : 
    2756                 :            : static void
    2757                 :          3 : account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
    2758                 :            : {
    2759                 :          3 :         update_load_add(&cfs_rq->load, se->load.weight);
    2760                 :            : #ifdef CONFIG_SMP
    2761                 :          3 :         if (entity_is_task(se)) {
    2762                 :            :                 struct rq *rq = rq_of(cfs_rq);
    2763                 :            : 
    2764                 :          3 :                 account_numa_enqueue(rq, task_of(se));
    2765                 :          3 :                 list_add(&se->group_node, &rq->cfs_tasks);
    2766                 :            :         }
    2767                 :            : #endif
    2768                 :          3 :         cfs_rq->nr_running++;
    2769                 :          3 : }
    2770                 :            : 
    2771                 :            : static void
    2772                 :          3 : account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
    2773                 :            : {
    2774                 :          3 :         update_load_sub(&cfs_rq->load, se->load.weight);
    2775                 :            : #ifdef CONFIG_SMP
    2776                 :          3 :         if (entity_is_task(se)) {
    2777                 :          3 :                 account_numa_dequeue(rq_of(cfs_rq), task_of(se));
    2778                 :          3 :                 list_del_init(&se->group_node);
    2779                 :            :         }
    2780                 :            : #endif
    2781                 :          3 :         cfs_rq->nr_running--;
    2782                 :          3 : }
    2783                 :            : 
    2784                 :            : /*
    2785                 :            :  * Signed add and clamp on underflow.
    2786                 :            :  *
    2787                 :            :  * Explicitly do a load-store to ensure the intermediate value never hits
    2788                 :            :  * memory. This allows lockless observations without ever seeing the negative
    2789                 :            :  * values.
    2790                 :            :  */
    2791                 :            : #define add_positive(_ptr, _val) do {                           \
    2792                 :            :         typeof(_ptr) ptr = (_ptr);                              \
    2793                 :            :         typeof(_val) val = (_val);                              \
    2794                 :            :         typeof(*ptr) res, var = READ_ONCE(*ptr);                \
    2795                 :            :                                                                 \
    2796                 :            :         res = var + val;                                        \
    2797                 :            :                                                                 \
    2798                 :            :         if (val < 0 && res > var)                               \
    2799                 :            :                 res = 0;                                        \
    2800                 :            :                                                                 \
    2801                 :            :         WRITE_ONCE(*ptr, res);                                  \
    2802                 :            : } while (0)
    2803                 :            : 
    2804                 :            : /*
    2805                 :            :  * Unsigned subtract and clamp on underflow.
    2806                 :            :  *
    2807                 :            :  * Explicitly do a load-store to ensure the intermediate value never hits
    2808                 :            :  * memory. This allows lockless observations without ever seeing the negative
    2809                 :            :  * values.
    2810                 :            :  */
    2811                 :            : #define sub_positive(_ptr, _val) do {                           \
    2812                 :            :         typeof(_ptr) ptr = (_ptr);                              \
    2813                 :            :         typeof(*ptr) val = (_val);                              \
    2814                 :            :         typeof(*ptr) res, var = READ_ONCE(*ptr);                \
    2815                 :            :         res = var - val;                                        \
    2816                 :            :         if (res > var)                                               \
    2817                 :            :                 res = 0;                                        \
    2818                 :            :         WRITE_ONCE(*ptr, res);                                  \
    2819                 :            : } while (0)
    2820                 :            : 
    2821                 :            : /*
    2822                 :            :  * Remove and clamp on negative, from a local variable.
    2823                 :            :  *
    2824                 :            :  * A variant of sub_positive(), which does not use explicit load-store
    2825                 :            :  * and is thus optimized for local variable updates.
    2826                 :            :  */
    2827                 :            : #define lsub_positive(_ptr, _val) do {                          \
    2828                 :            :         typeof(_ptr) ptr = (_ptr);                              \
    2829                 :            :         *ptr -= min_t(typeof(*ptr), *ptr, _val);                \
    2830                 :            : } while (0)
    2831                 :            : 
    2832                 :            : #ifdef CONFIG_SMP
    2833                 :            : static inline void
    2834                 :            : enqueue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
    2835                 :            : {
    2836                 :          3 :         cfs_rq->runnable_weight += se->runnable_weight;
    2837                 :            : 
    2838                 :          3 :         cfs_rq->avg.runnable_load_avg += se->avg.runnable_load_avg;
    2839                 :          3 :         cfs_rq->avg.runnable_load_sum += se_runnable(se) * se->avg.runnable_load_sum;
    2840                 :            : }
    2841                 :            : 
    2842                 :            : static inline void
    2843                 :          3 : dequeue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
    2844                 :            : {
    2845                 :          3 :         cfs_rq->runnable_weight -= se->runnable_weight;
    2846                 :            : 
    2847                 :          3 :         sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg);
    2848                 :          3 :         sub_positive(&cfs_rq->avg.runnable_load_sum,
    2849                 :            :                      se_runnable(se) * se->avg.runnable_load_sum);
    2850                 :          3 : }
    2851                 :            : 
    2852                 :            : static inline void
    2853                 :            : enqueue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
    2854                 :            : {
    2855                 :          3 :         cfs_rq->avg.load_avg += se->avg.load_avg;
    2856                 :          3 :         cfs_rq->avg.load_sum += se_weight(se) * se->avg.load_sum;
    2857                 :            : }
    2858                 :            : 
    2859                 :            : static inline void
    2860                 :            : dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
    2861                 :            : {
    2862                 :          3 :         sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg);
    2863                 :          3 :         sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum);
    2864                 :            : }
    2865                 :            : #else
    2866                 :            : static inline void
    2867                 :            : enqueue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
    2868                 :            : static inline void
    2869                 :            : dequeue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
    2870                 :            : static inline void
    2871                 :            : enqueue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
    2872                 :            : static inline void
    2873                 :            : dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
    2874                 :            : #endif
    2875                 :            : 
    2876                 :          3 : static void reweight_entity(struct cfs_rq *cfs_rq, struct sched_entity *se,
    2877                 :            :                             unsigned long weight, unsigned long runnable)
    2878                 :            : {
    2879                 :          3 :         if (se->on_rq) {
    2880                 :            :                 /* commit outstanding execution time */
    2881                 :          3 :                 if (cfs_rq->curr == se)
    2882                 :          3 :                         update_curr(cfs_rq);
    2883                 :          3 :                 account_entity_dequeue(cfs_rq, se);
    2884                 :          3 :                 dequeue_runnable_load_avg(cfs_rq, se);
    2885                 :            :         }
    2886                 :            :         dequeue_load_avg(cfs_rq, se);
    2887                 :            : 
    2888                 :          3 :         se->runnable_weight = runnable;
    2889                 :            :         update_load_set(&se->load, weight);
    2890                 :            : 
    2891                 :            : #ifdef CONFIG_SMP
    2892                 :            :         do {
    2893                 :          3 :                 u32 divider = LOAD_AVG_MAX - 1024 + se->avg.period_contrib;
    2894                 :            : 
    2895                 :          3 :                 se->avg.load_avg = div_u64(se_weight(se) * se->avg.load_sum, divider);
    2896                 :          3 :                 se->avg.runnable_load_avg =
    2897                 :          3 :                         div_u64(se_runnable(se) * se->avg.runnable_load_sum, divider);
    2898                 :            :         } while (0);
    2899                 :            : #endif
    2900                 :            : 
    2901                 :            :         enqueue_load_avg(cfs_rq, se);
    2902                 :          3 :         if (se->on_rq) {
    2903                 :          3 :                 account_entity_enqueue(cfs_rq, se);
    2904                 :            :                 enqueue_runnable_load_avg(cfs_rq, se);
    2905                 :            :         }
    2906                 :          3 : }
    2907                 :            : 
    2908                 :          3 : void reweight_task(struct task_struct *p, int prio)
    2909                 :            : {
    2910                 :          3 :         struct sched_entity *se = &p->se;
    2911                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
    2912                 :            :         struct load_weight *load = &se->load;
    2913                 :          3 :         unsigned long weight = scale_load(sched_prio_to_weight[prio]);
    2914                 :            : 
    2915                 :          3 :         reweight_entity(cfs_rq, se, weight, weight);
    2916                 :          3 :         load->inv_weight = sched_prio_to_wmult[prio];
    2917                 :          3 : }
    2918                 :            : 
    2919                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
    2920                 :            : #ifdef CONFIG_SMP
    2921                 :            : /*
    2922                 :            :  * All this does is approximate the hierarchical proportion which includes that
    2923                 :            :  * global sum we all love to hate.
    2924                 :            :  *
    2925                 :            :  * That is, the weight of a group entity, is the proportional share of the
    2926                 :            :  * group weight based on the group runqueue weights. That is:
    2927                 :            :  *
    2928                 :            :  *                     tg->weight * grq->load.weight
    2929                 :            :  *   ge->load.weight = -----------------------------               (1)
    2930                 :            :  *                        \Sum grq->load.weight
    2931                 :            :  *
    2932                 :            :  * Now, because computing that sum is prohibitively expensive to compute (been
    2933                 :            :  * there, done that) we approximate it with this average stuff. The average
    2934                 :            :  * moves slower and therefore the approximation is cheaper and more stable.
    2935                 :            :  *
    2936                 :            :  * So instead of the above, we substitute:
    2937                 :            :  *
    2938                 :            :  *   grq->load.weight -> grq->avg.load_avg                         (2)
    2939                 :            :  *
    2940                 :            :  * which yields the following:
    2941                 :            :  *
    2942                 :            :  *                     tg->weight * grq->avg.load_avg
    2943                 :            :  *   ge->load.weight = ------------------------------              (3)
    2944                 :            :  *                              tg->load_avg
    2945                 :            :  *
    2946                 :            :  * Where: tg->load_avg ~= \Sum grq->avg.load_avg
    2947                 :            :  *
    2948                 :            :  * That is shares_avg, and it is right (given the approximation (2)).
    2949                 :            :  *
    2950                 :            :  * The problem with it is that because the average is slow -- it was designed
    2951                 :            :  * to be exactly that of course -- this leads to transients in boundary
    2952                 :            :  * conditions. In specific, the case where the group was idle and we start the
    2953                 :            :  * one task. It takes time for our CPU's grq->avg.load_avg to build up,
    2954                 :            :  * yielding bad latency etc..
    2955                 :            :  *
    2956                 :            :  * Now, in that special case (1) reduces to:
    2957                 :            :  *
    2958                 :            :  *                     tg->weight * grq->load.weight
    2959                 :            :  *   ge->load.weight = ----------------------------- = tg->weight   (4)
    2960                 :            :  *                          grp->load.weight
    2961                 :            :  *
    2962                 :            :  * That is, the sum collapses because all other CPUs are idle; the UP scenario.
    2963                 :            :  *
    2964                 :            :  * So what we do is modify our approximation (3) to approach (4) in the (near)
    2965                 :            :  * UP case, like:
    2966                 :            :  *
    2967                 :            :  *   ge->load.weight =
    2968                 :            :  *
    2969                 :            :  *              tg->weight * grq->load.weight
    2970                 :            :  *     ---------------------------------------------------         (5)
    2971                 :            :  *     tg->load_avg - grq->avg.load_avg + grq->load.weight
    2972                 :            :  *
    2973                 :            :  * But because grq->load.weight can drop to 0, resulting in a divide by zero,
    2974                 :            :  * we need to use grq->avg.load_avg as its lower bound, which then gives:
    2975                 :            :  *
    2976                 :            :  *
    2977                 :            :  *                     tg->weight * grq->load.weight
    2978                 :            :  *   ge->load.weight = -----------------------------            (6)
    2979                 :            :  *                              tg_load_avg'
    2980                 :            :  *
    2981                 :            :  * Where:
    2982                 :            :  *
    2983                 :            :  *   tg_load_avg' = tg->load_avg - grq->avg.load_avg +
    2984                 :            :  *                  max(grq->load.weight, grq->avg.load_avg)
    2985                 :            :  *
    2986                 :            :  * And that is shares_weight and is icky. In the (near) UP case it approaches
    2987                 :            :  * (4) while in the normal case it approaches (3). It consistently
    2988                 :            :  * overestimates the ge->load.weight and therefore:
    2989                 :            :  *
    2990                 :            :  *   \Sum ge->load.weight >= tg->weight
    2991                 :            :  *
    2992                 :            :  * hence icky!
    2993                 :            :  */
    2994                 :            : static long calc_group_shares(struct cfs_rq *cfs_rq)
    2995                 :            : {
    2996                 :            :         long tg_weight, tg_shares, load, shares;
    2997                 :          3 :         struct task_group *tg = cfs_rq->tg;
    2998                 :            : 
    2999                 :          3 :         tg_shares = READ_ONCE(tg->shares);
    3000                 :            : 
    3001                 :          3 :         load = max(scale_load_down(cfs_rq->load.weight), cfs_rq->avg.load_avg);
    3002                 :            : 
    3003                 :            :         tg_weight = atomic_long_read(&tg->load_avg);
    3004                 :            : 
    3005                 :            :         /* Ensure tg_weight >= load */
    3006                 :          3 :         tg_weight -= cfs_rq->tg_load_avg_contrib;
    3007                 :          3 :         tg_weight += load;
    3008                 :            : 
    3009                 :          3 :         shares = (tg_shares * load);
    3010                 :          3 :         if (tg_weight)
    3011                 :          3 :                 shares /= tg_weight;
    3012                 :            : 
    3013                 :            :         /*
    3014                 :            :          * MIN_SHARES has to be unscaled here to support per-CPU partitioning
    3015                 :            :          * of a group with small tg->shares value. It is a floor value which is
    3016                 :            :          * assigned as a minimum load.weight to the sched_entity representing
    3017                 :            :          * the group on a CPU.
    3018                 :            :          *
    3019                 :            :          * E.g. on 64-bit for a group with tg->shares of scale_load(15)=15*1024
    3020                 :            :          * on an 8-core system with 8 tasks each runnable on one CPU shares has
    3021                 :            :          * to be 15*1024*1/8=1920 instead of scale_load(MIN_SHARES)=2*1024. In
    3022                 :            :          * case no task is runnable on a CPU MIN_SHARES=2 should be returned
    3023                 :            :          * instead of 0.
    3024                 :            :          */
    3025                 :          3 :         return clamp_t(long, shares, MIN_SHARES, tg_shares);
    3026                 :            : }
    3027                 :            : 
    3028                 :            : /*
    3029                 :            :  * This calculates the effective runnable weight for a group entity based on
    3030                 :            :  * the group entity weight calculated above.
    3031                 :            :  *
    3032                 :            :  * Because of the above approximation (2), our group entity weight is
    3033                 :            :  * an load_avg based ratio (3). This means that it includes blocked load and
    3034                 :            :  * does not represent the runnable weight.
    3035                 :            :  *
    3036                 :            :  * Approximate the group entity's runnable weight per ratio from the group
    3037                 :            :  * runqueue:
    3038                 :            :  *
    3039                 :            :  *                                           grq->avg.runnable_load_avg
    3040                 :            :  *   ge->runnable_weight = ge->load.weight * -------------------------- (7)
    3041                 :            :  *                                               grq->avg.load_avg
    3042                 :            :  *
    3043                 :            :  * However, analogous to above, since the avg numbers are slow, this leads to
    3044                 :            :  * transients in the from-idle case. Instead we use:
    3045                 :            :  *
    3046                 :            :  *   ge->runnable_weight = ge->load.weight *
    3047                 :            :  *
    3048                 :            :  *              max(grq->avg.runnable_load_avg, grq->runnable_weight)
    3049                 :            :  *              -----------------------------------------------------   (8)
    3050                 :            :  *                    max(grq->avg.load_avg, grq->load.weight)
    3051                 :            :  *
    3052                 :            :  * Where these max() serve both to use the 'instant' values to fix the slow
    3053                 :            :  * from-idle and avoid the /0 on to-idle, similar to (6).
    3054                 :            :  */
    3055                 :            : static long calc_group_runnable(struct cfs_rq *cfs_rq, long shares)
    3056                 :            : {
    3057                 :            :         long runnable, load_avg;
    3058                 :            : 
    3059                 :            :         load_avg = max(cfs_rq->avg.load_avg,
    3060                 :            :                        scale_load_down(cfs_rq->load.weight));
    3061                 :            : 
    3062                 :          3 :         runnable = max(cfs_rq->avg.runnable_load_avg,
    3063                 :            :                        scale_load_down(cfs_rq->runnable_weight));
    3064                 :            : 
    3065                 :          3 :         runnable *= shares;
    3066                 :          3 :         if (load_avg)
    3067                 :          3 :                 runnable /= load_avg;
    3068                 :            : 
    3069                 :          3 :         return clamp_t(long, runnable, MIN_SHARES, shares);
    3070                 :            : }
    3071                 :            : #endif /* CONFIG_SMP */
    3072                 :            : 
    3073                 :            : static inline int throttled_hierarchy(struct cfs_rq *cfs_rq);
    3074                 :            : 
    3075                 :            : /*
    3076                 :            :  * Recomputes the group entity based on the current state of its group
    3077                 :            :  * runqueue.
    3078                 :            :  */
    3079                 :          3 : static void update_cfs_group(struct sched_entity *se)
    3080                 :            : {
    3081                 :            :         struct cfs_rq *gcfs_rq = group_cfs_rq(se);
    3082                 :            :         long shares, runnable;
    3083                 :            : 
    3084                 :          3 :         if (!gcfs_rq)
    3085                 :            :                 return;
    3086                 :            : 
    3087                 :          3 :         if (throttled_hierarchy(gcfs_rq))
    3088                 :            :                 return;
    3089                 :            : 
    3090                 :            : #ifndef CONFIG_SMP
    3091                 :            :         runnable = shares = READ_ONCE(gcfs_rq->tg->shares);
    3092                 :            : 
    3093                 :            :         if (likely(se->load.weight == shares))
    3094                 :            :                 return;
    3095                 :            : #else
    3096                 :            :         shares   = calc_group_shares(gcfs_rq);
    3097                 :            :         runnable = calc_group_runnable(gcfs_rq, shares);
    3098                 :            : #endif
    3099                 :            : 
    3100                 :          3 :         reweight_entity(cfs_rq_of(se), se, shares, runnable);
    3101                 :            : }
    3102                 :            : 
    3103                 :            : #else /* CONFIG_FAIR_GROUP_SCHED */
    3104                 :            : static inline void update_cfs_group(struct sched_entity *se)
    3105                 :            : {
    3106                 :            : }
    3107                 :            : #endif /* CONFIG_FAIR_GROUP_SCHED */
    3108                 :            : 
    3109                 :          3 : static inline void cfs_rq_util_change(struct cfs_rq *cfs_rq, int flags)
    3110                 :            : {
    3111                 :            :         struct rq *rq = rq_of(cfs_rq);
    3112                 :            : 
    3113                 :          3 :         if (&rq->cfs == cfs_rq || (flags & SCHED_CPUFREQ_MIGRATION)) {
    3114                 :            :                 /*
    3115                 :            :                  * There are a few boundary cases this might miss but it should
    3116                 :            :                  * get called often enough that that should (hopefully) not be
    3117                 :            :                  * a real problem.
    3118                 :            :                  *
    3119                 :            :                  * It will not get called when we go idle, because the idle
    3120                 :            :                  * thread is a different class (!fair), nor will the utilization
    3121                 :            :                  * number include things like RT tasks.
    3122                 :            :                  *
    3123                 :            :                  * As is, the util number is not freq-invariant (we'd have to
    3124                 :            :                  * implement arch_scale_freq_capacity() for that).
    3125                 :            :                  *
    3126                 :            :                  * See cpu_util().
    3127                 :            :                  */
    3128                 :          3 :                 cpufreq_update_util(rq, flags);
    3129                 :            :         }
    3130                 :          3 : }
    3131                 :            : 
    3132                 :            : #ifdef CONFIG_SMP
    3133                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
    3134                 :            : /**
    3135                 :            :  * update_tg_load_avg - update the tg's load avg
    3136                 :            :  * @cfs_rq: the cfs_rq whose avg changed
    3137                 :            :  * @force: update regardless of how small the difference
    3138                 :            :  *
    3139                 :            :  * This function 'ensures': tg->load_avg := \Sum tg->cfs_rq[]->avg.load.
    3140                 :            :  * However, because tg->load_avg is a global value there are performance
    3141                 :            :  * considerations.
    3142                 :            :  *
    3143                 :            :  * In order to avoid having to look at the other cfs_rq's, we use a
    3144                 :            :  * differential update where we store the last value we propagated. This in
    3145                 :            :  * turn allows skipping updates if the differential is 'small'.
    3146                 :            :  *
    3147                 :            :  * Updating tg's load_avg is necessary before update_cfs_share().
    3148                 :            :  */
    3149                 :          3 : static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
    3150                 :            : {
    3151                 :          3 :         long delta = cfs_rq->avg.load_avg - cfs_rq->tg_load_avg_contrib;
    3152                 :            : 
    3153                 :            :         /*
    3154                 :            :          * No need to update load_avg for root_task_group as it is not used.
    3155                 :            :          */
    3156                 :          3 :         if (cfs_rq->tg == &root_task_group)
    3157                 :          3 :                 return;
    3158                 :            : 
    3159                 :          3 :         if (force || abs(delta) > cfs_rq->tg_load_avg_contrib / 64) {
    3160                 :          3 :                 atomic_long_add(delta, &cfs_rq->tg->load_avg);
    3161                 :          3 :                 cfs_rq->tg_load_avg_contrib = cfs_rq->avg.load_avg;
    3162                 :            :         }
    3163                 :            : }
    3164                 :            : 
    3165                 :            : /*
    3166                 :            :  * Called within set_task_rq() right before setting a task's CPU. The
    3167                 :            :  * caller only guarantees p->pi_lock is held; no other assumptions,
    3168                 :            :  * including the state of rq->lock, should be made.
    3169                 :            :  */
    3170                 :          3 : void set_task_rq_fair(struct sched_entity *se,
    3171                 :            :                       struct cfs_rq *prev, struct cfs_rq *next)
    3172                 :            : {
    3173                 :            :         u64 p_last_update_time;
    3174                 :            :         u64 n_last_update_time;
    3175                 :            : 
    3176                 :          3 :         if (!sched_feat(ATTACH_AGE_LOAD))
    3177                 :            :                 return;
    3178                 :            : 
    3179                 :            :         /*
    3180                 :            :          * We are supposed to update the task to "current" time, then its up to
    3181                 :            :          * date and ready to go to new CPU/cfs_rq. But we have difficulty in
    3182                 :            :          * getting what current time is, so simply throw away the out-of-date
    3183                 :            :          * time. This will result in the wakee task is less decayed, but giving
    3184                 :            :          * the wakee more load sounds not bad.
    3185                 :            :          */
    3186                 :          3 :         if (!(se->avg.last_update_time && prev))
    3187                 :            :                 return;
    3188                 :            : 
    3189                 :            : #ifndef CONFIG_64BIT
    3190                 :            :         {
    3191                 :            :                 u64 p_last_update_time_copy;
    3192                 :            :                 u64 n_last_update_time_copy;
    3193                 :            : 
    3194                 :            :                 do {
    3195                 :          3 :                         p_last_update_time_copy = prev->load_last_update_time_copy;
    3196                 :          3 :                         n_last_update_time_copy = next->load_last_update_time_copy;
    3197                 :            : 
    3198                 :          3 :                         smp_rmb();
    3199                 :            : 
    3200                 :          3 :                         p_last_update_time = prev->avg.last_update_time;
    3201                 :          3 :                         n_last_update_time = next->avg.last_update_time;
    3202                 :            : 
    3203                 :          3 :                 } while (p_last_update_time != p_last_update_time_copy ||
    3204                 :          3 :                          n_last_update_time != n_last_update_time_copy);
    3205                 :            :         }
    3206                 :            : #else
    3207                 :            :         p_last_update_time = prev->avg.last_update_time;
    3208                 :            :         n_last_update_time = next->avg.last_update_time;
    3209                 :            : #endif
    3210                 :          3 :         __update_load_avg_blocked_se(p_last_update_time, se);
    3211                 :          3 :         se->avg.last_update_time = n_last_update_time;
    3212                 :            : }
    3213                 :            : 
    3214                 :            : 
    3215                 :            : /*
    3216                 :            :  * When on migration a sched_entity joins/leaves the PELT hierarchy, we need to
    3217                 :            :  * propagate its contribution. The key to this propagation is the invariant
    3218                 :            :  * that for each group:
    3219                 :            :  *
    3220                 :            :  *   ge->avg == grq->avg                                          (1)
    3221                 :            :  *
    3222                 :            :  * _IFF_ we look at the pure running and runnable sums. Because they
    3223                 :            :  * represent the very same entity, just at different points in the hierarchy.
    3224                 :            :  *
    3225                 :            :  * Per the above update_tg_cfs_util() is trivial and simply copies the running
    3226                 :            :  * sum over (but still wrong, because the group entity and group rq do not have
    3227                 :            :  * their PELT windows aligned).
    3228                 :            :  *
    3229                 :            :  * However, update_tg_cfs_runnable() is more complex. So we have:
    3230                 :            :  *
    3231                 :            :  *   ge->avg.load_avg = ge->load.weight * ge->avg.runnable_avg         (2)
    3232                 :            :  *
    3233                 :            :  * And since, like util, the runnable part should be directly transferable,
    3234                 :            :  * the following would _appear_ to be the straight forward approach:
    3235                 :            :  *
    3236                 :            :  *   grq->avg.load_avg = grq->load.weight * grq->avg.runnable_avg      (3)
    3237                 :            :  *
    3238                 :            :  * And per (1) we have:
    3239                 :            :  *
    3240                 :            :  *   ge->avg.runnable_avg == grq->avg.runnable_avg
    3241                 :            :  *
    3242                 :            :  * Which gives:
    3243                 :            :  *
    3244                 :            :  *                      ge->load.weight * grq->avg.load_avg
    3245                 :            :  *   ge->avg.load_avg = -----------------------------------          (4)
    3246                 :            :  *                               grq->load.weight
    3247                 :            :  *
    3248                 :            :  * Except that is wrong!
    3249                 :            :  *
    3250                 :            :  * Because while for entities historical weight is not important and we
    3251                 :            :  * really only care about our future and therefore can consider a pure
    3252                 :            :  * runnable sum, runqueues can NOT do this.
    3253                 :            :  *
    3254                 :            :  * We specifically want runqueues to have a load_avg that includes
    3255                 :            :  * historical weights. Those represent the blocked load, the load we expect
    3256                 :            :  * to (shortly) return to us. This only works by keeping the weights as
    3257                 :            :  * integral part of the sum. We therefore cannot decompose as per (3).
    3258                 :            :  *
    3259                 :            :  * Another reason this doesn't work is that runnable isn't a 0-sum entity.
    3260                 :            :  * Imagine a rq with 2 tasks that each are runnable 2/3 of the time. Then the
    3261                 :            :  * rq itself is runnable anywhere between 2/3 and 1 depending on how the
    3262                 :            :  * runnable section of these tasks overlap (or not). If they were to perfectly
    3263                 :            :  * align the rq as a whole would be runnable 2/3 of the time. If however we
    3264                 :            :  * always have at least 1 runnable task, the rq as a whole is always runnable.
    3265                 :            :  *
    3266                 :            :  * So we'll have to approximate.. :/
    3267                 :            :  *
    3268                 :            :  * Given the constraint:
    3269                 :            :  *
    3270                 :            :  *   ge->avg.running_sum <= ge->avg.runnable_sum <= LOAD_AVG_MAX
    3271                 :            :  *
    3272                 :            :  * We can construct a rule that adds runnable to a rq by assuming minimal
    3273                 :            :  * overlap.
    3274                 :            :  *
    3275                 :            :  * On removal, we'll assume each task is equally runnable; which yields:
    3276                 :            :  *
    3277                 :            :  *   grq->avg.runnable_sum = grq->avg.load_sum / grq->load.weight
    3278                 :            :  *
    3279                 :            :  * XXX: only do this for the part of runnable > running ?
    3280                 :            :  *
    3281                 :            :  */
    3282                 :            : 
    3283                 :            : static inline void
    3284                 :            : update_tg_cfs_util(struct cfs_rq *cfs_rq, struct sched_entity *se, struct cfs_rq *gcfs_rq)
    3285                 :            : {
    3286                 :          3 :         long delta = gcfs_rq->avg.util_avg - se->avg.util_avg;
    3287                 :            : 
    3288                 :            :         /* Nothing to update */
    3289                 :          3 :         if (!delta)
    3290                 :            :                 return;
    3291                 :            : 
    3292                 :            :         /*
    3293                 :            :          * The relation between sum and avg is:
    3294                 :            :          *
    3295                 :            :          *   LOAD_AVG_MAX - 1024 + sa->period_contrib
    3296                 :            :          *
    3297                 :            :          * however, the PELT windows are not aligned between grq and gse.
    3298                 :            :          */
    3299                 :            : 
    3300                 :            :         /* Set new sched_entity's utilization */
    3301                 :          3 :         se->avg.util_avg = gcfs_rq->avg.util_avg;
    3302                 :          3 :         se->avg.util_sum = se->avg.util_avg * LOAD_AVG_MAX;
    3303                 :            : 
    3304                 :            :         /* Update parent cfs_rq utilization */
    3305                 :          3 :         add_positive(&cfs_rq->avg.util_avg, delta);
    3306                 :          3 :         cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX;
    3307                 :            : }
    3308                 :            : 
    3309                 :            : static inline void
    3310                 :          3 : update_tg_cfs_runnable(struct cfs_rq *cfs_rq, struct sched_entity *se, struct cfs_rq *gcfs_rq)
    3311                 :            : {
    3312                 :          3 :         long delta_avg, running_sum, runnable_sum = gcfs_rq->prop_runnable_sum;
    3313                 :            :         unsigned long runnable_load_avg, load_avg;
    3314                 :            :         u64 runnable_load_sum, load_sum = 0;
    3315                 :            :         s64 delta_sum;
    3316                 :            : 
    3317                 :          3 :         if (!runnable_sum)
    3318                 :          3 :                 return;
    3319                 :            : 
    3320                 :          3 :         gcfs_rq->prop_runnable_sum = 0;
    3321                 :            : 
    3322                 :          3 :         if (runnable_sum >= 0) {
    3323                 :            :                 /*
    3324                 :            :                  * Add runnable; clip at LOAD_AVG_MAX. Reflects that until
    3325                 :            :                  * the CPU is saturated running == runnable.
    3326                 :            :                  */
    3327                 :          3 :                 runnable_sum += se->avg.load_sum;
    3328                 :          3 :                 runnable_sum = min(runnable_sum, (long)LOAD_AVG_MAX);
    3329                 :            :         } else {
    3330                 :            :                 /*
    3331                 :            :                  * Estimate the new unweighted runnable_sum of the gcfs_rq by
    3332                 :            :                  * assuming all tasks are equally runnable.
    3333                 :            :                  */
    3334                 :          3 :                 if (scale_load_down(gcfs_rq->load.weight)) {
    3335                 :          3 :                         load_sum = div_s64(gcfs_rq->avg.load_sum,
    3336                 :            :                                 scale_load_down(gcfs_rq->load.weight));
    3337                 :            :                 }
    3338                 :            : 
    3339                 :            :                 /* But make sure to not inflate se's runnable */
    3340                 :          3 :                 runnable_sum = min(se->avg.load_sum, load_sum);
    3341                 :            :         }
    3342                 :            : 
    3343                 :            :         /*
    3344                 :            :          * runnable_sum can't be lower than running_sum
    3345                 :            :          * Rescale running sum to be in the same range as runnable sum
    3346                 :            :          * running_sum is in [0 : LOAD_AVG_MAX <<  SCHED_CAPACITY_SHIFT]
    3347                 :            :          * runnable_sum is in [0 : LOAD_AVG_MAX]
    3348                 :            :          */
    3349                 :          3 :         running_sum = se->avg.util_sum >> SCHED_CAPACITY_SHIFT;
    3350                 :          3 :         runnable_sum = max(runnable_sum, running_sum);
    3351                 :            : 
    3352                 :          3 :         load_sum = (s64)se_weight(se) * runnable_sum;
    3353                 :          3 :         load_avg = div_s64(load_sum, LOAD_AVG_MAX);
    3354                 :            : 
    3355                 :          3 :         delta_sum = load_sum - (s64)se_weight(se) * se->avg.load_sum;
    3356                 :          3 :         delta_avg = load_avg - se->avg.load_avg;
    3357                 :            : 
    3358                 :          3 :         se->avg.load_sum = runnable_sum;
    3359                 :          3 :         se->avg.load_avg = load_avg;
    3360                 :          3 :         add_positive(&cfs_rq->avg.load_avg, delta_avg);
    3361                 :          3 :         add_positive(&cfs_rq->avg.load_sum, delta_sum);
    3362                 :            : 
    3363                 :          3 :         runnable_load_sum = (s64)se_runnable(se) * runnable_sum;
    3364                 :          3 :         runnable_load_avg = div_s64(runnable_load_sum, LOAD_AVG_MAX);
    3365                 :          3 :         delta_sum = runnable_load_sum - se_weight(se) * se->avg.runnable_load_sum;
    3366                 :          3 :         delta_avg = runnable_load_avg - se->avg.runnable_load_avg;
    3367                 :            : 
    3368                 :          3 :         se->avg.runnable_load_sum = runnable_sum;
    3369                 :          3 :         se->avg.runnable_load_avg = runnable_load_avg;
    3370                 :            : 
    3371                 :          3 :         if (se->on_rq) {
    3372                 :          3 :                 add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg);
    3373                 :          3 :                 add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum);
    3374                 :            :         }
    3375                 :            : }
    3376                 :            : 
    3377                 :            : static inline void add_tg_cfs_propagate(struct cfs_rq *cfs_rq, long runnable_sum)
    3378                 :            : {
    3379                 :          3 :         cfs_rq->propagate = 1;
    3380                 :          3 :         cfs_rq->prop_runnable_sum += runnable_sum;
    3381                 :            : }
    3382                 :            : 
    3383                 :            : /* Update task and its cfs_rq load average */
    3384                 :          3 : static inline int propagate_entity_load_avg(struct sched_entity *se)
    3385                 :            : {
    3386                 :            :         struct cfs_rq *cfs_rq, *gcfs_rq;
    3387                 :            : 
    3388                 :          3 :         if (entity_is_task(se))
    3389                 :            :                 return 0;
    3390                 :            : 
    3391                 :            :         gcfs_rq = group_cfs_rq(se);
    3392                 :          3 :         if (!gcfs_rq->propagate)
    3393                 :            :                 return 0;
    3394                 :            : 
    3395                 :          3 :         gcfs_rq->propagate = 0;
    3396                 :            : 
    3397                 :            :         cfs_rq = cfs_rq_of(se);
    3398                 :            : 
    3399                 :          3 :         add_tg_cfs_propagate(cfs_rq, gcfs_rq->prop_runnable_sum);
    3400                 :            : 
    3401                 :            :         update_tg_cfs_util(cfs_rq, se, gcfs_rq);
    3402                 :          3 :         update_tg_cfs_runnable(cfs_rq, se, gcfs_rq);
    3403                 :            : 
    3404                 :          3 :         trace_pelt_cfs_tp(cfs_rq);
    3405                 :          3 :         trace_pelt_se_tp(se);
    3406                 :            : 
    3407                 :          3 :         return 1;
    3408                 :            : }
    3409                 :            : 
    3410                 :            : /*
    3411                 :            :  * Check if we need to update the load and the utilization of a blocked
    3412                 :            :  * group_entity:
    3413                 :            :  */
    3414                 :            : static inline bool skip_blocked_update(struct sched_entity *se)
    3415                 :            : {
    3416                 :            :         struct cfs_rq *gcfs_rq = group_cfs_rq(se);
    3417                 :            : 
    3418                 :            :         /*
    3419                 :            :          * If sched_entity still have not zero load or utilization, we have to
    3420                 :            :          * decay it:
    3421                 :            :          */
    3422                 :          3 :         if (se->avg.load_avg || se->avg.util_avg)
    3423                 :            :                 return false;
    3424                 :            : 
    3425                 :            :         /*
    3426                 :            :          * If there is a pending propagation, we have to update the load and
    3427                 :            :          * the utilization of the sched_entity:
    3428                 :            :          */
    3429                 :          3 :         if (gcfs_rq->propagate)
    3430                 :            :                 return false;
    3431                 :            : 
    3432                 :            :         /*
    3433                 :            :          * Otherwise, the load and the utilization of the sched_entity is
    3434                 :            :          * already zero and there is no pending propagation, so it will be a
    3435                 :            :          * waste of time to try to decay it:
    3436                 :            :          */
    3437                 :            :         return true;
    3438                 :            : }
    3439                 :            : 
    3440                 :            : #else /* CONFIG_FAIR_GROUP_SCHED */
    3441                 :            : 
    3442                 :            : static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force) {}
    3443                 :            : 
    3444                 :            : static inline int propagate_entity_load_avg(struct sched_entity *se)
    3445                 :            : {
    3446                 :            :         return 0;
    3447                 :            : }
    3448                 :            : 
    3449                 :            : static inline void add_tg_cfs_propagate(struct cfs_rq *cfs_rq, long runnable_sum) {}
    3450                 :            : 
    3451                 :            : #endif /* CONFIG_FAIR_GROUP_SCHED */
    3452                 :            : 
    3453                 :            : /**
    3454                 :            :  * update_cfs_rq_load_avg - update the cfs_rq's load/util averages
    3455                 :            :  * @now: current time, as per cfs_rq_clock_pelt()
    3456                 :            :  * @cfs_rq: cfs_rq to update
    3457                 :            :  *
    3458                 :            :  * The cfs_rq avg is the direct sum of all its entities (blocked and runnable)
    3459                 :            :  * avg. The immediate corollary is that all (fair) tasks must be attached, see
    3460                 :            :  * post_init_entity_util_avg().
    3461                 :            :  *
    3462                 :            :  * cfs_rq->avg is used for task_h_load() and update_cfs_share() for example.
    3463                 :            :  *
    3464                 :            :  * Returns true if the load decayed or we removed load.
    3465                 :            :  *
    3466                 :            :  * Since both these conditions indicate a changed cfs_rq->avg.load we should
    3467                 :            :  * call update_tg_load_avg() when this function returns true.
    3468                 :            :  */
    3469                 :            : static inline int
    3470                 :          3 : update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq)
    3471                 :            : {
    3472                 :            :         unsigned long removed_load = 0, removed_util = 0, removed_runnable_sum = 0;
    3473                 :            :         struct sched_avg *sa = &cfs_rq->avg;
    3474                 :            :         int decayed = 0;
    3475                 :            : 
    3476                 :          3 :         if (cfs_rq->removed.nr) {
    3477                 :            :                 unsigned long r;
    3478                 :          3 :                 u32 divider = LOAD_AVG_MAX - 1024 + sa->period_contrib;
    3479                 :            : 
    3480                 :          3 :                 raw_spin_lock(&cfs_rq->removed.lock);
    3481                 :          3 :                 swap(cfs_rq->removed.util_avg, removed_util);
    3482                 :          3 :                 swap(cfs_rq->removed.load_avg, removed_load);
    3483                 :          3 :                 swap(cfs_rq->removed.runnable_sum, removed_runnable_sum);
    3484                 :          3 :                 cfs_rq->removed.nr = 0;
    3485                 :            :                 raw_spin_unlock(&cfs_rq->removed.lock);
    3486                 :            : 
    3487                 :            :                 r = removed_load;
    3488                 :          3 :                 sub_positive(&sa->load_avg, r);
    3489                 :          3 :                 sub_positive(&sa->load_sum, r * divider);
    3490                 :            : 
    3491                 :            :                 r = removed_util;
    3492                 :          3 :                 sub_positive(&sa->util_avg, r);
    3493                 :          3 :                 sub_positive(&sa->util_sum, r * divider);
    3494                 :            : 
    3495                 :          3 :                 add_tg_cfs_propagate(cfs_rq, -(long)removed_runnable_sum);
    3496                 :            : 
    3497                 :            :                 decayed = 1;
    3498                 :            :         }
    3499                 :            : 
    3500                 :          3 :         decayed |= __update_load_avg_cfs_rq(now, cfs_rq);
    3501                 :            : 
    3502                 :            : #ifndef CONFIG_64BIT
    3503                 :          3 :         smp_wmb();
    3504                 :          3 :         cfs_rq->load_last_update_time_copy = sa->last_update_time;
    3505                 :            : #endif
    3506                 :            : 
    3507                 :          3 :         return decayed;
    3508                 :            : }
    3509                 :            : 
    3510                 :            : /**
    3511                 :            :  * attach_entity_load_avg - attach this entity to its cfs_rq load avg
    3512                 :            :  * @cfs_rq: cfs_rq to attach to
    3513                 :            :  * @se: sched_entity to attach
    3514                 :            :  * @flags: migration hints
    3515                 :            :  *
    3516                 :            :  * Must call update_cfs_rq_load_avg() before this, since we rely on
    3517                 :            :  * cfs_rq->avg.last_update_time being current.
    3518                 :            :  */
    3519                 :          3 : static void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
    3520                 :            : {
    3521                 :          3 :         u32 divider = LOAD_AVG_MAX - 1024 + cfs_rq->avg.period_contrib;
    3522                 :            : 
    3523                 :            :         /*
    3524                 :            :          * When we attach the @se to the @cfs_rq, we must align the decay
    3525                 :            :          * window because without that, really weird and wonderful things can
    3526                 :            :          * happen.
    3527                 :            :          *
    3528                 :            :          * XXX illustrate
    3529                 :            :          */
    3530                 :          3 :         se->avg.last_update_time = cfs_rq->avg.last_update_time;
    3531                 :          3 :         se->avg.period_contrib = cfs_rq->avg.period_contrib;
    3532                 :            : 
    3533                 :            :         /*
    3534                 :            :          * Hell(o) Nasty stuff.. we need to recompute _sum based on the new
    3535                 :            :          * period_contrib. This isn't strictly correct, but since we're
    3536                 :            :          * entirely outside of the PELT hierarchy, nobody cares if we truncate
    3537                 :            :          * _sum a little.
    3538                 :            :          */
    3539                 :          3 :         se->avg.util_sum = se->avg.util_avg * divider;
    3540                 :            : 
    3541                 :          3 :         se->avg.load_sum = divider;
    3542                 :          3 :         if (se_weight(se)) {
    3543                 :          3 :                 se->avg.load_sum =
    3544                 :          3 :                         div_u64(se->avg.load_avg * se->avg.load_sum, se_weight(se));
    3545                 :            :         }
    3546                 :            : 
    3547                 :          3 :         se->avg.runnable_load_sum = se->avg.load_sum;
    3548                 :            : 
    3549                 :            :         enqueue_load_avg(cfs_rq, se);
    3550                 :          3 :         cfs_rq->avg.util_avg += se->avg.util_avg;
    3551                 :          3 :         cfs_rq->avg.util_sum += se->avg.util_sum;
    3552                 :            : 
    3553                 :          3 :         add_tg_cfs_propagate(cfs_rq, se->avg.load_sum);
    3554                 :            : 
    3555                 :          3 :         cfs_rq_util_change(cfs_rq, flags);
    3556                 :            : 
    3557                 :          3 :         trace_pelt_cfs_tp(cfs_rq);
    3558                 :          3 : }
    3559                 :            : 
    3560                 :            : /**
    3561                 :            :  * detach_entity_load_avg - detach this entity from its cfs_rq load avg
    3562                 :            :  * @cfs_rq: cfs_rq to detach from
    3563                 :            :  * @se: sched_entity to detach
    3564                 :            :  *
    3565                 :            :  * Must call update_cfs_rq_load_avg() before this, since we rely on
    3566                 :            :  * cfs_rq->avg.last_update_time being current.
    3567                 :            :  */
    3568                 :          3 : static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
    3569                 :            : {
    3570                 :            :         dequeue_load_avg(cfs_rq, se);
    3571                 :          3 :         sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg);
    3572                 :          3 :         sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum);
    3573                 :            : 
    3574                 :          3 :         add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum);
    3575                 :            : 
    3576                 :          3 :         cfs_rq_util_change(cfs_rq, 0);
    3577                 :            : 
    3578                 :          3 :         trace_pelt_cfs_tp(cfs_rq);
    3579                 :          3 : }
    3580                 :            : 
    3581                 :            : /*
    3582                 :            :  * Optional action to be done while updating the load average
    3583                 :            :  */
    3584                 :            : #define UPDATE_TG       0x1
    3585                 :            : #define SKIP_AGE_LOAD   0x2
    3586                 :            : #define DO_ATTACH       0x4
    3587                 :            : 
    3588                 :            : /* Update task and its cfs_rq load average */
    3589                 :          3 : static inline void update_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
    3590                 :            : {
    3591                 :          3 :         u64 now = cfs_rq_clock_pelt(cfs_rq);
    3592                 :            :         int decayed;
    3593                 :            : 
    3594                 :            :         /*
    3595                 :            :          * Track task load average for carrying it to new CPU after migrated, and
    3596                 :            :          * track group sched_entity load average for task_h_load calc in migration
    3597                 :            :          */
    3598                 :          3 :         if (se->avg.last_update_time && !(flags & SKIP_AGE_LOAD))
    3599                 :          3 :                 __update_load_avg_se(now, cfs_rq, se);
    3600                 :            : 
    3601                 :          3 :         decayed  = update_cfs_rq_load_avg(now, cfs_rq);
    3602                 :          3 :         decayed |= propagate_entity_load_avg(se);
    3603                 :            : 
    3604                 :          3 :         if (!se->avg.last_update_time && (flags & DO_ATTACH)) {
    3605                 :            : 
    3606                 :            :                 /*
    3607                 :            :                  * DO_ATTACH means we're here from enqueue_entity().
    3608                 :            :                  * !last_update_time means we've passed through
    3609                 :            :                  * migrate_task_rq_fair() indicating we migrated.
    3610                 :            :                  *
    3611                 :            :                  * IOW we're enqueueing a task on a new CPU.
    3612                 :            :                  */
    3613                 :          3 :                 attach_entity_load_avg(cfs_rq, se, SCHED_CPUFREQ_MIGRATION);
    3614                 :          3 :                 update_tg_load_avg(cfs_rq, 0);
    3615                 :            : 
    3616                 :          3 :         } else if (decayed) {
    3617                 :          3 :                 cfs_rq_util_change(cfs_rq, 0);
    3618                 :            : 
    3619                 :          3 :                 if (flags & UPDATE_TG)
    3620                 :          3 :                         update_tg_load_avg(cfs_rq, 0);
    3621                 :            :         }
    3622                 :          3 : }
    3623                 :            : 
    3624                 :            : #ifndef CONFIG_64BIT
    3625                 :            : static inline u64 cfs_rq_last_update_time(struct cfs_rq *cfs_rq)
    3626                 :            : {
    3627                 :            :         u64 last_update_time_copy;
    3628                 :            :         u64 last_update_time;
    3629                 :            : 
    3630                 :            :         do {
    3631                 :          3 :                 last_update_time_copy = cfs_rq->load_last_update_time_copy;
    3632                 :          3 :                 smp_rmb();
    3633                 :          3 :                 last_update_time = cfs_rq->avg.last_update_time;
    3634                 :          3 :         } while (last_update_time != last_update_time_copy);
    3635                 :            : 
    3636                 :          3 :         return last_update_time;
    3637                 :            : }
    3638                 :            : #else
    3639                 :            : static inline u64 cfs_rq_last_update_time(struct cfs_rq *cfs_rq)
    3640                 :            : {
    3641                 :            :         return cfs_rq->avg.last_update_time;
    3642                 :            : }
    3643                 :            : #endif
    3644                 :            : 
    3645                 :            : /*
    3646                 :            :  * Synchronize entity load avg of dequeued entity without locking
    3647                 :            :  * the previous rq.
    3648                 :            :  */
    3649                 :          3 : static void sync_entity_load_avg(struct sched_entity *se)
    3650                 :            : {
    3651                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
    3652                 :            :         u64 last_update_time;
    3653                 :            : 
    3654                 :            :         last_update_time = cfs_rq_last_update_time(cfs_rq);
    3655                 :          3 :         __update_load_avg_blocked_se(last_update_time, se);
    3656                 :          3 : }
    3657                 :            : 
    3658                 :            : /*
    3659                 :            :  * Task first catches up with cfs_rq, and then subtract
    3660                 :            :  * itself from the cfs_rq (task must be off the queue now).
    3661                 :            :  */
    3662                 :          3 : static void remove_entity_load_avg(struct sched_entity *se)
    3663                 :            : {
    3664                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
    3665                 :            :         unsigned long flags;
    3666                 :            : 
    3667                 :            :         /*
    3668                 :            :          * tasks cannot exit without having gone through wake_up_new_task() ->
    3669                 :            :          * post_init_entity_util_avg() which will have added things to the
    3670                 :            :          * cfs_rq, so we can remove unconditionally.
    3671                 :            :          */
    3672                 :            : 
    3673                 :          3 :         sync_entity_load_avg(se);
    3674                 :            : 
    3675                 :          3 :         raw_spin_lock_irqsave(&cfs_rq->removed.lock, flags);
    3676                 :          3 :         ++cfs_rq->removed.nr;
    3677                 :          3 :         cfs_rq->removed.util_avg     += se->avg.util_avg;
    3678                 :          3 :         cfs_rq->removed.load_avg     += se->avg.load_avg;
    3679                 :          3 :         cfs_rq->removed.runnable_sum += se->avg.load_sum; /* == runnable_sum */
    3680                 :          3 :         raw_spin_unlock_irqrestore(&cfs_rq->removed.lock, flags);
    3681                 :          3 : }
    3682                 :            : 
    3683                 :            : static inline unsigned long cfs_rq_runnable_load_avg(struct cfs_rq *cfs_rq)
    3684                 :            : {
    3685                 :          3 :         return cfs_rq->avg.runnable_load_avg;
    3686                 :            : }
    3687                 :            : 
    3688                 :            : static inline unsigned long cfs_rq_load_avg(struct cfs_rq *cfs_rq)
    3689                 :            : {
    3690                 :          3 :         return cfs_rq->avg.load_avg;
    3691                 :            : }
    3692                 :            : 
    3693                 :            : static inline unsigned long task_util(struct task_struct *p)
    3694                 :            : {
    3695                 :            :         return READ_ONCE(p->se.avg.util_avg);
    3696                 :            : }
    3697                 :            : 
    3698                 :            : static inline unsigned long _task_util_est(struct task_struct *p)
    3699                 :            : {
    3700                 :          3 :         struct util_est ue = READ_ONCE(p->se.avg.util_est);
    3701                 :            : 
    3702                 :          3 :         return (max(ue.ewma, ue.enqueued) | UTIL_AVG_UNCHANGED);
    3703                 :            : }
    3704                 :            : 
    3705                 :            : static inline unsigned long task_util_est(struct task_struct *p)
    3706                 :            : {
    3707                 :          0 :         return max(task_util(p), _task_util_est(p));
    3708                 :            : }
    3709                 :            : 
    3710                 :          3 : static inline void util_est_enqueue(struct cfs_rq *cfs_rq,
    3711                 :            :                                     struct task_struct *p)
    3712                 :            : {
    3713                 :            :         unsigned int enqueued;
    3714                 :            : 
    3715                 :          3 :         if (!sched_feat(UTIL_EST))
    3716                 :          3 :                 return;
    3717                 :            : 
    3718                 :            :         /* Update root cfs_rq's estimated utilization */
    3719                 :          3 :         enqueued  = cfs_rq->avg.util_est.enqueued;
    3720                 :          3 :         enqueued += _task_util_est(p);
    3721                 :            :         WRITE_ONCE(cfs_rq->avg.util_est.enqueued, enqueued);
    3722                 :            : }
    3723                 :            : 
    3724                 :            : /*
    3725                 :            :  * Check if a (signed) value is within a specified (unsigned) margin,
    3726                 :            :  * based on the observation that:
    3727                 :            :  *
    3728                 :            :  *     abs(x) < y := (unsigned)(x + y - 1) < (2 * y - 1)
    3729                 :            :  *
    3730                 :            :  * NOTE: this only works when value + maring < INT_MAX.
    3731                 :            :  */
    3732                 :            : static inline bool within_margin(int value, int margin)
    3733                 :            : {
    3734                 :          3 :         return ((unsigned int)(value + margin - 1) < (2 * margin - 1));
    3735                 :            : }
    3736                 :            : 
    3737                 :            : static void
    3738                 :          3 : util_est_dequeue(struct cfs_rq *cfs_rq, struct task_struct *p, bool task_sleep)
    3739                 :            : {
    3740                 :            :         long last_ewma_diff;
    3741                 :            :         struct util_est ue;
    3742                 :            :         int cpu;
    3743                 :            : 
    3744                 :          3 :         if (!sched_feat(UTIL_EST))
    3745                 :            :                 return;
    3746                 :            : 
    3747                 :            :         /* Update root cfs_rq's estimated utilization */
    3748                 :          3 :         ue.enqueued  = cfs_rq->avg.util_est.enqueued;
    3749                 :          3 :         ue.enqueued -= min_t(unsigned int, ue.enqueued, _task_util_est(p));
    3750                 :            :         WRITE_ONCE(cfs_rq->avg.util_est.enqueued, ue.enqueued);
    3751                 :            : 
    3752                 :            :         /*
    3753                 :            :          * Skip update of task's estimated utilization when the task has not
    3754                 :            :          * yet completed an activation, e.g. being migrated.
    3755                 :            :          */
    3756                 :          3 :         if (!task_sleep)
    3757                 :            :                 return;
    3758                 :            : 
    3759                 :            :         /*
    3760                 :            :          * If the PELT values haven't changed since enqueue time,
    3761                 :            :          * skip the util_est update.
    3762                 :            :          */
    3763                 :          3 :         ue = p->se.avg.util_est;
    3764                 :          3 :         if (ue.enqueued & UTIL_AVG_UNCHANGED)
    3765                 :            :                 return;
    3766                 :            : 
    3767                 :            :         /*
    3768                 :            :          * Skip update of task's estimated utilization when its EWMA is
    3769                 :            :          * already ~1% close to its last activation value.
    3770                 :            :          */
    3771                 :          3 :         ue.enqueued = (task_util(p) | UTIL_AVG_UNCHANGED);
    3772                 :          3 :         last_ewma_diff = ue.enqueued - ue.ewma;
    3773                 :          3 :         if (within_margin(last_ewma_diff, (SCHED_CAPACITY_SCALE / 100)))
    3774                 :            :                 return;
    3775                 :            : 
    3776                 :            :         /*
    3777                 :            :          * To avoid overestimation of actual task utilization, skip updates if
    3778                 :            :          * we cannot grant there is idle time in this CPU.
    3779                 :            :          */
    3780                 :            :         cpu = cpu_of(rq_of(cfs_rq));
    3781                 :          3 :         if (task_util(p) > capacity_orig_of(cpu))
    3782                 :            :                 return;
    3783                 :            : 
    3784                 :            :         /*
    3785                 :            :          * Update Task's estimated utilization
    3786                 :            :          *
    3787                 :            :          * When *p completes an activation we can consolidate another sample
    3788                 :            :          * of the task size. This is done by storing the current PELT value
    3789                 :            :          * as ue.enqueued and by using this value to update the Exponential
    3790                 :            :          * Weighted Moving Average (EWMA):
    3791                 :            :          *
    3792                 :            :          *  ewma(t) = w *  task_util(p) + (1-w) * ewma(t-1)
    3793                 :            :          *          = w *  task_util(p) +         ewma(t-1)  - w * ewma(t-1)
    3794                 :            :          *          = w * (task_util(p) -         ewma(t-1)) +     ewma(t-1)
    3795                 :            :          *          = w * (      last_ewma_diff            ) +     ewma(t-1)
    3796                 :            :          *          = w * (last_ewma_diff  +  ewma(t-1) / w)
    3797                 :            :          *
    3798                 :            :          * Where 'w' is the weight of new samples, which is configured to be
    3799                 :            :          * 0.25, thus making w=1/4 ( >>= UTIL_EST_WEIGHT_SHIFT)
    3800                 :            :          */
    3801                 :          3 :         ue.ewma <<= UTIL_EST_WEIGHT_SHIFT;
    3802                 :          3 :         ue.ewma  += last_ewma_diff;
    3803                 :          3 :         ue.ewma >>= UTIL_EST_WEIGHT_SHIFT;
    3804                 :          3 :         WRITE_ONCE(p->se.avg.util_est, ue);
    3805                 :            : }
    3806                 :            : 
    3807                 :            : static inline int task_fits_capacity(struct task_struct *p, long capacity)
    3808                 :            : {
    3809                 :          0 :         return fits_capacity(task_util_est(p), capacity);
    3810                 :            : }
    3811                 :            : 
    3812                 :          3 : static inline void update_misfit_status(struct task_struct *p, struct rq *rq)
    3813                 :            : {
    3814                 :          3 :         if (!static_branch_unlikely(&sched_asym_cpucapacity))
    3815                 :            :                 return;
    3816                 :            : 
    3817                 :          0 :         if (!p) {
    3818                 :          0 :                 rq->misfit_task_load = 0;
    3819                 :          0 :                 return;
    3820                 :            :         }
    3821                 :            : 
    3822                 :          0 :         if (task_fits_capacity(p, capacity_of(cpu_of(rq)))) {
    3823                 :          0 :                 rq->misfit_task_load = 0;
    3824                 :          0 :                 return;
    3825                 :            :         }
    3826                 :            : 
    3827                 :            :         /*
    3828                 :            :          * Make sure that misfit_task_load will not be null even if
    3829                 :            :          * task_h_load() returns 0.
    3830                 :            :          */
    3831                 :          0 :         rq->misfit_task_load = max_t(unsigned long, task_h_load(p), 1);
    3832                 :            : }
    3833                 :            : 
    3834                 :            : #else /* CONFIG_SMP */
    3835                 :            : 
    3836                 :            : #define UPDATE_TG       0x0
    3837                 :            : #define SKIP_AGE_LOAD   0x0
    3838                 :            : #define DO_ATTACH       0x0
    3839                 :            : 
    3840                 :            : static inline void update_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se, int not_used1)
    3841                 :            : {
    3842                 :            :         cfs_rq_util_change(cfs_rq, 0);
    3843                 :            : }
    3844                 :            : 
    3845                 :            : static inline void remove_entity_load_avg(struct sched_entity *se) {}
    3846                 :            : 
    3847                 :            : static inline void
    3848                 :            : attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) {}
    3849                 :            : static inline void
    3850                 :            : detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) {}
    3851                 :            : 
    3852                 :            : static inline int idle_balance(struct rq *rq, struct rq_flags *rf)
    3853                 :            : {
    3854                 :            :         return 0;
    3855                 :            : }
    3856                 :            : 
    3857                 :            : static inline void
    3858                 :            : util_est_enqueue(struct cfs_rq *cfs_rq, struct task_struct *p) {}
    3859                 :            : 
    3860                 :            : static inline void
    3861                 :            : util_est_dequeue(struct cfs_rq *cfs_rq, struct task_struct *p,
    3862                 :            :                  bool task_sleep) {}
    3863                 :            : static inline void update_misfit_status(struct task_struct *p, struct rq *rq) {}
    3864                 :            : 
    3865                 :            : #endif /* CONFIG_SMP */
    3866                 :            : 
    3867                 :          3 : static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se)
    3868                 :            : {
    3869                 :            : #ifdef CONFIG_SCHED_DEBUG
    3870                 :          3 :         s64 d = se->vruntime - cfs_rq->min_vruntime;
    3871                 :            : 
    3872                 :          3 :         if (d < 0)
    3873                 :          3 :                 d = -d;
    3874                 :            : 
    3875                 :          3 :         if (d > 3*sysctl_sched_latency)
    3876                 :          3 :                 schedstat_inc(cfs_rq->nr_spread_over);
    3877                 :            : #endif
    3878                 :          3 : }
    3879                 :            : 
    3880                 :            : static void
    3881                 :          3 : place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
    3882                 :            : {
    3883                 :          3 :         u64 vruntime = cfs_rq->min_vruntime;
    3884                 :            : 
    3885                 :            :         /*
    3886                 :            :          * The 'current' period is already promised to the current tasks,
    3887                 :            :          * however the extra weight of the new task will slow them down a
    3888                 :            :          * little, place the new task so that it fits in the slot that
    3889                 :            :          * stays open at the end.
    3890                 :            :          */
    3891                 :          3 :         if (initial && sched_feat(START_DEBIT))
    3892                 :          3 :                 vruntime += sched_vslice(cfs_rq, se);
    3893                 :            : 
    3894                 :            :         /* sleeps up to a single latency don't count. */
    3895                 :          3 :         if (!initial) {
    3896                 :          3 :                 unsigned long thresh = sysctl_sched_latency;
    3897                 :            : 
    3898                 :            :                 /*
    3899                 :            :                  * Halve their sleep time's effect, to allow
    3900                 :            :                  * for a gentler effect of sleepers:
    3901                 :            :                  */
    3902                 :          3 :                 if (sched_feat(GENTLE_FAIR_SLEEPERS))
    3903                 :          3 :                         thresh >>= 1;
    3904                 :            : 
    3905                 :          3 :                 vruntime -= thresh;
    3906                 :            :         }
    3907                 :            : 
    3908                 :            :         /* ensure we never gain time by being placed backwards. */
    3909                 :          3 :         se->vruntime = max_vruntime(se->vruntime, vruntime);
    3910                 :          3 : }
    3911                 :            : 
    3912                 :            : static void check_enqueue_throttle(struct cfs_rq *cfs_rq);
    3913                 :            : 
    3914                 :          3 : static inline void check_schedstat_required(void)
    3915                 :            : {
    3916                 :            : #ifdef CONFIG_SCHEDSTATS
    3917                 :          3 :         if (schedstat_enabled())
    3918                 :          3 :                 return;
    3919                 :            : 
    3920                 :            :         /* Force schedstat enabled if a dependent tracepoint is active */
    3921                 :          3 :         if (trace_sched_stat_wait_enabled()    ||
    3922                 :          3 :                         trace_sched_stat_sleep_enabled()   ||
    3923                 :          3 :                         trace_sched_stat_iowait_enabled()  ||
    3924                 :          3 :                         trace_sched_stat_blocked_enabled() ||
    3925                 :            :                         trace_sched_stat_runtime_enabled())  {
    3926                 :          0 :                 printk_deferred_once("Scheduler tracepoints stat_sleep, stat_iowait, "
    3927                 :            :                              "stat_blocked and stat_runtime require the "
    3928                 :            :                              "kernel parameter schedstats=enable or "
    3929                 :            :                              "kernel.sched_schedstats=1\n");
    3930                 :            :         }
    3931                 :            : #endif
    3932                 :            : }
    3933                 :            : 
    3934                 :            : static inline bool cfs_bandwidth_used(void);
    3935                 :            : 
    3936                 :            : /*
    3937                 :            :  * MIGRATION
    3938                 :            :  *
    3939                 :            :  *      dequeue
    3940                 :            :  *        update_curr()
    3941                 :            :  *          update_min_vruntime()
    3942                 :            :  *        vruntime -= min_vruntime
    3943                 :            :  *
    3944                 :            :  *      enqueue
    3945                 :            :  *        update_curr()
    3946                 :            :  *          update_min_vruntime()
    3947                 :            :  *        vruntime += min_vruntime
    3948                 :            :  *
    3949                 :            :  * this way the vruntime transition between RQs is done when both
    3950                 :            :  * min_vruntime are up-to-date.
    3951                 :            :  *
    3952                 :            :  * WAKEUP (remote)
    3953                 :            :  *
    3954                 :            :  *      ->migrate_task_rq_fair() (p->state == TASK_WAKING)
    3955                 :            :  *        vruntime -= min_vruntime
    3956                 :            :  *
    3957                 :            :  *      enqueue
    3958                 :            :  *        update_curr()
    3959                 :            :  *          update_min_vruntime()
    3960                 :            :  *        vruntime += min_vruntime
    3961                 :            :  *
    3962                 :            :  * this way we don't have the most up-to-date min_vruntime on the originating
    3963                 :            :  * CPU and an up-to-date min_vruntime on the destination CPU.
    3964                 :            :  */
    3965                 :            : 
    3966                 :            : static void
    3967                 :          3 : enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
    3968                 :            : {
    3969                 :          3 :         bool renorm = !(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_MIGRATED);
    3970                 :          3 :         bool curr = cfs_rq->curr == se;
    3971                 :            : 
    3972                 :            :         /*
    3973                 :            :          * If we're the current task, we must renormalise before calling
    3974                 :            :          * update_curr().
    3975                 :            :          */
    3976                 :          3 :         if (renorm && curr)
    3977                 :          0 :                 se->vruntime += cfs_rq->min_vruntime;
    3978                 :            : 
    3979                 :          3 :         update_curr(cfs_rq);
    3980                 :            : 
    3981                 :            :         /*
    3982                 :            :          * Otherwise, renormalise after, such that we're placed at the current
    3983                 :            :          * moment in time, instead of some random moment in the past. Being
    3984                 :            :          * placed in the past could significantly boost this task to the
    3985                 :            :          * fairness detriment of existing tasks.
    3986                 :            :          */
    3987                 :          3 :         if (renorm && !curr)
    3988                 :          3 :                 se->vruntime += cfs_rq->min_vruntime;
    3989                 :            : 
    3990                 :            :         /*
    3991                 :            :          * When enqueuing a sched_entity, we must:
    3992                 :            :          *   - Update loads to have both entity and cfs_rq synced with now.
    3993                 :            :          *   - Add its load to cfs_rq->runnable_avg
    3994                 :            :          *   - For group_entity, update its weight to reflect the new share of
    3995                 :            :          *     its group cfs_rq
    3996                 :            :          *   - Add its new weight to cfs_rq->load.weight
    3997                 :            :          */
    3998                 :          3 :         update_load_avg(cfs_rq, se, UPDATE_TG | DO_ATTACH);
    3999                 :          3 :         update_cfs_group(se);
    4000                 :            :         enqueue_runnable_load_avg(cfs_rq, se);
    4001                 :          3 :         account_entity_enqueue(cfs_rq, se);
    4002                 :            : 
    4003                 :          3 :         if (flags & ENQUEUE_WAKEUP)
    4004                 :          3 :                 place_entity(cfs_rq, se, 0);
    4005                 :            : 
    4006                 :          3 :         check_schedstat_required();
    4007                 :          3 :         update_stats_enqueue(cfs_rq, se, flags);
    4008                 :          3 :         check_spread(cfs_rq, se);
    4009                 :          3 :         if (!curr)
    4010                 :          3 :                 __enqueue_entity(cfs_rq, se);
    4011                 :          3 :         se->on_rq = 1;
    4012                 :            : 
    4013                 :            :         /*
    4014                 :            :          * When bandwidth control is enabled, cfs might have been removed
    4015                 :            :          * because of a parent been throttled but cfs->nr_running > 1. Try to
    4016                 :            :          * add it unconditionnally.
    4017                 :            :          */
    4018                 :          3 :         if (cfs_rq->nr_running == 1 || cfs_bandwidth_used())
    4019                 :          3 :                 list_add_leaf_cfs_rq(cfs_rq);
    4020                 :            : 
    4021                 :          3 :         if (cfs_rq->nr_running == 1)
    4022                 :          3 :                 check_enqueue_throttle(cfs_rq);
    4023                 :          3 : }
    4024                 :            : 
    4025                 :            : static void __clear_buddies_last(struct sched_entity *se)
    4026                 :            : {
    4027                 :          3 :         for_each_sched_entity(se) {
    4028                 :            :                 struct cfs_rq *cfs_rq = cfs_rq_of(se);
    4029                 :          3 :                 if (cfs_rq->last != se)
    4030                 :            :                         break;
    4031                 :            : 
    4032                 :          3 :                 cfs_rq->last = NULL;
    4033                 :            :         }
    4034                 :            : }
    4035                 :            : 
    4036                 :            : static void __clear_buddies_next(struct sched_entity *se)
    4037                 :            : {
    4038                 :          3 :         for_each_sched_entity(se) {
    4039                 :            :                 struct cfs_rq *cfs_rq = cfs_rq_of(se);
    4040                 :          3 :                 if (cfs_rq->next != se)
    4041                 :            :                         break;
    4042                 :            : 
    4043                 :          3 :                 cfs_rq->next = NULL;
    4044                 :            :         }
    4045                 :            : }
    4046                 :            : 
    4047                 :            : static void __clear_buddies_skip(struct sched_entity *se)
    4048                 :            : {
    4049                 :          0 :         for_each_sched_entity(se) {
    4050                 :            :                 struct cfs_rq *cfs_rq = cfs_rq_of(se);
    4051                 :          0 :                 if (cfs_rq->skip != se)
    4052                 :            :                         break;
    4053                 :            : 
    4054                 :          0 :                 cfs_rq->skip = NULL;
    4055                 :            :         }
    4056                 :            : }
    4057                 :            : 
    4058                 :          3 : static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
    4059                 :            : {
    4060                 :          3 :         if (cfs_rq->last == se)
    4061                 :            :                 __clear_buddies_last(se);
    4062                 :            : 
    4063                 :          3 :         if (cfs_rq->next == se)
    4064                 :            :                 __clear_buddies_next(se);
    4065                 :            : 
    4066                 :          3 :         if (cfs_rq->skip == se)
    4067                 :            :                 __clear_buddies_skip(se);
    4068                 :          3 : }
    4069                 :            : 
    4070                 :            : static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq);
    4071                 :            : 
    4072                 :            : static void
    4073                 :          3 : dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
    4074                 :            : {
    4075                 :            :         /*
    4076                 :            :          * Update run-time statistics of the 'current'.
    4077                 :            :          */
    4078                 :          3 :         update_curr(cfs_rq);
    4079                 :            : 
    4080                 :            :         /*
    4081                 :            :          * When dequeuing a sched_entity, we must:
    4082                 :            :          *   - Update loads to have both entity and cfs_rq synced with now.
    4083                 :            :          *   - Subtract its load from the cfs_rq->runnable_avg.
    4084                 :            :          *   - Subtract its previous weight from cfs_rq->load.weight.
    4085                 :            :          *   - For group entity, update its weight to reflect the new share
    4086                 :            :          *     of its group cfs_rq.
    4087                 :            :          */
    4088                 :          3 :         update_load_avg(cfs_rq, se, UPDATE_TG);
    4089                 :          3 :         dequeue_runnable_load_avg(cfs_rq, se);
    4090                 :            : 
    4091                 :          3 :         update_stats_dequeue(cfs_rq, se, flags);
    4092                 :            : 
    4093                 :          3 :         clear_buddies(cfs_rq, se);
    4094                 :            : 
    4095                 :          3 :         if (se != cfs_rq->curr)
    4096                 :            :                 __dequeue_entity(cfs_rq, se);
    4097                 :          3 :         se->on_rq = 0;
    4098                 :          3 :         account_entity_dequeue(cfs_rq, se);
    4099                 :            : 
    4100                 :            :         /*
    4101                 :            :          * Normalize after update_curr(); which will also have moved
    4102                 :            :          * min_vruntime if @se is the one holding it back. But before doing
    4103                 :            :          * update_min_vruntime() again, which will discount @se's position and
    4104                 :            :          * can move min_vruntime forward still more.
    4105                 :            :          */
    4106                 :          3 :         if (!(flags & DEQUEUE_SLEEP))
    4107                 :          3 :                 se->vruntime -= cfs_rq->min_vruntime;
    4108                 :            : 
    4109                 :            :         /* return excess runtime on last dequeue */
    4110                 :            :         return_cfs_rq_runtime(cfs_rq);
    4111                 :            : 
    4112                 :          3 :         update_cfs_group(se);
    4113                 :            : 
    4114                 :            :         /*
    4115                 :            :          * Now advance min_vruntime if @se was the entity holding it back,
    4116                 :            :          * except when: DEQUEUE_SAVE && !DEQUEUE_MOVE, in this case we'll be
    4117                 :            :          * put back on, and if we advance min_vruntime, we'll be placed back
    4118                 :            :          * further than we started -- ie. we'll be penalized.
    4119                 :            :          */
    4120                 :          3 :         if ((flags & (DEQUEUE_SAVE | DEQUEUE_MOVE)) != DEQUEUE_SAVE)
    4121                 :          3 :                 update_min_vruntime(cfs_rq);
    4122                 :          3 : }
    4123                 :            : 
    4124                 :            : /*
    4125                 :            :  * Preempt the current task with a newly woken task if needed:
    4126                 :            :  */
    4127                 :            : static void
    4128                 :          3 : check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
    4129                 :            : {
    4130                 :            :         unsigned long ideal_runtime, delta_exec;
    4131                 :            :         struct sched_entity *se;
    4132                 :            :         s64 delta;
    4133                 :            : 
    4134                 :          3 :         ideal_runtime = sched_slice(cfs_rq, curr);
    4135                 :          3 :         delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
    4136                 :          3 :         if (delta_exec > ideal_runtime) {
    4137                 :          3 :                 resched_curr(rq_of(cfs_rq));
    4138                 :            :                 /*
    4139                 :            :                  * The current task ran long enough, ensure it doesn't get
    4140                 :            :                  * re-elected due to buddy favours.
    4141                 :            :                  */
    4142                 :          3 :                 clear_buddies(cfs_rq, curr);
    4143                 :          3 :                 return;
    4144                 :            :         }
    4145                 :            : 
    4146                 :            :         /*
    4147                 :            :          * Ensure that a task that missed wakeup preemption by a
    4148                 :            :          * narrow margin doesn't have to wait for a full slice.
    4149                 :            :          * This also mitigates buddy induced latencies under load.
    4150                 :            :          */
    4151                 :          3 :         if (delta_exec < sysctl_sched_min_granularity)
    4152                 :            :                 return;
    4153                 :            : 
    4154                 :            :         se = __pick_first_entity(cfs_rq);
    4155                 :          3 :         delta = curr->vruntime - se->vruntime;
    4156                 :            : 
    4157                 :          3 :         if (delta < 0)
    4158                 :            :                 return;
    4159                 :            : 
    4160                 :          3 :         if (delta > ideal_runtime)
    4161                 :          3 :                 resched_curr(rq_of(cfs_rq));
    4162                 :            : }
    4163                 :            : 
    4164                 :            : static void
    4165                 :          3 : set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
    4166                 :            : {
    4167                 :            :         /* 'current' is not kept within the tree. */
    4168                 :          3 :         if (se->on_rq) {
    4169                 :            :                 /*
    4170                 :            :                  * Any task has to be enqueued before it get to execute on
    4171                 :            :                  * a CPU. So account for the time it spent waiting on the
    4172                 :            :                  * runqueue.
    4173                 :            :                  */
    4174                 :          3 :                 update_stats_wait_end(cfs_rq, se);
    4175                 :            :                 __dequeue_entity(cfs_rq, se);
    4176                 :          3 :                 update_load_avg(cfs_rq, se, UPDATE_TG);
    4177                 :            :         }
    4178                 :            : 
    4179                 :            :         update_stats_curr_start(cfs_rq, se);
    4180                 :          3 :         cfs_rq->curr = se;
    4181                 :            : 
    4182                 :            :         /*
    4183                 :            :          * Track our maximum slice length, if the CPU's load is at
    4184                 :            :          * least twice that of our own weight (i.e. dont track it
    4185                 :            :          * when there are only lesser-weight tasks around):
    4186                 :            :          */
    4187                 :          3 :         if (schedstat_enabled() &&
    4188                 :          0 :             rq_of(cfs_rq)->cfs.load.weight >= 2*se->load.weight) {
    4189                 :          0 :                 schedstat_set(se->statistics.slice_max,
    4190                 :            :                         max((u64)schedstat_val(se->statistics.slice_max),
    4191                 :            :                             se->sum_exec_runtime - se->prev_sum_exec_runtime));
    4192                 :            :         }
    4193                 :            : 
    4194                 :          3 :         se->prev_sum_exec_runtime = se->sum_exec_runtime;
    4195                 :          3 : }
    4196                 :            : 
    4197                 :            : static int
    4198                 :            : wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se);
    4199                 :            : 
    4200                 :            : /*
    4201                 :            :  * Pick the next process, keeping these things in mind, in this order:
    4202                 :            :  * 1) keep things fair between processes/task groups
    4203                 :            :  * 2) pick the "next" process, since someone really wants that to run
    4204                 :            :  * 3) pick the "last" process, for cache locality
    4205                 :            :  * 4) do not run the "skip" process, if something else is available
    4206                 :            :  */
    4207                 :            : static struct sched_entity *
    4208                 :          3 : pick_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *curr)
    4209                 :            : {
    4210                 :            :         struct sched_entity *left = __pick_first_entity(cfs_rq);
    4211                 :            :         struct sched_entity *se;
    4212                 :            : 
    4213                 :            :         /*
    4214                 :            :          * If curr is set we have to see if its left of the leftmost entity
    4215                 :            :          * still in the tree, provided there was anything in the tree at all.
    4216                 :            :          */
    4217                 :          3 :         if (!left || (curr && entity_before(curr, left)))
    4218                 :            :                 left = curr;
    4219                 :            : 
    4220                 :            :         se = left; /* ideally we run the leftmost entity */
    4221                 :            : 
    4222                 :            :         /*
    4223                 :            :          * Avoid running the skip buddy, if running something else can
    4224                 :            :          * be done without getting too unfair.
    4225                 :            :          */
    4226                 :          3 :         if (cfs_rq->skip == se) {
    4227                 :            :                 struct sched_entity *second;
    4228                 :            : 
    4229                 :          0 :                 if (se == curr) {
    4230                 :            :                         second = __pick_first_entity(cfs_rq);
    4231                 :            :                 } else {
    4232                 :            :                         second = __pick_next_entity(se);
    4233                 :          0 :                         if (!second || (curr && entity_before(curr, second)))
    4234                 :            :                                 second = curr;
    4235                 :            :                 }
    4236                 :            : 
    4237                 :          0 :                 if (second && wakeup_preempt_entity(second, left) < 1)
    4238                 :            :                         se = second;
    4239                 :            :         }
    4240                 :            : 
    4241                 :            :         /*
    4242                 :            :          * Prefer last buddy, try to return the CPU to a preempted task.
    4243                 :            :          */
    4244                 :          3 :         if (cfs_rq->last && wakeup_preempt_entity(cfs_rq->last, left) < 1)
    4245                 :          3 :                 se = cfs_rq->last;
    4246                 :            : 
    4247                 :            :         /*
    4248                 :            :          * Someone really wants this to run. If it's not unfair, run it.
    4249                 :            :          */
    4250                 :          3 :         if (cfs_rq->next && wakeup_preempt_entity(cfs_rq->next, left) < 1)
    4251                 :          3 :                 se = cfs_rq->next;
    4252                 :            : 
    4253                 :          3 :         clear_buddies(cfs_rq, se);
    4254                 :            : 
    4255                 :          3 :         return se;
    4256                 :            : }
    4257                 :            : 
    4258                 :            : static bool check_cfs_rq_runtime(struct cfs_rq *cfs_rq);
    4259                 :            : 
    4260                 :          3 : static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev)
    4261                 :            : {
    4262                 :            :         /*
    4263                 :            :          * If still on the runqueue then deactivate_task()
    4264                 :            :          * was not called and update_curr() has to be done:
    4265                 :            :          */
    4266                 :          3 :         if (prev->on_rq)
    4267                 :          3 :                 update_curr(cfs_rq);
    4268                 :            : 
    4269                 :            :         /* throttle cfs_rqs exceeding runtime */
    4270                 :          3 :         check_cfs_rq_runtime(cfs_rq);
    4271                 :            : 
    4272                 :          3 :         check_spread(cfs_rq, prev);
    4273                 :            : 
    4274                 :          3 :         if (prev->on_rq) {
    4275                 :          3 :                 update_stats_wait_start(cfs_rq, prev);
    4276                 :            :                 /* Put 'current' back into the tree. */
    4277                 :          3 :                 __enqueue_entity(cfs_rq, prev);
    4278                 :            :                 /* in !on_rq case, update occurred at dequeue */
    4279                 :          3 :                 update_load_avg(cfs_rq, prev, 0);
    4280                 :            :         }
    4281                 :          3 :         cfs_rq->curr = NULL;
    4282                 :          3 : }
    4283                 :            : 
    4284                 :            : static void
    4285                 :          3 : entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued)
    4286                 :            : {
    4287                 :            :         /*
    4288                 :            :          * Update run-time statistics of the 'current'.
    4289                 :            :          */
    4290                 :          3 :         update_curr(cfs_rq);
    4291                 :            : 
    4292                 :            :         /*
    4293                 :            :          * Ensure that runnable average is periodically updated.
    4294                 :            :          */
    4295                 :          3 :         update_load_avg(cfs_rq, curr, UPDATE_TG);
    4296                 :          3 :         update_cfs_group(curr);
    4297                 :            : 
    4298                 :            : #ifdef CONFIG_SCHED_HRTICK
    4299                 :            :         /*
    4300                 :            :          * queued ticks are scheduled to match the slice, so don't bother
    4301                 :            :          * validating it and just reschedule.
    4302                 :            :          */
    4303                 :          3 :         if (queued) {
    4304                 :          0 :                 resched_curr(rq_of(cfs_rq));
    4305                 :          0 :                 return;
    4306                 :            :         }
    4307                 :            :         /*
    4308                 :            :          * don't let the period tick interfere with the hrtick preemption
    4309                 :            :          */
    4310                 :          3 :         if (!sched_feat(DOUBLE_TICK) &&
    4311                 :          3 :                         hrtimer_active(&rq_of(cfs_rq)->hrtick_timer))
    4312                 :            :                 return;
    4313                 :            : #endif
    4314                 :            : 
    4315                 :          3 :         if (cfs_rq->nr_running > 1)
    4316                 :          3 :                 check_preempt_tick(cfs_rq, curr);
    4317                 :            : }
    4318                 :            : 
    4319                 :            : 
    4320                 :            : /**************************************************
    4321                 :            :  * CFS bandwidth control machinery
    4322                 :            :  */
    4323                 :            : 
    4324                 :            : #ifdef CONFIG_CFS_BANDWIDTH
    4325                 :            : 
    4326                 :            : #ifdef CONFIG_JUMP_LABEL
    4327                 :            : static struct static_key __cfs_bandwidth_used;
    4328                 :            : 
    4329                 :          3 : static inline bool cfs_bandwidth_used(void)
    4330                 :            : {
    4331                 :          3 :         return static_key_false(&__cfs_bandwidth_used);
    4332                 :            : }
    4333                 :            : 
    4334                 :          0 : void cfs_bandwidth_usage_inc(void)
    4335                 :            : {
    4336                 :          0 :         static_key_slow_inc_cpuslocked(&__cfs_bandwidth_used);
    4337                 :          0 : }
    4338                 :            : 
    4339                 :          0 : void cfs_bandwidth_usage_dec(void)
    4340                 :            : {
    4341                 :          0 :         static_key_slow_dec_cpuslocked(&__cfs_bandwidth_used);
    4342                 :          0 : }
    4343                 :            : #else /* CONFIG_JUMP_LABEL */
    4344                 :            : static bool cfs_bandwidth_used(void)
    4345                 :            : {
    4346                 :            :         return true;
    4347                 :            : }
    4348                 :            : 
    4349                 :            : void cfs_bandwidth_usage_inc(void) {}
    4350                 :            : void cfs_bandwidth_usage_dec(void) {}
    4351                 :            : #endif /* CONFIG_JUMP_LABEL */
    4352                 :            : 
    4353                 :            : /*
    4354                 :            :  * default period for cfs group bandwidth.
    4355                 :            :  * default: 0.1s, units: nanoseconds
    4356                 :            :  */
    4357                 :            : static inline u64 default_cfs_period(void)
    4358                 :            : {
    4359                 :            :         return 100000000ULL;
    4360                 :            : }
    4361                 :            : 
    4362                 :            : static inline u64 sched_cfs_bandwidth_slice(void)
    4363                 :            : {
    4364                 :          0 :         return (u64)sysctl_sched_cfs_bandwidth_slice * NSEC_PER_USEC;
    4365                 :            : }
    4366                 :            : 
    4367                 :            : /*
    4368                 :            :  * Replenish runtime according to assigned quota. We use sched_clock_cpu
    4369                 :            :  * directly instead of rq->clock to avoid adding additional synchronization
    4370                 :            :  * around rq->lock.
    4371                 :            :  *
    4372                 :            :  * requires cfs_b->lock
    4373                 :            :  */
    4374                 :          0 : void __refill_cfs_bandwidth_runtime(struct cfs_bandwidth *cfs_b)
    4375                 :            : {
    4376                 :          0 :         if (cfs_b->quota != RUNTIME_INF)
    4377                 :          0 :                 cfs_b->runtime = cfs_b->quota;
    4378                 :          0 : }
    4379                 :            : 
    4380                 :            : static inline struct cfs_bandwidth *tg_cfs_bandwidth(struct task_group *tg)
    4381                 :            : {
    4382                 :          3 :         return &tg->cfs_bandwidth;
    4383                 :            : }
    4384                 :            : 
    4385                 :            : /* returns 0 on failure to allocate runtime */
    4386                 :          0 : static int assign_cfs_rq_runtime(struct cfs_rq *cfs_rq)
    4387                 :            : {
    4388                 :          0 :         struct task_group *tg = cfs_rq->tg;
    4389                 :            :         struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(tg);
    4390                 :            :         u64 amount = 0, min_amount;
    4391                 :            : 
    4392                 :            :         /* note: this is a positive sum as runtime_remaining <= 0 */
    4393                 :          0 :         min_amount = sched_cfs_bandwidth_slice() - cfs_rq->runtime_remaining;
    4394                 :            : 
    4395                 :          0 :         raw_spin_lock(&cfs_b->lock);
    4396                 :          0 :         if (cfs_b->quota == RUNTIME_INF)
    4397                 :            :                 amount = min_amount;
    4398                 :            :         else {
    4399                 :          0 :                 start_cfs_bandwidth(cfs_b);
    4400                 :            : 
    4401                 :          0 :                 if (cfs_b->runtime > 0) {
    4402                 :          0 :                         amount = min(cfs_b->runtime, min_amount);
    4403                 :          0 :                         cfs_b->runtime -= amount;
    4404                 :          0 :                         cfs_b->idle = 0;
    4405                 :            :                 }
    4406                 :            :         }
    4407                 :            :         raw_spin_unlock(&cfs_b->lock);
    4408                 :            : 
    4409                 :          0 :         cfs_rq->runtime_remaining += amount;
    4410                 :            : 
    4411                 :          0 :         return cfs_rq->runtime_remaining > 0;
    4412                 :            : }
    4413                 :            : 
    4414                 :          0 : static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec)
    4415                 :            : {
    4416                 :            :         /* dock delta_exec before expiring quota (as it could span periods) */
    4417                 :          0 :         cfs_rq->runtime_remaining -= delta_exec;
    4418                 :            : 
    4419                 :          0 :         if (likely(cfs_rq->runtime_remaining > 0))
    4420                 :            :                 return;
    4421                 :            : 
    4422                 :          0 :         if (cfs_rq->throttled)
    4423                 :            :                 return;
    4424                 :            :         /*
    4425                 :            :          * if we're unable to extend our runtime we resched so that the active
    4426                 :            :          * hierarchy can be throttled
    4427                 :            :          */
    4428                 :          0 :         if (!assign_cfs_rq_runtime(cfs_rq) && likely(cfs_rq->curr))
    4429                 :          0 :                 resched_curr(rq_of(cfs_rq));
    4430                 :            : }
    4431                 :            : 
    4432                 :            : static __always_inline
    4433                 :            : void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec)
    4434                 :            : {
    4435                 :          3 :         if (!cfs_bandwidth_used() || !cfs_rq->runtime_enabled)
    4436                 :            :                 return;
    4437                 :            : 
    4438                 :          0 :         __account_cfs_rq_runtime(cfs_rq, delta_exec);
    4439                 :            : }
    4440                 :            : 
    4441                 :            : static inline int cfs_rq_throttled(struct cfs_rq *cfs_rq)
    4442                 :            : {
    4443                 :          3 :         return cfs_bandwidth_used() && cfs_rq->throttled;
    4444                 :            : }
    4445                 :            : 
    4446                 :            : /* check whether cfs_rq, or any parent, is throttled */
    4447                 :            : static inline int throttled_hierarchy(struct cfs_rq *cfs_rq)
    4448                 :            : {
    4449                 :          3 :         return cfs_bandwidth_used() && cfs_rq->throttle_count;
    4450                 :            : }
    4451                 :            : 
    4452                 :            : /*
    4453                 :            :  * Ensure that neither of the group entities corresponding to src_cpu or
    4454                 :            :  * dest_cpu are members of a throttled hierarchy when performing group
    4455                 :            :  * load-balance operations.
    4456                 :            :  */
    4457                 :          3 : static inline int throttled_lb_pair(struct task_group *tg,
    4458                 :            :                                     int src_cpu, int dest_cpu)
    4459                 :            : {
    4460                 :            :         struct cfs_rq *src_cfs_rq, *dest_cfs_rq;
    4461                 :            : 
    4462                 :          3 :         src_cfs_rq = tg->cfs_rq[src_cpu];
    4463                 :          3 :         dest_cfs_rq = tg->cfs_rq[dest_cpu];
    4464                 :            : 
    4465                 :          3 :         return throttled_hierarchy(src_cfs_rq) ||
    4466                 :            :                throttled_hierarchy(dest_cfs_rq);
    4467                 :            : }
    4468                 :            : 
    4469                 :          0 : static int tg_unthrottle_up(struct task_group *tg, void *data)
    4470                 :            : {
    4471                 :            :         struct rq *rq = data;
    4472                 :          0 :         struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
    4473                 :            : 
    4474                 :          0 :         cfs_rq->throttle_count--;
    4475                 :          0 :         if (!cfs_rq->throttle_count) {
    4476                 :          0 :                 cfs_rq->throttled_clock_task_time += rq_clock_task(rq) -
    4477                 :          0 :                                              cfs_rq->throttled_clock_task;
    4478                 :            : 
    4479                 :            :                 /* Add cfs_rq with already running entity in the list */
    4480                 :          0 :                 if (cfs_rq->nr_running >= 1)
    4481                 :          0 :                         list_add_leaf_cfs_rq(cfs_rq);
    4482                 :            :         }
    4483                 :            : 
    4484                 :          0 :         return 0;
    4485                 :            : }
    4486                 :            : 
    4487                 :          0 : static int tg_throttle_down(struct task_group *tg, void *data)
    4488                 :            : {
    4489                 :            :         struct rq *rq = data;
    4490                 :          0 :         struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
    4491                 :            : 
    4492                 :            :         /* group is entering throttled state, stop time */
    4493                 :          0 :         if (!cfs_rq->throttle_count) {
    4494                 :          0 :                 cfs_rq->throttled_clock_task = rq_clock_task(rq);
    4495                 :            :                 list_del_leaf_cfs_rq(cfs_rq);
    4496                 :            :         }
    4497                 :          0 :         cfs_rq->throttle_count++;
    4498                 :            : 
    4499                 :          0 :         return 0;
    4500                 :            : }
    4501                 :            : 
    4502                 :          0 : static void throttle_cfs_rq(struct cfs_rq *cfs_rq)
    4503                 :            : {
    4504                 :            :         struct rq *rq = rq_of(cfs_rq);
    4505                 :          0 :         struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
    4506                 :            :         struct sched_entity *se;
    4507                 :            :         long task_delta, idle_task_delta, dequeue = 1;
    4508                 :            :         bool empty;
    4509                 :            : 
    4510                 :          0 :         se = cfs_rq->tg->se[cpu_of(rq_of(cfs_rq))];
    4511                 :            : 
    4512                 :            :         /* freeze hierarchy runnable averages while throttled */
    4513                 :            :         rcu_read_lock();
    4514                 :          0 :         walk_tg_tree_from(cfs_rq->tg, tg_throttle_down, tg_nop, (void *)rq);
    4515                 :            :         rcu_read_unlock();
    4516                 :            : 
    4517                 :          0 :         task_delta = cfs_rq->h_nr_running;
    4518                 :          0 :         idle_task_delta = cfs_rq->idle_h_nr_running;
    4519                 :          0 :         for_each_sched_entity(se) {
    4520                 :            :                 struct cfs_rq *qcfs_rq = cfs_rq_of(se);
    4521                 :            :                 /* throttled entity or throttle-on-deactivate */
    4522                 :          0 :                 if (!se->on_rq)
    4523                 :            :                         break;
    4524                 :            : 
    4525                 :          0 :                 if (dequeue)
    4526                 :          0 :                         dequeue_entity(qcfs_rq, se, DEQUEUE_SLEEP);
    4527                 :          0 :                 qcfs_rq->h_nr_running -= task_delta;
    4528                 :          0 :                 qcfs_rq->idle_h_nr_running -= idle_task_delta;
    4529                 :            : 
    4530                 :          0 :                 if (qcfs_rq->load.weight)
    4531                 :            :                         dequeue = 0;
    4532                 :            :         }
    4533                 :            : 
    4534                 :          0 :         if (!se)
    4535                 :            :                 sub_nr_running(rq, task_delta);
    4536                 :            : 
    4537                 :          0 :         cfs_rq->throttled = 1;
    4538                 :          0 :         cfs_rq->throttled_clock = rq_clock(rq);
    4539                 :          0 :         raw_spin_lock(&cfs_b->lock);
    4540                 :          0 :         empty = list_empty(&cfs_b->throttled_cfs_rq);
    4541                 :            : 
    4542                 :            :         /*
    4543                 :            :          * Add to the _head_ of the list, so that an already-started
    4544                 :            :          * distribute_cfs_runtime will not see us. If disribute_cfs_runtime is
    4545                 :            :          * not running add to the tail so that later runqueues don't get starved.
    4546                 :            :          */
    4547                 :          0 :         if (cfs_b->distribute_running)
    4548                 :          0 :                 list_add_rcu(&cfs_rq->throttled_list, &cfs_b->throttled_cfs_rq);
    4549                 :            :         else
    4550                 :          0 :                 list_add_tail_rcu(&cfs_rq->throttled_list, &cfs_b->throttled_cfs_rq);
    4551                 :            : 
    4552                 :            :         /*
    4553                 :            :          * If we're the first throttled task, make sure the bandwidth
    4554                 :            :          * timer is running.
    4555                 :            :          */
    4556                 :          0 :         if (empty)
    4557                 :          0 :                 start_cfs_bandwidth(cfs_b);
    4558                 :            : 
    4559                 :            :         raw_spin_unlock(&cfs_b->lock);
    4560                 :          0 : }
    4561                 :            : 
    4562                 :          0 : void unthrottle_cfs_rq(struct cfs_rq *cfs_rq)
    4563                 :            : {
    4564                 :            :         struct rq *rq = rq_of(cfs_rq);
    4565                 :          0 :         struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
    4566                 :            :         struct sched_entity *se;
    4567                 :            :         int enqueue = 1;
    4568                 :            :         long task_delta, idle_task_delta;
    4569                 :            : 
    4570                 :          0 :         se = cfs_rq->tg->se[cpu_of(rq)];
    4571                 :            : 
    4572                 :          0 :         cfs_rq->throttled = 0;
    4573                 :            : 
    4574                 :          0 :         update_rq_clock(rq);
    4575                 :            : 
    4576                 :          0 :         raw_spin_lock(&cfs_b->lock);
    4577                 :          0 :         cfs_b->throttled_time += rq_clock(rq) - cfs_rq->throttled_clock;
    4578                 :            :         list_del_rcu(&cfs_rq->throttled_list);
    4579                 :            :         raw_spin_unlock(&cfs_b->lock);
    4580                 :            : 
    4581                 :            :         /* update hierarchical throttle state */
    4582                 :          0 :         walk_tg_tree_from(cfs_rq->tg, tg_nop, tg_unthrottle_up, (void *)rq);
    4583                 :            : 
    4584                 :          0 :         if (!cfs_rq->load.weight)
    4585                 :          0 :                 return;
    4586                 :            : 
    4587                 :          0 :         task_delta = cfs_rq->h_nr_running;
    4588                 :          0 :         idle_task_delta = cfs_rq->idle_h_nr_running;
    4589                 :          0 :         for_each_sched_entity(se) {
    4590                 :          0 :                 if (se->on_rq)
    4591                 :            :                         enqueue = 0;
    4592                 :            : 
    4593                 :            :                 cfs_rq = cfs_rq_of(se);
    4594                 :          0 :                 if (enqueue)
    4595                 :          0 :                         enqueue_entity(cfs_rq, se, ENQUEUE_WAKEUP);
    4596                 :          0 :                 cfs_rq->h_nr_running += task_delta;
    4597                 :          0 :                 cfs_rq->idle_h_nr_running += idle_task_delta;
    4598                 :            : 
    4599                 :          0 :                 if (cfs_rq_throttled(cfs_rq))
    4600                 :            :                         break;
    4601                 :            :         }
    4602                 :            : 
    4603                 :          0 :         if (!se)
    4604                 :            :                 add_nr_running(rq, task_delta);
    4605                 :            : 
    4606                 :            :         /*
    4607                 :            :          * The cfs_rq_throttled() breaks in the above iteration can result in
    4608                 :            :          * incomplete leaf list maintenance, resulting in triggering the
    4609                 :            :          * assertion below.
    4610                 :            :          */
    4611                 :          0 :         for_each_sched_entity(se) {
    4612                 :            :                 cfs_rq = cfs_rq_of(se);
    4613                 :            : 
    4614                 :          0 :                 list_add_leaf_cfs_rq(cfs_rq);
    4615                 :            :         }
    4616                 :            : 
    4617                 :          0 :         assert_list_leaf_cfs_rq(rq);
    4618                 :            : 
    4619                 :            :         /* Determine whether we need to wake up potentially idle CPU: */
    4620                 :          0 :         if (rq->curr == rq->idle && rq->cfs.nr_running)
    4621                 :          0 :                 resched_curr(rq);
    4622                 :            : }
    4623                 :            : 
    4624                 :          0 : static u64 distribute_cfs_runtime(struct cfs_bandwidth *cfs_b, u64 remaining)
    4625                 :            : {
    4626                 :            :         struct cfs_rq *cfs_rq;
    4627                 :            :         u64 runtime;
    4628                 :            :         u64 starting_runtime = remaining;
    4629                 :            : 
    4630                 :            :         rcu_read_lock();
    4631                 :          0 :         list_for_each_entry_rcu(cfs_rq, &cfs_b->throttled_cfs_rq,
    4632                 :            :                                 throttled_list) {
    4633                 :            :                 struct rq *rq = rq_of(cfs_rq);
    4634                 :            :                 struct rq_flags rf;
    4635                 :            : 
    4636                 :            :                 rq_lock_irqsave(rq, &rf);
    4637                 :          0 :                 if (!cfs_rq_throttled(cfs_rq))
    4638                 :            :                         goto next;
    4639                 :            : 
    4640                 :            :                 /* By the above check, this should never be true */
    4641                 :          0 :                 SCHED_WARN_ON(cfs_rq->runtime_remaining > 0);
    4642                 :            : 
    4643                 :          0 :                 runtime = -cfs_rq->runtime_remaining + 1;
    4644                 :          0 :                 if (runtime > remaining)
    4645                 :            :                         runtime = remaining;
    4646                 :          0 :                 remaining -= runtime;
    4647                 :            : 
    4648                 :          0 :                 cfs_rq->runtime_remaining += runtime;
    4649                 :            : 
    4650                 :            :                 /* we check whether we're throttled above */
    4651                 :          0 :                 if (cfs_rq->runtime_remaining > 0)
    4652                 :          0 :                         unthrottle_cfs_rq(cfs_rq);
    4653                 :            : 
    4654                 :            : next:
    4655                 :            :                 rq_unlock_irqrestore(rq, &rf);
    4656                 :            : 
    4657                 :          0 :                 if (!remaining)
    4658                 :            :                         break;
    4659                 :            :         }
    4660                 :            :         rcu_read_unlock();
    4661                 :            : 
    4662                 :          0 :         return starting_runtime - remaining;
    4663                 :            : }
    4664                 :            : 
    4665                 :            : /*
    4666                 :            :  * Responsible for refilling a task_group's bandwidth and unthrottling its
    4667                 :            :  * cfs_rqs as appropriate. If there has been no activity within the last
    4668                 :            :  * period the timer is deactivated until scheduling resumes; cfs_b->idle is
    4669                 :            :  * used to track this state.
    4670                 :            :  */
    4671                 :          0 : static int do_sched_cfs_period_timer(struct cfs_bandwidth *cfs_b, int overrun, unsigned long flags)
    4672                 :            : {
    4673                 :            :         u64 runtime;
    4674                 :            :         int throttled;
    4675                 :            : 
    4676                 :            :         /* no need to continue the timer with no bandwidth constraint */
    4677                 :          0 :         if (cfs_b->quota == RUNTIME_INF)
    4678                 :            :                 goto out_deactivate;
    4679                 :            : 
    4680                 :          0 :         throttled = !list_empty(&cfs_b->throttled_cfs_rq);
    4681                 :          0 :         cfs_b->nr_periods += overrun;
    4682                 :            : 
    4683                 :            :         /*
    4684                 :            :          * idle depends on !throttled (for the case of a large deficit), and if
    4685                 :            :          * we're going inactive then everything else can be deferred
    4686                 :            :          */
    4687                 :          0 :         if (cfs_b->idle && !throttled)
    4688                 :            :                 goto out_deactivate;
    4689                 :            : 
    4690                 :            :         __refill_cfs_bandwidth_runtime(cfs_b);
    4691                 :            : 
    4692                 :          0 :         if (!throttled) {
    4693                 :            :                 /* mark as potentially idle for the upcoming period */
    4694                 :          0 :                 cfs_b->idle = 1;
    4695                 :          0 :                 return 0;
    4696                 :            :         }
    4697                 :            : 
    4698                 :            :         /* account preceding periods in which throttling occurred */
    4699                 :          0 :         cfs_b->nr_throttled += overrun;
    4700                 :            : 
    4701                 :            :         /*
    4702                 :            :          * This check is repeated as we are holding onto the new bandwidth while
    4703                 :            :          * we unthrottle. This can potentially race with an unthrottled group
    4704                 :            :          * trying to acquire new bandwidth from the global pool. This can result
    4705                 :            :          * in us over-using our runtime if it is all used during this loop, but
    4706                 :            :          * only by limited amounts in that extreme case.
    4707                 :            :          */
    4708                 :          0 :         while (throttled && cfs_b->runtime > 0 && !cfs_b->distribute_running) {
    4709                 :            :                 runtime = cfs_b->runtime;
    4710                 :          0 :                 cfs_b->distribute_running = 1;
    4711                 :          0 :                 raw_spin_unlock_irqrestore(&cfs_b->lock, flags);
    4712                 :            :                 /* we can't nest cfs_b->lock while distributing bandwidth */
    4713                 :          0 :                 runtime = distribute_cfs_runtime(cfs_b, runtime);
    4714                 :          0 :                 raw_spin_lock_irqsave(&cfs_b->lock, flags);
    4715                 :            : 
    4716                 :          0 :                 cfs_b->distribute_running = 0;
    4717                 :          0 :                 throttled = !list_empty(&cfs_b->throttled_cfs_rq);
    4718                 :            : 
    4719                 :          0 :                 lsub_positive(&cfs_b->runtime, runtime);
    4720                 :            :         }
    4721                 :            : 
    4722                 :            :         /*
    4723                 :            :          * While we are ensured activity in the period following an
    4724                 :            :          * unthrottle, this also covers the case in which the new bandwidth is
    4725                 :            :          * insufficient to cover the existing bandwidth deficit.  (Forcing the
    4726                 :            :          * timer to remain active while there are any throttled entities.)
    4727                 :            :          */
    4728                 :          0 :         cfs_b->idle = 0;
    4729                 :            : 
    4730                 :          0 :         return 0;
    4731                 :            : 
    4732                 :            : out_deactivate:
    4733                 :            :         return 1;
    4734                 :            : }
    4735                 :            : 
    4736                 :            : /* a cfs_rq won't donate quota below this amount */
    4737                 :            : static const u64 min_cfs_rq_runtime = 1 * NSEC_PER_MSEC;
    4738                 :            : /* minimum remaining period time to redistribute slack quota */
    4739                 :            : static const u64 min_bandwidth_expiration = 2 * NSEC_PER_MSEC;
    4740                 :            : /* how long we wait to gather additional slack before distributing */
    4741                 :            : static const u64 cfs_bandwidth_slack_period = 5 * NSEC_PER_MSEC;
    4742                 :            : 
    4743                 :            : /*
    4744                 :            :  * Are we near the end of the current quota period?
    4745                 :            :  *
    4746                 :            :  * Requires cfs_b->lock for hrtimer_expires_remaining to be safe against the
    4747                 :            :  * hrtimer base being cleared by hrtimer_start. In the case of
    4748                 :            :  * migrate_hrtimers, base is never cleared, so we are fine.
    4749                 :            :  */
    4750                 :            : static int runtime_refresh_within(struct cfs_bandwidth *cfs_b, u64 min_expire)
    4751                 :            : {
    4752                 :          0 :         struct hrtimer *refresh_timer = &cfs_b->period_timer;
    4753                 :            :         u64 remaining;
    4754                 :            : 
    4755                 :            :         /* if the call-back is running a quota refresh is already occurring */
    4756                 :          0 :         if (hrtimer_callback_running(refresh_timer))
    4757                 :            :                 return 1;
    4758                 :            : 
    4759                 :            :         /* is a quota refresh about to occur? */
    4760                 :          0 :         remaining = ktime_to_ns(hrtimer_expires_remaining(refresh_timer));
    4761                 :          0 :         if (remaining < min_expire)
    4762                 :            :                 return 1;
    4763                 :            : 
    4764                 :            :         return 0;
    4765                 :            : }
    4766                 :            : 
    4767                 :          0 : static void start_cfs_slack_bandwidth(struct cfs_bandwidth *cfs_b)
    4768                 :            : {
    4769                 :            :         u64 min_left = cfs_bandwidth_slack_period + min_bandwidth_expiration;
    4770                 :            : 
    4771                 :            :         /* if there's a quota refresh soon don't bother with slack */
    4772                 :          0 :         if (runtime_refresh_within(cfs_b, min_left))
    4773                 :            :                 return;
    4774                 :            : 
    4775                 :            :         /* don't push forwards an existing deferred unthrottle */
    4776                 :          0 :         if (cfs_b->slack_started)
    4777                 :            :                 return;
    4778                 :          0 :         cfs_b->slack_started = true;
    4779                 :            : 
    4780                 :          0 :         hrtimer_start(&cfs_b->slack_timer,
    4781                 :            :                         ns_to_ktime(cfs_bandwidth_slack_period),
    4782                 :            :                         HRTIMER_MODE_REL);
    4783                 :            : }
    4784                 :            : 
    4785                 :            : /* we know any runtime found here is valid as update_curr() precedes return */
    4786                 :          0 : static void __return_cfs_rq_runtime(struct cfs_rq *cfs_rq)
    4787                 :            : {
    4788                 :          0 :         struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
    4789                 :          0 :         s64 slack_runtime = cfs_rq->runtime_remaining - min_cfs_rq_runtime;
    4790                 :            : 
    4791                 :          0 :         if (slack_runtime <= 0)
    4792                 :          0 :                 return;
    4793                 :            : 
    4794                 :          0 :         raw_spin_lock(&cfs_b->lock);
    4795                 :          0 :         if (cfs_b->quota != RUNTIME_INF) {
    4796                 :          0 :                 cfs_b->runtime += slack_runtime;
    4797                 :            : 
    4798                 :            :                 /* we are under rq->lock, defer unthrottling using a timer */
    4799                 :          0 :                 if (cfs_b->runtime > sched_cfs_bandwidth_slice() &&
    4800                 :          0 :                     !list_empty(&cfs_b->throttled_cfs_rq))
    4801                 :          0 :                         start_cfs_slack_bandwidth(cfs_b);
    4802                 :            :         }
    4803                 :            :         raw_spin_unlock(&cfs_b->lock);
    4804                 :            : 
    4805                 :            :         /* even if it's not valid for return we don't want to try again */
    4806                 :          0 :         cfs_rq->runtime_remaining -= slack_runtime;
    4807                 :            : }
    4808                 :            : 
    4809                 :            : static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq)
    4810                 :            : {
    4811                 :          3 :         if (!cfs_bandwidth_used())
    4812                 :            :                 return;
    4813                 :            : 
    4814                 :          0 :         if (!cfs_rq->runtime_enabled || cfs_rq->nr_running)
    4815                 :            :                 return;
    4816                 :            : 
    4817                 :          0 :         __return_cfs_rq_runtime(cfs_rq);
    4818                 :            : }
    4819                 :            : 
    4820                 :            : /*
    4821                 :            :  * This is done with a timer (instead of inline with bandwidth return) since
    4822                 :            :  * it's necessary to juggle rq->locks to unthrottle their respective cfs_rqs.
    4823                 :            :  */
    4824                 :          0 : static void do_sched_cfs_slack_timer(struct cfs_bandwidth *cfs_b)
    4825                 :            : {
    4826                 :            :         u64 runtime = 0, slice = sched_cfs_bandwidth_slice();
    4827                 :            :         unsigned long flags;
    4828                 :            : 
    4829                 :            :         /* confirm we're still not at a refresh boundary */
    4830                 :          0 :         raw_spin_lock_irqsave(&cfs_b->lock, flags);
    4831                 :          0 :         cfs_b->slack_started = false;
    4832                 :          0 :         if (cfs_b->distribute_running) {
    4833                 :          0 :                 raw_spin_unlock_irqrestore(&cfs_b->lock, flags);
    4834                 :          0 :                 return;
    4835                 :            :         }
    4836                 :            : 
    4837                 :          0 :         if (runtime_refresh_within(cfs_b, min_bandwidth_expiration)) {
    4838                 :          0 :                 raw_spin_unlock_irqrestore(&cfs_b->lock, flags);
    4839                 :          0 :                 return;
    4840                 :            :         }
    4841                 :            : 
    4842                 :          0 :         if (cfs_b->quota != RUNTIME_INF && cfs_b->runtime > slice)
    4843                 :            :                 runtime = cfs_b->runtime;
    4844                 :            : 
    4845                 :          0 :         if (runtime)
    4846                 :          0 :                 cfs_b->distribute_running = 1;
    4847                 :            : 
    4848                 :          0 :         raw_spin_unlock_irqrestore(&cfs_b->lock, flags);
    4849                 :            : 
    4850                 :          0 :         if (!runtime)
    4851                 :            :                 return;
    4852                 :            : 
    4853                 :          0 :         runtime = distribute_cfs_runtime(cfs_b, runtime);
    4854                 :            : 
    4855                 :          0 :         raw_spin_lock_irqsave(&cfs_b->lock, flags);
    4856                 :          0 :         lsub_positive(&cfs_b->runtime, runtime);
    4857                 :          0 :         cfs_b->distribute_running = 0;
    4858                 :          0 :         raw_spin_unlock_irqrestore(&cfs_b->lock, flags);
    4859                 :            : }
    4860                 :            : 
    4861                 :            : /*
    4862                 :            :  * When a group wakes up we want to make sure that its quota is not already
    4863                 :            :  * expired/exceeded, otherwise it may be allowed to steal additional ticks of
    4864                 :            :  * runtime as update_curr() throttling can not not trigger until it's on-rq.
    4865                 :            :  */
    4866                 :          3 : static void check_enqueue_throttle(struct cfs_rq *cfs_rq)
    4867                 :            : {
    4868                 :          3 :         if (!cfs_bandwidth_used())
    4869                 :            :                 return;
    4870                 :            : 
    4871                 :            :         /* an active group must be handled by the update_curr()->put() path */
    4872                 :          0 :         if (!cfs_rq->runtime_enabled || cfs_rq->curr)
    4873                 :            :                 return;
    4874                 :            : 
    4875                 :            :         /* ensure the group is not already throttled */
    4876                 :          0 :         if (cfs_rq_throttled(cfs_rq))
    4877                 :            :                 return;
    4878                 :            : 
    4879                 :            :         /* update runtime allocation */
    4880                 :            :         account_cfs_rq_runtime(cfs_rq, 0);
    4881                 :          0 :         if (cfs_rq->runtime_remaining <= 0)
    4882                 :          0 :                 throttle_cfs_rq(cfs_rq);
    4883                 :            : }
    4884                 :            : 
    4885                 :          3 : static void sync_throttle(struct task_group *tg, int cpu)
    4886                 :            : {
    4887                 :            :         struct cfs_rq *pcfs_rq, *cfs_rq;
    4888                 :            : 
    4889                 :          3 :         if (!cfs_bandwidth_used())
    4890                 :            :                 return;
    4891                 :            : 
    4892                 :          0 :         if (!tg->parent)
    4893                 :            :                 return;
    4894                 :            : 
    4895                 :          0 :         cfs_rq = tg->cfs_rq[cpu];
    4896                 :          0 :         pcfs_rq = tg->parent->cfs_rq[cpu];
    4897                 :            : 
    4898                 :          0 :         cfs_rq->throttle_count = pcfs_rq->throttle_count;
    4899                 :          0 :         cfs_rq->throttled_clock_task = rq_clock_task(cpu_rq(cpu));
    4900                 :            : }
    4901                 :            : 
    4902                 :            : /* conditionally throttle active cfs_rq's from put_prev_entity() */
    4903                 :          3 : static bool check_cfs_rq_runtime(struct cfs_rq *cfs_rq)
    4904                 :            : {
    4905                 :          3 :         if (!cfs_bandwidth_used())
    4906                 :            :                 return false;
    4907                 :            : 
    4908                 :          0 :         if (likely(!cfs_rq->runtime_enabled || cfs_rq->runtime_remaining > 0))
    4909                 :            :                 return false;
    4910                 :            : 
    4911                 :            :         /*
    4912                 :            :          * it's possible for a throttled entity to be forced into a running
    4913                 :            :          * state (e.g. set_curr_task), in this case we're finished.
    4914                 :            :          */
    4915                 :          0 :         if (cfs_rq_throttled(cfs_rq))
    4916                 :            :                 return true;
    4917                 :            : 
    4918                 :          0 :         throttle_cfs_rq(cfs_rq);
    4919                 :          0 :         return true;
    4920                 :            : }
    4921                 :            : 
    4922                 :          0 : static enum hrtimer_restart sched_cfs_slack_timer(struct hrtimer *timer)
    4923                 :            : {
    4924                 :            :         struct cfs_bandwidth *cfs_b =
    4925                 :          0 :                 container_of(timer, struct cfs_bandwidth, slack_timer);
    4926                 :            : 
    4927                 :          0 :         do_sched_cfs_slack_timer(cfs_b);
    4928                 :            : 
    4929                 :          0 :         return HRTIMER_NORESTART;
    4930                 :            : }
    4931                 :            : 
    4932                 :            : extern const u64 max_cfs_quota_period;
    4933                 :            : 
    4934                 :          0 : static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)
    4935                 :            : {
    4936                 :            :         struct cfs_bandwidth *cfs_b =
    4937                 :          0 :                 container_of(timer, struct cfs_bandwidth, period_timer);
    4938                 :            :         unsigned long flags;
    4939                 :            :         int overrun;
    4940                 :            :         int idle = 0;
    4941                 :            :         int count = 0;
    4942                 :            : 
    4943                 :          0 :         raw_spin_lock_irqsave(&cfs_b->lock, flags);
    4944                 :            :         for (;;) {
    4945                 :          0 :                 overrun = hrtimer_forward_now(timer, cfs_b->period);
    4946                 :          0 :                 if (!overrun)
    4947                 :            :                         break;
    4948                 :            : 
    4949                 :          0 :                 idle = do_sched_cfs_period_timer(cfs_b, overrun, flags);
    4950                 :            : 
    4951                 :          0 :                 if (++count > 3) {
    4952                 :          0 :                         u64 new, old = ktime_to_ns(cfs_b->period);
    4953                 :            : 
    4954                 :            :                         /*
    4955                 :            :                          * Grow period by a factor of 2 to avoid losing precision.
    4956                 :            :                          * Precision loss in the quota/period ratio can cause __cfs_schedulable
    4957                 :            :                          * to fail.
    4958                 :            :                          */
    4959                 :          0 :                         new = old * 2;
    4960                 :          0 :                         if (new < max_cfs_quota_period) {
    4961                 :          0 :                                 cfs_b->period = ns_to_ktime(new);
    4962                 :          0 :                                 cfs_b->quota *= 2;
    4963                 :            : 
    4964                 :          0 :                                 pr_warn_ratelimited(
    4965                 :            :         "cfs_period_timer[cpu%d]: period too short, scaling up (new cfs_period_us = %lld, cfs_quota_us = %lld)\n",
    4966                 :            :                                         smp_processor_id(),
    4967                 :            :                                         div_u64(new, NSEC_PER_USEC),
    4968                 :            :                                         div_u64(cfs_b->quota, NSEC_PER_USEC));
    4969                 :            :                         } else {
    4970                 :          0 :                                 pr_warn_ratelimited(
    4971                 :            :         "cfs_period_timer[cpu%d]: period too short, but cannot scale up without losing precision (cfs_period_us = %lld, cfs_quota_us = %lld)\n",
    4972                 :            :                                         smp_processor_id(),
    4973                 :            :                                         div_u64(old, NSEC_PER_USEC),
    4974                 :            :                                         div_u64(cfs_b->quota, NSEC_PER_USEC));
    4975                 :            :                         }
    4976                 :            : 
    4977                 :            :                         /* reset count so we don't come right back in here */
    4978                 :            :                         count = 0;
    4979                 :            :                 }
    4980                 :            :         }
    4981                 :          0 :         if (idle)
    4982                 :          0 :                 cfs_b->period_active = 0;
    4983                 :          0 :         raw_spin_unlock_irqrestore(&cfs_b->lock, flags);
    4984                 :            : 
    4985                 :          0 :         return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
    4986                 :            : }
    4987                 :            : 
    4988                 :          3 : void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
    4989                 :            : {
    4990                 :          3 :         raw_spin_lock_init(&cfs_b->lock);
    4991                 :          3 :         cfs_b->runtime = 0;
    4992                 :          3 :         cfs_b->quota = RUNTIME_INF;
    4993                 :          3 :         cfs_b->period = ns_to_ktime(default_cfs_period());
    4994                 :            : 
    4995                 :          3 :         INIT_LIST_HEAD(&cfs_b->throttled_cfs_rq);
    4996                 :          3 :         hrtimer_init(&cfs_b->period_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
    4997                 :          3 :         cfs_b->period_timer.function = sched_cfs_period_timer;
    4998                 :          3 :         hrtimer_init(&cfs_b->slack_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
    4999                 :          3 :         cfs_b->slack_timer.function = sched_cfs_slack_timer;
    5000                 :          3 :         cfs_b->distribute_running = 0;
    5001                 :          3 :         cfs_b->slack_started = false;
    5002                 :          3 : }
    5003                 :            : 
    5004                 :            : static void init_cfs_rq_runtime(struct cfs_rq *cfs_rq)
    5005                 :            : {
    5006                 :          3 :         cfs_rq->runtime_enabled = 0;
    5007                 :          3 :         INIT_LIST_HEAD(&cfs_rq->throttled_list);
    5008                 :            : }
    5009                 :            : 
    5010                 :          0 : void start_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
    5011                 :            : {
    5012                 :            :         lockdep_assert_held(&cfs_b->lock);
    5013                 :            : 
    5014                 :          0 :         if (cfs_b->period_active)
    5015                 :          0 :                 return;
    5016                 :            : 
    5017                 :          0 :         cfs_b->period_active = 1;
    5018                 :          0 :         hrtimer_forward_now(&cfs_b->period_timer, cfs_b->period);
    5019                 :          0 :         hrtimer_start_expires(&cfs_b->period_timer, HRTIMER_MODE_ABS_PINNED);
    5020                 :            : }
    5021                 :            : 
    5022                 :          3 : static void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
    5023                 :            : {
    5024                 :            :         /* init_cfs_bandwidth() was not called */
    5025                 :          3 :         if (!cfs_b->throttled_cfs_rq.next)
    5026                 :          3 :                 return;
    5027                 :            : 
    5028                 :          3 :         hrtimer_cancel(&cfs_b->period_timer);
    5029                 :          3 :         hrtimer_cancel(&cfs_b->slack_timer);
    5030                 :            : }
    5031                 :            : 
    5032                 :            : /*
    5033                 :            :  * Both these CPU hotplug callbacks race against unregister_fair_sched_group()
    5034                 :            :  *
    5035                 :            :  * The race is harmless, since modifying bandwidth settings of unhooked group
    5036                 :            :  * bits doesn't do much.
    5037                 :            :  */
    5038                 :            : 
    5039                 :            : /* cpu online calback */
    5040                 :          3 : static void __maybe_unused update_runtime_enabled(struct rq *rq)
    5041                 :            : {
    5042                 :            :         struct task_group *tg;
    5043                 :            : 
    5044                 :            :         lockdep_assert_held(&rq->lock);
    5045                 :            : 
    5046                 :            :         rcu_read_lock();
    5047                 :          3 :         list_for_each_entry_rcu(tg, &task_groups, list) {
    5048                 :            :                 struct cfs_bandwidth *cfs_b = &tg->cfs_bandwidth;
    5049                 :          3 :                 struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
    5050                 :            : 
    5051                 :          3 :                 raw_spin_lock(&cfs_b->lock);
    5052                 :          3 :                 cfs_rq->runtime_enabled = cfs_b->quota != RUNTIME_INF;
    5053                 :            :                 raw_spin_unlock(&cfs_b->lock);
    5054                 :            :         }
    5055                 :            :         rcu_read_unlock();
    5056                 :          3 : }
    5057                 :            : 
    5058                 :            : /* cpu offline callback */
    5059                 :          3 : static void __maybe_unused unthrottle_offline_cfs_rqs(struct rq *rq)
    5060                 :            : {
    5061                 :            :         struct task_group *tg;
    5062                 :            : 
    5063                 :            :         lockdep_assert_held(&rq->lock);
    5064                 :            : 
    5065                 :            :         rcu_read_lock();
    5066                 :          3 :         list_for_each_entry_rcu(tg, &task_groups, list) {
    5067                 :          3 :                 struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
    5068                 :            : 
    5069                 :          3 :                 if (!cfs_rq->runtime_enabled)
    5070                 :          3 :                         continue;
    5071                 :            : 
    5072                 :            :                 /*
    5073                 :            :                  * clock_task is not advancing so we just need to make sure
    5074                 :            :                  * there's some valid quota amount
    5075                 :            :                  */
    5076                 :          0 :                 cfs_rq->runtime_remaining = 1;
    5077                 :            :                 /*
    5078                 :            :                  * Offline rq is schedulable till CPU is completely disabled
    5079                 :            :                  * in take_cpu_down(), so we prevent new cfs throttling here.
    5080                 :            :                  */
    5081                 :          0 :                 cfs_rq->runtime_enabled = 0;
    5082                 :            : 
    5083                 :          0 :                 if (cfs_rq_throttled(cfs_rq))
    5084                 :          0 :                         unthrottle_cfs_rq(cfs_rq);
    5085                 :            :         }
    5086                 :            :         rcu_read_unlock();
    5087                 :          3 : }
    5088                 :            : 
    5089                 :            : #else /* CONFIG_CFS_BANDWIDTH */
    5090                 :            : 
    5091                 :            : static inline bool cfs_bandwidth_used(void)
    5092                 :            : {
    5093                 :            :         return false;
    5094                 :            : }
    5095                 :            : 
    5096                 :            : static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec) {}
    5097                 :            : static bool check_cfs_rq_runtime(struct cfs_rq *cfs_rq) { return false; }
    5098                 :            : static void check_enqueue_throttle(struct cfs_rq *cfs_rq) {}
    5099                 :            : static inline void sync_throttle(struct task_group *tg, int cpu) {}
    5100                 :            : static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
    5101                 :            : 
    5102                 :            : static inline int cfs_rq_throttled(struct cfs_rq *cfs_rq)
    5103                 :            : {
    5104                 :            :         return 0;
    5105                 :            : }
    5106                 :            : 
    5107                 :            : static inline int throttled_hierarchy(struct cfs_rq *cfs_rq)
    5108                 :            : {
    5109                 :            :         return 0;
    5110                 :            : }
    5111                 :            : 
    5112                 :            : static inline int throttled_lb_pair(struct task_group *tg,
    5113                 :            :                                     int src_cpu, int dest_cpu)
    5114                 :            : {
    5115                 :            :         return 0;
    5116                 :            : }
    5117                 :            : 
    5118                 :            : void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b) {}
    5119                 :            : 
    5120                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
    5121                 :            : static void init_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
    5122                 :            : #endif
    5123                 :            : 
    5124                 :            : static inline struct cfs_bandwidth *tg_cfs_bandwidth(struct task_group *tg)
    5125                 :            : {
    5126                 :            :         return NULL;
    5127                 :            : }
    5128                 :            : static inline void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b) {}
    5129                 :            : static inline void update_runtime_enabled(struct rq *rq) {}
    5130                 :            : static inline void unthrottle_offline_cfs_rqs(struct rq *rq) {}
    5131                 :            : 
    5132                 :            : #endif /* CONFIG_CFS_BANDWIDTH */
    5133                 :            : 
    5134                 :            : /**************************************************
    5135                 :            :  * CFS operations on tasks:
    5136                 :            :  */
    5137                 :            : 
    5138                 :            : #ifdef CONFIG_SCHED_HRTICK
    5139                 :          0 : static void hrtick_start_fair(struct rq *rq, struct task_struct *p)
    5140                 :            : {
    5141                 :          0 :         struct sched_entity *se = &p->se;
    5142                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
    5143                 :            : 
    5144                 :          0 :         SCHED_WARN_ON(task_rq(p) != rq);
    5145                 :            : 
    5146                 :          0 :         if (rq->cfs.h_nr_running > 1) {
    5147                 :          0 :                 u64 slice = sched_slice(cfs_rq, se);
    5148                 :          0 :                 u64 ran = se->sum_exec_runtime - se->prev_sum_exec_runtime;
    5149                 :          0 :                 s64 delta = slice - ran;
    5150                 :            : 
    5151                 :          0 :                 if (delta < 0) {
    5152                 :          0 :                         if (rq->curr == p)
    5153                 :          0 :                                 resched_curr(rq);
    5154                 :          0 :                         return;
    5155                 :            :                 }
    5156                 :          0 :                 hrtick_start(rq, delta);
    5157                 :            :         }
    5158                 :            : }
    5159                 :            : 
    5160                 :            : /*
    5161                 :            :  * called from enqueue/dequeue and updates the hrtick when the
    5162                 :            :  * current task is from our class and nr_running is low enough
    5163                 :            :  * to matter.
    5164                 :            :  */
    5165                 :          3 : static void hrtick_update(struct rq *rq)
    5166                 :            : {
    5167                 :          3 :         struct task_struct *curr = rq->curr;
    5168                 :            : 
    5169                 :          3 :         if (!hrtick_enabled(rq) || curr->sched_class != &fair_sched_class)
    5170                 :          3 :                 return;
    5171                 :            : 
    5172                 :          0 :         if (cfs_rq_of(&curr->se)->nr_running < sched_nr_latency)
    5173                 :          0 :                 hrtick_start_fair(rq, curr);
    5174                 :            : }
    5175                 :            : #else /* !CONFIG_SCHED_HRTICK */
    5176                 :            : static inline void
    5177                 :            : hrtick_start_fair(struct rq *rq, struct task_struct *p)
    5178                 :            : {
    5179                 :            : }
    5180                 :            : 
    5181                 :            : static inline void hrtick_update(struct rq *rq)
    5182                 :            : {
    5183                 :            : }
    5184                 :            : #endif
    5185                 :            : 
    5186                 :            : #ifdef CONFIG_SMP
    5187                 :            : static inline unsigned long cpu_util(int cpu);
    5188                 :            : 
    5189                 :          3 : static inline bool cpu_overutilized(int cpu)
    5190                 :            : {
    5191                 :          3 :         return !fits_capacity(cpu_util(cpu), capacity_of(cpu));
    5192                 :            : }
    5193                 :            : 
    5194                 :          3 : static inline void update_overutilized_status(struct rq *rq)
    5195                 :            : {
    5196                 :          3 :         if (!READ_ONCE(rq->rd->overutilized) && cpu_overutilized(rq->cpu)) {
    5197                 :          3 :                 WRITE_ONCE(rq->rd->overutilized, SG_OVERUTILIZED);
    5198                 :          3 :                 trace_sched_overutilized_tp(rq->rd, SG_OVERUTILIZED);
    5199                 :            :         }
    5200                 :          3 : }
    5201                 :            : #else
    5202                 :            : static inline void update_overutilized_status(struct rq *rq) { }
    5203                 :            : #endif
    5204                 :            : 
    5205                 :            : /*
    5206                 :            :  * The enqueue_task method is called before nr_running is
    5207                 :            :  * increased. Here we update the fair scheduling stats and
    5208                 :            :  * then put the task into the rbtree:
    5209                 :            :  */
    5210                 :            : static void
    5211                 :          3 : enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
    5212                 :            : {
    5213                 :            :         struct cfs_rq *cfs_rq;
    5214                 :          3 :         struct sched_entity *se = &p->se;
    5215                 :            :         int idle_h_nr_running = task_has_idle_policy(p);
    5216                 :            : 
    5217                 :            :         /*
    5218                 :            :          * The code below (indirectly) updates schedutil which looks at
    5219                 :            :          * the cfs_rq utilization to select a frequency.
    5220                 :            :          * Let's add the task's estimated utilization to the cfs_rq's
    5221                 :            :          * estimated utilization, before we update schedutil.
    5222                 :            :          */
    5223                 :          3 :         util_est_enqueue(&rq->cfs, p);
    5224                 :            : 
    5225                 :            :         /*
    5226                 :            :          * If in_iowait is set, the code below may not trigger any cpufreq
    5227                 :            :          * utilization updates, so do it here explicitly with the IOWAIT flag
    5228                 :            :          * passed.
    5229                 :            :          */
    5230                 :          3 :         if (p->in_iowait)
    5231                 :          3 :                 cpufreq_update_util(rq, SCHED_CPUFREQ_IOWAIT);
    5232                 :            : 
    5233                 :          3 :         for_each_sched_entity(se) {
    5234                 :          3 :                 if (se->on_rq)
    5235                 :            :                         break;
    5236                 :            :                 cfs_rq = cfs_rq_of(se);
    5237                 :          3 :                 enqueue_entity(cfs_rq, se, flags);
    5238                 :            : 
    5239                 :          3 :                 cfs_rq->h_nr_running++;
    5240                 :          3 :                 cfs_rq->idle_h_nr_running += idle_h_nr_running;
    5241                 :            : 
    5242                 :            :                 /* end evaluation on encountering a throttled cfs_rq */
    5243                 :          3 :                 if (cfs_rq_throttled(cfs_rq))
    5244                 :            :                         goto enqueue_throttle;
    5245                 :            : 
    5246                 :            :                 flags = ENQUEUE_WAKEUP;
    5247                 :            :         }
    5248                 :            : 
    5249                 :          3 :         for_each_sched_entity(se) {
    5250                 :            :                 cfs_rq = cfs_rq_of(se);
    5251                 :            : 
    5252                 :          3 :                 update_load_avg(cfs_rq, se, UPDATE_TG);
    5253                 :          3 :                 update_cfs_group(se);
    5254                 :            : 
    5255                 :          3 :                 cfs_rq->h_nr_running++;
    5256                 :          3 :                 cfs_rq->idle_h_nr_running += idle_h_nr_running;
    5257                 :            : 
    5258                 :            :                 /* end evaluation on encountering a throttled cfs_rq */
    5259                 :          3 :                 if (cfs_rq_throttled(cfs_rq))
    5260                 :            :                         goto enqueue_throttle;
    5261                 :            : 
    5262                 :            :                /*
    5263                 :            :                 * One parent has been throttled and cfs_rq removed from the
    5264                 :            :                 * list. Add it back to not break the leaf list.
    5265                 :            :                 */
    5266                 :          3 :                if (throttled_hierarchy(cfs_rq))
    5267                 :          0 :                        list_add_leaf_cfs_rq(cfs_rq);
    5268                 :            :         }
    5269                 :            : 
    5270                 :            : enqueue_throttle:
    5271                 :          3 :         if (!se) {
    5272                 :            :                 add_nr_running(rq, 1);
    5273                 :            :                 /*
    5274                 :            :                  * Since new tasks are assigned an initial util_avg equal to
    5275                 :            :                  * half of the spare capacity of their CPU, tiny tasks have the
    5276                 :            :                  * ability to cross the overutilized threshold, which will
    5277                 :            :                  * result in the load balancer ruining all the task placement
    5278                 :            :                  * done by EAS. As a way to mitigate that effect, do not account
    5279                 :            :                  * for the first enqueue operation of new tasks during the
    5280                 :            :                  * overutilized flag detection.
    5281                 :            :                  *
    5282                 :            :                  * A better way of solving this problem would be to wait for
    5283                 :            :                  * the PELT signals of tasks to converge before taking them
    5284                 :            :                  * into account, but that is not straightforward to implement,
    5285                 :            :                  * and the following generally works well enough in practice.
    5286                 :            :                  */
    5287                 :          3 :                 if (flags & ENQUEUE_WAKEUP)
    5288                 :          3 :                         update_overutilized_status(rq);
    5289                 :            : 
    5290                 :            :         }
    5291                 :            : 
    5292                 :          3 :         if (cfs_bandwidth_used()) {
    5293                 :            :                 /*
    5294                 :            :                  * When bandwidth control is enabled; the cfs_rq_throttled()
    5295                 :            :                  * breaks in the above iteration can result in incomplete
    5296                 :            :                  * leaf list maintenance, resulting in triggering the assertion
    5297                 :            :                  * below.
    5298                 :            :                  */
    5299                 :          0 :                 for_each_sched_entity(se) {
    5300                 :            :                         cfs_rq = cfs_rq_of(se);
    5301                 :            : 
    5302                 :          0 :                         if (list_add_leaf_cfs_rq(cfs_rq))
    5303                 :            :                                 break;
    5304                 :            :                 }
    5305                 :            :         }
    5306                 :            : 
    5307                 :          3 :         assert_list_leaf_cfs_rq(rq);
    5308                 :            : 
    5309                 :          3 :         hrtick_update(rq);
    5310                 :          3 : }
    5311                 :            : 
    5312                 :            : static void set_next_buddy(struct sched_entity *se);
    5313                 :            : 
    5314                 :            : /*
    5315                 :            :  * The dequeue_task method is called before nr_running is
    5316                 :            :  * decreased. We remove the task from the rbtree and
    5317                 :            :  * update the fair scheduling stats:
    5318                 :            :  */
    5319                 :          3 : static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags)
    5320                 :            : {
    5321                 :            :         struct cfs_rq *cfs_rq;
    5322                 :          3 :         struct sched_entity *se = &p->se;
    5323                 :          3 :         int task_sleep = flags & DEQUEUE_SLEEP;
    5324                 :            :         int idle_h_nr_running = task_has_idle_policy(p);
    5325                 :            : 
    5326                 :          3 :         for_each_sched_entity(se) {
    5327                 :            :                 cfs_rq = cfs_rq_of(se);
    5328                 :          3 :                 dequeue_entity(cfs_rq, se, flags);
    5329                 :            : 
    5330                 :          3 :                 cfs_rq->h_nr_running--;
    5331                 :          3 :                 cfs_rq->idle_h_nr_running -= idle_h_nr_running;
    5332                 :            : 
    5333                 :            :                 /* end evaluation on encountering a throttled cfs_rq */
    5334                 :          3 :                 if (cfs_rq_throttled(cfs_rq))
    5335                 :            :                         goto dequeue_throttle;
    5336                 :            : 
    5337                 :            :                 /* Don't dequeue parent if it has other entities besides us */
    5338                 :          3 :                 if (cfs_rq->load.weight) {
    5339                 :            :                         /* Avoid re-evaluating load for this entity: */
    5340                 :            :                         se = parent_entity(se);
    5341                 :            :                         /*
    5342                 :            :                          * Bias pick_next to pick a task from this cfs_rq, as
    5343                 :            :                          * p is sleeping when it is within its sched_slice.
    5344                 :            :                          */
    5345                 :          3 :                         if (task_sleep && se && !throttled_hierarchy(cfs_rq))
    5346                 :          3 :                                 set_next_buddy(se);
    5347                 :            :                         break;
    5348                 :            :                 }
    5349                 :          3 :                 flags |= DEQUEUE_SLEEP;
    5350                 :            :         }
    5351                 :            : 
    5352                 :          3 :         for_each_sched_entity(se) {
    5353                 :            :                 cfs_rq = cfs_rq_of(se);
    5354                 :            : 
    5355                 :          3 :                 update_load_avg(cfs_rq, se, UPDATE_TG);
    5356                 :          3 :                 update_cfs_group(se);
    5357                 :            : 
    5358                 :          3 :                 cfs_rq->h_nr_running--;
    5359                 :          3 :                 cfs_rq->idle_h_nr_running -= idle_h_nr_running;
    5360                 :            : 
    5361                 :            :                 /* end evaluation on encountering a throttled cfs_rq */
    5362                 :          3 :                 if (cfs_rq_throttled(cfs_rq))
    5363                 :            :                         goto dequeue_throttle;
    5364                 :            : 
    5365                 :            :         }
    5366                 :            : 
    5367                 :            : dequeue_throttle:
    5368                 :          3 :         if (!se)
    5369                 :            :                 sub_nr_running(rq, 1);
    5370                 :            : 
    5371                 :          3 :         util_est_dequeue(&rq->cfs, p, task_sleep);
    5372                 :          3 :         hrtick_update(rq);
    5373                 :          3 : }
    5374                 :            : 
    5375                 :            : #ifdef CONFIG_SMP
    5376                 :            : 
    5377                 :            : /* Working cpumask for: load_balance, load_balance_newidle. */
    5378                 :            : DEFINE_PER_CPU(cpumask_var_t, load_balance_mask);
    5379                 :            : DEFINE_PER_CPU(cpumask_var_t, select_idle_mask);
    5380                 :            : 
    5381                 :            : #ifdef CONFIG_NO_HZ_COMMON
    5382                 :            : 
    5383                 :            : static struct {
    5384                 :            :         cpumask_var_t idle_cpus_mask;
    5385                 :            :         atomic_t nr_cpus;
    5386                 :            :         int has_blocked;                /* Idle CPUS has blocked load */
    5387                 :            :         unsigned long next_balance;     /* in jiffy units */
    5388                 :            :         unsigned long next_blocked;     /* Next update of blocked load in jiffies */
    5389                 :            : } nohz ____cacheline_aligned;
    5390                 :            : 
    5391                 :            : #endif /* CONFIG_NO_HZ_COMMON */
    5392                 :            : 
    5393                 :            : /* CPU only has SCHED_IDLE tasks enqueued */
    5394                 :            : static int sched_idle_cpu(int cpu)
    5395                 :            : {
    5396                 :          3 :         struct rq *rq = cpu_rq(cpu);
    5397                 :            : 
    5398                 :          3 :         return unlikely(rq->nr_running == rq->cfs.idle_h_nr_running &&
    5399                 :            :                         rq->nr_running);
    5400                 :            : }
    5401                 :            : 
    5402                 :            : static unsigned long cpu_runnable_load(struct rq *rq)
    5403                 :            : {
    5404                 :            :         return cfs_rq_runnable_load_avg(&rq->cfs);
    5405                 :            : }
    5406                 :            : 
    5407                 :            : static unsigned long capacity_of(int cpu)
    5408                 :            : {
    5409                 :          3 :         return cpu_rq(cpu)->cpu_capacity;
    5410                 :            : }
    5411                 :            : 
    5412                 :            : static unsigned long cpu_avg_load_per_task(int cpu)
    5413                 :            : {
    5414                 :          3 :         struct rq *rq = cpu_rq(cpu);
    5415                 :            :         unsigned long nr_running = READ_ONCE(rq->cfs.h_nr_running);
    5416                 :            :         unsigned long load_avg = cpu_runnable_load(rq);
    5417                 :            : 
    5418                 :          3 :         if (nr_running)
    5419                 :          3 :                 return load_avg / nr_running;
    5420                 :            : 
    5421                 :            :         return 0;
    5422                 :            : }
    5423                 :            : 
    5424                 :          3 : static void record_wakee(struct task_struct *p)
    5425                 :            : {
    5426                 :            :         /*
    5427                 :            :          * Only decay a single time; tasks that have less then 1 wakeup per
    5428                 :            :          * jiffy will not have built up many flips.
    5429                 :            :          */
    5430                 :          3 :         if (time_after(jiffies, current->wakee_flip_decay_ts + HZ)) {
    5431                 :          0 :                 current->wakee_flips >>= 1;
    5432                 :          0 :                 current->wakee_flip_decay_ts = jiffies;
    5433                 :            :         }
    5434                 :            : 
    5435                 :          3 :         if (current->last_wakee != p) {
    5436                 :          3 :                 current->last_wakee = p;
    5437                 :          3 :                 current->wakee_flips++;
    5438                 :            :         }
    5439                 :          3 : }
    5440                 :            : 
    5441                 :            : /*
    5442                 :            :  * Detect M:N waker/wakee relationships via a switching-frequency heuristic.
    5443                 :            :  *
    5444                 :            :  * A waker of many should wake a different task than the one last awakened
    5445                 :            :  * at a frequency roughly N times higher than one of its wakees.
    5446                 :            :  *
    5447                 :            :  * In order to determine whether we should let the load spread vs consolidating
    5448                 :            :  * to shared cache, we look for a minimum 'flip' frequency of llc_size in one
    5449                 :            :  * partner, and a factor of lls_size higher frequency in the other.
    5450                 :            :  *
    5451                 :            :  * With both conditions met, we can be relatively sure that the relationship is
    5452                 :            :  * non-monogamous, with partner count exceeding socket size.
    5453                 :            :  *
    5454                 :            :  * Waker/wakee being client/server, worker/dispatcher, interrupt source or
    5455                 :            :  * whatever is irrelevant, spread criteria is apparent partner count exceeds
    5456                 :            :  * socket size.
    5457                 :            :  */
    5458                 :          3 : static int wake_wide(struct task_struct *p)
    5459                 :            : {
    5460                 :          3 :         unsigned int master = current->wakee_flips;
    5461                 :          3 :         unsigned int slave = p->wakee_flips;
    5462                 :          3 :         int factor = this_cpu_read(sd_llc_size);
    5463                 :            : 
    5464                 :          3 :         if (master < slave)
    5465                 :            :                 swap(master, slave);
    5466                 :          3 :         if (slave < factor || master < slave * factor)
    5467                 :            :                 return 0;
    5468                 :          3 :         return 1;
    5469                 :            : }
    5470                 :            : 
    5471                 :            : /*
    5472                 :            :  * The purpose of wake_affine() is to quickly determine on which CPU we can run
    5473                 :            :  * soonest. For the purpose of speed we only consider the waking and previous
    5474                 :            :  * CPU.
    5475                 :            :  *
    5476                 :            :  * wake_affine_idle() - only considers 'now', it check if the waking CPU is
    5477                 :            :  *                      cache-affine and is (or will be) idle.
    5478                 :            :  *
    5479                 :            :  * wake_affine_weight() - considers the weight to reflect the average
    5480                 :            :  *                        scheduling latency of the CPUs. This seems to work
    5481                 :            :  *                        for the overloaded case.
    5482                 :            :  */
    5483                 :            : static int
    5484                 :          3 : wake_affine_idle(int this_cpu, int prev_cpu, int sync)
    5485                 :            : {
    5486                 :            :         /*
    5487                 :            :          * If this_cpu is idle, it implies the wakeup is from interrupt
    5488                 :            :          * context. Only allow the move if cache is shared. Otherwise an
    5489                 :            :          * interrupt intensive workload could force all tasks onto one
    5490                 :            :          * node depending on the IO topology or IRQ affinity settings.
    5491                 :            :          *
    5492                 :            :          * If the prev_cpu is idle and cache affine then avoid a migration.
    5493                 :            :          * There is no guarantee that the cache hot data from an interrupt
    5494                 :            :          * is more important than cache hot data on the prev_cpu and from
    5495                 :            :          * a cpufreq perspective, it's better to have higher utilisation
    5496                 :            :          * on one CPU.
    5497                 :            :          */
    5498                 :          3 :         if (available_idle_cpu(this_cpu) && cpus_share_cache(this_cpu, prev_cpu))
    5499                 :          0 :                 return available_idle_cpu(prev_cpu) ? prev_cpu : this_cpu;
    5500                 :            : 
    5501                 :          3 :         if (sync && cpu_rq(this_cpu)->nr_running == 1)
    5502                 :          0 :                 return this_cpu;
    5503                 :            : 
    5504                 :            :         return nr_cpumask_bits;
    5505                 :            : }
    5506                 :            : 
    5507                 :            : static int
    5508                 :          3 : wake_affine_weight(struct sched_domain *sd, struct task_struct *p,
    5509                 :            :                    int this_cpu, int prev_cpu, int sync)
    5510                 :            : {
    5511                 :            :         s64 this_eff_load, prev_eff_load;
    5512                 :            :         unsigned long task_load;
    5513                 :            : 
    5514                 :          3 :         this_eff_load = cpu_runnable_load(cpu_rq(this_cpu));
    5515                 :            : 
    5516                 :          3 :         if (sync) {
    5517                 :          0 :                 unsigned long current_load = task_h_load(current);
    5518                 :            : 
    5519                 :          0 :                 if (current_load > this_eff_load)
    5520                 :            :                         return this_cpu;
    5521                 :            : 
    5522                 :          0 :                 this_eff_load -= current_load;
    5523                 :            :         }
    5524                 :            : 
    5525                 :          3 :         task_load = task_h_load(p);
    5526                 :            : 
    5527                 :          3 :         this_eff_load += task_load;
    5528                 :          3 :         if (sched_feat(WA_BIAS))
    5529                 :          3 :                 this_eff_load *= 100;
    5530                 :          3 :         this_eff_load *= capacity_of(prev_cpu);
    5531                 :            : 
    5532                 :          3 :         prev_eff_load = cpu_runnable_load(cpu_rq(prev_cpu));
    5533                 :          3 :         prev_eff_load -= task_load;
    5534                 :          3 :         if (sched_feat(WA_BIAS))
    5535                 :          3 :                 prev_eff_load *= 100 + (sd->imbalance_pct - 100) / 2;
    5536                 :          3 :         prev_eff_load *= capacity_of(this_cpu);
    5537                 :            : 
    5538                 :            :         /*
    5539                 :            :          * If sync, adjust the weight of prev_eff_load such that if
    5540                 :            :          * prev_eff == this_eff that select_idle_sibling() will consider
    5541                 :            :          * stacking the wakee on top of the waker if no other CPU is
    5542                 :            :          * idle.
    5543                 :            :          */
    5544                 :          3 :         if (sync)
    5545                 :          0 :                 prev_eff_load += 1;
    5546                 :            : 
    5547                 :          3 :         return this_eff_load < prev_eff_load ? this_cpu : nr_cpumask_bits;
    5548                 :            : }
    5549                 :            : 
    5550                 :          3 : static int wake_affine(struct sched_domain *sd, struct task_struct *p,
    5551                 :            :                        int this_cpu, int prev_cpu, int sync)
    5552                 :            : {
    5553                 :            :         int target = nr_cpumask_bits;
    5554                 :            : 
    5555                 :          3 :         if (sched_feat(WA_IDLE))
    5556                 :          3 :                 target = wake_affine_idle(this_cpu, prev_cpu, sync);
    5557                 :            : 
    5558                 :          3 :         if (sched_feat(WA_WEIGHT) && target == nr_cpumask_bits)
    5559                 :          3 :                 target = wake_affine_weight(sd, p, this_cpu, prev_cpu, sync);
    5560                 :            : 
    5561                 :          3 :         schedstat_inc(p->se.statistics.nr_wakeups_affine_attempts);
    5562                 :          3 :         if (target == nr_cpumask_bits)
    5563                 :            :                 return prev_cpu;
    5564                 :            : 
    5565                 :          3 :         schedstat_inc(sd->ttwu_move_affine);
    5566                 :          3 :         schedstat_inc(p->se.statistics.nr_wakeups_affine);
    5567                 :          3 :         return target;
    5568                 :            : }
    5569                 :            : 
    5570                 :            : static unsigned long cpu_util_without(int cpu, struct task_struct *p);
    5571                 :            : 
    5572                 :            : static unsigned long capacity_spare_without(int cpu, struct task_struct *p)
    5573                 :            : {
    5574                 :          3 :         return max_t(long, capacity_of(cpu) - cpu_util_without(cpu, p), 0);
    5575                 :            : }
    5576                 :            : 
    5577                 :            : /*
    5578                 :            :  * find_idlest_group finds and returns the least busy CPU group within the
    5579                 :            :  * domain.
    5580                 :            :  *
    5581                 :            :  * Assumes p is allowed on at least one CPU in sd.
    5582                 :            :  */
    5583                 :            : static struct sched_group *
    5584                 :          3 : find_idlest_group(struct sched_domain *sd, struct task_struct *p,
    5585                 :            :                   int this_cpu, int sd_flag)
    5586                 :            : {
    5587                 :          3 :         struct sched_group *idlest = NULL, *group = sd->groups;
    5588                 :            :         struct sched_group *most_spare_sg = NULL;
    5589                 :            :         unsigned long min_runnable_load = ULONG_MAX;
    5590                 :            :         unsigned long this_runnable_load = ULONG_MAX;
    5591                 :            :         unsigned long min_avg_load = ULONG_MAX, this_avg_load = ULONG_MAX;
    5592                 :            :         unsigned long most_spare = 0, this_spare = 0;
    5593                 :          3 :         int imbalance_scale = 100 + (sd->imbalance_pct-100)/2;
    5594                 :          3 :         unsigned long imbalance = scale_load_down(NICE_0_LOAD) *
    5595                 :            :                                 (sd->imbalance_pct-100) / 100;
    5596                 :            : 
    5597                 :            :         do {
    5598                 :            :                 unsigned long load, avg_load, runnable_load;
    5599                 :            :                 unsigned long spare_cap, max_spare_cap;
    5600                 :            :                 int local_group;
    5601                 :            :                 int i;
    5602                 :            : 
    5603                 :            :                 /* Skip over this group if it has no CPUs allowed */
    5604                 :          3 :                 if (!cpumask_intersects(sched_group_span(group),
    5605                 :          3 :                                         p->cpus_ptr))
    5606                 :          3 :                         continue;
    5607                 :            : 
    5608                 :            :                 local_group = cpumask_test_cpu(this_cpu,
    5609                 :            :                                                sched_group_span(group));
    5610                 :            : 
    5611                 :            :                 /*
    5612                 :            :                  * Tally up the load of all CPUs in the group and find
    5613                 :            :                  * the group containing the CPU with most spare capacity.
    5614                 :            :                  */
    5615                 :            :                 avg_load = 0;
    5616                 :            :                 runnable_load = 0;
    5617                 :            :                 max_spare_cap = 0;
    5618                 :            : 
    5619                 :          3 :                 for_each_cpu(i, sched_group_span(group)) {
    5620                 :          3 :                         load = cpu_runnable_load(cpu_rq(i));
    5621                 :          3 :                         runnable_load += load;
    5622                 :            : 
    5623                 :          3 :                         avg_load += cfs_rq_load_avg(&cpu_rq(i)->cfs);
    5624                 :            : 
    5625                 :            :                         spare_cap = capacity_spare_without(i, p);
    5626                 :            : 
    5627                 :          3 :                         if (spare_cap > max_spare_cap)
    5628                 :            :                                 max_spare_cap = spare_cap;
    5629                 :            :                 }
    5630                 :            : 
    5631                 :            :                 /* Adjust by relative CPU capacity of the group */
    5632                 :          3 :                 avg_load = (avg_load * SCHED_CAPACITY_SCALE) /
    5633                 :          3 :                                         group->sgc->capacity;
    5634                 :          3 :                 runnable_load = (runnable_load * SCHED_CAPACITY_SCALE) /
    5635                 :            :                                         group->sgc->capacity;
    5636                 :            : 
    5637                 :          3 :                 if (local_group) {
    5638                 :            :                         this_runnable_load = runnable_load;
    5639                 :            :                         this_avg_load = avg_load;
    5640                 :          3 :                         this_spare = max_spare_cap;
    5641                 :            :                 } else {
    5642                 :          3 :                         if (min_runnable_load > (runnable_load + imbalance)) {
    5643                 :            :                                 /*
    5644                 :            :                                  * The runnable load is significantly smaller
    5645                 :            :                                  * so we can pick this new CPU:
    5646                 :            :                                  */
    5647                 :            :                                 min_runnable_load = runnable_load;
    5648                 :            :                                 min_avg_load = avg_load;
    5649                 :            :                                 idlest = group;
    5650                 :          3 :                         } else if ((runnable_load < (min_runnable_load + imbalance)) &&
    5651                 :          3 :                                    (100*min_avg_load > imbalance_scale*avg_load)) {
    5652                 :            :                                 /*
    5653                 :            :                                  * The runnable loads are close so take the
    5654                 :            :                                  * blocked load into account through avg_load:
    5655                 :            :                                  */
    5656                 :            :                                 min_avg_load = avg_load;
    5657                 :            :                                 idlest = group;
    5658                 :            :                         }
    5659                 :            : 
    5660                 :          3 :                         if (most_spare < max_spare_cap) {
    5661                 :          3 :                                 most_spare = max_spare_cap;
    5662                 :            :                                 most_spare_sg = group;
    5663                 :            :                         }
    5664                 :            :                 }
    5665                 :          3 :         } while (group = group->next, group != sd->groups);
    5666                 :            : 
    5667                 :            :         /*
    5668                 :            :          * The cross-over point between using spare capacity or least load
    5669                 :            :          * is too conservative for high utilization tasks on partially
    5670                 :            :          * utilized systems if we require spare_capacity > task_util(p),
    5671                 :            :          * so we allow for some task stuffing by using
    5672                 :            :          * spare_capacity > task_util(p)/2.
    5673                 :            :          *
    5674                 :            :          * Spare capacity can't be used for fork because the utilization has
    5675                 :            :          * not been set yet, we must first select a rq to compute the initial
    5676                 :            :          * utilization.
    5677                 :            :          */
    5678                 :          3 :         if (sd_flag & SD_BALANCE_FORK)
    5679                 :            :                 goto skip_spare;
    5680                 :            : 
    5681                 :          3 :         if (this_spare > task_util(p) / 2 &&
    5682                 :          3 :             imbalance_scale*this_spare > 100*most_spare)
    5683                 :            :                 return NULL;
    5684                 :            : 
    5685                 :          3 :         if (most_spare > task_util(p) / 2)
    5686                 :          3 :                 return most_spare_sg;
    5687                 :            : 
    5688                 :            : skip_spare:
    5689                 :          3 :         if (!idlest)
    5690                 :            :                 return NULL;
    5691                 :            : 
    5692                 :            :         /*
    5693                 :            :          * When comparing groups across NUMA domains, it's possible for the
    5694                 :            :          * local domain to be very lightly loaded relative to the remote
    5695                 :            :          * domains but "imbalance" skews the comparison making remote CPUs
    5696                 :            :          * look much more favourable. When considering cross-domain, add
    5697                 :            :          * imbalance to the runnable load on the remote node and consider
    5698                 :            :          * staying local.
    5699                 :            :          */
    5700                 :          3 :         if ((sd->flags & SD_NUMA) &&
    5701                 :          0 :             min_runnable_load + imbalance >= this_runnable_load)
    5702                 :            :                 return NULL;
    5703                 :            : 
    5704                 :          3 :         if (min_runnable_load > (this_runnable_load + imbalance))
    5705                 :            :                 return NULL;
    5706                 :            : 
    5707                 :          3 :         if ((this_runnable_load < (min_runnable_load + imbalance)) &&
    5708                 :          3 :              (100*this_avg_load < imbalance_scale*min_avg_load))
    5709                 :            :                 return NULL;
    5710                 :            : 
    5711                 :          3 :         return idlest;
    5712                 :            : }
    5713                 :            : 
    5714                 :            : /*
    5715                 :            :  * find_idlest_group_cpu - find the idlest CPU among the CPUs in the group.
    5716                 :            :  */
    5717                 :            : static int
    5718                 :          3 : find_idlest_group_cpu(struct sched_group *group, struct task_struct *p, int this_cpu)
    5719                 :            : {
    5720                 :            :         unsigned long load, min_load = ULONG_MAX;
    5721                 :            :         unsigned int min_exit_latency = UINT_MAX;
    5722                 :            :         u64 latest_idle_timestamp = 0;
    5723                 :            :         int least_loaded_cpu = this_cpu;
    5724                 :            :         int shallowest_idle_cpu = -1, si_cpu = -1;
    5725                 :            :         int i;
    5726                 :            : 
    5727                 :            :         /* Check if we have any choice: */
    5728                 :          3 :         if (group->group_weight == 1)
    5729                 :          3 :                 return cpumask_first(sched_group_span(group));
    5730                 :            : 
    5731                 :            :         /* Traverse only the allowed CPUs */
    5732                 :          0 :         for_each_cpu_and(i, sched_group_span(group), p->cpus_ptr) {
    5733                 :          0 :                 if (available_idle_cpu(i)) {
    5734                 :          0 :                         struct rq *rq = cpu_rq(i);
    5735                 :            :                         struct cpuidle_state *idle = idle_get_state(rq);
    5736                 :            :                         if (idle && idle->exit_latency < min_exit_latency) {
    5737                 :            :                                 /*
    5738                 :            :                                  * We give priority to a CPU whose idle state
    5739                 :            :                                  * has the smallest exit latency irrespective
    5740                 :            :                                  * of any idle timestamp.
    5741                 :            :                                  */
    5742                 :            :                                 min_exit_latency = idle->exit_latency;
    5743                 :            :                                 latest_idle_timestamp = rq->idle_stamp;
    5744                 :            :                                 shallowest_idle_cpu = i;
    5745                 :          0 :                         } else if ((!idle || idle->exit_latency == min_exit_latency) &&
    5746                 :          0 :                                    rq->idle_stamp > latest_idle_timestamp) {
    5747                 :            :                                 /*
    5748                 :            :                                  * If equal or no active idle state, then
    5749                 :            :                                  * the most recently idled CPU might have
    5750                 :            :                                  * a warmer cache.
    5751                 :            :                                  */
    5752                 :            :                                 latest_idle_timestamp = rq->idle_stamp;
    5753                 :            :                                 shallowest_idle_cpu = i;
    5754                 :            :                         }
    5755                 :          0 :                 } else if (shallowest_idle_cpu == -1 && si_cpu == -1) {
    5756                 :          0 :                         if (sched_idle_cpu(i)) {
    5757                 :            :                                 si_cpu = i;
    5758                 :          0 :                                 continue;
    5759                 :            :                         }
    5760                 :            : 
    5761                 :          0 :                         load = cpu_runnable_load(cpu_rq(i));
    5762                 :          0 :                         if (load < min_load) {
    5763                 :            :                                 min_load = load;
    5764                 :            :                                 least_loaded_cpu = i;
    5765                 :            :                         }
    5766                 :            :                 }
    5767                 :            :         }
    5768                 :            : 
    5769                 :          0 :         if (shallowest_idle_cpu != -1)
    5770                 :          0 :                 return shallowest_idle_cpu;
    5771                 :          0 :         if (si_cpu != -1)
    5772                 :          0 :                 return si_cpu;
    5773                 :          0 :         return least_loaded_cpu;
    5774                 :            : }
    5775                 :            : 
    5776                 :          3 : static inline int find_idlest_cpu(struct sched_domain *sd, struct task_struct *p,
    5777                 :            :                                   int cpu, int prev_cpu, int sd_flag)
    5778                 :            : {
    5779                 :            :         int new_cpu = cpu;
    5780                 :            : 
    5781                 :          3 :         if (!cpumask_intersects(sched_domain_span(sd), p->cpus_ptr))
    5782                 :            :                 return prev_cpu;
    5783                 :            : 
    5784                 :            :         /*
    5785                 :            :          * We need task's util for capacity_spare_without, sync it up to
    5786                 :            :          * prev_cpu's last_update_time.
    5787                 :            :          */
    5788                 :          3 :         if (!(sd_flag & SD_BALANCE_FORK))
    5789                 :          3 :                 sync_entity_load_avg(&p->se);
    5790                 :            : 
    5791                 :          3 :         while (sd) {
    5792                 :            :                 struct sched_group *group;
    5793                 :            :                 struct sched_domain *tmp;
    5794                 :            :                 int weight;
    5795                 :            : 
    5796                 :          3 :                 if (!(sd->flags & sd_flag)) {
    5797                 :          3 :                         sd = sd->child;
    5798                 :          3 :                         continue;
    5799                 :            :                 }
    5800                 :            : 
    5801                 :          3 :                 group = find_idlest_group(sd, p, cpu, sd_flag);
    5802                 :          3 :                 if (!group) {
    5803                 :          3 :                         sd = sd->child;
    5804                 :          3 :                         continue;
    5805                 :            :                 }
    5806                 :            : 
    5807                 :          3 :                 new_cpu = find_idlest_group_cpu(group, p, cpu);
    5808                 :          3 :                 if (new_cpu == cpu) {
    5809                 :            :                         /* Now try balancing at a lower domain level of 'cpu': */
    5810                 :          0 :                         sd = sd->child;
    5811                 :          0 :                         continue;
    5812                 :            :                 }
    5813                 :            : 
    5814                 :            :                 /* Now try balancing at a lower domain level of 'new_cpu': */
    5815                 :            :                 cpu = new_cpu;
    5816                 :          3 :                 weight = sd->span_weight;
    5817                 :            :                 sd = NULL;
    5818                 :          3 :                 for_each_domain(cpu, tmp) {
    5819                 :          3 :                         if (weight <= tmp->span_weight)
    5820                 :            :                                 break;
    5821                 :          0 :                         if (tmp->flags & sd_flag)
    5822                 :            :                                 sd = tmp;
    5823                 :            :                 }
    5824                 :            :         }
    5825                 :            : 
    5826                 :          3 :         return new_cpu;
    5827                 :            : }
    5828                 :            : 
    5829                 :            : #ifdef CONFIG_SCHED_SMT
    5830                 :            : DEFINE_STATIC_KEY_FALSE(sched_smt_present);
    5831                 :            : EXPORT_SYMBOL_GPL(sched_smt_present);
    5832                 :            : 
    5833                 :            : static inline void set_idle_cores(int cpu, int val)
    5834                 :            : {
    5835                 :            :         struct sched_domain_shared *sds;
    5836                 :            : 
    5837                 :            :         sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
    5838                 :            :         if (sds)
    5839                 :            :                 WRITE_ONCE(sds->has_idle_cores, val);
    5840                 :            : }
    5841                 :            : 
    5842                 :            : static inline bool test_idle_cores(int cpu, bool def)
    5843                 :            : {
    5844                 :            :         struct sched_domain_shared *sds;
    5845                 :            : 
    5846                 :            :         sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
    5847                 :            :         if (sds)
    5848                 :            :                 return READ_ONCE(sds->has_idle_cores);
    5849                 :            : 
    5850                 :            :         return def;
    5851                 :            : }
    5852                 :            : 
    5853                 :            : /*
    5854                 :            :  * Scans the local SMT mask to see if the entire core is idle, and records this
    5855                 :            :  * information in sd_llc_shared->has_idle_cores.
    5856                 :            :  *
    5857                 :            :  * Since SMT siblings share all cache levels, inspecting this limited remote
    5858                 :            :  * state should be fairly cheap.
    5859                 :            :  */
    5860                 :            : void __update_idle_core(struct rq *rq)
    5861                 :            : {
    5862                 :            :         int core = cpu_of(rq);
    5863                 :            :         int cpu;
    5864                 :            : 
    5865                 :            :         rcu_read_lock();
    5866                 :            :         if (test_idle_cores(core, true))
    5867                 :            :                 goto unlock;
    5868                 :            : 
    5869                 :            :         for_each_cpu(cpu, cpu_smt_mask(core)) {
    5870                 :            :                 if (cpu == core)
    5871                 :            :                         continue;
    5872                 :            : 
    5873                 :            :                 if (!available_idle_cpu(cpu))
    5874                 :            :                         goto unlock;
    5875                 :            :         }
    5876                 :            : 
    5877                 :            :         set_idle_cores(core, 1);
    5878                 :            : unlock:
    5879                 :            :         rcu_read_unlock();
    5880                 :            : }
    5881                 :            : 
    5882                 :            : /*
    5883                 :            :  * Scan the entire LLC domain for idle cores; this dynamically switches off if
    5884                 :            :  * there are no idle cores left in the system; tracked through
    5885                 :            :  * sd_llc->shared->has_idle_cores and enabled through update_idle_core() above.
    5886                 :            :  */
    5887                 :            : static int select_idle_core(struct task_struct *p, struct sched_domain *sd, int target)
    5888                 :            : {
    5889                 :            :         struct cpumask *cpus = this_cpu_cpumask_var_ptr(select_idle_mask);
    5890                 :            :         int core, cpu;
    5891                 :            : 
    5892                 :            :         if (!static_branch_likely(&sched_smt_present))
    5893                 :            :                 return -1;
    5894                 :            : 
    5895                 :            :         if (!test_idle_cores(target, false))
    5896                 :            :                 return -1;
    5897                 :            : 
    5898                 :            :         cpumask_and(cpus, sched_domain_span(sd), p->cpus_ptr);
    5899                 :            : 
    5900                 :            :         for_each_cpu_wrap(core, cpus, target) {
    5901                 :            :                 bool idle = true;
    5902                 :            : 
    5903                 :            :                 for_each_cpu(cpu, cpu_smt_mask(core)) {
    5904                 :            :                         __cpumask_clear_cpu(cpu, cpus);
    5905                 :            :                         if (!available_idle_cpu(cpu))
    5906                 :            :                                 idle = false;
    5907                 :            :                 }
    5908                 :            : 
    5909                 :            :                 if (idle)
    5910                 :            :                         return core;
    5911                 :            :         }
    5912                 :            : 
    5913                 :            :         /*
    5914                 :            :          * Failed to find an idle core; stop looking for one.
    5915                 :            :          */
    5916                 :            :         set_idle_cores(target, 0);
    5917                 :            : 
    5918                 :            :         return -1;
    5919                 :            : }
    5920                 :            : 
    5921                 :            : /*
    5922                 :            :  * Scan the local SMT mask for idle CPUs.
    5923                 :            :  */
    5924                 :            : static int select_idle_smt(struct task_struct *p, int target)
    5925                 :            : {
    5926                 :            :         int cpu, si_cpu = -1;
    5927                 :            : 
    5928                 :            :         if (!static_branch_likely(&sched_smt_present))
    5929                 :            :                 return -1;
    5930                 :            : 
    5931                 :            :         for_each_cpu(cpu, cpu_smt_mask(target)) {
    5932                 :            :                 if (!cpumask_test_cpu(cpu, p->cpus_ptr))
    5933                 :            :                         continue;
    5934                 :            :                 if (available_idle_cpu(cpu))
    5935                 :            :                         return cpu;
    5936                 :            :                 if (si_cpu == -1 && sched_idle_cpu(cpu))
    5937                 :            :                         si_cpu = cpu;
    5938                 :            :         }
    5939                 :            : 
    5940                 :            :         return si_cpu;
    5941                 :            : }
    5942                 :            : 
    5943                 :            : #else /* CONFIG_SCHED_SMT */
    5944                 :            : 
    5945                 :            : static inline int select_idle_core(struct task_struct *p, struct sched_domain *sd, int target)
    5946                 :            : {
    5947                 :            :         return -1;
    5948                 :            : }
    5949                 :            : 
    5950                 :            : static inline int select_idle_smt(struct task_struct *p, int target)
    5951                 :            : {
    5952                 :            :         return -1;
    5953                 :            : }
    5954                 :            : 
    5955                 :            : #endif /* CONFIG_SCHED_SMT */
    5956                 :            : 
    5957                 :            : /*
    5958                 :            :  * Scan the LLC domain for idle CPUs; this is dynamically regulated by
    5959                 :            :  * comparing the average scan cost (tracked in sd->avg_scan_cost) against the
    5960                 :            :  * average idle time for this rq (as found in rq->avg_idle).
    5961                 :            :  */
    5962                 :          0 : static int select_idle_cpu(struct task_struct *p, struct sched_domain *sd, int target)
    5963                 :            : {
    5964                 :          0 :         struct cpumask *cpus = this_cpu_cpumask_var_ptr(select_idle_mask);
    5965                 :            :         struct sched_domain *this_sd;
    5966                 :            :         u64 avg_cost, avg_idle;
    5967                 :            :         u64 time, cost;
    5968                 :            :         s64 delta;
    5969                 :            :         int this = smp_processor_id();
    5970                 :            :         int cpu, nr = INT_MAX, si_cpu = -1;
    5971                 :            : 
    5972                 :          0 :         this_sd = rcu_dereference(*this_cpu_ptr(&sd_llc));
    5973                 :          0 :         if (!this_sd)
    5974                 :            :                 return -1;
    5975                 :            : 
    5976                 :            :         /*
    5977                 :            :          * Due to large variance we need a large fuzz factor; hackbench in
    5978                 :            :          * particularly is sensitive here.
    5979                 :            :          */
    5980                 :          0 :         avg_idle = this_rq()->avg_idle / 512;
    5981                 :          0 :         avg_cost = this_sd->avg_scan_cost + 1;
    5982                 :            : 
    5983                 :          0 :         if (sched_feat(SIS_AVG_CPU) && avg_idle < avg_cost)
    5984                 :            :                 return -1;
    5985                 :            : 
    5986                 :          0 :         if (sched_feat(SIS_PROP)) {
    5987                 :          0 :                 u64 span_avg = sd->span_weight * avg_idle;
    5988                 :          0 :                 if (span_avg > 4*avg_cost)
    5989                 :          0 :                         nr = div_u64(span_avg, avg_cost);
    5990                 :            :                 else
    5991                 :            :                         nr = 4;
    5992                 :            :         }
    5993                 :            : 
    5994                 :            :         time = cpu_clock(this);
    5995                 :            : 
    5996                 :          0 :         cpumask_and(cpus, sched_domain_span(sd), p->cpus_ptr);
    5997                 :            : 
    5998                 :          0 :         for_each_cpu_wrap(cpu, cpus, target) {
    5999                 :          0 :                 if (!--nr)
    6000                 :          0 :                         return si_cpu;
    6001                 :          0 :                 if (available_idle_cpu(cpu))
    6002                 :            :                         break;
    6003                 :          0 :                 if (si_cpu == -1 && sched_idle_cpu(cpu))
    6004                 :            :                         si_cpu = cpu;
    6005                 :            :         }
    6006                 :            : 
    6007                 :          0 :         time = cpu_clock(this) - time;
    6008                 :          0 :         cost = this_sd->avg_scan_cost;
    6009                 :          0 :         delta = (s64)(time - cost) / 8;
    6010                 :          0 :         this_sd->avg_scan_cost += delta;
    6011                 :            : 
    6012                 :          0 :         return cpu;
    6013                 :            : }
    6014                 :            : 
    6015                 :            : /*
    6016                 :            :  * Try and locate an idle core/thread in the LLC cache domain.
    6017                 :            :  */
    6018                 :          3 : static int select_idle_sibling(struct task_struct *p, int prev, int target)
    6019                 :            : {
    6020                 :            :         struct sched_domain *sd;
    6021                 :            :         int i, recent_used_cpu;
    6022                 :            : 
    6023                 :          3 :         if (available_idle_cpu(target) || sched_idle_cpu(target))
    6024                 :            :                 return target;
    6025                 :            : 
    6026                 :            :         /*
    6027                 :            :          * If the previous CPU is cache affine and idle, don't be stupid:
    6028                 :            :          */
    6029                 :          3 :         if (prev != target && cpus_share_cache(prev, target) &&
    6030                 :          0 :             (available_idle_cpu(prev) || sched_idle_cpu(prev)))
    6031                 :            :                 return prev;
    6032                 :            : 
    6033                 :            :         /* Check a recently used CPU as a potential idle candidate: */
    6034                 :          3 :         recent_used_cpu = p->recent_used_cpu;
    6035                 :          3 :         if (recent_used_cpu != prev &&
    6036                 :          3 :             recent_used_cpu != target &&
    6037                 :          3 :             cpus_share_cache(recent_used_cpu, target) &&
    6038                 :          0 :             (available_idle_cpu(recent_used_cpu) || sched_idle_cpu(recent_used_cpu)) &&
    6039                 :          0 :             cpumask_test_cpu(p->recent_used_cpu, p->cpus_ptr)) {
    6040                 :            :                 /*
    6041                 :            :                  * Replace recent_used_cpu with prev as it is a potential
    6042                 :            :                  * candidate for the next wake:
    6043                 :            :                  */
    6044                 :          0 :                 p->recent_used_cpu = prev;
    6045                 :          0 :                 return recent_used_cpu;
    6046                 :            :         }
    6047                 :            : 
    6048                 :          3 :         sd = rcu_dereference(per_cpu(sd_llc, target));
    6049                 :          3 :         if (!sd)
    6050                 :            :                 return target;
    6051                 :            : 
    6052                 :            :         i = select_idle_core(p, sd, target);
    6053                 :            :         if ((unsigned)i < nr_cpumask_bits)
    6054                 :            :                 return i;
    6055                 :            : 
    6056                 :          0 :         i = select_idle_cpu(p, sd, target);
    6057                 :          0 :         if ((unsigned)i < nr_cpumask_bits)
    6058                 :            :                 return i;
    6059                 :            : 
    6060                 :            :         i = select_idle_smt(p, target);
    6061                 :            :         if ((unsigned)i < nr_cpumask_bits)
    6062                 :            :                 return i;
    6063                 :            : 
    6064                 :          0 :         return target;
    6065                 :            : }
    6066                 :            : 
    6067                 :            : /**
    6068                 :            :  * Amount of capacity of a CPU that is (estimated to be) used by CFS tasks
    6069                 :            :  * @cpu: the CPU to get the utilization of
    6070                 :            :  *
    6071                 :            :  * The unit of the return value must be the one of capacity so we can compare
    6072                 :            :  * the utilization with the capacity of the CPU that is available for CFS task
    6073                 :            :  * (ie cpu_capacity).
    6074                 :            :  *
    6075                 :            :  * cfs_rq.avg.util_avg is the sum of running time of runnable tasks plus the
    6076                 :            :  * recent utilization of currently non-runnable tasks on a CPU. It represents
    6077                 :            :  * the amount of utilization of a CPU in the range [0..capacity_orig] where
    6078                 :            :  * capacity_orig is the cpu_capacity available at the highest frequency
    6079                 :            :  * (arch_scale_freq_capacity()).
    6080                 :            :  * The utilization of a CPU converges towards a sum equal to or less than the
    6081                 :            :  * current capacity (capacity_curr <= capacity_orig) of the CPU because it is
    6082                 :            :  * the running time on this CPU scaled by capacity_curr.
    6083                 :            :  *
    6084                 :            :  * The estimated utilization of a CPU is defined to be the maximum between its
    6085                 :            :  * cfs_rq.avg.util_avg and the sum of the estimated utilization of the tasks
    6086                 :            :  * currently RUNNABLE on that CPU.
    6087                 :            :  * This allows to properly represent the expected utilization of a CPU which
    6088                 :            :  * has just got a big task running since a long sleep period. At the same time
    6089                 :            :  * however it preserves the benefits of the "blocked utilization" in
    6090                 :            :  * describing the potential for other tasks waking up on the same CPU.
    6091                 :            :  *
    6092                 :            :  * Nevertheless, cfs_rq.avg.util_avg can be higher than capacity_curr or even
    6093                 :            :  * higher than capacity_orig because of unfortunate rounding in
    6094                 :            :  * cfs.avg.util_avg or just after migrating tasks and new task wakeups until
    6095                 :            :  * the average stabilizes with the new running time. We need to check that the
    6096                 :            :  * utilization stays within the range of [0..capacity_orig] and cap it if
    6097                 :            :  * necessary. Without utilization capping, a group could be seen as overloaded
    6098                 :            :  * (CPU0 utilization at 121% + CPU1 utilization at 80%) whereas CPU1 has 20% of
    6099                 :            :  * available capacity. We allow utilization to overshoot capacity_curr (but not
    6100                 :            :  * capacity_orig) as it useful for predicting the capacity required after task
    6101                 :            :  * migrations (scheduler-driven DVFS).
    6102                 :            :  *
    6103                 :            :  * Return: the (estimated) utilization for the specified CPU
    6104                 :            :  */
    6105                 :          3 : static inline unsigned long cpu_util(int cpu)
    6106                 :            : {
    6107                 :            :         struct cfs_rq *cfs_rq;
    6108                 :            :         unsigned int util;
    6109                 :            : 
    6110                 :          3 :         cfs_rq = &cpu_rq(cpu)->cfs;
    6111                 :            :         util = READ_ONCE(cfs_rq->avg.util_avg);
    6112                 :            : 
    6113                 :          3 :         if (sched_feat(UTIL_EST))
    6114                 :          3 :                 util = max(util, READ_ONCE(cfs_rq->avg.util_est.enqueued));
    6115                 :            : 
    6116                 :          3 :         return min_t(unsigned long, util, capacity_orig_of(cpu));
    6117                 :            : }
    6118                 :            : 
    6119                 :            : /*
    6120                 :            :  * cpu_util_without: compute cpu utilization without any contributions from *p
    6121                 :            :  * @cpu: the CPU which utilization is requested
    6122                 :            :  * @p: the task which utilization should be discounted
    6123                 :            :  *
    6124                 :            :  * The utilization of a CPU is defined by the utilization of tasks currently
    6125                 :            :  * enqueued on that CPU as well as tasks which are currently sleeping after an
    6126                 :            :  * execution on that CPU.
    6127                 :            :  *
    6128                 :            :  * This method returns the utilization of the specified CPU by discounting the
    6129                 :            :  * utilization of the specified task, whenever the task is currently
    6130                 :            :  * contributing to the CPU utilization.
    6131                 :            :  */
    6132                 :          3 : static unsigned long cpu_util_without(int cpu, struct task_struct *p)
    6133                 :            : {
    6134                 :            :         struct cfs_rq *cfs_rq;
    6135                 :            :         unsigned int util;
    6136                 :            : 
    6137                 :            :         /* Task has no contribution or is new */
    6138                 :          3 :         if (cpu != task_cpu(p) || !READ_ONCE(p->se.avg.last_update_time))
    6139                 :          3 :                 return cpu_util(cpu);
    6140                 :            : 
    6141                 :          3 :         cfs_rq = &cpu_rq(cpu)->cfs;
    6142                 :            :         util = READ_ONCE(cfs_rq->avg.util_avg);
    6143                 :            : 
    6144                 :            :         /* Discount task's util from CPU's util */
    6145                 :          3 :         lsub_positive(&util, task_util(p));
    6146                 :            : 
    6147                 :            :         /*
    6148                 :            :          * Covered cases:
    6149                 :            :          *
    6150                 :            :          * a) if *p is the only task sleeping on this CPU, then:
    6151                 :            :          *      cpu_util (== task_util) > util_est (== 0)
    6152                 :            :          *    and thus we return:
    6153                 :            :          *      cpu_util_without = (cpu_util - task_util) = 0
    6154                 :            :          *
    6155                 :            :          * b) if other tasks are SLEEPING on this CPU, which is now exiting
    6156                 :            :          *    IDLE, then:
    6157                 :            :          *      cpu_util >= task_util
    6158                 :            :          *      cpu_util > util_est (== 0)
    6159                 :            :          *    and thus we discount *p's blocked utilization to return:
    6160                 :            :          *      cpu_util_without = (cpu_util - task_util) >= 0
    6161                 :            :          *
    6162                 :            :          * c) if other tasks are RUNNABLE on that CPU and
    6163                 :            :          *      util_est > cpu_util
    6164                 :            :          *    then we use util_est since it returns a more restrictive
    6165                 :            :          *    estimation of the spare capacity on that CPU, by just
    6166                 :            :          *    considering the expected utilization of tasks already
    6167                 :            :          *    runnable on that CPU.
    6168                 :            :          *
    6169                 :            :          * Cases a) and b) are covered by the above code, while case c) is
    6170                 :            :          * covered by the following code when estimated utilization is
    6171                 :            :          * enabled.
    6172                 :            :          */
    6173                 :          3 :         if (sched_feat(UTIL_EST)) {
    6174                 :            :                 unsigned int estimated =
    6175                 :            :                         READ_ONCE(cfs_rq->avg.util_est.enqueued);
    6176                 :            : 
    6177                 :            :                 /*
    6178                 :            :                  * Despite the following checks we still have a small window
    6179                 :            :                  * for a possible race, when an execl's select_task_rq_fair()
    6180                 :            :                  * races with LB's detach_task():
    6181                 :            :                  *
    6182                 :            :                  *   detach_task()
    6183                 :            :                  *     p->on_rq = TASK_ON_RQ_MIGRATING;
    6184                 :            :                  *     ---------------------------------- A
    6185                 :            :                  *     deactivate_task()                   \
    6186                 :            :                  *       dequeue_task()                     + RaceTime
    6187                 :            :                  *         util_est_dequeue()              /
    6188                 :            :                  *     ---------------------------------- B
    6189                 :            :                  *
    6190                 :            :                  * The additional check on "current == p" it's required to
    6191                 :            :                  * properly fix the execl regression and it helps in further
    6192                 :            :                  * reducing the chances for the above race.
    6193                 :            :                  */
    6194                 :          3 :                 if (unlikely(task_on_rq_queued(p) || current == p))
    6195                 :          3 :                         lsub_positive(&estimated, _task_util_est(p));
    6196                 :            : 
    6197                 :          3 :                 util = max(util, estimated);
    6198                 :            :         }
    6199                 :            : 
    6200                 :            :         /*
    6201                 :            :          * Utilization (estimated) can exceed the CPU capacity, thus let's
    6202                 :            :          * clamp to the maximum CPU capacity to ensure consistency with
    6203                 :            :          * the cpu_util call.
    6204                 :            :          */
    6205                 :          3 :         return min_t(unsigned long, util, capacity_orig_of(cpu));
    6206                 :            : }
    6207                 :            : 
    6208                 :            : /*
    6209                 :            :  * Disable WAKE_AFFINE in the case where task @p doesn't fit in the
    6210                 :            :  * capacity of either the waking CPU @cpu or the previous CPU @prev_cpu.
    6211                 :            :  *
    6212                 :            :  * In that case WAKE_AFFINE doesn't make sense and we'll let
    6213                 :            :  * BALANCE_WAKE sort things out.
    6214                 :            :  */
    6215                 :          3 : static int wake_cap(struct task_struct *p, int cpu, int prev_cpu)
    6216                 :            : {
    6217                 :            :         long min_cap, max_cap;
    6218                 :            : 
    6219                 :          3 :         if (!static_branch_unlikely(&sched_asym_cpucapacity))
    6220                 :            :                 return 0;
    6221                 :            : 
    6222                 :          0 :         min_cap = min(capacity_orig_of(prev_cpu), capacity_orig_of(cpu));
    6223                 :          0 :         max_cap = cpu_rq(cpu)->rd->max_cpu_capacity;
    6224                 :            : 
    6225                 :            :         /* Minimum capacity is close to max, no need to abort wake_affine */
    6226                 :          0 :         if (max_cap - min_cap < max_cap >> 3)
    6227                 :            :                 return 0;
    6228                 :            : 
    6229                 :            :         /* Bring task utilization in sync with prev_cpu */
    6230                 :          0 :         sync_entity_load_avg(&p->se);
    6231                 :            : 
    6232                 :          0 :         return !task_fits_capacity(p, min_cap);
    6233                 :            : }
    6234                 :            : 
    6235                 :            : /*
    6236                 :            :  * Predicts what cpu_util(@cpu) would return if @p was migrated (and enqueued)
    6237                 :            :  * to @dst_cpu.
    6238                 :            :  */
    6239                 :            : static unsigned long cpu_util_next(int cpu, struct task_struct *p, int dst_cpu)
    6240                 :            : {
    6241                 :            :         struct cfs_rq *cfs_rq = &cpu_rq(cpu)->cfs;
    6242                 :            :         unsigned long util_est, util = READ_ONCE(cfs_rq->avg.util_avg);
    6243                 :            : 
    6244                 :            :         /*
    6245                 :            :          * If @p migrates from @cpu to another, remove its contribution. Or,
    6246                 :            :          * if @p migrates from another CPU to @cpu, add its contribution. In
    6247                 :            :          * the other cases, @cpu is not impacted by the migration, so the
    6248                 :            :          * util_avg should already be correct.
    6249                 :            :          */
    6250                 :            :         if (task_cpu(p) == cpu && dst_cpu != cpu)
    6251                 :            :                 sub_positive(&util, task_util(p));
    6252                 :            :         else if (task_cpu(p) != cpu && dst_cpu == cpu)
    6253                 :            :                 util += task_util(p);
    6254                 :            : 
    6255                 :            :         if (sched_feat(UTIL_EST)) {
    6256                 :            :                 util_est = READ_ONCE(cfs_rq->avg.util_est.enqueued);
    6257                 :            : 
    6258                 :            :                 /*
    6259                 :            :                  * During wake-up, the task isn't enqueued yet and doesn't
    6260                 :            :                  * appear in the cfs_rq->avg.util_est.enqueued of any rq,
    6261                 :            :                  * so just add it (if needed) to "simulate" what will be
    6262                 :            :                  * cpu_util() after the task has been enqueued.
    6263                 :            :                  */
    6264                 :            :                 if (dst_cpu == cpu)
    6265                 :            :                         util_est += _task_util_est(p);
    6266                 :            : 
    6267                 :            :                 util = max(util, util_est);
    6268                 :            :         }
    6269                 :            : 
    6270                 :            :         return min(util, capacity_orig_of(cpu));
    6271                 :            : }
    6272                 :            : 
    6273                 :            : /*
    6274                 :            :  * compute_energy(): Estimates the energy that @pd would consume if @p was
    6275                 :            :  * migrated to @dst_cpu. compute_energy() predicts what will be the utilization
    6276                 :            :  * landscape of @pd's CPUs after the task migration, and uses the Energy Model
    6277                 :            :  * to compute what would be the energy if we decided to actually migrate that
    6278                 :            :  * task.
    6279                 :            :  */
    6280                 :            : static long
    6281                 :            : compute_energy(struct task_struct *p, int dst_cpu, struct perf_domain *pd)
    6282                 :            : {
    6283                 :            :         struct cpumask *pd_mask = perf_domain_span(pd);
    6284                 :            :         unsigned long cpu_cap = arch_scale_cpu_capacity(cpumask_first(pd_mask));
    6285                 :            :         unsigned long max_util = 0, sum_util = 0;
    6286                 :            :         int cpu;
    6287                 :            : 
    6288                 :            :         /*
    6289                 :            :          * The capacity state of CPUs of the current rd can be driven by CPUs
    6290                 :            :          * of another rd if they belong to the same pd. So, account for the
    6291                 :            :          * utilization of these CPUs too by masking pd with cpu_online_mask
    6292                 :            :          * instead of the rd span.
    6293                 :            :          *
    6294                 :            :          * If an entire pd is outside of the current rd, it will not appear in
    6295                 :            :          * its pd list and will not be accounted by compute_energy().
    6296                 :            :          */
    6297                 :            :         for_each_cpu_and(cpu, pd_mask, cpu_online_mask) {
    6298                 :            :                 unsigned long cpu_util, util_cfs = cpu_util_next(cpu, p, dst_cpu);
    6299                 :            :                 struct task_struct *tsk = cpu == dst_cpu ? p : NULL;
    6300                 :            : 
    6301                 :            :                 /*
    6302                 :            :                  * Busy time computation: utilization clamping is not
    6303                 :            :                  * required since the ratio (sum_util / cpu_capacity)
    6304                 :            :                  * is already enough to scale the EM reported power
    6305                 :            :                  * consumption at the (eventually clamped) cpu_capacity.
    6306                 :            :                  */
    6307                 :            :                 sum_util += schedutil_cpu_util(cpu, util_cfs, cpu_cap,
    6308                 :            :                                                ENERGY_UTIL, NULL);
    6309                 :            : 
    6310                 :            :                 /*
    6311                 :            :                  * Performance domain frequency: utilization clamping
    6312                 :            :                  * must be considered since it affects the selection
    6313                 :            :                  * of the performance domain frequency.
    6314                 :            :                  * NOTE: in case RT tasks are running, by default the
    6315                 :            :                  * FREQUENCY_UTIL's utilization can be max OPP.
    6316                 :            :                  */
    6317                 :            :                 cpu_util = schedutil_cpu_util(cpu, util_cfs, cpu_cap,
    6318                 :            :                                               FREQUENCY_UTIL, tsk);
    6319                 :            :                 max_util = max(max_util, cpu_util);
    6320                 :            :         }
    6321                 :            : 
    6322                 :            :         return em_pd_energy(pd->em_pd, max_util, sum_util);
    6323                 :            : }
    6324                 :            : 
    6325                 :            : /*
    6326                 :            :  * find_energy_efficient_cpu(): Find most energy-efficient target CPU for the
    6327                 :            :  * waking task. find_energy_efficient_cpu() looks for the CPU with maximum
    6328                 :            :  * spare capacity in each performance domain and uses it as a potential
    6329                 :            :  * candidate to execute the task. Then, it uses the Energy Model to figure
    6330                 :            :  * out which of the CPU candidates is the most energy-efficient.
    6331                 :            :  *
    6332                 :            :  * The rationale for this heuristic is as follows. In a performance domain,
    6333                 :            :  * all the most energy efficient CPU candidates (according to the Energy
    6334                 :            :  * Model) are those for which we'll request a low frequency. When there are
    6335                 :            :  * several CPUs for which the frequency request will be the same, we don't
    6336                 :            :  * have enough data to break the tie between them, because the Energy Model
    6337                 :            :  * only includes active power costs. With this model, if we assume that
    6338                 :            :  * frequency requests follow utilization (e.g. using schedutil), the CPU with
    6339                 :            :  * the maximum spare capacity in a performance domain is guaranteed to be among
    6340                 :            :  * the best candidates of the performance domain.
    6341                 :            :  *
    6342                 :            :  * In practice, it could be preferable from an energy standpoint to pack
    6343                 :            :  * small tasks on a CPU in order to let other CPUs go in deeper idle states,
    6344                 :            :  * but that could also hurt our chances to go cluster idle, and we have no
    6345                 :            :  * ways to tell with the current Energy Model if this is actually a good
    6346                 :            :  * idea or not. So, find_energy_efficient_cpu() basically favors
    6347                 :            :  * cluster-packing, and spreading inside a cluster. That should at least be
    6348                 :            :  * a good thing for latency, and this is consistent with the idea that most
    6349                 :            :  * of the energy savings of EAS come from the asymmetry of the system, and
    6350                 :            :  * not so much from breaking the tie between identical CPUs. That's also the
    6351                 :            :  * reason why EAS is enabled in the topology code only for systems where
    6352                 :            :  * SD_ASYM_CPUCAPACITY is set.
    6353                 :            :  *
    6354                 :            :  * NOTE: Forkees are not accepted in the energy-aware wake-up path because
    6355                 :            :  * they don't have any useful utilization data yet and it's not possible to
    6356                 :            :  * forecast their impact on energy consumption. Consequently, they will be
    6357                 :            :  * placed by find_idlest_cpu() on the least loaded CPU, which might turn out
    6358                 :            :  * to be energy-inefficient in some use-cases. The alternative would be to
    6359                 :            :  * bias new tasks towards specific types of CPUs first, or to try to infer
    6360                 :            :  * their util_avg from the parent task, but those heuristics could hurt
    6361                 :            :  * other use-cases too. So, until someone finds a better way to solve this,
    6362                 :            :  * let's keep things simple by re-using the existing slow path.
    6363                 :            :  */
    6364                 :            : static int find_energy_efficient_cpu(struct task_struct *p, int prev_cpu)
    6365                 :            : {
    6366                 :            :         unsigned long prev_delta = ULONG_MAX, best_delta = ULONG_MAX;
    6367                 :            :         struct root_domain *rd = cpu_rq(smp_processor_id())->rd;
    6368                 :            :         unsigned long cpu_cap, util, base_energy = 0;
    6369                 :            :         int cpu, best_energy_cpu = prev_cpu;
    6370                 :            :         struct sched_domain *sd;
    6371                 :            :         struct perf_domain *pd;
    6372                 :            : 
    6373                 :            :         rcu_read_lock();
    6374                 :            :         pd = rcu_dereference(rd->pd);
    6375                 :            :         if (!pd || READ_ONCE(rd->overutilized))
    6376                 :            :                 goto fail;
    6377                 :            : 
    6378                 :            :         /*
    6379                 :            :          * Energy-aware wake-up happens on the lowest sched_domain starting
    6380                 :            :          * from sd_asym_cpucapacity spanning over this_cpu and prev_cpu.
    6381                 :            :          */
    6382                 :            :         sd = rcu_dereference(*this_cpu_ptr(&sd_asym_cpucapacity));
    6383                 :            :         while (sd && !cpumask_test_cpu(prev_cpu, sched_domain_span(sd)))
    6384                 :            :                 sd = sd->parent;
    6385                 :            :         if (!sd)
    6386                 :            :                 goto fail;
    6387                 :            : 
    6388                 :            :         sync_entity_load_avg(&p->se);
    6389                 :            :         if (!task_util_est(p))
    6390                 :            :                 goto unlock;
    6391                 :            : 
    6392                 :            :         for (; pd; pd = pd->next) {
    6393                 :            :                 unsigned long cur_delta, spare_cap, max_spare_cap = 0;
    6394                 :            :                 unsigned long base_energy_pd;
    6395                 :            :                 int max_spare_cap_cpu = -1;
    6396                 :            : 
    6397                 :            :                 /* Compute the 'base' energy of the pd, without @p */
    6398                 :            :                 base_energy_pd = compute_energy(p, -1, pd);
    6399                 :            :                 base_energy += base_energy_pd;
    6400                 :            : 
    6401                 :            :                 for_each_cpu_and(cpu, perf_domain_span(pd), sched_domain_span(sd)) {
    6402                 :            :                         if (!cpumask_test_cpu(cpu, p->cpus_ptr))
    6403                 :            :                                 continue;
    6404                 :            : 
    6405                 :            :                         /* Skip CPUs that will be overutilized. */
    6406                 :            :                         util = cpu_util_next(cpu, p, cpu);
    6407                 :            :                         cpu_cap = capacity_of(cpu);
    6408                 :            :                         if (!fits_capacity(util, cpu_cap))
    6409                 :            :                                 continue;
    6410                 :            : 
    6411                 :            :                         /* Always use prev_cpu as a candidate. */
    6412                 :            :                         if (cpu == prev_cpu) {
    6413                 :            :                                 prev_delta = compute_energy(p, prev_cpu, pd);
    6414                 :            :                                 prev_delta -= base_energy_pd;
    6415                 :            :                                 best_delta = min(best_delta, prev_delta);
    6416                 :            :                         }
    6417                 :            : 
    6418                 :            :                         /*
    6419                 :            :                          * Find the CPU with the maximum spare capacity in
    6420                 :            :                          * the performance domain
    6421                 :            :                          */
    6422                 :            :                         spare_cap = cpu_cap - util;
    6423                 :            :                         if (spare_cap > max_spare_cap) {
    6424                 :            :                                 max_spare_cap = spare_cap;
    6425                 :            :                                 max_spare_cap_cpu = cpu;
    6426                 :            :                         }
    6427                 :            :                 }
    6428                 :            : 
    6429                 :            :                 /* Evaluate the energy impact of using this CPU. */
    6430                 :            :                 if (max_spare_cap_cpu >= 0 && max_spare_cap_cpu != prev_cpu) {
    6431                 :            :                         cur_delta = compute_energy(p, max_spare_cap_cpu, pd);
    6432                 :            :                         cur_delta -= base_energy_pd;
    6433                 :            :                         if (cur_delta < best_delta) {
    6434                 :            :                                 best_delta = cur_delta;
    6435                 :            :                                 best_energy_cpu = max_spare_cap_cpu;
    6436                 :            :                         }
    6437                 :            :                 }
    6438                 :            :         }
    6439                 :            : unlock:
    6440                 :            :         rcu_read_unlock();
    6441                 :            : 
    6442                 :            :         /*
    6443                 :            :          * Pick the best CPU if prev_cpu cannot be used, or if it saves at
    6444                 :            :          * least 6% of the energy used by prev_cpu.
    6445                 :            :          */
    6446                 :            :         if (prev_delta == ULONG_MAX)
    6447                 :            :                 return best_energy_cpu;
    6448                 :            : 
    6449                 :            :         if ((prev_delta - best_delta) > ((prev_delta + base_energy) >> 4))
    6450                 :            :                 return best_energy_cpu;
    6451                 :            : 
    6452                 :            :         return prev_cpu;
    6453                 :            : 
    6454                 :            : fail:
    6455                 :            :         rcu_read_unlock();
    6456                 :            : 
    6457                 :            :         return -1;
    6458                 :            : }
    6459                 :            : 
    6460                 :            : /*
    6461                 :            :  * select_task_rq_fair: Select target runqueue for the waking task in domains
    6462                 :            :  * that have the 'sd_flag' flag set. In practice, this is SD_BALANCE_WAKE,
    6463                 :            :  * SD_BALANCE_FORK, or SD_BALANCE_EXEC.
    6464                 :            :  *
    6465                 :            :  * Balances load by selecting the idlest CPU in the idlest group, or under
    6466                 :            :  * certain conditions an idle sibling CPU if the domain has SD_WAKE_AFFINE set.
    6467                 :            :  *
    6468                 :            :  * Returns the target CPU number.
    6469                 :            :  *
    6470                 :            :  * preempt must be disabled.
    6471                 :            :  */
    6472                 :            : static int
    6473                 :          3 : select_task_rq_fair(struct task_struct *p, int prev_cpu, int sd_flag, int wake_flags)
    6474                 :            : {
    6475                 :            :         struct sched_domain *tmp, *sd = NULL;
    6476                 :          3 :         int cpu = smp_processor_id();
    6477                 :            :         int new_cpu = prev_cpu;
    6478                 :            :         int want_affine = 0;
    6479                 :          3 :         int sync = (wake_flags & WF_SYNC) && !(current->flags & PF_EXITING);
    6480                 :            : 
    6481                 :          3 :         if (sd_flag & SD_BALANCE_WAKE) {
    6482                 :          3 :                 record_wakee(p);
    6483                 :            : 
    6484                 :            :                 if (sched_energy_enabled()) {
    6485                 :            :                         new_cpu = find_energy_efficient_cpu(p, prev_cpu);
    6486                 :            :                         if (new_cpu >= 0)
    6487                 :            :                                 return new_cpu;
    6488                 :            :                         new_cpu = prev_cpu;
    6489                 :            :                 }
    6490                 :            : 
    6491                 :          3 :                 want_affine = !wake_wide(p) && !wake_cap(p, cpu, prev_cpu) &&
    6492                 :          3 :                               cpumask_test_cpu(cpu, p->cpus_ptr);
    6493                 :            :         }
    6494                 :            : 
    6495                 :            :         rcu_read_lock();
    6496                 :          3 :         for_each_domain(cpu, tmp) {
    6497                 :          3 :                 if (!(tmp->flags & SD_LOAD_BALANCE))
    6498                 :            :                         break;
    6499                 :            : 
    6500                 :            :                 /*
    6501                 :            :                  * If both 'cpu' and 'prev_cpu' are part of this domain,
    6502                 :            :                  * cpu is a valid SD_WAKE_AFFINE target.
    6503                 :            :                  */
    6504                 :          3 :                 if (want_affine && (tmp->flags & SD_WAKE_AFFINE) &&
    6505                 :            :                     cpumask_test_cpu(prev_cpu, sched_domain_span(tmp))) {
    6506                 :          3 :                         if (cpu != prev_cpu)
    6507                 :          3 :                                 new_cpu = wake_affine(tmp, p, cpu, prev_cpu, sync);
    6508                 :            : 
    6509                 :            :                         sd = NULL; /* Prefer wake_affine over balance flags */
    6510                 :            :                         break;
    6511                 :            :                 }
    6512                 :            : 
    6513                 :          3 :                 if (tmp->flags & sd_flag)
    6514                 :            :                         sd = tmp;
    6515                 :          3 :                 else if (!want_affine)
    6516                 :            :                         break;
    6517                 :            :         }
    6518                 :            : 
    6519                 :          3 :         if (unlikely(sd)) {
    6520                 :            :                 /* Slow path */
    6521                 :          3 :                 new_cpu = find_idlest_cpu(sd, p, cpu, prev_cpu, sd_flag);
    6522                 :          3 :         } else if (sd_flag & SD_BALANCE_WAKE) { /* XXX always ? */
    6523                 :            :                 /* Fast path */
    6524                 :            : 
    6525                 :          3 :                 new_cpu = select_idle_sibling(p, prev_cpu, new_cpu);
    6526                 :            : 
    6527                 :          3 :                 if (want_affine)
    6528                 :          3 :                         current->recent_used_cpu = cpu;
    6529                 :            :         }
    6530                 :            :         rcu_read_unlock();
    6531                 :            : 
    6532                 :            :         return new_cpu;
    6533                 :            : }
    6534                 :            : 
    6535                 :            : static void detach_entity_cfs_rq(struct sched_entity *se);
    6536                 :            : 
    6537                 :            : /*
    6538                 :            :  * Called immediately before a task is migrated to a new CPU; task_cpu(p) and
    6539                 :            :  * cfs_rq_of(p) references at time of call are still valid and identify the
    6540                 :            :  * previous CPU. The caller guarantees p->pi_lock or task_rq(p)->lock is held.
    6541                 :            :  */
    6542                 :          3 : static void migrate_task_rq_fair(struct task_struct *p, int new_cpu)
    6543                 :            : {
    6544                 :            :         /*
    6545                 :            :          * As blocked tasks retain absolute vruntime the migration needs to
    6546                 :            :          * deal with this by subtracting the old and adding the new
    6547                 :            :          * min_vruntime -- the latter is done by enqueue_entity() when placing
    6548                 :            :          * the task on the new runqueue.
    6549                 :            :          */
    6550                 :          3 :         if (p->state == TASK_WAKING) {
    6551                 :            :                 struct sched_entity *se = &p->se;
    6552                 :            :                 struct cfs_rq *cfs_rq = cfs_rq_of(se);
    6553                 :            :                 u64 min_vruntime;
    6554                 :            : 
    6555                 :            : #ifndef CONFIG_64BIT
    6556                 :            :                 u64 min_vruntime_copy;
    6557                 :            : 
    6558                 :            :                 do {
    6559                 :          3 :                         min_vruntime_copy = cfs_rq->min_vruntime_copy;
    6560                 :          3 :                         smp_rmb();
    6561                 :          3 :                         min_vruntime = cfs_rq->min_vruntime;
    6562                 :          3 :                 } while (min_vruntime != min_vruntime_copy);
    6563                 :            : #else
    6564                 :            :                 min_vruntime = cfs_rq->min_vruntime;
    6565                 :            : #endif
    6566                 :            : 
    6567                 :          3 :                 se->vruntime -= min_vruntime;
    6568                 :            :         }
    6569                 :            : 
    6570                 :          3 :         if (p->on_rq == TASK_ON_RQ_MIGRATING) {
    6571                 :            :                 /*
    6572                 :            :                  * In case of TASK_ON_RQ_MIGRATING we in fact hold the 'old'
    6573                 :            :                  * rq->lock and can modify state directly.
    6574                 :            :                  */
    6575                 :          3 :                 lockdep_assert_held(&task_rq(p)->lock);
    6576                 :          3 :                 detach_entity_cfs_rq(&p->se);
    6577                 :            : 
    6578                 :            :         } else {
    6579                 :            :                 /*
    6580                 :            :                  * We are supposed to update the task to "current" time, then
    6581                 :            :                  * its up to date and ready to go to new CPU/cfs_rq. But we
    6582                 :            :                  * have difficulty in getting what current time is, so simply
    6583                 :            :                  * throw away the out-of-date time. This will result in the
    6584                 :            :                  * wakee task is less decayed, but giving the wakee more load
    6585                 :            :                  * sounds not bad.
    6586                 :            :                  */
    6587                 :          3 :                 remove_entity_load_avg(&p->se);
    6588                 :            :         }
    6589                 :            : 
    6590                 :            :         /* Tell new CPU we are migrated */
    6591                 :          3 :         p->se.avg.last_update_time = 0;
    6592                 :            : 
    6593                 :            :         /* We have migrated, no longer consider this task hot */
    6594                 :          3 :         p->se.exec_start = 0;
    6595                 :            : 
    6596                 :            :         update_scan_period(p, new_cpu);
    6597                 :          3 : }
    6598                 :            : 
    6599                 :          3 : static void task_dead_fair(struct task_struct *p)
    6600                 :            : {
    6601                 :          3 :         remove_entity_load_avg(&p->se);
    6602                 :          3 : }
    6603                 :            : 
    6604                 :            : static int
    6605                 :          3 : balance_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf)
    6606                 :            : {
    6607                 :          3 :         if (rq->nr_running)
    6608                 :            :                 return 1;
    6609                 :            : 
    6610                 :          3 :         return newidle_balance(rq, rf) != 0;
    6611                 :            : }
    6612                 :            : #endif /* CONFIG_SMP */
    6613                 :            : 
    6614                 :          3 : static unsigned long wakeup_gran(struct sched_entity *se)
    6615                 :            : {
    6616                 :          3 :         unsigned long gran = sysctl_sched_wakeup_granularity;
    6617                 :            : 
    6618                 :            :         /*
    6619                 :            :          * Since its curr running now, convert the gran from real-time
    6620                 :            :          * to virtual-time in his units.
    6621                 :            :          *
    6622                 :            :          * By using 'se' instead of 'curr' we penalize light tasks, so
    6623                 :            :          * they get preempted easier. That is, if 'se' < 'curr' then
    6624                 :            :          * the resulting gran will be larger, therefore penalizing the
    6625                 :            :          * lighter, if otoh 'se' > 'curr' then the resulting gran will
    6626                 :            :          * be smaller, again penalizing the lighter task.
    6627                 :            :          *
    6628                 :            :          * This is especially important for buddies when the leftmost
    6629                 :            :          * task is higher priority than the buddy.
    6630                 :            :          */
    6631                 :          3 :         return calc_delta_fair(gran, se);
    6632                 :            : }
    6633                 :            : 
    6634                 :            : /*
    6635                 :            :  * Should 'se' preempt 'curr'.
    6636                 :            :  *
    6637                 :            :  *             |s1
    6638                 :            :  *        |s2
    6639                 :            :  *   |s3
    6640                 :            :  *         g
    6641                 :            :  *      |<--->|c
    6642                 :            :  *
    6643                 :            :  *  w(c, s1) = -1
    6644                 :            :  *  w(c, s2) =  0
    6645                 :            :  *  w(c, s3) =  1
    6646                 :            :  *
    6647                 :            :  */
    6648                 :            : static int
    6649                 :          3 : wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
    6650                 :            : {
    6651                 :          3 :         s64 gran, vdiff = curr->vruntime - se->vruntime;
    6652                 :            : 
    6653                 :          3 :         if (vdiff <= 0)
    6654                 :            :                 return -1;
    6655                 :            : 
    6656                 :          3 :         gran = wakeup_gran(se);
    6657                 :          3 :         if (vdiff > gran)
    6658                 :            :                 return 1;
    6659                 :            : 
    6660                 :          3 :         return 0;
    6661                 :            : }
    6662                 :            : 
    6663                 :          3 : static void set_last_buddy(struct sched_entity *se)
    6664                 :            : {
    6665                 :          3 :         if (entity_is_task(se) && unlikely(task_has_idle_policy(task_of(se))))
    6666                 :            :                 return;
    6667                 :            : 
    6668                 :          3 :         for_each_sched_entity(se) {
    6669                 :          3 :                 if (SCHED_WARN_ON(!se->on_rq))
    6670                 :            :                         return;
    6671                 :          3 :                 cfs_rq_of(se)->last = se;
    6672                 :            :         }
    6673                 :            : }
    6674                 :            : 
    6675                 :          3 : static void set_next_buddy(struct sched_entity *se)
    6676                 :            : {
    6677                 :          3 :         if (entity_is_task(se) && unlikely(task_has_idle_policy(task_of(se))))
    6678                 :            :                 return;
    6679                 :            : 
    6680                 :          3 :         for_each_sched_entity(se) {
    6681                 :          3 :                 if (SCHED_WARN_ON(!se->on_rq))
    6682                 :            :                         return;
    6683                 :          3 :                 cfs_rq_of(se)->next = se;
    6684                 :            :         }
    6685                 :            : }
    6686                 :            : 
    6687                 :            : static void set_skip_buddy(struct sched_entity *se)
    6688                 :            : {
    6689                 :          0 :         for_each_sched_entity(se)
    6690                 :          0 :                 cfs_rq_of(se)->skip = se;
    6691                 :            : }
    6692                 :            : 
    6693                 :            : /*
    6694                 :            :  * Preempt the current task with a newly woken task if needed:
    6695                 :            :  */
    6696                 :          3 : static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
    6697                 :            : {
    6698                 :          3 :         struct task_struct *curr = rq->curr;
    6699                 :          3 :         struct sched_entity *se = &curr->se, *pse = &p->se;
    6700                 :            :         struct cfs_rq *cfs_rq = task_cfs_rq(curr);
    6701                 :          3 :         int scale = cfs_rq->nr_running >= sched_nr_latency;
    6702                 :            :         int next_buddy_marked = 0;
    6703                 :            : 
    6704                 :          3 :         if (unlikely(se == pse))
    6705                 :          3 :                 return;
    6706                 :            : 
    6707                 :            :         /*
    6708                 :            :          * This is possible from callers such as attach_tasks(), in which we
    6709                 :            :          * unconditionally check_prempt_curr() after an enqueue (which may have
    6710                 :            :          * lead to a throttle).  This both saves work and prevents false
    6711                 :            :          * next-buddy nomination below.
    6712                 :            :          */
    6713                 :          3 :         if (unlikely(throttled_hierarchy(cfs_rq_of(pse))))
    6714                 :            :                 return;
    6715                 :            : 
    6716                 :          3 :         if (sched_feat(NEXT_BUDDY) && scale && !(wake_flags & WF_FORK)) {
    6717                 :          0 :                 set_next_buddy(pse);
    6718                 :            :                 next_buddy_marked = 1;
    6719                 :            :         }
    6720                 :            : 
    6721                 :            :         /*
    6722                 :            :          * We can come here with TIF_NEED_RESCHED already set from new task
    6723                 :            :          * wake up path.
    6724                 :            :          *
    6725                 :            :          * Note: this also catches the edge-case of curr being in a throttled
    6726                 :            :          * group (e.g. via set_curr_task), since update_curr() (in the
    6727                 :            :          * enqueue of curr) will have resulted in resched being set.  This
    6728                 :            :          * prevents us from potentially nominating it as a false LAST_BUDDY
    6729                 :            :          * below.
    6730                 :            :          */
    6731                 :          3 :         if (test_tsk_need_resched(curr))
    6732                 :            :                 return;
    6733                 :            : 
    6734                 :            :         /* Idle tasks are by definition preempted by non-idle tasks. */
    6735                 :          3 :         if (unlikely(task_has_idle_policy(curr)) &&
    6736                 :          0 :             likely(!task_has_idle_policy(p)))
    6737                 :            :                 goto preempt;
    6738                 :            : 
    6739                 :            :         /*
    6740                 :            :          * Batch and idle tasks do not preempt non-idle tasks (their preemption
    6741                 :            :          * is driven by the tick):
    6742                 :            :          */
    6743                 :          3 :         if (unlikely(p->policy != SCHED_NORMAL) || !sched_feat(WAKEUP_PREEMPTION))
    6744                 :            :                 return;
    6745                 :            : 
    6746                 :          3 :         find_matching_se(&se, &pse);
    6747                 :          3 :         update_curr(cfs_rq_of(se));
    6748                 :          3 :         BUG_ON(!pse);
    6749                 :          3 :         if (wakeup_preempt_entity(se, pse) == 1) {
    6750                 :            :                 /*
    6751                 :            :                  * Bias pick_next to pick the sched entity that is
    6752                 :            :                  * triggering this preemption.
    6753                 :            :                  */
    6754                 :          3 :                 if (!next_buddy_marked)
    6755                 :          3 :                         set_next_buddy(pse);
    6756                 :            :                 goto preempt;
    6757                 :            :         }
    6758                 :            : 
    6759                 :            :         return;
    6760                 :            : 
    6761                 :            : preempt:
    6762                 :          3 :         resched_curr(rq);
    6763                 :            :         /*
    6764                 :            :          * Only set the backward buddy when the current task is still
    6765                 :            :          * on the rq. This can happen when a wakeup gets interleaved
    6766                 :            :          * with schedule on the ->pre_schedule() or idle_balance()
    6767                 :            :          * point, either of which can * drop the rq lock.
    6768                 :            :          *
    6769                 :            :          * Also, during early boot the idle thread is in the fair class,
    6770                 :            :          * for obvious reasons its a bad idea to schedule back to it.
    6771                 :            :          */
    6772                 :          3 :         if (unlikely(!se->on_rq || curr == rq->idle))
    6773                 :            :                 return;
    6774                 :            : 
    6775                 :          3 :         if (sched_feat(LAST_BUDDY) && scale && entity_is_task(se))
    6776                 :          3 :                 set_last_buddy(se);
    6777                 :            : }
    6778                 :            : 
    6779                 :            : static struct task_struct *
    6780                 :          3 : pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf)
    6781                 :            : {
    6782                 :          3 :         struct cfs_rq *cfs_rq = &rq->cfs;
    6783                 :            :         struct sched_entity *se;
    6784                 :            :         struct task_struct *p;
    6785                 :            :         int new_tasks;
    6786                 :            : 
    6787                 :            : again:
    6788                 :          3 :         if (!sched_fair_runnable(rq))
    6789                 :            :                 goto idle;
    6790                 :            : 
    6791                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
    6792                 :          3 :         if (!prev || prev->sched_class != &fair_sched_class)
    6793                 :            :                 goto simple;
    6794                 :            : 
    6795                 :            :         /*
    6796                 :            :          * Because of the set_next_buddy() in dequeue_task_fair() it is rather
    6797                 :            :          * likely that a next task is from the same cgroup as the current.
    6798                 :            :          *
    6799                 :            :          * Therefore attempt to avoid putting and setting the entire cgroup
    6800                 :            :          * hierarchy, only change the part that actually changes.
    6801                 :            :          */
    6802                 :            : 
    6803                 :            :         do {
    6804                 :          3 :                 struct sched_entity *curr = cfs_rq->curr;
    6805                 :            : 
    6806                 :            :                 /*
    6807                 :            :                  * Since we got here without doing put_prev_entity() we also
    6808                 :            :                  * have to consider cfs_rq->curr. If it is still a runnable
    6809                 :            :                  * entity, update_curr() will update its vruntime, otherwise
    6810                 :            :                  * forget we've ever seen it.
    6811                 :            :                  */
    6812                 :          3 :                 if (curr) {
    6813                 :          3 :                         if (curr->on_rq)
    6814                 :          3 :                                 update_curr(cfs_rq);
    6815                 :            :                         else
    6816                 :            :                                 curr = NULL;
    6817                 :            : 
    6818                 :            :                         /*
    6819                 :            :                          * This call to check_cfs_rq_runtime() will do the
    6820                 :            :                          * throttle and dequeue its entity in the parent(s).
    6821                 :            :                          * Therefore the nr_running test will indeed
    6822                 :            :                          * be correct.
    6823                 :            :                          */
    6824                 :          3 :                         if (unlikely(check_cfs_rq_runtime(cfs_rq))) {
    6825                 :            :                                 cfs_rq = &rq->cfs;
    6826                 :            : 
    6827                 :          0 :                                 if (!cfs_rq->nr_running)
    6828                 :            :                                         goto idle;
    6829                 :            : 
    6830                 :            :                                 goto simple;
    6831                 :            :                         }
    6832                 :            :                 }
    6833                 :            : 
    6834                 :          3 :                 se = pick_next_entity(cfs_rq, curr);
    6835                 :            :                 cfs_rq = group_cfs_rq(se);
    6836                 :          3 :         } while (cfs_rq);
    6837                 :            : 
    6838                 :          3 :         p = task_of(se);
    6839                 :            : 
    6840                 :            :         /*
    6841                 :            :          * Since we haven't yet done put_prev_entity and if the selected task
    6842                 :            :          * is a different task than we started out with, try and touch the
    6843                 :            :          * least amount of cfs_rqs.
    6844                 :            :          */
    6845                 :          3 :         if (prev != p) {
    6846                 :          3 :                 struct sched_entity *pse = &prev->se;
    6847                 :            : 
    6848                 :          3 :                 while (!(cfs_rq = is_same_group(se, pse))) {
    6849                 :          3 :                         int se_depth = se->depth;
    6850                 :          3 :                         int pse_depth = pse->depth;
    6851                 :            : 
    6852                 :          3 :                         if (se_depth <= pse_depth) {
    6853                 :          3 :                                 put_prev_entity(cfs_rq_of(pse), pse);
    6854                 :            :                                 pse = parent_entity(pse);
    6855                 :            :                         }
    6856                 :          3 :                         if (se_depth >= pse_depth) {
    6857                 :          3 :                                 set_next_entity(cfs_rq_of(se), se);
    6858                 :            :                                 se = parent_entity(se);
    6859                 :            :                         }
    6860                 :            :                 }
    6861                 :            : 
    6862                 :          3 :                 put_prev_entity(cfs_rq, pse);
    6863                 :          3 :                 set_next_entity(cfs_rq, se);
    6864                 :            :         }
    6865                 :            : 
    6866                 :            :         goto done;
    6867                 :            : simple:
    6868                 :            : #endif
    6869                 :          3 :         if (prev)
    6870                 :          3 :                 put_prev_task(rq, prev);
    6871                 :            : 
    6872                 :            :         do {
    6873                 :          3 :                 se = pick_next_entity(cfs_rq, NULL);
    6874                 :          3 :                 set_next_entity(cfs_rq, se);
    6875                 :            :                 cfs_rq = group_cfs_rq(se);
    6876                 :          3 :         } while (cfs_rq);
    6877                 :            : 
    6878                 :          3 :         p = task_of(se);
    6879                 :            : 
    6880                 :            : done: __maybe_unused;
    6881                 :            : #ifdef CONFIG_SMP
    6882                 :            :         /*
    6883                 :            :          * Move the next running task to the front of
    6884                 :            :          * the list, so our cfs_tasks list becomes MRU
    6885                 :            :          * one.
    6886                 :            :          */
    6887                 :          3 :         list_move(&p->se.group_node, &rq->cfs_tasks);
    6888                 :            : #endif
    6889                 :            : 
    6890                 :          3 :         if (hrtick_enabled(rq))
    6891                 :          0 :                 hrtick_start_fair(rq, p);
    6892                 :            : 
    6893                 :          3 :         update_misfit_status(p, rq);
    6894                 :            : 
    6895                 :          3 :         return p;
    6896                 :            : 
    6897                 :            : idle:
    6898                 :          3 :         if (!rf)
    6899                 :            :                 return NULL;
    6900                 :            : 
    6901                 :          3 :         new_tasks = newidle_balance(rq, rf);
    6902                 :            : 
    6903                 :            :         /*
    6904                 :            :          * Because newidle_balance() releases (and re-acquires) rq->lock, it is
    6905                 :            :          * possible for any higher priority task to appear. In that case we
    6906                 :            :          * must re-start the pick_next_entity() loop.
    6907                 :            :          */
    6908                 :          3 :         if (new_tasks < 0)
    6909                 :            :                 return RETRY_TASK;
    6910                 :            : 
    6911                 :          3 :         if (new_tasks > 0)
    6912                 :            :                 goto again;
    6913                 :            : 
    6914                 :            :         /*
    6915                 :            :          * rq is about to be idle, check if we need to update the
    6916                 :            :          * lost_idle_time of clock_pelt
    6917                 :            :          */
    6918                 :          3 :         update_idle_rq_clock_pelt(rq);
    6919                 :            : 
    6920                 :          3 :         return NULL;
    6921                 :            : }
    6922                 :            : 
    6923                 :            : /*
    6924                 :            :  * Account for a descheduled task:
    6925                 :            :  */
    6926                 :          3 : static void put_prev_task_fair(struct rq *rq, struct task_struct *prev)
    6927                 :            : {
    6928                 :          3 :         struct sched_entity *se = &prev->se;
    6929                 :            :         struct cfs_rq *cfs_rq;
    6930                 :            : 
    6931                 :          3 :         for_each_sched_entity(se) {
    6932                 :            :                 cfs_rq = cfs_rq_of(se);
    6933                 :          3 :                 put_prev_entity(cfs_rq, se);
    6934                 :            :         }
    6935                 :          3 : }
    6936                 :            : 
    6937                 :            : /*
    6938                 :            :  * sched_yield() is very simple
    6939                 :            :  *
    6940                 :            :  * The magic of dealing with the ->skip buddy is in pick_next_entity.
    6941                 :            :  */
    6942                 :          0 : static void yield_task_fair(struct rq *rq)
    6943                 :            : {
    6944                 :          0 :         struct task_struct *curr = rq->curr;
    6945                 :            :         struct cfs_rq *cfs_rq = task_cfs_rq(curr);
    6946                 :          0 :         struct sched_entity *se = &curr->se;
    6947                 :            : 
    6948                 :            :         /*
    6949                 :            :          * Are we the only task in the tree?
    6950                 :            :          */
    6951                 :          0 :         if (unlikely(rq->nr_running == 1))
    6952                 :          0 :                 return;
    6953                 :            : 
    6954                 :          0 :         clear_buddies(cfs_rq, se);
    6955                 :            : 
    6956                 :          0 :         if (curr->policy != SCHED_BATCH) {
    6957                 :          0 :                 update_rq_clock(rq);
    6958                 :            :                 /*
    6959                 :            :                  * Update run-time statistics of the 'current'.
    6960                 :            :                  */
    6961                 :          0 :                 update_curr(cfs_rq);
    6962                 :            :                 /*
    6963                 :            :                  * Tell update_rq_clock() that we've just updated,
    6964                 :            :                  * so we don't do microscopic update in schedule()
    6965                 :            :                  * and double the fastpath cost.
    6966                 :            :                  */
    6967                 :            :                 rq_clock_skip_update(rq);
    6968                 :            :         }
    6969                 :            : 
    6970                 :            :         set_skip_buddy(se);
    6971                 :            : }
    6972                 :            : 
    6973                 :          0 : static bool yield_to_task_fair(struct rq *rq, struct task_struct *p, bool preempt)
    6974                 :            : {
    6975                 :          0 :         struct sched_entity *se = &p->se;
    6976                 :            : 
    6977                 :            :         /* throttled hierarchies are not runnable */
    6978                 :          0 :         if (!se->on_rq || throttled_hierarchy(cfs_rq_of(se)))
    6979                 :            :                 return false;
    6980                 :            : 
    6981                 :            :         /* Tell the scheduler that we'd really like pse to run next. */
    6982                 :          0 :         set_next_buddy(se);
    6983                 :            : 
    6984                 :          0 :         yield_task_fair(rq);
    6985                 :            : 
    6986                 :          0 :         return true;
    6987                 :            : }
    6988                 :            : 
    6989                 :            : #ifdef CONFIG_SMP
    6990                 :            : /**************************************************
    6991                 :            :  * Fair scheduling class load-balancing methods.
    6992                 :            :  *
    6993                 :            :  * BASICS
    6994                 :            :  *
    6995                 :            :  * The purpose of load-balancing is to achieve the same basic fairness the
    6996                 :            :  * per-CPU scheduler provides, namely provide a proportional amount of compute
    6997                 :            :  * time to each task. This is expressed in the following equation:
    6998                 :            :  *
    6999                 :            :  *   W_i,n/P_i == W_j,n/P_j for all i,j                               (1)
    7000                 :            :  *
    7001                 :            :  * Where W_i,n is the n-th weight average for CPU i. The instantaneous weight
    7002                 :            :  * W_i,0 is defined as:
    7003                 :            :  *
    7004                 :            :  *   W_i,0 = \Sum_j w_i,j                                             (2)
    7005                 :            :  *
    7006                 :            :  * Where w_i,j is the weight of the j-th runnable task on CPU i. This weight
    7007                 :            :  * is derived from the nice value as per sched_prio_to_weight[].
    7008                 :            :  *
    7009                 :            :  * The weight average is an exponential decay average of the instantaneous
    7010                 :            :  * weight:
    7011                 :            :  *
    7012                 :            :  *   W'_i,n = (2^n - 1) / 2^n * W_i,n + 1 / 2^n * W_i,0               (3)
    7013                 :            :  *
    7014                 :            :  * C_i is the compute capacity of CPU i, typically it is the
    7015                 :            :  * fraction of 'recent' time available for SCHED_OTHER task execution. But it
    7016                 :            :  * can also include other factors [XXX].
    7017                 :            :  *
    7018                 :            :  * To achieve this balance we define a measure of imbalance which follows
    7019                 :            :  * directly from (1):
    7020                 :            :  *
    7021                 :            :  *   imb_i,j = max{ avg(W/C), W_i/C_i } - min{ avg(W/C), W_j/C_j }    (4)
    7022                 :            :  *
    7023                 :            :  * We them move tasks around to minimize the imbalance. In the continuous
    7024                 :            :  * function space it is obvious this converges, in the discrete case we get
    7025                 :            :  * a few fun cases generally called infeasible weight scenarios.
    7026                 :            :  *
    7027                 :            :  * [XXX expand on:
    7028                 :            :  *     - infeasible weights;
    7029                 :            :  *     - local vs global optima in the discrete case. ]
    7030                 :            :  *
    7031                 :            :  *
    7032                 :            :  * SCHED DOMAINS
    7033                 :            :  *
    7034                 :            :  * In order to solve the imbalance equation (4), and avoid the obvious O(n^2)
    7035                 :            :  * for all i,j solution, we create a tree of CPUs that follows the hardware
    7036                 :            :  * topology where each level pairs two lower groups (or better). This results
    7037                 :            :  * in O(log n) layers. Furthermore we reduce the number of CPUs going up the
    7038                 :            :  * tree to only the first of the previous level and we decrease the frequency
    7039                 :            :  * of load-balance at each level inv. proportional to the number of CPUs in
    7040                 :            :  * the groups.
    7041                 :            :  *
    7042                 :            :  * This yields:
    7043                 :            :  *
    7044                 :            :  *     log_2 n     1     n
    7045                 :            :  *   \Sum       { --- * --- * 2^i } = O(n)                            (5)
    7046                 :            :  *     i = 0      2^i   2^i
    7047                 :            :  *                               `- size of each group
    7048                 :            :  *         |         |     `- number of CPUs doing load-balance
    7049                 :            :  *         |         `- freq
    7050                 :            :  *         `- sum over all levels
    7051                 :            :  *
    7052                 :            :  * Coupled with a limit on how many tasks we can migrate every balance pass,
    7053                 :            :  * this makes (5) the runtime complexity of the balancer.
    7054                 :            :  *
    7055                 :            :  * An important property here is that each CPU is still (indirectly) connected
    7056                 :            :  * to every other CPU in at most O(log n) steps:
    7057                 :            :  *
    7058                 :            :  * The adjacency matrix of the resulting graph is given by:
    7059                 :            :  *
    7060                 :            :  *             log_2 n
    7061                 :            :  *   A_i,j = \Union     (i % 2^k == 0) && i / 2^(k+1) == j / 2^(k+1)  (6)
    7062                 :            :  *             k = 0
    7063                 :            :  *
    7064                 :            :  * And you'll find that:
    7065                 :            :  *
    7066                 :            :  *   A^(log_2 n)_i,j != 0  for all i,j                                (7)
    7067                 :            :  *
    7068                 :            :  * Showing there's indeed a path between every CPU in at most O(log n) steps.
    7069                 :            :  * The task movement gives a factor of O(m), giving a convergence complexity
    7070                 :            :  * of:
    7071                 :            :  *
    7072                 :            :  *   O(nm log n),  n := nr_cpus, m := nr_tasks                        (8)
    7073                 :            :  *
    7074                 :            :  *
    7075                 :            :  * WORK CONSERVING
    7076                 :            :  *
    7077                 :            :  * In order to avoid CPUs going idle while there's still work to do, new idle
    7078                 :            :  * balancing is more aggressive and has the newly idle CPU iterate up the domain
    7079                 :            :  * tree itself instead of relying on other CPUs to bring it work.
    7080                 :            :  *
    7081                 :            :  * This adds some complexity to both (5) and (8) but it reduces the total idle
    7082                 :            :  * time.
    7083                 :            :  *
    7084                 :            :  * [XXX more?]
    7085                 :            :  *
    7086                 :            :  *
    7087                 :            :  * CGROUPS
    7088                 :            :  *
    7089                 :            :  * Cgroups make a horror show out of (2), instead of a simple sum we get:
    7090                 :            :  *
    7091                 :            :  *                                s_k,i
    7092                 :            :  *   W_i,0 = \Sum_j \Prod_k w_k * -----                               (9)
    7093                 :            :  *                                 S_k
    7094                 :            :  *
    7095                 :            :  * Where
    7096                 :            :  *
    7097                 :            :  *   s_k,i = \Sum_j w_i,j,k  and  S_k = \Sum_i s_k,i                 (10)
    7098                 :            :  *
    7099                 :            :  * w_i,j,k is the weight of the j-th runnable task in the k-th cgroup on CPU i.
    7100                 :            :  *
    7101                 :            :  * The big problem is S_k, its a global sum needed to compute a local (W_i)
    7102                 :            :  * property.
    7103                 :            :  *
    7104                 :            :  * [XXX write more on how we solve this.. _after_ merging pjt's patches that
    7105                 :            :  *      rewrite all of this once again.]
    7106                 :            :  */
    7107                 :            : 
    7108                 :            : static unsigned long __read_mostly max_load_balance_interval = HZ/10;
    7109                 :            : 
    7110                 :            : enum fbq_type { regular, remote, all };
    7111                 :            : 
    7112                 :            : enum group_type {
    7113                 :            :         group_other = 0,
    7114                 :            :         group_misfit_task,
    7115                 :            :         group_imbalanced,
    7116                 :            :         group_overloaded,
    7117                 :            : };
    7118                 :            : 
    7119                 :            : #define LBF_ALL_PINNED  0x01
    7120                 :            : #define LBF_NEED_BREAK  0x02
    7121                 :            : #define LBF_DST_PINNED  0x04
    7122                 :            : #define LBF_SOME_PINNED 0x08
    7123                 :            : #define LBF_NOHZ_STATS  0x10
    7124                 :            : #define LBF_NOHZ_AGAIN  0x20
    7125                 :            : 
    7126                 :            : struct lb_env {
    7127                 :            :         struct sched_domain     *sd;
    7128                 :            : 
    7129                 :            :         struct rq               *src_rq;
    7130                 :            :         int                     src_cpu;
    7131                 :            : 
    7132                 :            :         int                     dst_cpu;
    7133                 :            :         struct rq               *dst_rq;
    7134                 :            : 
    7135                 :            :         struct cpumask          *dst_grpmask;
    7136                 :            :         int                     new_dst_cpu;
    7137                 :            :         enum cpu_idle_type      idle;
    7138                 :            :         long                    imbalance;
    7139                 :            :         /* The set of CPUs under consideration for load-balancing */
    7140                 :            :         struct cpumask          *cpus;
    7141                 :            : 
    7142                 :            :         unsigned int            flags;
    7143                 :            : 
    7144                 :            :         unsigned int            loop;
    7145                 :            :         unsigned int            loop_break;
    7146                 :            :         unsigned int            loop_max;
    7147                 :            : 
    7148                 :            :         enum fbq_type           fbq_type;
    7149                 :            :         enum group_type         src_grp_type;
    7150                 :            :         struct list_head        tasks;
    7151                 :            : };
    7152                 :            : 
    7153                 :            : /*
    7154                 :            :  * Is this task likely cache-hot:
    7155                 :            :  */
    7156                 :          3 : static int task_hot(struct task_struct *p, struct lb_env *env)
    7157                 :            : {
    7158                 :            :         s64 delta;
    7159                 :            : 
    7160                 :            :         lockdep_assert_held(&env->src_rq->lock);
    7161                 :            : 
    7162                 :          3 :         if (p->sched_class != &fair_sched_class)
    7163                 :            :                 return 0;
    7164                 :            : 
    7165                 :          3 :         if (unlikely(task_has_idle_policy(p)))
    7166                 :            :                 return 0;
    7167                 :            : 
    7168                 :            :         /*
    7169                 :            :          * Buddy candidates are cache hot:
    7170                 :            :          */
    7171                 :          3 :         if (sched_feat(CACHE_HOT_BUDDY) && env->dst_rq->nr_running &&
    7172                 :          3 :                         (&p->se == cfs_rq_of(&p->se)->next ||
    7173                 :          3 :                          &p->se == cfs_rq_of(&p->se)->last))
    7174                 :            :                 return 1;
    7175                 :            : 
    7176                 :          3 :         if (sysctl_sched_migration_cost == -1)
    7177                 :            :                 return 1;
    7178                 :          3 :         if (sysctl_sched_migration_cost == 0)
    7179                 :            :                 return 0;
    7180                 :            : 
    7181                 :          3 :         delta = rq_clock_task(env->src_rq) - p->se.exec_start;
    7182                 :            : 
    7183                 :          3 :         return delta < (s64)sysctl_sched_migration_cost;
    7184                 :            : }
    7185                 :            : 
    7186                 :            : #ifdef CONFIG_NUMA_BALANCING
    7187                 :            : /*
    7188                 :            :  * Returns 1, if task migration degrades locality
    7189                 :            :  * Returns 0, if task migration improves locality i.e migration preferred.
    7190                 :            :  * Returns -1, if task migration is not affected by locality.
    7191                 :            :  */
    7192                 :            : static int migrate_degrades_locality(struct task_struct *p, struct lb_env *env)
    7193                 :            : {
    7194                 :            :         struct numa_group *numa_group = rcu_dereference(p->numa_group);
    7195                 :            :         unsigned long src_weight, dst_weight;
    7196                 :            :         int src_nid, dst_nid, dist;
    7197                 :            : 
    7198                 :            :         if (!static_branch_likely(&sched_numa_balancing))
    7199                 :            :                 return -1;
    7200                 :            : 
    7201                 :            :         if (!p->numa_faults || !(env->sd->flags & SD_NUMA))
    7202                 :            :                 return -1;
    7203                 :            : 
    7204                 :            :         src_nid = cpu_to_node(env->src_cpu);
    7205                 :            :         dst_nid = cpu_to_node(env->dst_cpu);
    7206                 :            : 
    7207                 :            :         if (src_nid == dst_nid)
    7208                 :            :                 return -1;
    7209                 :            : 
    7210                 :            :         /* Migrating away from the preferred node is always bad. */
    7211                 :            :         if (src_nid == p->numa_preferred_nid) {
    7212                 :            :                 if (env->src_rq->nr_running > env->src_rq->nr_preferred_running)
    7213                 :            :                         return 1;
    7214                 :            :                 else
    7215                 :            :                         return -1;
    7216                 :            :         }
    7217                 :            : 
    7218                 :            :         /* Encourage migration to the preferred node. */
    7219                 :            :         if (dst_nid == p->numa_preferred_nid)
    7220                 :            :                 return 0;
    7221                 :            : 
    7222                 :            :         /* Leaving a core idle is often worse than degrading locality. */
    7223                 :            :         if (env->idle == CPU_IDLE)
    7224                 :            :                 return -1;
    7225                 :            : 
    7226                 :            :         dist = node_distance(src_nid, dst_nid);
    7227                 :            :         if (numa_group) {
    7228                 :            :                 src_weight = group_weight(p, src_nid, dist);
    7229                 :            :                 dst_weight = group_weight(p, dst_nid, dist);
    7230                 :            :         } else {
    7231                 :            :                 src_weight = task_weight(p, src_nid, dist);
    7232                 :            :                 dst_weight = task_weight(p, dst_nid, dist);
    7233                 :            :         }
    7234                 :            : 
    7235                 :            :         return dst_weight < src_weight;
    7236                 :            : }
    7237                 :            : 
    7238                 :            : #else
    7239                 :            : static inline int migrate_degrades_locality(struct task_struct *p,
    7240                 :            :                                              struct lb_env *env)
    7241                 :            : {
    7242                 :            :         return -1;
    7243                 :            : }
    7244                 :            : #endif
    7245                 :            : 
    7246                 :            : /*
    7247                 :            :  * can_migrate_task - may task p from runqueue rq be migrated to this_cpu?
    7248                 :            :  */
    7249                 :            : static
    7250                 :          3 : int can_migrate_task(struct task_struct *p, struct lb_env *env)
    7251                 :            : {
    7252                 :            :         int tsk_cache_hot;
    7253                 :            : 
    7254                 :            :         lockdep_assert_held(&env->src_rq->lock);
    7255                 :            : 
    7256                 :            :         /*
    7257                 :            :          * We do not migrate tasks that are:
    7258                 :            :          * 1) throttled_lb_pair, or
    7259                 :            :          * 2) cannot be migrated to this CPU due to cpus_ptr, or
    7260                 :            :          * 3) running (obviously), or
    7261                 :            :          * 4) are cache-hot on their current CPU.
    7262                 :            :          */
    7263                 :          3 :         if (throttled_lb_pair(task_group(p), env->src_cpu, env->dst_cpu))
    7264                 :            :                 return 0;
    7265                 :            : 
    7266                 :          3 :         if (!cpumask_test_cpu(env->dst_cpu, p->cpus_ptr)) {
    7267                 :            :                 int cpu;
    7268                 :            : 
    7269                 :          3 :                 schedstat_inc(p->se.statistics.nr_failed_migrations_affine);
    7270                 :            : 
    7271                 :          3 :                 env->flags |= LBF_SOME_PINNED;
    7272                 :            : 
    7273                 :            :                 /*
    7274                 :            :                  * Remember if this task can be migrated to any other CPU in
    7275                 :            :                  * our sched_group. We may want to revisit it if we couldn't
    7276                 :            :                  * meet load balance goals by pulling other tasks on src_cpu.
    7277                 :            :                  *
    7278                 :            :                  * Avoid computing new_dst_cpu for NEWLY_IDLE or if we have
    7279                 :            :                  * already computed one in current iteration.
    7280                 :            :                  */
    7281                 :          3 :                 if (env->idle == CPU_NEWLY_IDLE || (env->flags & LBF_DST_PINNED))
    7282                 :            :                         return 0;
    7283                 :            : 
    7284                 :            :                 /* Prevent to re-select dst_cpu via env's CPUs: */
    7285                 :          3 :                 for_each_cpu_and(cpu, env->dst_grpmask, env->cpus) {
    7286                 :          3 :                         if (cpumask_test_cpu(cpu, p->cpus_ptr)) {
    7287                 :          0 :                                 env->flags |= LBF_DST_PINNED;
    7288                 :          0 :                                 env->new_dst_cpu = cpu;
    7289                 :          0 :                                 break;
    7290                 :            :                         }
    7291                 :            :                 }
    7292                 :            : 
    7293                 :            :                 return 0;
    7294                 :            :         }
    7295                 :            : 
    7296                 :            :         /* Record that we found atleast one task that could run on dst_cpu */
    7297                 :          3 :         env->flags &= ~LBF_ALL_PINNED;
    7298                 :            : 
    7299                 :          3 :         if (task_running(env->src_rq, p)) {
    7300                 :          3 :                 schedstat_inc(p->se.statistics.nr_failed_migrations_running);
    7301                 :            :                 return 0;
    7302                 :            :         }
    7303                 :            : 
    7304                 :            :         /*
    7305                 :            :          * Aggressive migration if:
    7306                 :            :          * 1) destination numa is preferred
    7307                 :            :          * 2) task is cache cold, or
    7308                 :            :          * 3) too many balance attempts have failed.
    7309                 :            :          */
    7310                 :            :         tsk_cache_hot = migrate_degrades_locality(p, env);
    7311                 :            :         if (tsk_cache_hot == -1)
    7312                 :          3 :                 tsk_cache_hot = task_hot(p, env);
    7313                 :            : 
    7314                 :          3 :         if (tsk_cache_hot <= 0 ||
    7315                 :          3 :             env->sd->nr_balance_failed > env->sd->cache_nice_tries) {
    7316                 :          3 :                 if (tsk_cache_hot == 1) {
    7317                 :          3 :                         schedstat_inc(env->sd->lb_hot_gained[env->idle]);
    7318                 :          3 :                         schedstat_inc(p->se.statistics.nr_forced_migrations);
    7319                 :            :                 }
    7320                 :            :                 return 1;
    7321                 :            :         }
    7322                 :            : 
    7323                 :          3 :         schedstat_inc(p->se.statistics.nr_failed_migrations_hot);
    7324                 :            :         return 0;
    7325                 :            : }
    7326                 :            : 
    7327                 :            : /*
    7328                 :            :  * detach_task() -- detach the task for the migration specified in env
    7329                 :            :  */
    7330                 :          3 : static void detach_task(struct task_struct *p, struct lb_env *env)
    7331                 :            : {
    7332                 :            :         lockdep_assert_held(&env->src_rq->lock);
    7333                 :            : 
    7334                 :          3 :         deactivate_task(env->src_rq, p, DEQUEUE_NOCLOCK);
    7335                 :          3 :         set_task_cpu(p, env->dst_cpu);
    7336                 :          3 : }
    7337                 :            : 
    7338                 :            : /*
    7339                 :            :  * detach_one_task() -- tries to dequeue exactly one task from env->src_rq, as
    7340                 :            :  * part of active balancing operations within "domain".
    7341                 :            :  *
    7342                 :            :  * Returns a task if successful and NULL otherwise.
    7343                 :            :  */
    7344                 :          3 : static struct task_struct *detach_one_task(struct lb_env *env)
    7345                 :            : {
    7346                 :            :         struct task_struct *p;
    7347                 :            : 
    7348                 :            :         lockdep_assert_held(&env->src_rq->lock);
    7349                 :            : 
    7350                 :          3 :         list_for_each_entry_reverse(p,
    7351                 :            :                         &env->src_rq->cfs_tasks, se.group_node) {
    7352                 :          3 :                 if (!can_migrate_task(p, env))
    7353                 :          3 :                         continue;
    7354                 :            : 
    7355                 :          3 :                 detach_task(p, env);
    7356                 :            : 
    7357                 :            :                 /*
    7358                 :            :                  * Right now, this is only the second place where
    7359                 :            :                  * lb_gained[env->idle] is updated (other is detach_tasks)
    7360                 :            :                  * so we can safely collect stats here rather than
    7361                 :            :                  * inside detach_tasks().
    7362                 :            :                  */
    7363                 :          3 :                 schedstat_inc(env->sd->lb_gained[env->idle]);
    7364                 :          3 :                 return p;
    7365                 :            :         }
    7366                 :            :         return NULL;
    7367                 :            : }
    7368                 :            : 
    7369                 :            : static const unsigned int sched_nr_migrate_break = 32;
    7370                 :            : 
    7371                 :            : /*
    7372                 :            :  * detach_tasks() -- tries to detach up to imbalance runnable load from
    7373                 :            :  * busiest_rq, as part of a balancing operation within domain "sd".
    7374                 :            :  *
    7375                 :            :  * Returns number of detached tasks if successful and 0 otherwise.
    7376                 :            :  */
    7377                 :          3 : static int detach_tasks(struct lb_env *env)
    7378                 :            : {
    7379                 :          3 :         struct list_head *tasks = &env->src_rq->cfs_tasks;
    7380                 :            :         struct task_struct *p;
    7381                 :            :         unsigned long load;
    7382                 :            :         int detached = 0;
    7383                 :            : 
    7384                 :            :         lockdep_assert_held(&env->src_rq->lock);
    7385                 :            : 
    7386                 :          3 :         if (env->imbalance <= 0)
    7387                 :            :                 return 0;
    7388                 :            : 
    7389                 :          3 :         while (!list_empty(tasks)) {
    7390                 :            :                 /*
    7391                 :            :                  * We don't want to steal all, otherwise we may be treated likewise,
    7392                 :            :                  * which could at worst lead to a livelock crash.
    7393                 :            :                  */
    7394                 :          3 :                 if (env->idle != CPU_NOT_IDLE && env->src_rq->nr_running <= 1)
    7395                 :            :                         break;
    7396                 :            : 
    7397                 :          3 :                 p = list_last_entry(tasks, struct task_struct, se.group_node);
    7398                 :            : 
    7399                 :          3 :                 env->loop++;
    7400                 :            :                 /* We've more or less seen every task there is, call it quits */
    7401                 :          3 :                 if (env->loop > env->loop_max)
    7402                 :            :                         break;
    7403                 :            : 
    7404                 :            :                 /* take a breather every nr_migrate tasks */
    7405                 :          3 :                 if (env->loop > env->loop_break) {
    7406                 :          0 :                         env->loop_break += sched_nr_migrate_break;
    7407                 :          0 :                         env->flags |= LBF_NEED_BREAK;
    7408                 :          0 :                         break;
    7409                 :            :                 }
    7410                 :            : 
    7411                 :          3 :                 if (!can_migrate_task(p, env))
    7412                 :            :                         goto next;
    7413                 :            : 
    7414                 :            :                 /*
    7415                 :            :                  * Depending of the number of CPUs and tasks and the
    7416                 :            :                  * cgroup hierarchy, task_h_load() can return a null
    7417                 :            :                  * value. Make sure that env->imbalance decreases
    7418                 :            :                  * otherwise detach_tasks() will stop only after
    7419                 :            :                  * detaching up to loop_max tasks.
    7420                 :            :                  */
    7421                 :          3 :                 load = max_t(unsigned long, task_h_load(p), 1);
    7422                 :            : 
    7423                 :            : 
    7424                 :          3 :                 if (sched_feat(LB_MIN) && load < 16 && !env->sd->nr_balance_failed)
    7425                 :            :                         goto next;
    7426                 :            : 
    7427                 :          3 :                 if ((load / 2) > env->imbalance)
    7428                 :            :                         goto next;
    7429                 :            : 
    7430                 :          3 :                 detach_task(p, env);
    7431                 :          3 :                 list_add(&p->se.group_node, &env->tasks);
    7432                 :            : 
    7433                 :          3 :                 detached++;
    7434                 :          3 :                 env->imbalance -= load;
    7435                 :            : 
    7436                 :            : #ifdef CONFIG_PREEMPTION
    7437                 :            :                 /*
    7438                 :            :                  * NEWIDLE balancing is a source of latency, so preemptible
    7439                 :            :                  * kernels will stop after the first task is detached to minimize
    7440                 :            :                  * the critical section.
    7441                 :            :                  */
    7442                 :            :                 if (env->idle == CPU_NEWLY_IDLE)
    7443                 :            :                         break;
    7444                 :            : #endif
    7445                 :            : 
    7446                 :            :                 /*
    7447                 :            :                  * We only want to steal up to the prescribed amount of
    7448                 :            :                  * runnable load.
    7449                 :            :                  */
    7450                 :          3 :                 if (env->imbalance <= 0)
    7451                 :            :                         break;
    7452                 :            : 
    7453                 :          3 :                 continue;
    7454                 :            : next:
    7455                 :          3 :                 list_move(&p->se.group_node, tasks);
    7456                 :            :         }
    7457                 :            : 
    7458                 :            :         /*
    7459                 :            :          * Right now, this is one of only two places we collect this stat
    7460                 :            :          * so we can safely collect detach_one_task() stats here rather
    7461                 :            :          * than inside detach_one_task().
    7462                 :            :          */
    7463                 :          3 :         schedstat_add(env->sd->lb_gained[env->idle], detached);
    7464                 :            : 
    7465                 :          3 :         return detached;
    7466                 :            : }
    7467                 :            : 
    7468                 :            : /*
    7469                 :            :  * attach_task() -- attach the task detached by detach_task() to its new rq.
    7470                 :            :  */
    7471                 :          3 : static void attach_task(struct rq *rq, struct task_struct *p)
    7472                 :            : {
    7473                 :            :         lockdep_assert_held(&rq->lock);
    7474                 :            : 
    7475                 :          3 :         BUG_ON(task_rq(p) != rq);
    7476                 :          3 :         activate_task(rq, p, ENQUEUE_NOCLOCK);
    7477                 :          3 :         check_preempt_curr(rq, p, 0);
    7478                 :          3 : }
    7479                 :            : 
    7480                 :            : /*
    7481                 :            :  * attach_one_task() -- attaches the task returned from detach_one_task() to
    7482                 :            :  * its new rq.
    7483                 :            :  */
    7484                 :          3 : static void attach_one_task(struct rq *rq, struct task_struct *p)
    7485                 :            : {
    7486                 :            :         struct rq_flags rf;
    7487                 :            : 
    7488                 :            :         rq_lock(rq, &rf);
    7489                 :          3 :         update_rq_clock(rq);
    7490                 :          3 :         attach_task(rq, p);
    7491                 :            :         rq_unlock(rq, &rf);
    7492                 :          3 : }
    7493                 :            : 
    7494                 :            : /*
    7495                 :            :  * attach_tasks() -- attaches all tasks detached by detach_tasks() to their
    7496                 :            :  * new rq.
    7497                 :            :  */
    7498                 :          3 : static void attach_tasks(struct lb_env *env)
    7499                 :            : {
    7500                 :          3 :         struct list_head *tasks = &env->tasks;
    7501                 :            :         struct task_struct *p;
    7502                 :            :         struct rq_flags rf;
    7503                 :            : 
    7504                 :          3 :         rq_lock(env->dst_rq, &rf);
    7505                 :          3 :         update_rq_clock(env->dst_rq);
    7506                 :            : 
    7507                 :          3 :         while (!list_empty(tasks)) {
    7508                 :          3 :                 p = list_first_entry(tasks, struct task_struct, se.group_node);
    7509                 :          3 :                 list_del_init(&p->se.group_node);
    7510                 :            : 
    7511                 :          3 :                 attach_task(env->dst_rq, p);
    7512                 :            :         }
    7513                 :            : 
    7514                 :          3 :         rq_unlock(env->dst_rq, &rf);
    7515                 :          3 : }
    7516                 :            : 
    7517                 :            : #ifdef CONFIG_NO_HZ_COMMON
    7518                 :            : static inline bool cfs_rq_has_blocked(struct cfs_rq *cfs_rq)
    7519                 :            : {
    7520                 :          3 :         if (cfs_rq->avg.load_avg)
    7521                 :            :                 return true;
    7522                 :            : 
    7523                 :          3 :         if (cfs_rq->avg.util_avg)
    7524                 :            :                 return true;
    7525                 :            : 
    7526                 :            :         return false;
    7527                 :            : }
    7528                 :            : 
    7529                 :            : static inline bool others_have_blocked(struct rq *rq)
    7530                 :            : {
    7531                 :          3 :         if (READ_ONCE(rq->avg_rt.util_avg))
    7532                 :            :                 return true;
    7533                 :            : 
    7534                 :          3 :         if (READ_ONCE(rq->avg_dl.util_avg))
    7535                 :            :                 return true;
    7536                 :            : 
    7537                 :            : #ifdef CONFIG_HAVE_SCHED_AVG_IRQ
    7538                 :            :         if (READ_ONCE(rq->avg_irq.util_avg))
    7539                 :            :                 return true;
    7540                 :            : #endif
    7541                 :            : 
    7542                 :            :         return false;
    7543                 :            : }
    7544                 :            : 
    7545                 :            : static inline void update_blocked_load_status(struct rq *rq, bool has_blocked)
    7546                 :            : {
    7547                 :          3 :         rq->last_blocked_load_update_tick = jiffies;
    7548                 :            : 
    7549                 :          3 :         if (!has_blocked)
    7550                 :          3 :                 rq->has_blocked_load = 0;
    7551                 :            : }
    7552                 :            : #else
    7553                 :            : static inline bool cfs_rq_has_blocked(struct cfs_rq *cfs_rq) { return false; }
    7554                 :            : static inline bool others_have_blocked(struct rq *rq) { return false; }
    7555                 :            : static inline void update_blocked_load_status(struct rq *rq, bool has_blocked) {}
    7556                 :            : #endif
    7557                 :            : 
    7558                 :          3 : static bool __update_blocked_others(struct rq *rq, bool *done)
    7559                 :            : {
    7560                 :            :         const struct sched_class *curr_class;
    7561                 :            :         u64 now = rq_clock_pelt(rq);
    7562                 :            :         bool decayed;
    7563                 :            : 
    7564                 :            :         /*
    7565                 :            :          * update_load_avg() can call cpufreq_update_util(). Make sure that RT,
    7566                 :            :          * DL and IRQ signals have been updated before updating CFS.
    7567                 :            :          */
    7568                 :          3 :         curr_class = rq->curr->sched_class;
    7569                 :            : 
    7570                 :          3 :         decayed = update_rt_rq_load_avg(now, rq, curr_class == &rt_sched_class) |
    7571                 :          3 :                   update_dl_rq_load_avg(now, rq, curr_class == &dl_sched_class) |
    7572                 :            :                   update_irq_load_avg(rq, 0);
    7573                 :            : 
    7574                 :          3 :         if (others_have_blocked(rq))
    7575                 :          3 :                 *done = false;
    7576                 :            : 
    7577                 :          3 :         return decayed;
    7578                 :            : }
    7579                 :            : 
    7580                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
    7581                 :            : 
    7582                 :            : static inline bool cfs_rq_is_decayed(struct cfs_rq *cfs_rq)
    7583                 :            : {
    7584                 :          3 :         if (cfs_rq->load.weight)
    7585                 :            :                 return false;
    7586                 :            : 
    7587                 :          3 :         if (cfs_rq->avg.load_sum)
    7588                 :            :                 return false;
    7589                 :            : 
    7590                 :          3 :         if (cfs_rq->avg.util_sum)
    7591                 :            :                 return false;
    7592                 :            : 
    7593                 :          3 :         if (cfs_rq->avg.runnable_load_sum)
    7594                 :            :                 return false;
    7595                 :            : 
    7596                 :            :         return true;
    7597                 :            : }
    7598                 :            : 
    7599                 :          3 : static bool __update_blocked_fair(struct rq *rq, bool *done)
    7600                 :            : {
    7601                 :            :         struct cfs_rq *cfs_rq, *pos;
    7602                 :            :         bool decayed = false;
    7603                 :            :         int cpu = cpu_of(rq);
    7604                 :            : 
    7605                 :            :         /*
    7606                 :            :          * Iterates the task_group tree in a bottom up fashion, see
    7607                 :            :          * list_add_leaf_cfs_rq() for details.
    7608                 :            :          */
    7609                 :          3 :         for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos) {
    7610                 :            :                 struct sched_entity *se;
    7611                 :            : 
    7612                 :          3 :                 if (update_cfs_rq_load_avg(cfs_rq_clock_pelt(cfs_rq), cfs_rq)) {
    7613                 :          3 :                         update_tg_load_avg(cfs_rq, 0);
    7614                 :            : 
    7615                 :          3 :                         if (cfs_rq == &rq->cfs)
    7616                 :            :                                 decayed = true;
    7617                 :            :                 }
    7618                 :            : 
    7619                 :            :                 /* Propagate pending load changes to the parent, if any: */
    7620                 :          3 :                 se = cfs_rq->tg->se[cpu];
    7621                 :          3 :                 if (se && !skip_blocked_update(se))
    7622                 :          3 :                         update_load_avg(cfs_rq_of(se), se, 0);
    7623                 :            : 
    7624                 :            :                 /*
    7625                 :            :                  * There can be a lot of idle CPU cgroups.  Don't let fully
    7626                 :            :                  * decayed cfs_rqs linger on the list.
    7627                 :            :                  */
    7628                 :          3 :                 if (cfs_rq_is_decayed(cfs_rq))
    7629                 :            :                         list_del_leaf_cfs_rq(cfs_rq);
    7630                 :            : 
    7631                 :            :                 /* Don't need periodic decay once load/util_avg are null */
    7632                 :          3 :                 if (cfs_rq_has_blocked(cfs_rq))
    7633                 :          3 :                         *done = false;
    7634                 :            :         }
    7635                 :            : 
    7636                 :          3 :         return decayed;
    7637                 :            : }
    7638                 :            : 
    7639                 :            : /*
    7640                 :            :  * Compute the hierarchical load factor for cfs_rq and all its ascendants.
    7641                 :            :  * This needs to be done in a top-down fashion because the load of a child
    7642                 :            :  * group is a fraction of its parents load.
    7643                 :            :  */
    7644                 :          3 : static void update_cfs_rq_h_load(struct cfs_rq *cfs_rq)
    7645                 :            : {
    7646                 :            :         struct rq *rq = rq_of(cfs_rq);
    7647                 :          3 :         struct sched_entity *se = cfs_rq->tg->se[cpu_of(rq)];
    7648                 :          3 :         unsigned long now = jiffies;
    7649                 :            :         unsigned long load;
    7650                 :            : 
    7651                 :          3 :         if (cfs_rq->last_h_load_update == now)
    7652                 :          3 :                 return;
    7653                 :            : 
    7654                 :            :         WRITE_ONCE(cfs_rq->h_load_next, NULL);
    7655                 :          3 :         for_each_sched_entity(se) {
    7656                 :            :                 cfs_rq = cfs_rq_of(se);
    7657                 :          3 :                 WRITE_ONCE(cfs_rq->h_load_next, se);
    7658                 :          3 :                 if (cfs_rq->last_h_load_update == now)
    7659                 :            :                         break;
    7660                 :            :         }
    7661                 :            : 
    7662                 :          3 :         if (!se) {
    7663                 :          3 :                 cfs_rq->h_load = cfs_rq_load_avg(cfs_rq);
    7664                 :          3 :                 cfs_rq->last_h_load_update = now;
    7665                 :            :         }
    7666                 :            : 
    7667                 :          3 :         while ((se = READ_ONCE(cfs_rq->h_load_next)) != NULL) {
    7668                 :          3 :                 load = cfs_rq->h_load;
    7669                 :          3 :                 load = div64_ul(load * se->avg.load_avg,
    7670                 :            :                         cfs_rq_load_avg(cfs_rq) + 1);
    7671                 :            :                 cfs_rq = group_cfs_rq(se);
    7672                 :          3 :                 cfs_rq->h_load = load;
    7673                 :          3 :                 cfs_rq->last_h_load_update = now;
    7674                 :            :         }
    7675                 :            : }
    7676                 :            : 
    7677                 :          3 : static unsigned long task_h_load(struct task_struct *p)
    7678                 :            : {
    7679                 :            :         struct cfs_rq *cfs_rq = task_cfs_rq(p);
    7680                 :            : 
    7681                 :          3 :         update_cfs_rq_h_load(cfs_rq);
    7682                 :          3 :         return div64_ul(p->se.avg.load_avg * cfs_rq->h_load,
    7683                 :            :                         cfs_rq_load_avg(cfs_rq) + 1);
    7684                 :            : }
    7685                 :            : #else
    7686                 :            : static bool __update_blocked_fair(struct rq *rq, bool *done)
    7687                 :            : {
    7688                 :            :         struct cfs_rq *cfs_rq = &rq->cfs;
    7689                 :            :         bool decayed;
    7690                 :            : 
    7691                 :            :         decayed = update_cfs_rq_load_avg(cfs_rq_clock_pelt(cfs_rq), cfs_rq);
    7692                 :            :         if (cfs_rq_has_blocked(cfs_rq))
    7693                 :            :                 *done = false;
    7694                 :            : 
    7695                 :            :         return decayed;
    7696                 :            : }
    7697                 :            : 
    7698                 :            : static unsigned long task_h_load(struct task_struct *p)
    7699                 :            : {
    7700                 :            :         return p->se.avg.load_avg;
    7701                 :            : }
    7702                 :            : #endif
    7703                 :            : 
    7704                 :          3 : static void update_blocked_averages(int cpu)
    7705                 :            : {
    7706                 :          3 :         bool decayed = false, done = true;
    7707                 :          3 :         struct rq *rq = cpu_rq(cpu);
    7708                 :            :         struct rq_flags rf;
    7709                 :            : 
    7710                 :            :         rq_lock_irqsave(rq, &rf);
    7711                 :          3 :         update_rq_clock(rq);
    7712                 :            : 
    7713                 :          3 :         decayed |= __update_blocked_others(rq, &done);
    7714                 :          3 :         decayed |= __update_blocked_fair(rq, &done);
    7715                 :            : 
    7716                 :          3 :         update_blocked_load_status(rq, !done);
    7717                 :          3 :         if (decayed)
    7718                 :          3 :                 cpufreq_update_util(rq, 0);
    7719                 :            :         rq_unlock_irqrestore(rq, &rf);
    7720                 :          3 : }
    7721                 :            : 
    7722                 :            : /********** Helpers for find_busiest_group ************************/
    7723                 :            : 
    7724                 :            : /*
    7725                 :            :  * sg_lb_stats - stats of a sched_group required for load_balancing
    7726                 :            :  */
    7727                 :            : struct sg_lb_stats {
    7728                 :            :         unsigned long avg_load; /*Avg load across the CPUs of the group */
    7729                 :            :         unsigned long group_load; /* Total load over the CPUs of the group */
    7730                 :            :         unsigned long load_per_task;
    7731                 :            :         unsigned long group_capacity;
    7732                 :            :         unsigned long group_util; /* Total utilization of the group */
    7733                 :            :         unsigned int sum_nr_running; /* Nr tasks running in the group */
    7734                 :            :         unsigned int idle_cpus;
    7735                 :            :         unsigned int group_weight;
    7736                 :            :         enum group_type group_type;
    7737                 :            :         int group_no_capacity;
    7738                 :            :         unsigned long group_misfit_task_load; /* A CPU has a task too big for its capacity */
    7739                 :            : #ifdef CONFIG_NUMA_BALANCING
    7740                 :            :         unsigned int nr_numa_running;
    7741                 :            :         unsigned int nr_preferred_running;
    7742                 :            : #endif
    7743                 :            : };
    7744                 :            : 
    7745                 :            : /*
    7746                 :            :  * sd_lb_stats - Structure to store the statistics of a sched_domain
    7747                 :            :  *               during load balancing.
    7748                 :            :  */
    7749                 :            : struct sd_lb_stats {
    7750                 :            :         struct sched_group *busiest;    /* Busiest group in this sd */
    7751                 :            :         struct sched_group *local;      /* Local group in this sd */
    7752                 :            :         unsigned long total_running;
    7753                 :            :         unsigned long total_load;       /* Total load of all groups in sd */
    7754                 :            :         unsigned long total_capacity;   /* Total capacity of all groups in sd */
    7755                 :            :         unsigned long avg_load; /* Average load across all groups in sd */
    7756                 :            : 
    7757                 :            :         struct sg_lb_stats busiest_stat;/* Statistics of the busiest group */
    7758                 :            :         struct sg_lb_stats local_stat;  /* Statistics of the local group */
    7759                 :            : };
    7760                 :            : 
    7761                 :            : static inline void init_sd_lb_stats(struct sd_lb_stats *sds)
    7762                 :            : {
    7763                 :            :         /*
    7764                 :            :          * Skimp on the clearing to avoid duplicate work. We can avoid clearing
    7765                 :            :          * local_stat because update_sg_lb_stats() does a full clear/assignment.
    7766                 :            :          * We must however clear busiest_stat::avg_load because
    7767                 :            :          * update_sd_pick_busiest() reads this before assignment.
    7768                 :            :          */
    7769                 :          3 :         *sds = (struct sd_lb_stats){
    7770                 :            :                 .busiest = NULL,
    7771                 :            :                 .local = NULL,
    7772                 :            :                 .total_running = 0UL,
    7773                 :            :                 .total_load = 0UL,
    7774                 :            :                 .total_capacity = 0UL,
    7775                 :            :                 .busiest_stat = {
    7776                 :            :                         .avg_load = 0UL,
    7777                 :            :                         .sum_nr_running = 0,
    7778                 :            :                         .group_type = group_other,
    7779                 :            :                 },
    7780                 :            :         };
    7781                 :            : }
    7782                 :            : 
    7783                 :            : static unsigned long scale_rt_capacity(struct sched_domain *sd, int cpu)
    7784                 :            : {
    7785                 :          3 :         struct rq *rq = cpu_rq(cpu);
    7786                 :            :         unsigned long max = arch_scale_cpu_capacity(cpu);
    7787                 :            :         unsigned long used, free;
    7788                 :            :         unsigned long irq;
    7789                 :            : 
    7790                 :            :         irq = cpu_util_irq(rq);
    7791                 :            : 
    7792                 :          3 :         if (unlikely(irq >= max))
    7793                 :            :                 return 1;
    7794                 :            : 
    7795                 :            :         used = READ_ONCE(rq->avg_rt.util_avg);
    7796                 :          3 :         used += READ_ONCE(rq->avg_dl.util_avg);
    7797                 :            : 
    7798                 :          3 :         if (unlikely(used >= max))
    7799                 :            :                 return 1;
    7800                 :            : 
    7801                 :          3 :         free = max - used;
    7802                 :            : 
    7803                 :            :         return scale_irq_capacity(free, irq, max);
    7804                 :            : }
    7805                 :            : 
    7806                 :          3 : static void update_cpu_capacity(struct sched_domain *sd, int cpu)
    7807                 :            : {
    7808                 :            :         unsigned long capacity = scale_rt_capacity(sd, cpu);
    7809                 :          3 :         struct sched_group *sdg = sd->groups;
    7810                 :            : 
    7811                 :          3 :         cpu_rq(cpu)->cpu_capacity_orig = arch_scale_cpu_capacity(cpu);
    7812                 :            : 
    7813                 :          3 :         if (!capacity)
    7814                 :            :                 capacity = 1;
    7815                 :            : 
    7816                 :          3 :         cpu_rq(cpu)->cpu_capacity = capacity;
    7817                 :          3 :         sdg->sgc->capacity = capacity;
    7818                 :          3 :         sdg->sgc->min_capacity = capacity;
    7819                 :          3 :         sdg->sgc->max_capacity = capacity;
    7820                 :          3 : }
    7821                 :            : 
    7822                 :          3 : void update_group_capacity(struct sched_domain *sd, int cpu)
    7823                 :            : {
    7824                 :          3 :         struct sched_domain *child = sd->child;
    7825                 :          3 :         struct sched_group *group, *sdg = sd->groups;
    7826                 :            :         unsigned long capacity, min_capacity, max_capacity;
    7827                 :            :         unsigned long interval;
    7828                 :            : 
    7829                 :          3 :         interval = msecs_to_jiffies(sd->balance_interval);
    7830                 :          3 :         interval = clamp(interval, 1UL, max_load_balance_interval);
    7831                 :          3 :         sdg->sgc->next_update = jiffies + interval;
    7832                 :            : 
    7833                 :          3 :         if (!child) {
    7834                 :          3 :                 update_cpu_capacity(sd, cpu);
    7835                 :          3 :                 return;
    7836                 :            :         }
    7837                 :            : 
    7838                 :            :         capacity = 0;
    7839                 :            :         min_capacity = ULONG_MAX;
    7840                 :            :         max_capacity = 0;
    7841                 :            : 
    7842                 :          0 :         if (child->flags & SD_OVERLAP) {
    7843                 :            :                 /*
    7844                 :            :                  * SD_OVERLAP domains cannot assume that child groups
    7845                 :            :                  * span the current group.
    7846                 :            :                  */
    7847                 :            : 
    7848                 :          0 :                 for_each_cpu(cpu, sched_group_span(sdg)) {
    7849                 :            :                         struct sched_group_capacity *sgc;
    7850                 :          0 :                         struct rq *rq = cpu_rq(cpu);
    7851                 :            : 
    7852                 :            :                         /*
    7853                 :            :                          * build_sched_domains() -> init_sched_groups_capacity()
    7854                 :            :                          * gets here before we've attached the domains to the
    7855                 :            :                          * runqueues.
    7856                 :            :                          *
    7857                 :            :                          * Use capacity_of(), which is set irrespective of domains
    7858                 :            :                          * in update_cpu_capacity().
    7859                 :            :                          *
    7860                 :            :                          * This avoids capacity from being 0 and
    7861                 :            :                          * causing divide-by-zero issues on boot.
    7862                 :            :                          */
    7863                 :          0 :                         if (unlikely(!rq->sd)) {
    7864                 :          0 :                                 capacity += capacity_of(cpu);
    7865                 :            :                         } else {
    7866                 :          0 :                                 sgc = rq->sd->groups->sgc;
    7867                 :          0 :                                 capacity += sgc->capacity;
    7868                 :            :                         }
    7869                 :            : 
    7870                 :          0 :                         min_capacity = min(capacity, min_capacity);
    7871                 :          0 :                         max_capacity = max(capacity, max_capacity);
    7872                 :            :                 }
    7873                 :            :         } else  {
    7874                 :            :                 /*
    7875                 :            :                  * !SD_OVERLAP domains can assume that child groups
    7876                 :            :                  * span the current group.
    7877                 :            :                  */
    7878                 :            : 
    7879                 :          0 :                 group = child->groups;
    7880                 :            :                 do {
    7881                 :          0 :                         struct sched_group_capacity *sgc = group->sgc;
    7882                 :            : 
    7883                 :          0 :                         capacity += sgc->capacity;
    7884                 :          0 :                         min_capacity = min(sgc->min_capacity, min_capacity);
    7885                 :          0 :                         max_capacity = max(sgc->max_capacity, max_capacity);
    7886                 :          0 :                         group = group->next;
    7887                 :          0 :                 } while (group != child->groups);
    7888                 :            :         }
    7889                 :            : 
    7890                 :          0 :         sdg->sgc->capacity = capacity;
    7891                 :          0 :         sdg->sgc->min_capacity = min_capacity;
    7892                 :          0 :         sdg->sgc->max_capacity = max_capacity;
    7893                 :            : }
    7894                 :            : 
    7895                 :            : /*
    7896                 :            :  * Check whether the capacity of the rq has been noticeably reduced by side
    7897                 :            :  * activity. The imbalance_pct is used for the threshold.
    7898                 :            :  * Return true is the capacity is reduced
    7899                 :            :  */
    7900                 :            : static inline int
    7901                 :            : check_cpu_capacity(struct rq *rq, struct sched_domain *sd)
    7902                 :            : {
    7903                 :          3 :         return ((rq->cpu_capacity * sd->imbalance_pct) <
    7904                 :          3 :                                 (rq->cpu_capacity_orig * 100));
    7905                 :            : }
    7906                 :            : 
    7907                 :            : /*
    7908                 :            :  * Check whether a rq has a misfit task and if it looks like we can actually
    7909                 :            :  * help that task: we can migrate the task to a CPU of higher capacity, or
    7910                 :            :  * the task's current CPU is heavily pressured.
    7911                 :            :  */
    7912                 :            : static inline int check_misfit_status(struct rq *rq, struct sched_domain *sd)
    7913                 :            : {
    7914                 :          0 :         return rq->misfit_task_load &&
    7915                 :          0 :                 (rq->cpu_capacity_orig < rq->rd->max_cpu_capacity ||
    7916                 :            :                  check_cpu_capacity(rq, sd));
    7917                 :            : }
    7918                 :            : 
    7919                 :            : /*
    7920                 :            :  * Group imbalance indicates (and tries to solve) the problem where balancing
    7921                 :            :  * groups is inadequate due to ->cpus_ptr constraints.
    7922                 :            :  *
    7923                 :            :  * Imagine a situation of two groups of 4 CPUs each and 4 tasks each with a
    7924                 :            :  * cpumask covering 1 CPU of the first group and 3 CPUs of the second group.
    7925                 :            :  * Something like:
    7926                 :            :  *
    7927                 :            :  *      { 0 1 2 3 } { 4 5 6 7 }
    7928                 :            :  *              *     * * *
    7929                 :            :  *
    7930                 :            :  * If we were to balance group-wise we'd place two tasks in the first group and
    7931                 :            :  * two tasks in the second group. Clearly this is undesired as it will overload
    7932                 :            :  * cpu 3 and leave one of the CPUs in the second group unused.
    7933                 :            :  *
    7934                 :            :  * The current solution to this issue is detecting the skew in the first group
    7935                 :            :  * by noticing the lower domain failed to reach balance and had difficulty
    7936                 :            :  * moving tasks due to affinity constraints.
    7937                 :            :  *
    7938                 :            :  * When this is so detected; this group becomes a candidate for busiest; see
    7939                 :            :  * update_sd_pick_busiest(). And calculate_imbalance() and
    7940                 :            :  * find_busiest_group() avoid some of the usual balance conditions to allow it
    7941                 :            :  * to create an effective group imbalance.
    7942                 :            :  *
    7943                 :            :  * This is a somewhat tricky proposition since the next run might not find the
    7944                 :            :  * group imbalance and decide the groups need to be balanced again. A most
    7945                 :            :  * subtle and fragile situation.
    7946                 :            :  */
    7947                 :            : 
    7948                 :            : static inline int sg_imbalanced(struct sched_group *group)
    7949                 :            : {
    7950                 :          3 :         return group->sgc->imbalance;
    7951                 :            : }
    7952                 :            : 
    7953                 :            : /*
    7954                 :            :  * group_has_capacity returns true if the group has spare capacity that could
    7955                 :            :  * be used by some tasks.
    7956                 :            :  * We consider that a group has spare capacity if the  * number of task is
    7957                 :            :  * smaller than the number of CPUs or if the utilization is lower than the
    7958                 :            :  * available capacity for CFS tasks.
    7959                 :            :  * For the latter, we use a threshold to stabilize the state, to take into
    7960                 :            :  * account the variance of the tasks' load and to return true if the available
    7961                 :            :  * capacity in meaningful for the load balancer.
    7962                 :            :  * As an example, an available capacity of 1% can appear but it doesn't make
    7963                 :            :  * any benefit for the load balance.
    7964                 :            :  */
    7965                 :            : static inline bool
    7966                 :            : group_has_capacity(struct lb_env *env, struct sg_lb_stats *sgs)
    7967                 :            : {
    7968                 :          3 :         if (sgs->sum_nr_running < sgs->group_weight)
    7969                 :            :                 return true;
    7970                 :            : 
    7971                 :          3 :         if ((sgs->group_capacity * 100) >
    7972                 :          3 :                         (sgs->group_util * env->sd->imbalance_pct))
    7973                 :            :                 return true;
    7974                 :            : 
    7975                 :            :         return false;
    7976                 :            : }
    7977                 :            : 
    7978                 :            : /*
    7979                 :            :  *  group_is_overloaded returns true if the group has more tasks than it can
    7980                 :            :  *  handle.
    7981                 :            :  *  group_is_overloaded is not equals to !group_has_capacity because a group
    7982                 :            :  *  with the exact right number of tasks, has no more spare capacity but is not
    7983                 :            :  *  overloaded so both group_has_capacity and group_is_overloaded return
    7984                 :            :  *  false.
    7985                 :            :  */
    7986                 :            : static inline bool
    7987                 :            : group_is_overloaded(struct lb_env *env, struct sg_lb_stats *sgs)
    7988                 :            : {
    7989                 :          3 :         if (sgs->sum_nr_running <= sgs->group_weight)
    7990                 :            :                 return false;
    7991                 :            : 
    7992                 :          3 :         if ((sgs->group_capacity * 100) <
    7993                 :          3 :                         (sgs->group_util * env->sd->imbalance_pct))
    7994                 :            :                 return true;
    7995                 :            : 
    7996                 :            :         return false;
    7997                 :            : }
    7998                 :            : 
    7999                 :            : /*
    8000                 :            :  * group_smaller_min_cpu_capacity: Returns true if sched_group sg has smaller
    8001                 :            :  * per-CPU capacity than sched_group ref.
    8002                 :            :  */
    8003                 :            : static inline bool
    8004                 :            : group_smaller_min_cpu_capacity(struct sched_group *sg, struct sched_group *ref)
    8005                 :            : {
    8006                 :          0 :         return fits_capacity(sg->sgc->min_capacity, ref->sgc->min_capacity);
    8007                 :            : }
    8008                 :            : 
    8009                 :            : /*
    8010                 :            :  * group_smaller_max_cpu_capacity: Returns true if sched_group sg has smaller
    8011                 :            :  * per-CPU capacity_orig than sched_group ref.
    8012                 :            :  */
    8013                 :            : static inline bool
    8014                 :            : group_smaller_max_cpu_capacity(struct sched_group *sg, struct sched_group *ref)
    8015                 :            : {
    8016                 :          0 :         return fits_capacity(sg->sgc->max_capacity, ref->sgc->max_capacity);
    8017                 :            : }
    8018                 :            : 
    8019                 :            : static inline enum
    8020                 :            : group_type group_classify(struct sched_group *group,
    8021                 :            :                           struct sg_lb_stats *sgs)
    8022                 :            : {
    8023                 :          3 :         if (sgs->group_no_capacity)
    8024                 :            :                 return group_overloaded;
    8025                 :            : 
    8026                 :          3 :         if (sg_imbalanced(group))
    8027                 :            :                 return group_imbalanced;
    8028                 :            : 
    8029                 :          3 :         if (sgs->group_misfit_task_load)
    8030                 :            :                 return group_misfit_task;
    8031                 :            : 
    8032                 :            :         return group_other;
    8033                 :            : }
    8034                 :            : 
    8035                 :          3 : static bool update_nohz_stats(struct rq *rq, bool force)
    8036                 :            : {
    8037                 :            : #ifdef CONFIG_NO_HZ_COMMON
    8038                 :          3 :         unsigned int cpu = rq->cpu;
    8039                 :            : 
    8040                 :          3 :         if (!rq->has_blocked_load)
    8041                 :            :                 return false;
    8042                 :            : 
    8043                 :          3 :         if (!cpumask_test_cpu(cpu, nohz.idle_cpus_mask))
    8044                 :            :                 return false;
    8045                 :            : 
    8046                 :          3 :         if (!force && !time_after(jiffies, rq->last_blocked_load_update_tick))
    8047                 :            :                 return true;
    8048                 :            : 
    8049                 :          3 :         update_blocked_averages(cpu);
    8050                 :            : 
    8051                 :          3 :         return rq->has_blocked_load;
    8052                 :            : #else
    8053                 :            :         return false;
    8054                 :            : #endif
    8055                 :            : }
    8056                 :            : 
    8057                 :            : /**
    8058                 :            :  * update_sg_lb_stats - Update sched_group's statistics for load balancing.
    8059                 :            :  * @env: The load balancing environment.
    8060                 :            :  * @group: sched_group whose statistics are to be updated.
    8061                 :            :  * @sgs: variable to hold the statistics for this group.
    8062                 :            :  * @sg_status: Holds flag indicating the status of the sched_group
    8063                 :            :  */
    8064                 :          3 : static inline void update_sg_lb_stats(struct lb_env *env,
    8065                 :            :                                       struct sched_group *group,
    8066                 :            :                                       struct sg_lb_stats *sgs,
    8067                 :            :                                       int *sg_status)
    8068                 :            : {
    8069                 :            :         int i, nr_running;
    8070                 :            : 
    8071                 :          3 :         memset(sgs, 0, sizeof(*sgs));
    8072                 :            : 
    8073                 :          3 :         for_each_cpu_and(i, sched_group_span(group), env->cpus) {
    8074                 :          3 :                 struct rq *rq = cpu_rq(i);
    8075                 :            : 
    8076                 :          3 :                 if ((env->flags & LBF_NOHZ_STATS) && update_nohz_stats(rq, false))
    8077                 :          3 :                         env->flags |= LBF_NOHZ_AGAIN;
    8078                 :            : 
    8079                 :          3 :                 sgs->group_load += cpu_runnable_load(rq);
    8080                 :          3 :                 sgs->group_util += cpu_util(i);
    8081                 :          3 :                 sgs->sum_nr_running += rq->cfs.h_nr_running;
    8082                 :            : 
    8083                 :          3 :                 nr_running = rq->nr_running;
    8084                 :          3 :                 if (nr_running > 1)
    8085                 :          3 :                         *sg_status |= SG_OVERLOAD;
    8086                 :            : 
    8087                 :          3 :                 if (cpu_overutilized(i))
    8088                 :          3 :                         *sg_status |= SG_OVERUTILIZED;
    8089                 :            : 
    8090                 :            : #ifdef CONFIG_NUMA_BALANCING
    8091                 :            :                 sgs->nr_numa_running += rq->nr_numa_running;
    8092                 :            :                 sgs->nr_preferred_running += rq->nr_preferred_running;
    8093                 :            : #endif
    8094                 :            :                 /*
    8095                 :            :                  * No need to call idle_cpu() if nr_running is not 0
    8096                 :            :                  */
    8097                 :          3 :                 if (!nr_running && idle_cpu(i))
    8098                 :          3 :                         sgs->idle_cpus++;
    8099                 :            : 
    8100                 :          3 :                 if (env->sd->flags & SD_ASYM_CPUCAPACITY &&
    8101                 :          0 :                     sgs->group_misfit_task_load < rq->misfit_task_load) {
    8102                 :          0 :                         sgs->group_misfit_task_load = rq->misfit_task_load;
    8103                 :          0 :                         *sg_status |= SG_OVERLOAD;
    8104                 :            :                 }
    8105                 :            :         }
    8106                 :            : 
    8107                 :            :         /* Adjust by relative CPU capacity of the group */
    8108                 :          3 :         sgs->group_capacity = group->sgc->capacity;
    8109                 :          3 :         sgs->avg_load = (sgs->group_load*SCHED_CAPACITY_SCALE) / sgs->group_capacity;
    8110                 :            : 
    8111                 :          3 :         if (sgs->sum_nr_running)
    8112                 :          3 :                 sgs->load_per_task = sgs->group_load / sgs->sum_nr_running;
    8113                 :            : 
    8114                 :          3 :         sgs->group_weight = group->group_weight;
    8115                 :            : 
    8116                 :          3 :         sgs->group_no_capacity = group_is_overloaded(env, sgs);
    8117                 :          3 :         sgs->group_type = group_classify(group, sgs);
    8118                 :          3 : }
    8119                 :            : 
    8120                 :            : /**
    8121                 :            :  * update_sd_pick_busiest - return 1 on busiest group
    8122                 :            :  * @env: The load balancing environment.
    8123                 :            :  * @sds: sched_domain statistics
    8124                 :            :  * @sg: sched_group candidate to be checked for being the busiest
    8125                 :            :  * @sgs: sched_group statistics
    8126                 :            :  *
    8127                 :            :  * Determine if @sg is a busier group than the previously selected
    8128                 :            :  * busiest group.
    8129                 :            :  *
    8130                 :            :  * Return: %true if @sg is a busier group than the previously selected
    8131                 :            :  * busiest group. %false otherwise.
    8132                 :            :  */
    8133                 :          3 : static bool update_sd_pick_busiest(struct lb_env *env,
    8134                 :            :                                    struct sd_lb_stats *sds,
    8135                 :            :                                    struct sched_group *sg,
    8136                 :            :                                    struct sg_lb_stats *sgs)
    8137                 :            : {
    8138                 :            :         struct sg_lb_stats *busiest = &sds->busiest_stat;
    8139                 :            : 
    8140                 :            :         /*
    8141                 :            :          * Don't try to pull misfit tasks we can't help.
    8142                 :            :          * We can use max_capacity here as reduction in capacity on some
    8143                 :            :          * CPUs in the group should either be possible to resolve
    8144                 :            :          * internally or be covered by avg_load imbalance (eventually).
    8145                 :            :          */
    8146                 :          3 :         if (sgs->group_type == group_misfit_task &&
    8147                 :          0 :             (!group_smaller_max_cpu_capacity(sg, sds->local) ||
    8148                 :            :              !group_has_capacity(env, &sds->local_stat)))
    8149                 :            :                 return false;
    8150                 :            : 
    8151                 :          3 :         if (sgs->group_type > busiest->group_type)
    8152                 :            :                 return true;
    8153                 :            : 
    8154                 :          3 :         if (sgs->group_type < busiest->group_type)
    8155                 :            :                 return false;
    8156                 :            : 
    8157                 :          3 :         if (sgs->avg_load <= busiest->avg_load)
    8158                 :            :                 return false;
    8159                 :            : 
    8160                 :          3 :         if (!(env->sd->flags & SD_ASYM_CPUCAPACITY))
    8161                 :            :                 goto asym_packing;
    8162                 :            : 
    8163                 :            :         /*
    8164                 :            :          * Candidate sg has no more than one task per CPU and
    8165                 :            :          * has higher per-CPU capacity. Migrating tasks to less
    8166                 :            :          * capable CPUs may harm throughput. Maximize throughput,
    8167                 :            :          * power/energy consequences are not considered.
    8168                 :            :          */
    8169                 :          0 :         if (sgs->sum_nr_running <= sgs->group_weight &&
    8170                 :          0 :             group_smaller_min_cpu_capacity(sds->local, sg))
    8171                 :            :                 return false;
    8172                 :            : 
    8173                 :            :         /*
    8174                 :            :          * If we have more than one misfit sg go with the biggest misfit.
    8175                 :            :          */
    8176                 :          3 :         if (sgs->group_type == group_misfit_task &&
    8177                 :          0 :             sgs->group_misfit_task_load < busiest->group_misfit_task_load)
    8178                 :            :                 return false;
    8179                 :            : 
    8180                 :            : asym_packing:
    8181                 :            :         /* This is the busiest node in its class. */
    8182                 :          3 :         if (!(env->sd->flags & SD_ASYM_PACKING))
    8183                 :            :                 return true;
    8184                 :            : 
    8185                 :            :         /* No ASYM_PACKING if target CPU is already busy */
    8186                 :          0 :         if (env->idle == CPU_NOT_IDLE)
    8187                 :            :                 return true;
    8188                 :            :         /*
    8189                 :            :          * ASYM_PACKING needs to move all the work to the highest
    8190                 :            :          * prority CPUs in the group, therefore mark all groups
    8191                 :            :          * of lower priority than ourself as busy.
    8192                 :            :          */
    8193                 :          0 :         if (sgs->sum_nr_running &&
    8194                 :          0 :             sched_asym_prefer(env->dst_cpu, sg->asym_prefer_cpu)) {
    8195                 :          0 :                 if (!sds->busiest)
    8196                 :            :                         return true;
    8197                 :            : 
    8198                 :            :                 /* Prefer to move from lowest priority CPU's work */
    8199                 :          0 :                 if (sched_asym_prefer(sds->busiest->asym_prefer_cpu,
    8200                 :            :                                       sg->asym_prefer_cpu))
    8201                 :            :                         return true;
    8202                 :            :         }
    8203                 :            : 
    8204                 :            :         return false;
    8205                 :            : }
    8206                 :            : 
    8207                 :            : #ifdef CONFIG_NUMA_BALANCING
    8208                 :            : static inline enum fbq_type fbq_classify_group(struct sg_lb_stats *sgs)
    8209                 :            : {
    8210                 :            :         if (sgs->sum_nr_running > sgs->nr_numa_running)
    8211                 :            :                 return regular;
    8212                 :            :         if (sgs->sum_nr_running > sgs->nr_preferred_running)
    8213                 :            :                 return remote;
    8214                 :            :         return all;
    8215                 :            : }
    8216                 :            : 
    8217                 :            : static inline enum fbq_type fbq_classify_rq(struct rq *rq)
    8218                 :            : {
    8219                 :            :         if (rq->nr_running > rq->nr_numa_running)
    8220                 :            :                 return regular;
    8221                 :            :         if (rq->nr_running > rq->nr_preferred_running)
    8222                 :            :                 return remote;
    8223                 :            :         return all;
    8224                 :            : }
    8225                 :            : #else
    8226                 :            : static inline enum fbq_type fbq_classify_group(struct sg_lb_stats *sgs)
    8227                 :            : {
    8228                 :            :         return all;
    8229                 :            : }
    8230                 :            : 
    8231                 :            : static inline enum fbq_type fbq_classify_rq(struct rq *rq)
    8232                 :            : {
    8233                 :            :         return regular;
    8234                 :            : }
    8235                 :            : #endif /* CONFIG_NUMA_BALANCING */
    8236                 :            : 
    8237                 :            : /**
    8238                 :            :  * update_sd_lb_stats - Update sched_domain's statistics for load balancing.
    8239                 :            :  * @env: The load balancing environment.
    8240                 :            :  * @sds: variable to hold the statistics for this sched_domain.
    8241                 :            :  */
    8242                 :          3 : static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sds)
    8243                 :            : {
    8244                 :          3 :         struct sched_domain *child = env->sd->child;
    8245                 :          3 :         struct sched_group *sg = env->sd->groups;
    8246                 :          3 :         struct sg_lb_stats *local = &sds->local_stat;
    8247                 :            :         struct sg_lb_stats tmp_sgs;
    8248                 :          3 :         bool prefer_sibling = child && child->flags & SD_PREFER_SIBLING;
    8249                 :          3 :         int sg_status = 0;
    8250                 :            : 
    8251                 :            : #ifdef CONFIG_NO_HZ_COMMON
    8252                 :          3 :         if (env->idle == CPU_NEWLY_IDLE && READ_ONCE(nohz.has_blocked))
    8253                 :          3 :                 env->flags |= LBF_NOHZ_STATS;
    8254                 :            : #endif
    8255                 :            : 
    8256                 :            :         do {
    8257                 :            :                 struct sg_lb_stats *sgs = &tmp_sgs;
    8258                 :            :                 int local_group;
    8259                 :            : 
    8260                 :          3 :                 local_group = cpumask_test_cpu(env->dst_cpu, sched_group_span(sg));
    8261                 :          3 :                 if (local_group) {
    8262                 :          3 :                         sds->local = sg;
    8263                 :            :                         sgs = local;
    8264                 :            : 
    8265                 :          3 :                         if (env->idle != CPU_NEWLY_IDLE ||
    8266                 :          3 :                             time_after_eq(jiffies, sg->sgc->next_update))
    8267                 :          3 :                                 update_group_capacity(env->sd, env->dst_cpu);
    8268                 :            :                 }
    8269                 :            : 
    8270                 :          3 :                 update_sg_lb_stats(env, sg, sgs, &sg_status);
    8271                 :            : 
    8272                 :          3 :                 if (local_group)
    8273                 :            :                         goto next_group;
    8274                 :            : 
    8275                 :            :                 /*
    8276                 :            :                  * In case the child domain prefers tasks go to siblings
    8277                 :            :                  * first, lower the sg capacity so that we'll try
    8278                 :            :                  * and move all the excess tasks away. We lower the capacity
    8279                 :            :                  * of a group only if the local group has the capacity to fit
    8280                 :            :                  * these excess tasks. The extra check prevents the case where
    8281                 :            :                  * you always pull from the heaviest group when it is already
    8282                 :            :                  * under-utilized (possible with a large weight task outweighs
    8283                 :            :                  * the tasks on the system).
    8284                 :            :                  */
    8285                 :          3 :                 if (prefer_sibling && sds->local &&
    8286                 :          0 :                     group_has_capacity(env, local) &&
    8287                 :          0 :                     (sgs->sum_nr_running > local->sum_nr_running + 1)) {
    8288                 :          0 :                         sgs->group_no_capacity = 1;
    8289                 :          0 :                         sgs->group_type = group_classify(sg, sgs);
    8290                 :            :                 }
    8291                 :            : 
    8292                 :          3 :                 if (update_sd_pick_busiest(env, sds, sg, sgs)) {
    8293                 :          3 :                         sds->busiest = sg;
    8294                 :          3 :                         sds->busiest_stat = *sgs;
    8295                 :            :                 }
    8296                 :            : 
    8297                 :            : next_group:
    8298                 :            :                 /* Now, start updating sd_lb_stats */
    8299                 :          3 :                 sds->total_running += sgs->sum_nr_running;
    8300                 :          3 :                 sds->total_load += sgs->group_load;
    8301                 :          3 :                 sds->total_capacity += sgs->group_capacity;
    8302                 :            : 
    8303                 :          3 :                 sg = sg->next;
    8304                 :          3 :         } while (sg != env->sd->groups);
    8305                 :            : 
    8306                 :            : #ifdef CONFIG_NO_HZ_COMMON
    8307                 :          3 :         if ((env->flags & LBF_NOHZ_AGAIN) &&
    8308                 :          3 :             cpumask_subset(nohz.idle_cpus_mask, sched_domain_span(env->sd))) {
    8309                 :            : 
    8310                 :          3 :                 WRITE_ONCE(nohz.next_blocked,
    8311                 :            :                            jiffies + msecs_to_jiffies(LOAD_AVG_PERIOD));
    8312                 :            :         }
    8313                 :            : #endif
    8314                 :            : 
    8315                 :          3 :         if (env->sd->flags & SD_NUMA)
    8316                 :          0 :                 env->fbq_type = fbq_classify_group(&sds->busiest_stat);
    8317                 :            : 
    8318                 :          3 :         if (!env->sd->parent) {
    8319                 :          3 :                 struct root_domain *rd = env->dst_rq->rd;
    8320                 :            : 
    8321                 :            :                 /* update overload indicator if we are at root domain */
    8322                 :          3 :                 WRITE_ONCE(rd->overload, sg_status & SG_OVERLOAD);
    8323                 :            : 
    8324                 :            :                 /* Update over-utilization (tipping point, U >= 0) indicator */
    8325                 :          3 :                 WRITE_ONCE(rd->overutilized, sg_status & SG_OVERUTILIZED);
    8326                 :          3 :                 trace_sched_overutilized_tp(rd, sg_status & SG_OVERUTILIZED);
    8327                 :          0 :         } else if (sg_status & SG_OVERUTILIZED) {
    8328                 :          0 :                 struct root_domain *rd = env->dst_rq->rd;
    8329                 :            : 
    8330                 :            :                 WRITE_ONCE(rd->overutilized, SG_OVERUTILIZED);
    8331                 :          0 :                 trace_sched_overutilized_tp(rd, SG_OVERUTILIZED);
    8332                 :            :         }
    8333                 :          3 : }
    8334                 :            : 
    8335                 :            : /**
    8336                 :            :  * check_asym_packing - Check to see if the group is packed into the
    8337                 :            :  *                      sched domain.
    8338                 :            :  *
    8339                 :            :  * This is primarily intended to used at the sibling level.  Some
    8340                 :            :  * cores like POWER7 prefer to use lower numbered SMT threads.  In the
    8341                 :            :  * case of POWER7, it can move to lower SMT modes only when higher
    8342                 :            :  * threads are idle.  When in lower SMT modes, the threads will
    8343                 :            :  * perform better since they share less core resources.  Hence when we
    8344                 :            :  * have idle threads, we want them to be the higher ones.
    8345                 :            :  *
    8346                 :            :  * This packing function is run on idle threads.  It checks to see if
    8347                 :            :  * the busiest CPU in this domain (core in the P7 case) has a higher
    8348                 :            :  * CPU number than the packing function is being run on.  Here we are
    8349                 :            :  * assuming lower CPU number will be equivalent to lower a SMT thread
    8350                 :            :  * number.
    8351                 :            :  *
    8352                 :            :  * Return: 1 when packing is required and a task should be moved to
    8353                 :            :  * this CPU.  The amount of the imbalance is returned in env->imbalance.
    8354                 :            :  *
    8355                 :            :  * @env: The load balancing environment.
    8356                 :            :  * @sds: Statistics of the sched_domain which is to be packed
    8357                 :            :  */
    8358                 :          3 : static int check_asym_packing(struct lb_env *env, struct sd_lb_stats *sds)
    8359                 :            : {
    8360                 :            :         int busiest_cpu;
    8361                 :            : 
    8362                 :          3 :         if (!(env->sd->flags & SD_ASYM_PACKING))
    8363                 :            :                 return 0;
    8364                 :            : 
    8365                 :          0 :         if (env->idle == CPU_NOT_IDLE)
    8366                 :            :                 return 0;
    8367                 :            : 
    8368                 :          0 :         if (!sds->busiest)
    8369                 :            :                 return 0;
    8370                 :            : 
    8371                 :          0 :         busiest_cpu = sds->busiest->asym_prefer_cpu;
    8372                 :          0 :         if (sched_asym_prefer(busiest_cpu, env->dst_cpu))
    8373                 :            :                 return 0;
    8374                 :            : 
    8375                 :          0 :         env->imbalance = sds->busiest_stat.group_load;
    8376                 :            : 
    8377                 :          0 :         return 1;
    8378                 :            : }
    8379                 :            : 
    8380                 :            : /**
    8381                 :            :  * fix_small_imbalance - Calculate the minor imbalance that exists
    8382                 :            :  *                      amongst the groups of a sched_domain, during
    8383                 :            :  *                      load balancing.
    8384                 :            :  * @env: The load balancing environment.
    8385                 :            :  * @sds: Statistics of the sched_domain whose imbalance is to be calculated.
    8386                 :            :  */
    8387                 :            : static inline
    8388                 :          3 : void fix_small_imbalance(struct lb_env *env, struct sd_lb_stats *sds)
    8389                 :            : {
    8390                 :            :         unsigned long tmp, capa_now = 0, capa_move = 0;
    8391                 :            :         unsigned int imbn = 2;
    8392                 :            :         unsigned long scaled_busy_load_per_task;
    8393                 :            :         struct sg_lb_stats *local, *busiest;
    8394                 :            : 
    8395                 :            :         local = &sds->local_stat;
    8396                 :            :         busiest = &sds->busiest_stat;
    8397                 :            : 
    8398                 :          3 :         if (!local->sum_nr_running)
    8399                 :          3 :                 local->load_per_task = cpu_avg_load_per_task(env->dst_cpu);
    8400                 :          3 :         else if (busiest->load_per_task > local->load_per_task)
    8401                 :            :                 imbn = 1;
    8402                 :            : 
    8403                 :          3 :         scaled_busy_load_per_task =
    8404                 :          3 :                 (busiest->load_per_task * SCHED_CAPACITY_SCALE) /
    8405                 :          3 :                 busiest->group_capacity;
    8406                 :            : 
    8407                 :          3 :         if (busiest->avg_load + scaled_busy_load_per_task >=
    8408                 :          3 :             local->avg_load + (scaled_busy_load_per_task * imbn)) {
    8409                 :          3 :                 env->imbalance = busiest->load_per_task;
    8410                 :          3 :                 return;
    8411                 :            :         }
    8412                 :            : 
    8413                 :            :         /*
    8414                 :            :          * OK, we don't have enough imbalance to justify moving tasks,
    8415                 :            :          * however we may be able to increase total CPU capacity used by
    8416                 :            :          * moving them.
    8417                 :            :          */
    8418                 :            : 
    8419                 :          3 :         capa_now += busiest->group_capacity *
    8420                 :          3 :                         min(busiest->load_per_task, busiest->avg_load);
    8421                 :          3 :         capa_now += local->group_capacity *
    8422                 :          3 :                         min(local->load_per_task, local->avg_load);
    8423                 :          3 :         capa_now /= SCHED_CAPACITY_SCALE;
    8424                 :            : 
    8425                 :            :         /* Amount of load we'd subtract */
    8426                 :          3 :         if (busiest->avg_load > scaled_busy_load_per_task) {
    8427                 :          3 :                 capa_move += busiest->group_capacity *
    8428                 :          3 :                             min(busiest->load_per_task,
    8429                 :            :                                 busiest->avg_load - scaled_busy_load_per_task);
    8430                 :            :         }
    8431                 :            : 
    8432                 :            :         /* Amount of load we'd add */
    8433                 :          3 :         if (busiest->avg_load * busiest->group_capacity <
    8434                 :            :             busiest->load_per_task * SCHED_CAPACITY_SCALE) {
    8435                 :          3 :                 tmp = (busiest->avg_load * busiest->group_capacity) /
    8436                 :            :                       local->group_capacity;
    8437                 :            :         } else {
    8438                 :          3 :                 tmp = (busiest->load_per_task * SCHED_CAPACITY_SCALE) /
    8439                 :            :                       local->group_capacity;
    8440                 :            :         }
    8441                 :          3 :         capa_move += local->group_capacity *
    8442                 :          3 :                     min(local->load_per_task, local->avg_load + tmp);
    8443                 :          3 :         capa_move /= SCHED_CAPACITY_SCALE;
    8444                 :            : 
    8445                 :            :         /* Move if we gain throughput */
    8446                 :          3 :         if (capa_move > capa_now)
    8447                 :          0 :                 env->imbalance = busiest->load_per_task;
    8448                 :            : }
    8449                 :            : 
    8450                 :            : /**
    8451                 :            :  * calculate_imbalance - Calculate the amount of imbalance present within the
    8452                 :            :  *                       groups of a given sched_domain during load balance.
    8453                 :            :  * @env: load balance environment
    8454                 :            :  * @sds: statistics of the sched_domain whose imbalance is to be calculated.
    8455                 :            :  */
    8456                 :          3 : static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *sds)
    8457                 :            : {
    8458                 :            :         unsigned long max_pull, load_above_capacity = ~0UL;
    8459                 :            :         struct sg_lb_stats *local, *busiest;
    8460                 :            : 
    8461                 :            :         local = &sds->local_stat;
    8462                 :            :         busiest = &sds->busiest_stat;
    8463                 :            : 
    8464                 :          3 :         if (busiest->group_type == group_imbalanced) {
    8465                 :            :                 /*
    8466                 :            :                  * In the group_imb case we cannot rely on group-wide averages
    8467                 :            :                  * to ensure CPU-load equilibrium, look at wider averages. XXX
    8468                 :            :                  */
    8469                 :          0 :                 busiest->load_per_task =
    8470                 :          0 :                         min(busiest->load_per_task, sds->avg_load);
    8471                 :            :         }
    8472                 :            : 
    8473                 :            :         /*
    8474                 :            :          * Avg load of busiest sg can be less and avg load of local sg can
    8475                 :            :          * be greater than avg load across all sgs of sd because avg load
    8476                 :            :          * factors in sg capacity and sgs with smaller group_type are
    8477                 :            :          * skipped when updating the busiest sg:
    8478                 :            :          */
    8479                 :          3 :         if (busiest->group_type != group_misfit_task &&
    8480                 :          3 :             (busiest->avg_load <= sds->avg_load ||
    8481                 :          3 :              local->avg_load >= sds->avg_load)) {
    8482                 :          3 :                 env->imbalance = 0;
    8483                 :          3 :                 return fix_small_imbalance(env, sds);
    8484                 :            :         }
    8485                 :            : 
    8486                 :            :         /*
    8487                 :            :          * If there aren't any idle CPUs, avoid creating some.
    8488                 :            :          */
    8489                 :          3 :         if (busiest->group_type == group_overloaded &&
    8490                 :          3 :             local->group_type   == group_overloaded) {
    8491                 :          3 :                 load_above_capacity = busiest->sum_nr_running * SCHED_CAPACITY_SCALE;
    8492                 :          3 :                 if (load_above_capacity > busiest->group_capacity) {
    8493                 :          3 :                         load_above_capacity -= busiest->group_capacity;
    8494                 :          3 :                         load_above_capacity *= scale_load_down(NICE_0_LOAD);
    8495                 :          3 :                         load_above_capacity /= busiest->group_capacity;
    8496                 :            :                 } else
    8497                 :            :                         load_above_capacity = ~0UL;
    8498                 :            :         }
    8499                 :            : 
    8500                 :            :         /*
    8501                 :            :          * We're trying to get all the CPUs to the average_load, so we don't
    8502                 :            :          * want to push ourselves above the average load, nor do we wish to
    8503                 :            :          * reduce the max loaded CPU below the average load. At the same time,
    8504                 :            :          * we also don't want to reduce the group load below the group
    8505                 :            :          * capacity. Thus we look for the minimum possible imbalance.
    8506                 :            :          */
    8507                 :          3 :         max_pull = min(busiest->avg_load - sds->avg_load, load_above_capacity);
    8508                 :            : 
    8509                 :            :         /* How much load to actually move to equalise the imbalance */
    8510                 :          3 :         env->imbalance = min(
    8511                 :            :                 max_pull * busiest->group_capacity,
    8512                 :            :                 (sds->avg_load - local->avg_load) * local->group_capacity
    8513                 :          3 :         ) / SCHED_CAPACITY_SCALE;
    8514                 :            : 
    8515                 :            :         /* Boost imbalance to allow misfit task to be balanced. */
    8516                 :          3 :         if (busiest->group_type == group_misfit_task) {
    8517                 :          0 :                 env->imbalance = max_t(long, env->imbalance,
    8518                 :            :                                        busiest->group_misfit_task_load);
    8519                 :            :         }
    8520                 :            : 
    8521                 :            :         /*
    8522                 :            :          * if *imbalance is less than the average load per runnable task
    8523                 :            :          * there is no guarantee that any tasks will be moved so we'll have
    8524                 :            :          * a think about bumping its value to force at least one task to be
    8525                 :            :          * moved
    8526                 :            :          */
    8527                 :          3 :         if (env->imbalance < busiest->load_per_task)
    8528                 :          3 :                 return fix_small_imbalance(env, sds);
    8529                 :            : }
    8530                 :            : 
    8531                 :            : /******* find_busiest_group() helpers end here *********************/
    8532                 :            : 
    8533                 :            : /**
    8534                 :            :  * find_busiest_group - Returns the busiest group within the sched_domain
    8535                 :            :  * if there is an imbalance.
    8536                 :            :  *
    8537                 :            :  * Also calculates the amount of runnable load which should be moved
    8538                 :            :  * to restore balance.
    8539                 :            :  *
    8540                 :            :  * @env: The load balancing environment.
    8541                 :            :  *
    8542                 :            :  * Return:      - The busiest group if imbalance exists.
    8543                 :            :  */
    8544                 :          3 : static struct sched_group *find_busiest_group(struct lb_env *env)
    8545                 :            : {
    8546                 :            :         struct sg_lb_stats *local, *busiest;
    8547                 :            :         struct sd_lb_stats sds;
    8548                 :            : 
    8549                 :            :         init_sd_lb_stats(&sds);
    8550                 :            : 
    8551                 :            :         /*
    8552                 :            :          * Compute the various statistics relavent for load balancing at
    8553                 :            :          * this level.
    8554                 :            :          */
    8555                 :          3 :         update_sd_lb_stats(env, &sds);
    8556                 :            : 
    8557                 :            :         if (sched_energy_enabled()) {
    8558                 :            :                 struct root_domain *rd = env->dst_rq->rd;
    8559                 :            : 
    8560                 :            :                 if (rcu_dereference(rd->pd) && !READ_ONCE(rd->overutilized))
    8561                 :            :                         goto out_balanced;
    8562                 :            :         }
    8563                 :            : 
    8564                 :            :         local = &sds.local_stat;
    8565                 :            :         busiest = &sds.busiest_stat;
    8566                 :            : 
    8567                 :            :         /* ASYM feature bypasses nice load balance check */
    8568                 :          3 :         if (check_asym_packing(env, &sds))
    8569                 :          0 :                 return sds.busiest;
    8570                 :            : 
    8571                 :            :         /* There is no busy sibling group to pull tasks from */
    8572                 :          3 :         if (!sds.busiest || busiest->sum_nr_running == 0)
    8573                 :            :                 goto out_balanced;
    8574                 :            : 
    8575                 :            :         /* XXX broken for overlapping NUMA groups */
    8576                 :          3 :         sds.avg_load = (SCHED_CAPACITY_SCALE * sds.total_load)
    8577                 :          3 :                                                 / sds.total_capacity;
    8578                 :            : 
    8579                 :            :         /*
    8580                 :            :          * If the busiest group is imbalanced the below checks don't
    8581                 :            :          * work because they assume all things are equal, which typically
    8582                 :            :          * isn't true due to cpus_ptr constraints and the like.
    8583                 :            :          */
    8584                 :          3 :         if (busiest->group_type == group_imbalanced)
    8585                 :            :                 goto force_balance;
    8586                 :            : 
    8587                 :            :         /*
    8588                 :            :          * When dst_cpu is idle, prevent SMP nice and/or asymmetric group
    8589                 :            :          * capacities from resulting in underutilization due to avg_load.
    8590                 :            :          */
    8591                 :          3 :         if (env->idle != CPU_NOT_IDLE && group_has_capacity(env, local) &&
    8592                 :          3 :             busiest->group_no_capacity)
    8593                 :            :                 goto force_balance;
    8594                 :            : 
    8595                 :            :         /* Misfit tasks should be dealt with regardless of the avg load */
    8596                 :          3 :         if (busiest->group_type == group_misfit_task)
    8597                 :            :                 goto force_balance;
    8598                 :            : 
    8599                 :            :         /*
    8600                 :            :          * If the local group is busier than the selected busiest group
    8601                 :            :          * don't try and pull any tasks.
    8602                 :            :          */
    8603                 :          3 :         if (local->avg_load >= busiest->avg_load)
    8604                 :            :                 goto out_balanced;
    8605                 :            : 
    8606                 :            :         /*
    8607                 :            :          * Don't pull any tasks if this group is already above the domain
    8608                 :            :          * average load.
    8609                 :            :          */
    8610                 :          3 :         if (local->avg_load >= sds.avg_load)
    8611                 :            :                 goto out_balanced;
    8612                 :            : 
    8613                 :          3 :         if (env->idle == CPU_IDLE) {
    8614                 :            :                 /*
    8615                 :            :                  * This CPU is idle. If the busiest group is not overloaded
    8616                 :            :                  * and there is no imbalance between this and busiest group
    8617                 :            :                  * wrt idle CPUs, it is balanced. The imbalance becomes
    8618                 :            :                  * significant if the diff is greater than 1 otherwise we
    8619                 :            :                  * might end up to just move the imbalance on another group
    8620                 :            :                  */
    8621                 :          3 :                 if ((busiest->group_type != group_overloaded) &&
    8622                 :          3 :                                 (local->idle_cpus <= (busiest->idle_cpus + 1)))
    8623                 :            :                         goto out_balanced;
    8624                 :            :         } else {
    8625                 :            :                 /*
    8626                 :            :                  * In the CPU_NEWLY_IDLE, CPU_NOT_IDLE cases, use
    8627                 :            :                  * imbalance_pct to be conservative.
    8628                 :            :                  */
    8629                 :          3 :                 if (100 * busiest->avg_load <=
    8630                 :          3 :                                 env->sd->imbalance_pct * local->avg_load)
    8631                 :            :                         goto out_balanced;
    8632                 :            :         }
    8633                 :            : 
    8634                 :            : force_balance:
    8635                 :            :         /* Looks like there is an imbalance. Compute it */
    8636                 :          3 :         env->src_grp_type = busiest->group_type;
    8637                 :          3 :         calculate_imbalance(env, &sds);
    8638                 :          3 :         return env->imbalance ? sds.busiest : NULL;
    8639                 :            : 
    8640                 :            : out_balanced:
    8641                 :          3 :         env->imbalance = 0;
    8642                 :          3 :         return NULL;
    8643                 :            : }
    8644                 :            : 
    8645                 :            : /*
    8646                 :            :  * find_busiest_queue - find the busiest runqueue among the CPUs in the group.
    8647                 :            :  */
    8648                 :          3 : static struct rq *find_busiest_queue(struct lb_env *env,
    8649                 :            :                                      struct sched_group *group)
    8650                 :            : {
    8651                 :            :         struct rq *busiest = NULL, *rq;
    8652                 :            :         unsigned long busiest_load = 0, busiest_capacity = 1;
    8653                 :            :         int i;
    8654                 :            : 
    8655                 :          3 :         for_each_cpu_and(i, sched_group_span(group), env->cpus) {
    8656                 :            :                 unsigned long capacity, load;
    8657                 :            :                 enum fbq_type rt;
    8658                 :            : 
    8659                 :          3 :                 rq = cpu_rq(i);
    8660                 :            :                 rt = fbq_classify_rq(rq);
    8661                 :            : 
    8662                 :            :                 /*
    8663                 :            :                  * We classify groups/runqueues into three groups:
    8664                 :            :                  *  - regular: there are !numa tasks
    8665                 :            :                  *  - remote:  there are numa tasks that run on the 'wrong' node
    8666                 :            :                  *  - all:     there is no distinction
    8667                 :            :                  *
    8668                 :            :                  * In order to avoid migrating ideally placed numa tasks,
    8669                 :            :                  * ignore those when there's better options.
    8670                 :            :                  *
    8671                 :            :                  * If we ignore the actual busiest queue to migrate another
    8672                 :            :                  * task, the next balance pass can still reduce the busiest
    8673                 :            :                  * queue by moving tasks around inside the node.
    8674                 :            :                  *
    8675                 :            :                  * If we cannot move enough load due to this classification
    8676                 :            :                  * the next pass will adjust the group classification and
    8677                 :            :                  * allow migration of more tasks.
    8678                 :            :                  *
    8679                 :            :                  * Both cases only affect the total convergence complexity.
    8680                 :            :                  */
    8681                 :            :                 if (rt > env->fbq_type)
    8682                 :            :                         continue;
    8683                 :            : 
    8684                 :            :                 /*
    8685                 :            :                  * For ASYM_CPUCAPACITY domains with misfit tasks we simply
    8686                 :            :                  * seek the "biggest" misfit task.
    8687                 :            :                  */
    8688                 :          3 :                 if (env->src_grp_type == group_misfit_task) {
    8689                 :          0 :                         if (rq->misfit_task_load > busiest_load) {
    8690                 :            :                                 busiest_load = rq->misfit_task_load;
    8691                 :            :                                 busiest = rq;
    8692                 :            :                         }
    8693                 :            : 
    8694                 :          0 :                         continue;
    8695                 :            :                 }
    8696                 :            : 
    8697                 :            :                 capacity = capacity_of(i);
    8698                 :            : 
    8699                 :            :                 /*
    8700                 :            :                  * For ASYM_CPUCAPACITY domains, don't pick a CPU that could
    8701                 :            :                  * eventually lead to active_balancing high->low capacity.
    8702                 :            :                  * Higher per-CPU capacity is considered better than balancing
    8703                 :            :                  * average load.
    8704                 :            :                  */
    8705                 :          3 :                 if (env->sd->flags & SD_ASYM_CPUCAPACITY &&
    8706                 :          0 :                     capacity_of(env->dst_cpu) < capacity &&
    8707                 :          0 :                     rq->nr_running == 1)
    8708                 :          0 :                         continue;
    8709                 :            : 
    8710                 :            :                 load = cpu_runnable_load(rq);
    8711                 :            : 
    8712                 :            :                 /*
    8713                 :            :                  * When comparing with imbalance, use cpu_runnable_load()
    8714                 :            :                  * which is not scaled with the CPU capacity.
    8715                 :            :                  */
    8716                 :            : 
    8717                 :          3 :                 if (rq->nr_running == 1 && load > env->imbalance &&
    8718                 :            :                     !check_cpu_capacity(rq, env->sd))
    8719                 :          3 :                         continue;
    8720                 :            : 
    8721                 :            :                 /*
    8722                 :            :                  * For the load comparisons with the other CPU's, consider
    8723                 :            :                  * the cpu_runnable_load() scaled with the CPU capacity, so
    8724                 :            :                  * that the load can be moved away from the CPU that is
    8725                 :            :                  * potentially running at a lower capacity.
    8726                 :            :                  *
    8727                 :            :                  * Thus we're looking for max(load_i / capacity_i), crosswise
    8728                 :            :                  * multiplication to rid ourselves of the division works out
    8729                 :            :                  * to: load_i * capacity_j > load_j * capacity_i;  where j is
    8730                 :            :                  * our previous maximum.
    8731                 :            :                  */
    8732                 :          3 :                 if (load * busiest_capacity > busiest_load * capacity) {
    8733                 :            :                         busiest_load = load;
    8734                 :            :                         busiest_capacity = capacity;
    8735                 :            :                         busiest = rq;
    8736                 :            :                 }
    8737                 :            :         }
    8738                 :            : 
    8739                 :          3 :         return busiest;
    8740                 :            : }
    8741                 :            : 
    8742                 :            : /*
    8743                 :            :  * Max backoff if we encounter pinned tasks. Pretty arbitrary value, but
    8744                 :            :  * so long as it is large enough.
    8745                 :            :  */
    8746                 :            : #define MAX_PINNED_INTERVAL     512
    8747                 :            : 
    8748                 :            : static inline bool
    8749                 :          3 : asym_active_balance(struct lb_env *env)
    8750                 :            : {
    8751                 :            :         /*
    8752                 :            :          * ASYM_PACKING needs to force migrate tasks from busy but
    8753                 :            :          * lower priority CPUs in order to pack all tasks in the
    8754                 :            :          * highest priority CPUs.
    8755                 :            :          */
    8756                 :          3 :         return env->idle != CPU_NOT_IDLE && (env->sd->flags & SD_ASYM_PACKING) &&
    8757                 :          0 :                sched_asym_prefer(env->dst_cpu, env->src_cpu);
    8758                 :            : }
    8759                 :            : 
    8760                 :            : static inline bool
    8761                 :          3 : voluntary_active_balance(struct lb_env *env)
    8762                 :            : {
    8763                 :          3 :         struct sched_domain *sd = env->sd;
    8764                 :            : 
    8765                 :          3 :         if (asym_active_balance(env))
    8766                 :            :                 return 1;
    8767                 :            : 
    8768                 :            :         /*
    8769                 :            :          * The dst_cpu is idle and the src_cpu CPU has only 1 CFS task.
    8770                 :            :          * It's worth migrating the task if the src_cpu's capacity is reduced
    8771                 :            :          * because of other sched_class or IRQs if more capacity stays
    8772                 :            :          * available on dst_cpu.
    8773                 :            :          */
    8774                 :          3 :         if ((env->idle != CPU_NOT_IDLE) &&
    8775                 :          3 :             (env->src_rq->cfs.h_nr_running == 1)) {
    8776                 :          3 :                 if ((check_cpu_capacity(env->src_rq, sd)) &&
    8777                 :          0 :                     (capacity_of(env->src_cpu)*sd->imbalance_pct < capacity_of(env->dst_cpu)*100))
    8778                 :            :                         return 1;
    8779                 :            :         }
    8780                 :            : 
    8781                 :          3 :         if (env->src_grp_type == group_misfit_task)
    8782                 :            :                 return 1;
    8783                 :            : 
    8784                 :          3 :         return 0;
    8785                 :            : }
    8786                 :            : 
    8787                 :          3 : static int need_active_balance(struct lb_env *env)
    8788                 :            : {
    8789                 :          3 :         struct sched_domain *sd = env->sd;
    8790                 :            : 
    8791                 :          3 :         if (voluntary_active_balance(env))
    8792                 :            :                 return 1;
    8793                 :            : 
    8794                 :          3 :         return unlikely(sd->nr_balance_failed > sd->cache_nice_tries+2);
    8795                 :            : }
    8796                 :            : 
    8797                 :            : static int active_load_balance_cpu_stop(void *data);
    8798                 :            : 
    8799                 :          3 : static int should_we_balance(struct lb_env *env)
    8800                 :            : {
    8801                 :          3 :         struct sched_group *sg = env->sd->groups;
    8802                 :            :         int cpu, balance_cpu = -1;
    8803                 :            : 
    8804                 :            :         /*
    8805                 :            :          * Ensure the balancing environment is consistent; can happen
    8806                 :            :          * when the softirq triggers 'during' hotplug.
    8807                 :            :          */
    8808                 :          3 :         if (!cpumask_test_cpu(env->dst_cpu, env->cpus))
    8809                 :            :                 return 0;
    8810                 :            : 
    8811                 :            :         /*
    8812                 :            :          * In the newly idle case, we will allow all the CPUs
    8813                 :            :          * to do the newly idle load balance.
    8814                 :            :          */
    8815                 :          3 :         if (env->idle == CPU_NEWLY_IDLE)
    8816                 :            :                 return 1;
    8817                 :            : 
    8818                 :            :         /* Try to find first idle CPU */
    8819                 :          3 :         for_each_cpu_and(cpu, group_balance_mask(sg), env->cpus) {
    8820                 :          3 :                 if (!idle_cpu(cpu))
    8821                 :          3 :                         continue;
    8822                 :            : 
    8823                 :          3 :                 balance_cpu = cpu;
    8824                 :          3 :                 break;
    8825                 :            :         }
    8826                 :            : 
    8827                 :          3 :         if (balance_cpu == -1)
    8828                 :          3 :                 balance_cpu = group_balance_cpu(sg);
    8829                 :            : 
    8830                 :            :         /*
    8831                 :            :          * First idle CPU or the first CPU(busiest) in this sched group
    8832                 :            :          * is eligible for doing load balancing at this and above domains.
    8833                 :            :          */
    8834                 :          3 :         return balance_cpu == env->dst_cpu;
    8835                 :            : }
    8836                 :            : 
    8837                 :            : /*
    8838                 :            :  * Check this_cpu to ensure it is balanced within domain. Attempt to move
    8839                 :            :  * tasks if there is an imbalance.
    8840                 :            :  */
    8841                 :          3 : static int load_balance(int this_cpu, struct rq *this_rq,
    8842                 :            :                         struct sched_domain *sd, enum cpu_idle_type idle,
    8843                 :            :                         int *continue_balancing)
    8844                 :            : {
    8845                 :            :         int ld_moved, cur_ld_moved, active_balance = 0;
    8846                 :          3 :         struct sched_domain *sd_parent = sd->parent;
    8847                 :            :         struct sched_group *group;
    8848                 :            :         struct rq *busiest;
    8849                 :            :         struct rq_flags rf;
    8850                 :          3 :         struct cpumask *cpus = this_cpu_cpumask_var_ptr(load_balance_mask);
    8851                 :            : 
    8852                 :          3 :         struct lb_env env = {
    8853                 :            :                 .sd             = sd,
    8854                 :            :                 .dst_cpu        = this_cpu,
    8855                 :            :                 .dst_rq         = this_rq,
    8856                 :          3 :                 .dst_grpmask    = sched_group_span(sd->groups),
    8857                 :            :                 .idle           = idle,
    8858                 :            :                 .loop_break     = sched_nr_migrate_break,
    8859                 :            :                 .cpus           = cpus,
    8860                 :            :                 .fbq_type       = all,
    8861                 :            :                 .tasks          = LIST_HEAD_INIT(env.tasks),
    8862                 :            :         };
    8863                 :            : 
    8864                 :            :         cpumask_and(cpus, sched_domain_span(sd), cpu_active_mask);
    8865                 :            : 
    8866                 :          3 :         schedstat_inc(sd->lb_count[idle]);
    8867                 :            : 
    8868                 :            : redo:
    8869                 :          3 :         if (!should_we_balance(&env)) {
    8870                 :          0 :                 *continue_balancing = 0;
    8871                 :          0 :                 goto out_balanced;
    8872                 :            :         }
    8873                 :            : 
    8874                 :          3 :         group = find_busiest_group(&env);
    8875                 :          3 :         if (!group) {
    8876                 :          3 :                 schedstat_inc(sd->lb_nobusyg[idle]);
    8877                 :            :                 goto out_balanced;
    8878                 :            :         }
    8879                 :            : 
    8880                 :          3 :         busiest = find_busiest_queue(&env, group);
    8881                 :          3 :         if (!busiest) {
    8882                 :          3 :                 schedstat_inc(sd->lb_nobusyq[idle]);
    8883                 :            :                 goto out_balanced;
    8884                 :            :         }
    8885                 :            : 
    8886                 :          3 :         BUG_ON(busiest == env.dst_rq);
    8887                 :            : 
    8888                 :          3 :         schedstat_add(sd->lb_imbalance[idle], env.imbalance);
    8889                 :            : 
    8890                 :          3 :         env.src_cpu = busiest->cpu;
    8891                 :          3 :         env.src_rq = busiest;
    8892                 :            : 
    8893                 :            :         ld_moved = 0;
    8894                 :          3 :         if (busiest->nr_running > 1) {
    8895                 :            :                 /*
    8896                 :            :                  * Attempt to move tasks. If find_busiest_group has found
    8897                 :            :                  * an imbalance but busiest->nr_running <= 1, the group is
    8898                 :            :                  * still unbalanced. ld_moved simply stays zero, so it is
    8899                 :            :                  * correctly treated as an imbalance.
    8900                 :            :                  */
    8901                 :          3 :                 env.flags |= LBF_ALL_PINNED;
    8902                 :          3 :                 env.loop_max  = min(sysctl_sched_nr_migrate, busiest->nr_running);
    8903                 :            : 
    8904                 :            : more_balance:
    8905                 :            :                 rq_lock_irqsave(busiest, &rf);
    8906                 :          3 :                 update_rq_clock(busiest);
    8907                 :            : 
    8908                 :            :                 /*
    8909                 :            :                  * cur_ld_moved - load moved in current iteration
    8910                 :            :                  * ld_moved     - cumulative load moved across iterations
    8911                 :            :                  */
    8912                 :          3 :                 cur_ld_moved = detach_tasks(&env);
    8913                 :            : 
    8914                 :            :                 /*
    8915                 :            :                  * We've detached some tasks from busiest_rq. Every
    8916                 :            :                  * task is masked "TASK_ON_RQ_MIGRATING", so we can safely
    8917                 :            :                  * unlock busiest->lock, and we are able to be sure
    8918                 :            :                  * that nobody can manipulate the tasks in parallel.
    8919                 :            :                  * See task_rq_lock() family for the details.
    8920                 :            :                  */
    8921                 :            : 
    8922                 :            :                 rq_unlock(busiest, &rf);
    8923                 :            : 
    8924                 :          3 :                 if (cur_ld_moved) {
    8925                 :          3 :                         attach_tasks(&env);
    8926                 :          3 :                         ld_moved += cur_ld_moved;
    8927                 :            :                 }
    8928                 :            : 
    8929                 :          3 :                 local_irq_restore(rf.flags);
    8930                 :            : 
    8931                 :          3 :                 if (env.flags & LBF_NEED_BREAK) {
    8932                 :          0 :                         env.flags &= ~LBF_NEED_BREAK;
    8933                 :          0 :                         goto more_balance;
    8934                 :            :                 }
    8935                 :            : 
    8936                 :            :                 /*
    8937                 :            :                  * Revisit (affine) tasks on src_cpu that couldn't be moved to
    8938                 :            :                  * us and move them to an alternate dst_cpu in our sched_group
    8939                 :            :                  * where they can run. The upper limit on how many times we
    8940                 :            :                  * iterate on same src_cpu is dependent on number of CPUs in our
    8941                 :            :                  * sched_group.
    8942                 :            :                  *
    8943                 :            :                  * This changes load balance semantics a bit on who can move
    8944                 :            :                  * load to a given_cpu. In addition to the given_cpu itself
    8945                 :            :                  * (or a ilb_cpu acting on its behalf where given_cpu is
    8946                 :            :                  * nohz-idle), we now have balance_cpu in a position to move
    8947                 :            :                  * load to given_cpu. In rare situations, this may cause
    8948                 :            :                  * conflicts (balance_cpu and given_cpu/ilb_cpu deciding
    8949                 :            :                  * _independently_ and at _same_ time to move some load to
    8950                 :            :                  * given_cpu) causing exceess load to be moved to given_cpu.
    8951                 :            :                  * This however should not happen so much in practice and
    8952                 :            :                  * moreover subsequent load balance cycles should correct the
    8953                 :            :                  * excess load moved.
    8954                 :            :                  */
    8955                 :          3 :                 if ((env.flags & LBF_DST_PINNED) && env.imbalance > 0) {
    8956                 :            : 
    8957                 :            :                         /* Prevent to re-select dst_cpu via env's CPUs */
    8958                 :          0 :                         __cpumask_clear_cpu(env.dst_cpu, env.cpus);
    8959                 :            : 
    8960                 :          0 :                         env.dst_rq       = cpu_rq(env.new_dst_cpu);
    8961                 :          0 :                         env.dst_cpu      = env.new_dst_cpu;
    8962                 :          0 :                         env.flags       &= ~LBF_DST_PINNED;
    8963                 :          0 :                         env.loop         = 0;
    8964                 :          0 :                         env.loop_break   = sched_nr_migrate_break;
    8965                 :            : 
    8966                 :            :                         /*
    8967                 :            :                          * Go back to "more_balance" rather than "redo" since we
    8968                 :            :                          * need to continue with same src_cpu.
    8969                 :            :                          */
    8970                 :          0 :                         goto more_balance;
    8971                 :            :                 }
    8972                 :            : 
    8973                 :            :                 /*
    8974                 :            :                  * We failed to reach balance because of affinity.
    8975                 :            :                  */
    8976                 :          3 :                 if (sd_parent) {
    8977                 :          0 :                         int *group_imbalance = &sd_parent->groups->sgc->imbalance;
    8978                 :            : 
    8979                 :          0 :                         if ((env.flags & LBF_SOME_PINNED) && env.imbalance > 0)
    8980                 :          0 :                                 *group_imbalance = 1;
    8981                 :            :                 }
    8982                 :            : 
    8983                 :            :                 /* All tasks on this runqueue were pinned by CPU affinity */
    8984                 :          3 :                 if (unlikely(env.flags & LBF_ALL_PINNED)) {
    8985                 :            :                         __cpumask_clear_cpu(cpu_of(busiest), cpus);
    8986                 :            :                         /*
    8987                 :            :                          * Attempting to continue load balancing at the current
    8988                 :            :                          * sched_domain level only makes sense if there are
    8989                 :            :                          * active CPUs remaining as possible busiest CPUs to
    8990                 :            :                          * pull load from which are not contained within the
    8991                 :            :                          * destination group that is receiving any migrated
    8992                 :            :                          * load.
    8993                 :            :                          */
    8994                 :          3 :                         if (!cpumask_subset(cpus, env.dst_grpmask)) {
    8995                 :          3 :                                 env.loop = 0;
    8996                 :          3 :                                 env.loop_break = sched_nr_migrate_break;
    8997                 :          3 :                                 goto redo;
    8998                 :            :                         }
    8999                 :            :                         goto out_all_pinned;
    9000                 :            :                 }
    9001                 :            :         }
    9002                 :            : 
    9003                 :          3 :         if (!ld_moved) {
    9004                 :          3 :                 schedstat_inc(sd->lb_failed[idle]);
    9005                 :            :                 /*
    9006                 :            :                  * Increment the failure counter only on periodic balance.
    9007                 :            :                  * We do not want newidle balance, which can be very
    9008                 :            :                  * frequent, pollute the failure counter causing
    9009                 :            :                  * excessive cache_hot migrations and active balances.
    9010                 :            :                  */
    9011                 :          3 :                 if (idle != CPU_NEWLY_IDLE)
    9012                 :          3 :                         sd->nr_balance_failed++;
    9013                 :            : 
    9014                 :          3 :                 if (need_active_balance(&env)) {
    9015                 :            :                         unsigned long flags;
    9016                 :            : 
    9017                 :          3 :                         raw_spin_lock_irqsave(&busiest->lock, flags);
    9018                 :            : 
    9019                 :            :                         /*
    9020                 :            :                          * Don't kick the active_load_balance_cpu_stop,
    9021                 :            :                          * if the curr task on busiest CPU can't be
    9022                 :            :                          * moved to this_cpu:
    9023                 :            :                          */
    9024                 :          3 :                         if (!cpumask_test_cpu(this_cpu, busiest->curr->cpus_ptr)) {
    9025                 :          3 :                                 raw_spin_unlock_irqrestore(&busiest->lock,
    9026                 :            :                                                             flags);
    9027                 :          3 :                                 env.flags |= LBF_ALL_PINNED;
    9028                 :          3 :                                 goto out_one_pinned;
    9029                 :            :                         }
    9030                 :            : 
    9031                 :            :                         /*
    9032                 :            :                          * ->active_balance synchronizes accesses to
    9033                 :            :                          * ->active_balance_work.  Once set, it's cleared
    9034                 :            :                          * only after active load balance is finished.
    9035                 :            :                          */
    9036                 :          3 :                         if (!busiest->active_balance) {
    9037                 :          3 :                                 busiest->active_balance = 1;
    9038                 :          3 :                                 busiest->push_cpu = this_cpu;
    9039                 :            :                                 active_balance = 1;
    9040                 :            :                         }
    9041                 :          3 :                         raw_spin_unlock_irqrestore(&busiest->lock, flags);
    9042                 :            : 
    9043                 :          3 :                         if (active_balance) {
    9044                 :          3 :                                 stop_one_cpu_nowait(cpu_of(busiest),
    9045                 :            :                                         active_load_balance_cpu_stop, busiest,
    9046                 :            :                                         &busiest->active_balance_work);
    9047                 :            :                         }
    9048                 :            : 
    9049                 :            :                         /* We've kicked active balancing, force task migration. */
    9050                 :          3 :                         sd->nr_balance_failed = sd->cache_nice_tries+1;
    9051                 :            :                 }
    9052                 :            :         } else
    9053                 :          3 :                 sd->nr_balance_failed = 0;
    9054                 :            : 
    9055                 :          3 :         if (likely(!active_balance) || voluntary_active_balance(&env)) {
    9056                 :            :                 /* We were unbalanced, so reset the balancing interval */
    9057                 :          3 :                 sd->balance_interval = sd->min_interval;
    9058                 :            :         } else {
    9059                 :            :                 /*
    9060                 :            :                  * If we've begun active balancing, start to back off. This
    9061                 :            :                  * case may not be covered by the all_pinned logic if there
    9062                 :            :                  * is only 1 task on the busy runqueue (because we don't call
    9063                 :            :                  * detach_tasks).
    9064                 :            :                  */
    9065                 :          3 :                 if (sd->balance_interval < sd->max_interval)
    9066                 :          3 :                         sd->balance_interval *= 2;
    9067                 :            :         }
    9068                 :            : 
    9069                 :            :         goto out;
    9070                 :            : 
    9071                 :            : out_balanced:
    9072                 :            :         /*
    9073                 :            :          * We reach balance although we may have faced some affinity
    9074                 :            :          * constraints. Clear the imbalance flag only if other tasks got
    9075                 :            :          * a chance to move and fix the imbalance.
    9076                 :            :          */
    9077                 :          3 :         if (sd_parent && !(env.flags & LBF_ALL_PINNED)) {
    9078                 :          0 :                 int *group_imbalance = &sd_parent->groups->sgc->imbalance;
    9079                 :            : 
    9080                 :          0 :                 if (*group_imbalance)
    9081                 :          0 :                         *group_imbalance = 0;
    9082                 :            :         }
    9083                 :            : 
    9084                 :            : out_all_pinned:
    9085                 :            :         /*
    9086                 :            :          * We reach balance because all tasks are pinned at this level so
    9087                 :            :          * we can't migrate them. Let the imbalance flag set so parent level
    9088                 :            :          * can try to migrate them.
    9089                 :            :          */
    9090                 :          3 :         schedstat_inc(sd->lb_balanced[idle]);
    9091                 :            : 
    9092                 :          3 :         sd->nr_balance_failed = 0;
    9093                 :            : 
    9094                 :            : out_one_pinned:
    9095                 :            :         ld_moved = 0;
    9096                 :            : 
    9097                 :            :         /*
    9098                 :            :          * newidle_balance() disregards balance intervals, so we could
    9099                 :            :          * repeatedly reach this code, which would lead to balance_interval
    9100                 :            :          * skyrocketting in a short amount of time. Skip the balance_interval
    9101                 :            :          * increase logic to avoid that.
    9102                 :            :          */
    9103                 :          3 :         if (env.idle == CPU_NEWLY_IDLE)
    9104                 :            :                 goto out;
    9105                 :            : 
    9106                 :            :         /* tune up the balancing interval */
    9107                 :          3 :         if ((env.flags & LBF_ALL_PINNED &&
    9108                 :          3 :              sd->balance_interval < MAX_PINNED_INTERVAL) ||
    9109                 :          3 :             sd->balance_interval < sd->max_interval)
    9110                 :          3 :                 sd->balance_interval *= 2;
    9111                 :            : out:
    9112                 :          3 :         return ld_moved;
    9113                 :            : }
    9114                 :            : 
    9115                 :            : static inline unsigned long
    9116                 :          3 : get_sd_balance_interval(struct sched_domain *sd, int cpu_busy)
    9117                 :            : {
    9118                 :          3 :         unsigned long interval = sd->balance_interval;
    9119                 :            : 
    9120                 :          3 :         if (cpu_busy)
    9121                 :          3 :                 interval *= sd->busy_factor;
    9122                 :            : 
    9123                 :            :         /* scale ms to jiffies */
    9124                 :            :         interval = msecs_to_jiffies(interval);
    9125                 :          3 :         interval = clamp(interval, 1UL, max_load_balance_interval);
    9126                 :            : 
    9127                 :          3 :         return interval;
    9128                 :            : }
    9129                 :            : 
    9130                 :            : static inline void
    9131                 :          3 : update_next_balance(struct sched_domain *sd, unsigned long *next_balance)
    9132                 :            : {
    9133                 :            :         unsigned long interval, next;
    9134                 :            : 
    9135                 :            :         /* used by idle balance, so cpu_busy = 0 */
    9136                 :          3 :         interval = get_sd_balance_interval(sd, 0);
    9137                 :          3 :         next = sd->last_balance + interval;
    9138                 :            : 
    9139                 :          3 :         if (time_after(*next_balance, next))
    9140                 :          3 :                 *next_balance = next;
    9141                 :          3 : }
    9142                 :            : 
    9143                 :            : /*
    9144                 :            :  * active_load_balance_cpu_stop is run by the CPU stopper. It pushes
    9145                 :            :  * running tasks off the busiest CPU onto idle CPUs. It requires at
    9146                 :            :  * least 1 task to be running on each physical CPU where possible, and
    9147                 :            :  * avoids physical / logical imbalances.
    9148                 :            :  */
    9149                 :          3 : static int active_load_balance_cpu_stop(void *data)
    9150                 :            : {
    9151                 :            :         struct rq *busiest_rq = data;
    9152                 :            :         int busiest_cpu = cpu_of(busiest_rq);
    9153                 :          3 :         int target_cpu = busiest_rq->push_cpu;
    9154                 :          3 :         struct rq *target_rq = cpu_rq(target_cpu);
    9155                 :            :         struct sched_domain *sd;
    9156                 :            :         struct task_struct *p = NULL;
    9157                 :            :         struct rq_flags rf;
    9158                 :            : 
    9159                 :            :         rq_lock_irq(busiest_rq, &rf);
    9160                 :            :         /*
    9161                 :            :          * Between queueing the stop-work and running it is a hole in which
    9162                 :            :          * CPUs can become inactive. We should not move tasks from or to
    9163                 :            :          * inactive CPUs.
    9164                 :            :          */
    9165                 :          3 :         if (!cpu_active(busiest_cpu) || !cpu_active(target_cpu))
    9166                 :            :                 goto out_unlock;
    9167                 :            : 
    9168                 :            :         /* Make sure the requested CPU hasn't gone down in the meantime: */
    9169                 :          3 :         if (unlikely(busiest_cpu != smp_processor_id() ||
    9170                 :            :                      !busiest_rq->active_balance))
    9171                 :            :                 goto out_unlock;
    9172                 :            : 
    9173                 :            :         /* Is there any task to move? */
    9174                 :          3 :         if (busiest_rq->nr_running <= 1)
    9175                 :            :                 goto out_unlock;
    9176                 :            : 
    9177                 :            :         /*
    9178                 :            :          * This condition is "impossible", if it occurs
    9179                 :            :          * we need to fix it. Originally reported by
    9180                 :            :          * Bjorn Helgaas on a 128-CPU setup.
    9181                 :            :          */
    9182                 :          3 :         BUG_ON(busiest_rq == target_rq);
    9183                 :            : 
    9184                 :            :         /* Search for an sd spanning us and the target CPU. */
    9185                 :            :         rcu_read_lock();
    9186                 :          3 :         for_each_domain(target_cpu, sd) {
    9187                 :          3 :                 if ((sd->flags & SD_LOAD_BALANCE) &&
    9188                 :            :                     cpumask_test_cpu(busiest_cpu, sched_domain_span(sd)))
    9189                 :            :                                 break;
    9190                 :            :         }
    9191                 :            : 
    9192                 :          3 :         if (likely(sd)) {
    9193                 :          3 :                 struct lb_env env = {
    9194                 :            :                         .sd             = sd,
    9195                 :            :                         .dst_cpu        = target_cpu,
    9196                 :            :                         .dst_rq         = target_rq,
    9197                 :          3 :                         .src_cpu        = busiest_rq->cpu,
    9198                 :            :                         .src_rq         = busiest_rq,
    9199                 :            :                         .idle           = CPU_IDLE,
    9200                 :            :                         /*
    9201                 :            :                          * can_migrate_task() doesn't need to compute new_dst_cpu
    9202                 :            :                          * for active balancing. Since we have CPU_IDLE, but no
    9203                 :            :                          * @dst_grpmask we need to make that test go away with lying
    9204                 :            :                          * about DST_PINNED.
    9205                 :            :                          */
    9206                 :            :                         .flags          = LBF_DST_PINNED,
    9207                 :            :                 };
    9208                 :            : 
    9209                 :          3 :                 schedstat_inc(sd->alb_count);
    9210                 :          3 :                 update_rq_clock(busiest_rq);
    9211                 :            : 
    9212                 :          3 :                 p = detach_one_task(&env);
    9213                 :          3 :                 if (p) {
    9214                 :          3 :                         schedstat_inc(sd->alb_pushed);
    9215                 :            :                         /* Active balancing done, reset the failure counter. */
    9216                 :          3 :                         sd->nr_balance_failed = 0;
    9217                 :            :                 } else {
    9218                 :          3 :                         schedstat_inc(sd->alb_failed);
    9219                 :            :                 }
    9220                 :            :         }
    9221                 :            :         rcu_read_unlock();
    9222                 :            : out_unlock:
    9223                 :          3 :         busiest_rq->active_balance = 0;
    9224                 :            :         rq_unlock(busiest_rq, &rf);
    9225                 :            : 
    9226                 :          3 :         if (p)
    9227                 :          3 :                 attach_one_task(target_rq, p);
    9228                 :            : 
    9229                 :          3 :         local_irq_enable();
    9230                 :            : 
    9231                 :          3 :         return 0;
    9232                 :            : }
    9233                 :            : 
    9234                 :            : static DEFINE_SPINLOCK(balancing);
    9235                 :            : 
    9236                 :            : /*
    9237                 :            :  * Scale the max load_balance interval with the number of CPUs in the system.
    9238                 :            :  * This trades load-balance latency on larger machines for less cross talk.
    9239                 :            :  */
    9240                 :          3 : void update_max_interval(void)
    9241                 :            : {
    9242                 :          3 :         max_load_balance_interval = HZ*num_online_cpus()/10;
    9243                 :          3 : }
    9244                 :            : 
    9245                 :            : /*
    9246                 :            :  * It checks each scheduling domain to see if it is due to be balanced,
    9247                 :            :  * and initiates a balancing operation if so.
    9248                 :            :  *
    9249                 :            :  * Balancing parameters are set up in init_sched_domains.
    9250                 :            :  */
    9251                 :          3 : static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle)
    9252                 :            : {
    9253                 :          3 :         int continue_balancing = 1;
    9254                 :          3 :         int cpu = rq->cpu;
    9255                 :            :         unsigned long interval;
    9256                 :            :         struct sched_domain *sd;
    9257                 :            :         /* Earliest time when we have to do rebalance again */
    9258                 :          3 :         unsigned long next_balance = jiffies + 60*HZ;
    9259                 :            :         int update_next_balance = 0;
    9260                 :            :         int need_serialize, need_decay = 0;
    9261                 :            :         u64 max_cost = 0;
    9262                 :            : 
    9263                 :            :         rcu_read_lock();
    9264                 :          3 :         for_each_domain(cpu, sd) {
    9265                 :            :                 /*
    9266                 :            :                  * Decay the newidle max times here because this is a regular
    9267                 :            :                  * visit to all the domains. Decay ~1% per second.
    9268                 :            :                  */
    9269                 :          3 :                 if (time_after(jiffies, sd->next_decay_max_lb_cost)) {
    9270                 :          3 :                         sd->max_newidle_lb_cost =
    9271                 :          3 :                                 (sd->max_newidle_lb_cost * 253) / 256;
    9272                 :          3 :                         sd->next_decay_max_lb_cost = jiffies + HZ;
    9273                 :            :                         need_decay = 1;
    9274                 :            :                 }
    9275                 :          3 :                 max_cost += sd->max_newidle_lb_cost;
    9276                 :            : 
    9277                 :          3 :                 if (!(sd->flags & SD_LOAD_BALANCE))
    9278                 :          1 :                         continue;
    9279                 :            : 
    9280                 :            :                 /*
    9281                 :            :                  * Stop the load balance at this level. There is another
    9282                 :            :                  * CPU in our sched group which is doing load balancing more
    9283                 :            :                  * actively.
    9284                 :            :                  */
    9285                 :          3 :                 if (!continue_balancing) {
    9286                 :          0 :                         if (need_decay)
    9287                 :          0 :                                 continue;
    9288                 :            :                         break;
    9289                 :            :                 }
    9290                 :            : 
    9291                 :          3 :                 interval = get_sd_balance_interval(sd, idle != CPU_IDLE);
    9292                 :            : 
    9293                 :          3 :                 need_serialize = sd->flags & SD_SERIALIZE;
    9294                 :          3 :                 if (need_serialize) {
    9295                 :          0 :                         if (!spin_trylock(&balancing))
    9296                 :            :                                 goto out;
    9297                 :            :                 }
    9298                 :            : 
    9299                 :          3 :                 if (time_after_eq(jiffies, sd->last_balance + interval)) {
    9300                 :          3 :                         if (load_balance(cpu, rq, sd, idle, &continue_balancing)) {
    9301                 :            :                                 /*
    9302                 :            :                                  * The LBF_DST_PINNED logic could have changed
    9303                 :            :                                  * env->dst_cpu, so we can't know our idle
    9304                 :            :                                  * state even if we migrated tasks. Update it.
    9305                 :            :                                  */
    9306                 :          3 :                                 idle = idle_cpu(cpu) ? CPU_IDLE : CPU_NOT_IDLE;
    9307                 :            :                         }
    9308                 :          3 :                         sd->last_balance = jiffies;
    9309                 :          3 :                         interval = get_sd_balance_interval(sd, idle != CPU_IDLE);
    9310                 :            :                 }
    9311                 :          3 :                 if (need_serialize)
    9312                 :            :                         spin_unlock(&balancing);
    9313                 :            : out:
    9314                 :          3 :                 if (time_after(next_balance, sd->last_balance + interval)) {
    9315                 :            :                         next_balance = sd->last_balance + interval;
    9316                 :            :                         update_next_balance = 1;
    9317                 :            :                 }
    9318                 :            :         }
    9319                 :          3 :         if (need_decay) {
    9320                 :            :                 /*
    9321                 :            :                  * Ensure the rq-wide value also decays but keep it at a
    9322                 :            :                  * reasonable floor to avoid funnies with rq->avg_idle.
    9323                 :            :                  */
    9324                 :          3 :                 rq->max_idle_balance_cost =
    9325                 :          3 :                         max((u64)sysctl_sched_migration_cost, max_cost);
    9326                 :            :         }
    9327                 :            :         rcu_read_unlock();
    9328                 :            : 
    9329                 :            :         /*
    9330                 :            :          * next_balance will be updated only when there is a need.
    9331                 :            :          * When the cpu is attached to null domain for ex, it will not be
    9332                 :            :          * updated.
    9333                 :            :          */
    9334                 :          3 :         if (likely(update_next_balance)) {
    9335                 :          3 :                 rq->next_balance = next_balance;
    9336                 :            : 
    9337                 :            : #ifdef CONFIG_NO_HZ_COMMON
    9338                 :            :                 /*
    9339                 :            :                  * If this CPU has been elected to perform the nohz idle
    9340                 :            :                  * balance. Other idle CPUs have already rebalanced with
    9341                 :            :                  * nohz_idle_balance() and nohz.next_balance has been
    9342                 :            :                  * updated accordingly. This CPU is now running the idle load
    9343                 :            :                  * balance for itself and we need to update the
    9344                 :            :                  * nohz.next_balance accordingly.
    9345                 :            :                  */
    9346                 :          3 :                 if ((idle == CPU_IDLE) && time_after(nohz.next_balance, rq->next_balance))
    9347                 :          3 :                         nohz.next_balance = rq->next_balance;
    9348                 :            : #endif
    9349                 :            :         }
    9350                 :          3 : }
    9351                 :            : 
    9352                 :            : static inline int on_null_domain(struct rq *rq)
    9353                 :            : {
    9354                 :          3 :         return unlikely(!rcu_dereference_sched(rq->sd));
    9355                 :            : }
    9356                 :            : 
    9357                 :            : #ifdef CONFIG_NO_HZ_COMMON
    9358                 :            : /*
    9359                 :            :  * idle load balancing details
    9360                 :            :  * - When one of the busy CPUs notice that there may be an idle rebalancing
    9361                 :            :  *   needed, they will kick the idle load balancer, which then does idle
    9362                 :            :  *   load balancing for all the idle CPUs.
    9363                 :            :  * - HK_FLAG_MISC CPUs are used for this task, because HK_FLAG_SCHED not set
    9364                 :            :  *   anywhere yet.
    9365                 :            :  */
    9366                 :            : 
    9367                 :          3 : static inline int find_new_ilb(void)
    9368                 :            : {
    9369                 :            :         int ilb;
    9370                 :            : 
    9371                 :          3 :         for_each_cpu_and(ilb, nohz.idle_cpus_mask,
    9372                 :            :                               housekeeping_cpumask(HK_FLAG_MISC)) {
    9373                 :          3 :                 if (idle_cpu(ilb))
    9374                 :          3 :                         return ilb;
    9375                 :            :         }
    9376                 :            : 
    9377                 :          3 :         return nr_cpu_ids;
    9378                 :            : }
    9379                 :            : 
    9380                 :            : /*
    9381                 :            :  * Kick a CPU to do the nohz balancing, if it is time for it. We pick any
    9382                 :            :  * idle CPU in the HK_FLAG_MISC housekeeping set (if there is one).
    9383                 :            :  */
    9384                 :          3 : static void kick_ilb(unsigned int flags)
    9385                 :            : {
    9386                 :            :         int ilb_cpu;
    9387                 :            : 
    9388                 :            :         /*
    9389                 :            :          * Increase nohz.next_balance only when if full ilb is triggered but
    9390                 :            :          * not if we only update stats.
    9391                 :            :          */
    9392                 :          3 :         if (flags & NOHZ_BALANCE_KICK)
    9393                 :          3 :                 nohz.next_balance = jiffies+1;
    9394                 :            : 
    9395                 :          3 :         ilb_cpu = find_new_ilb();
    9396                 :            : 
    9397                 :          3 :         if (ilb_cpu >= nr_cpu_ids)
    9398                 :            :                 return;
    9399                 :            : 
    9400                 :          3 :         flags = atomic_fetch_or(flags, nohz_flags(ilb_cpu));
    9401                 :          3 :         if (flags & NOHZ_KICK_MASK)
    9402                 :            :                 return;
    9403                 :            : 
    9404                 :            :         /*
    9405                 :            :          * Use smp_send_reschedule() instead of resched_cpu().
    9406                 :            :          * This way we generate a sched IPI on the target CPU which
    9407                 :            :          * is idle. And the softirq performing nohz idle load balance
    9408                 :            :          * will be run before returning from the IPI.
    9409                 :            :          */
    9410                 :          3 :         smp_send_reschedule(ilb_cpu);
    9411                 :            : }
    9412                 :            : 
    9413                 :            : /*
    9414                 :            :  * Current decision point for kicking the idle load balancer in the presence
    9415                 :            :  * of idle CPUs in the system.
    9416                 :            :  */
    9417                 :          3 : static void nohz_balancer_kick(struct rq *rq)
    9418                 :            : {
    9419                 :          3 :         unsigned long now = jiffies;
    9420                 :            :         struct sched_domain_shared *sds;
    9421                 :            :         struct sched_domain *sd;
    9422                 :          3 :         int nr_busy, i, cpu = rq->cpu;
    9423                 :            :         unsigned int flags = 0;
    9424                 :            : 
    9425                 :          3 :         if (unlikely(rq->idle_balance))
    9426                 :            :                 return;
    9427                 :            : 
    9428                 :            :         /*
    9429                 :            :          * We may be recently in ticked or tickless idle mode. At the first
    9430                 :            :          * busy tick after returning from idle, we will update the busy stats.
    9431                 :            :          */
    9432                 :          3 :         nohz_balance_exit_idle(rq);
    9433                 :            : 
    9434                 :            :         /*
    9435                 :            :          * None are in tickless mode and hence no need for NOHZ idle load
    9436                 :            :          * balancing.
    9437                 :            :          */
    9438                 :          3 :         if (likely(!atomic_read(&nohz.nr_cpus)))
    9439                 :            :                 return;
    9440                 :            : 
    9441                 :          3 :         if (READ_ONCE(nohz.has_blocked) &&
    9442                 :          3 :             time_after(now, READ_ONCE(nohz.next_blocked)))
    9443                 :            :                 flags = NOHZ_STATS_KICK;
    9444                 :            : 
    9445                 :          3 :         if (time_before(now, nohz.next_balance))
    9446                 :            :                 goto out;
    9447                 :            : 
    9448                 :          3 :         if (rq->nr_running >= 2) {
    9449                 :            :                 flags = NOHZ_KICK_MASK;
    9450                 :            :                 goto out;
    9451                 :            :         }
    9452                 :            : 
    9453                 :            :         rcu_read_lock();
    9454                 :            : 
    9455                 :          3 :         sd = rcu_dereference(rq->sd);
    9456                 :          3 :         if (sd) {
    9457                 :            :                 /*
    9458                 :            :                  * If there's a CFS task and the current CPU has reduced
    9459                 :            :                  * capacity; kick the ILB to see if there's a better CPU to run
    9460                 :            :                  * on.
    9461                 :            :                  */
    9462                 :          3 :                 if (rq->cfs.h_nr_running >= 1 && check_cpu_capacity(rq, sd)) {
    9463                 :            :                         flags = NOHZ_KICK_MASK;
    9464                 :            :                         goto unlock;
    9465                 :            :                 }
    9466                 :            :         }
    9467                 :            : 
    9468                 :          3 :         sd = rcu_dereference(per_cpu(sd_asym_packing, cpu));
    9469                 :          3 :         if (sd) {
    9470                 :            :                 /*
    9471                 :            :                  * When ASYM_PACKING; see if there's a more preferred CPU
    9472                 :            :                  * currently idle; in which case, kick the ILB to move tasks
    9473                 :            :                  * around.
    9474                 :            :                  */
    9475                 :          0 :                 for_each_cpu_and(i, sched_domain_span(sd), nohz.idle_cpus_mask) {
    9476                 :          0 :                         if (sched_asym_prefer(i, cpu)) {
    9477                 :            :                                 flags = NOHZ_KICK_MASK;
    9478                 :            :                                 goto unlock;
    9479                 :            :                         }
    9480                 :            :                 }
    9481                 :            :         }
    9482                 :            : 
    9483                 :          3 :         sd = rcu_dereference(per_cpu(sd_asym_cpucapacity, cpu));
    9484                 :          3 :         if (sd) {
    9485                 :            :                 /*
    9486                 :            :                  * When ASYM_CPUCAPACITY; see if there's a higher capacity CPU
    9487                 :            :                  * to run the misfit task on.
    9488                 :            :                  */
    9489                 :          0 :                 if (check_misfit_status(rq, sd)) {
    9490                 :            :                         flags = NOHZ_KICK_MASK;
    9491                 :          0 :                         goto unlock;
    9492                 :            :                 }
    9493                 :            : 
    9494                 :            :                 /*
    9495                 :            :                  * For asymmetric systems, we do not want to nicely balance
    9496                 :            :                  * cache use, instead we want to embrace asymmetry and only
    9497                 :            :                  * ensure tasks have enough CPU capacity.
    9498                 :            :                  *
    9499                 :            :                  * Skip the LLC logic because it's not relevant in that case.
    9500                 :            :                  */
    9501                 :            :                 goto unlock;
    9502                 :            :         }
    9503                 :            : 
    9504                 :          3 :         sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
    9505                 :          3 :         if (sds) {
    9506                 :            :                 /*
    9507                 :            :                  * If there is an imbalance between LLC domains (IOW we could
    9508                 :            :                  * increase the overall cache use), we need some less-loaded LLC
    9509                 :            :                  * domain to pull some load. Likewise, we may need to spread
    9510                 :            :                  * load within the current LLC domain (e.g. packed SMT cores but
    9511                 :            :                  * other CPUs are idle). We can't really know from here how busy
    9512                 :            :                  * the others are - so just get a nohz balance going if it looks
    9513                 :            :                  * like this LLC domain has tasks we could move.
    9514                 :            :                  */
    9515                 :          0 :                 nr_busy = atomic_read(&sds->nr_busy_cpus);
    9516                 :          0 :                 if (nr_busy > 1) {
    9517                 :            :                         flags = NOHZ_KICK_MASK;
    9518                 :          0 :                         goto unlock;
    9519                 :            :                 }
    9520                 :            :         }
    9521                 :            : unlock:
    9522                 :            :         rcu_read_unlock();
    9523                 :            : out:
    9524                 :          3 :         if (flags)
    9525                 :          3 :                 kick_ilb(flags);
    9526                 :            : }
    9527                 :            : 
    9528                 :          3 : static void set_cpu_sd_state_busy(int cpu)
    9529                 :            : {
    9530                 :            :         struct sched_domain *sd;
    9531                 :            : 
    9532                 :            :         rcu_read_lock();
    9533                 :          3 :         sd = rcu_dereference(per_cpu(sd_llc, cpu));
    9534                 :            : 
    9535                 :          3 :         if (!sd || !sd->nohz_idle)
    9536                 :            :                 goto unlock;
    9537                 :          0 :         sd->nohz_idle = 0;
    9538                 :            : 
    9539                 :          0 :         atomic_inc(&sd->shared->nr_busy_cpus);
    9540                 :            : unlock:
    9541                 :            :         rcu_read_unlock();
    9542                 :          3 : }
    9543                 :            : 
    9544                 :          3 : void nohz_balance_exit_idle(struct rq *rq)
    9545                 :            : {
    9546                 :          3 :         SCHED_WARN_ON(rq != this_rq());
    9547                 :            : 
    9548                 :          3 :         if (likely(!rq->nohz_tick_stopped))
    9549                 :          3 :                 return;
    9550                 :            : 
    9551                 :          3 :         rq->nohz_tick_stopped = 0;
    9552                 :          3 :         cpumask_clear_cpu(rq->cpu, nohz.idle_cpus_mask);
    9553                 :            :         atomic_dec(&nohz.nr_cpus);
    9554                 :            : 
    9555                 :          3 :         set_cpu_sd_state_busy(rq->cpu);
    9556                 :            : }
    9557                 :            : 
    9558                 :          3 : static void set_cpu_sd_state_idle(int cpu)
    9559                 :            : {
    9560                 :            :         struct sched_domain *sd;
    9561                 :            : 
    9562                 :            :         rcu_read_lock();
    9563                 :          3 :         sd = rcu_dereference(per_cpu(sd_llc, cpu));
    9564                 :            : 
    9565                 :          3 :         if (!sd || sd->nohz_idle)
    9566                 :            :                 goto unlock;
    9567                 :          0 :         sd->nohz_idle = 1;
    9568                 :            : 
    9569                 :          0 :         atomic_dec(&sd->shared->nr_busy_cpus);
    9570                 :            : unlock:
    9571                 :            :         rcu_read_unlock();
    9572                 :          3 : }
    9573                 :            : 
    9574                 :            : /*
    9575                 :            :  * This routine will record that the CPU is going idle with tick stopped.
    9576                 :            :  * This info will be used in performing idle load balancing in the future.
    9577                 :            :  */
    9578                 :          3 : void nohz_balance_enter_idle(int cpu)
    9579                 :            : {
    9580                 :          3 :         struct rq *rq = cpu_rq(cpu);
    9581                 :            : 
    9582                 :          3 :         SCHED_WARN_ON(cpu != smp_processor_id());
    9583                 :            : 
    9584                 :            :         /* If this CPU is going down, then nothing needs to be done: */
    9585                 :          3 :         if (!cpu_active(cpu))
    9586                 :            :                 return;
    9587                 :            : 
    9588                 :            :         /* Spare idle load balancing on CPUs that don't want to be disturbed: */
    9589                 :          3 :         if (!housekeeping_cpu(cpu, HK_FLAG_SCHED))
    9590                 :            :                 return;
    9591                 :            : 
    9592                 :            :         /*
    9593                 :            :          * Can be set safely without rq->lock held
    9594                 :            :          * If a clear happens, it will have evaluated last additions because
    9595                 :            :          * rq->lock is held during the check and the clear
    9596                 :            :          */
    9597                 :          3 :         rq->has_blocked_load = 1;
    9598                 :            : 
    9599                 :            :         /*
    9600                 :            :          * The tick is still stopped but load could have been added in the
    9601                 :            :          * meantime. We set the nohz.has_blocked flag to trig a check of the
    9602                 :            :          * *_avg. The CPU is already part of nohz.idle_cpus_mask so the clear
    9603                 :            :          * of nohz.has_blocked can only happen after checking the new load
    9604                 :            :          */
    9605                 :          3 :         if (rq->nohz_tick_stopped)
    9606                 :            :                 goto out;
    9607                 :            : 
    9608                 :            :         /* If we're a completely isolated CPU, we don't play: */
    9609                 :          3 :         if (on_null_domain(rq))
    9610                 :            :                 return;
    9611                 :            : 
    9612                 :          3 :         rq->nohz_tick_stopped = 1;
    9613                 :            : 
    9614                 :            :         cpumask_set_cpu(cpu, nohz.idle_cpus_mask);
    9615                 :            :         atomic_inc(&nohz.nr_cpus);
    9616                 :            : 
    9617                 :            :         /*
    9618                 :            :          * Ensures that if nohz_idle_balance() fails to observe our
    9619                 :            :          * @idle_cpus_mask store, it must observe the @has_blocked
    9620                 :            :          * store.
    9621                 :            :          */
    9622                 :          3 :         smp_mb__after_atomic();
    9623                 :            : 
    9624                 :          3 :         set_cpu_sd_state_idle(cpu);
    9625                 :            : 
    9626                 :            : out:
    9627                 :            :         /*
    9628                 :            :          * Each time a cpu enter idle, we assume that it has blocked load and
    9629                 :            :          * enable the periodic update of the load of idle cpus
    9630                 :            :          */
    9631                 :            :         WRITE_ONCE(nohz.has_blocked, 1);
    9632                 :            : }
    9633                 :            : 
    9634                 :            : /*
    9635                 :            :  * Internal function that runs load balance for all idle cpus. The load balance
    9636                 :            :  * can be a simple update of blocked load or a complete load balance with
    9637                 :            :  * tasks movement depending of flags.
    9638                 :            :  * The function returns false if the loop has stopped before running
    9639                 :            :  * through all idle CPUs.
    9640                 :            :  */
    9641                 :          3 : static bool _nohz_idle_balance(struct rq *this_rq, unsigned int flags,
    9642                 :            :                                enum cpu_idle_type idle)
    9643                 :            : {
    9644                 :            :         /* Earliest time when we have to do rebalance again */
    9645                 :          3 :         unsigned long now = jiffies;
    9646                 :          3 :         unsigned long next_balance = now + 60*HZ;
    9647                 :            :         bool has_blocked_load = false;
    9648                 :            :         int update_next_balance = 0;
    9649                 :          3 :         int this_cpu = this_rq->cpu;
    9650                 :            :         int balance_cpu;
    9651                 :            :         int ret = false;
    9652                 :            :         struct rq *rq;
    9653                 :            : 
    9654                 :          3 :         SCHED_WARN_ON((flags & NOHZ_KICK_MASK) == NOHZ_BALANCE_KICK);
    9655                 :            : 
    9656                 :            :         /*
    9657                 :            :          * We assume there will be no idle load after this update and clear
    9658                 :            :          * the has_blocked flag. If a cpu enters idle in the mean time, it will
    9659                 :            :          * set the has_blocked flag and trig another update of idle load.
    9660                 :            :          * Because a cpu that becomes idle, is added to idle_cpus_mask before
    9661                 :            :          * setting the flag, we are sure to not clear the state and not
    9662                 :            :          * check the load of an idle cpu.
    9663                 :            :          */
    9664                 :            :         WRITE_ONCE(nohz.has_blocked, 0);
    9665                 :            : 
    9666                 :            :         /*
    9667                 :            :          * Ensures that if we miss the CPU, we must see the has_blocked
    9668                 :            :          * store from nohz_balance_enter_idle().
    9669                 :            :          */
    9670                 :          3 :         smp_mb();
    9671                 :            : 
    9672                 :          3 :         for_each_cpu(balance_cpu, nohz.idle_cpus_mask) {
    9673                 :          3 :                 if (balance_cpu == this_cpu || !idle_cpu(balance_cpu))
    9674                 :          3 :                         continue;
    9675                 :            : 
    9676                 :            :                 /*
    9677                 :            :                  * If this CPU gets work to do, stop the load balancing
    9678                 :            :                  * work being done for other CPUs. Next load
    9679                 :            :                  * balancing owner will pick it up.
    9680                 :            :                  */
    9681                 :          3 :                 if (need_resched()) {
    9682                 :            :                         has_blocked_load = true;
    9683                 :            :                         goto abort;
    9684                 :            :                 }
    9685                 :            : 
    9686                 :          3 :                 rq = cpu_rq(balance_cpu);
    9687                 :            : 
    9688                 :          3 :                 has_blocked_load |= update_nohz_stats(rq, true);
    9689                 :            : 
    9690                 :            :                 /*
    9691                 :            :                  * If time for next balance is due,
    9692                 :            :                  * do the balance.
    9693                 :            :                  */
    9694                 :          3 :                 if (time_after_eq(jiffies, rq->next_balance)) {
    9695                 :            :                         struct rq_flags rf;
    9696                 :            : 
    9697                 :            :                         rq_lock_irqsave(rq, &rf);
    9698                 :          3 :                         update_rq_clock(rq);
    9699                 :            :                         rq_unlock_irqrestore(rq, &rf);
    9700                 :            : 
    9701                 :          3 :                         if (flags & NOHZ_BALANCE_KICK)
    9702                 :          3 :                                 rebalance_domains(rq, CPU_IDLE);
    9703                 :            :                 }
    9704                 :            : 
    9705                 :          3 :                 if (time_after(next_balance, rq->next_balance)) {
    9706                 :            :                         next_balance = rq->next_balance;
    9707                 :            :                         update_next_balance = 1;
    9708                 :            :                 }
    9709                 :            :         }
    9710                 :            : 
    9711                 :            :         /*
    9712                 :            :          * next_balance will be updated only when there is a need.
    9713                 :            :          * When the CPU is attached to null domain for ex, it will not be
    9714                 :            :          * updated.
    9715                 :            :          */
    9716                 :          3 :         if (likely(update_next_balance))
    9717                 :          3 :                 nohz.next_balance = next_balance;
    9718                 :            : 
    9719                 :            :         /* Newly idle CPU doesn't need an update */
    9720                 :          3 :         if (idle != CPU_NEWLY_IDLE) {
    9721                 :          3 :                 update_blocked_averages(this_cpu);
    9722                 :          3 :                 has_blocked_load |= this_rq->has_blocked_load;
    9723                 :            :         }
    9724                 :            : 
    9725                 :          3 :         if (flags & NOHZ_BALANCE_KICK)
    9726                 :          3 :                 rebalance_domains(this_rq, CPU_IDLE);
    9727                 :            : 
    9728                 :          3 :         WRITE_ONCE(nohz.next_blocked,
    9729                 :            :                 now + msecs_to_jiffies(LOAD_AVG_PERIOD));
    9730                 :            : 
    9731                 :            :         /* The full idle balance loop has been done */
    9732                 :            :         ret = true;
    9733                 :            : 
    9734                 :            : abort:
    9735                 :            :         /* There is still blocked load, enable periodic update */
    9736                 :          3 :         if (has_blocked_load)
    9737                 :            :                 WRITE_ONCE(nohz.has_blocked, 1);
    9738                 :            : 
    9739                 :          3 :         return ret;
    9740                 :            : }
    9741                 :            : 
    9742                 :            : /*
    9743                 :            :  * In CONFIG_NO_HZ_COMMON case, the idle balance kickee will do the
    9744                 :            :  * rebalancing for all the cpus for whom scheduler ticks are stopped.
    9745                 :            :  */
    9746                 :          3 : static bool nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
    9747                 :            : {
    9748                 :          3 :         int this_cpu = this_rq->cpu;
    9749                 :            :         unsigned int flags;
    9750                 :            : 
    9751                 :          3 :         if (!(atomic_read(nohz_flags(this_cpu)) & NOHZ_KICK_MASK))
    9752                 :            :                 return false;
    9753                 :            : 
    9754                 :          3 :         if (idle != CPU_IDLE) {
    9755                 :          3 :                 atomic_andnot(NOHZ_KICK_MASK, nohz_flags(this_cpu));
    9756                 :          3 :                 return false;
    9757                 :            :         }
    9758                 :            : 
    9759                 :            :         /* could be _relaxed() */
    9760                 :          3 :         flags = atomic_fetch_andnot(NOHZ_KICK_MASK, nohz_flags(this_cpu));
    9761                 :          3 :         if (!(flags & NOHZ_KICK_MASK))
    9762                 :            :                 return false;
    9763                 :            : 
    9764                 :          3 :         _nohz_idle_balance(this_rq, flags, idle);
    9765                 :            : 
    9766                 :          3 :         return true;
    9767                 :            : }
    9768                 :            : 
    9769                 :          3 : static void nohz_newidle_balance(struct rq *this_rq)
    9770                 :            : {
    9771                 :          3 :         int this_cpu = this_rq->cpu;
    9772                 :            : 
    9773                 :            :         /*
    9774                 :            :          * This CPU doesn't want to be disturbed by scheduler
    9775                 :            :          * housekeeping
    9776                 :            :          */
    9777                 :          3 :         if (!housekeeping_cpu(this_cpu, HK_FLAG_SCHED))
    9778                 :            :                 return;
    9779                 :            : 
    9780                 :            :         /* Will wake up very soon. No time for doing anything else*/
    9781                 :          3 :         if (this_rq->avg_idle < sysctl_sched_migration_cost)
    9782                 :            :                 return;
    9783                 :            : 
    9784                 :            :         /* Don't need to update blocked load of idle CPUs*/
    9785                 :          3 :         if (!READ_ONCE(nohz.has_blocked) ||
    9786                 :          3 :             time_before(jiffies, READ_ONCE(nohz.next_blocked)))
    9787                 :            :                 return;
    9788                 :            : 
    9789                 :            :         raw_spin_unlock(&this_rq->lock);
    9790                 :            :         /*
    9791                 :            :          * This CPU is going to be idle and blocked load of idle CPUs
    9792                 :            :          * need to be updated. Run the ilb locally as it is a good
    9793                 :            :          * candidate for ilb instead of waking up another idle CPU.
    9794                 :            :          * Kick an normal ilb if we failed to do the update.
    9795                 :            :          */
    9796                 :          3 :         if (!_nohz_idle_balance(this_rq, NOHZ_STATS_KICK, CPU_NEWLY_IDLE))
    9797                 :          3 :                 kick_ilb(NOHZ_STATS_KICK);
    9798                 :          3 :         raw_spin_lock(&this_rq->lock);
    9799                 :            : }
    9800                 :            : 
    9801                 :            : #else /* !CONFIG_NO_HZ_COMMON */
    9802                 :            : static inline void nohz_balancer_kick(struct rq *rq) { }
    9803                 :            : 
    9804                 :            : static inline bool nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
    9805                 :            : {
    9806                 :            :         return false;
    9807                 :            : }
    9808                 :            : 
    9809                 :            : static inline void nohz_newidle_balance(struct rq *this_rq) { }
    9810                 :            : #endif /* CONFIG_NO_HZ_COMMON */
    9811                 :            : 
    9812                 :            : /*
    9813                 :            :  * idle_balance is called by schedule() if this_cpu is about to become
    9814                 :            :  * idle. Attempts to pull tasks from other CPUs.
    9815                 :            :  */
    9816                 :          3 : int newidle_balance(struct rq *this_rq, struct rq_flags *rf)
    9817                 :            : {
    9818                 :          3 :         unsigned long next_balance = jiffies + HZ;
    9819                 :          3 :         int this_cpu = this_rq->cpu;
    9820                 :            :         struct sched_domain *sd;
    9821                 :            :         int pulled_task = 0;
    9822                 :            :         u64 curr_cost = 0;
    9823                 :            : 
    9824                 :          3 :         update_misfit_status(NULL, this_rq);
    9825                 :            :         /*
    9826                 :            :          * We must set idle_stamp _before_ calling idle_balance(), such that we
    9827                 :            :          * measure the duration of idle_balance() as idle time.
    9828                 :            :          */
    9829                 :          3 :         this_rq->idle_stamp = rq_clock(this_rq);
    9830                 :            : 
    9831                 :            :         /*
    9832                 :            :          * Do not pull tasks towards !active CPUs...
    9833                 :            :          */
    9834                 :          3 :         if (!cpu_active(this_cpu))
    9835                 :            :                 return 0;
    9836                 :            : 
    9837                 :            :         /*
    9838                 :            :          * This is OK, because current is on_cpu, which avoids it being picked
    9839                 :            :          * for load-balance and preemption/IRQs are still disabled avoiding
    9840                 :            :          * further scheduler activity on it and we're being very careful to
    9841                 :            :          * re-start the picking loop.
    9842                 :            :          */
    9843                 :            :         rq_unpin_lock(this_rq, rf);
    9844                 :            : 
    9845                 :          3 :         if (this_rq->avg_idle < sysctl_sched_migration_cost ||
    9846                 :          3 :             !READ_ONCE(this_rq->rd->overload)) {
    9847                 :            : 
    9848                 :            :                 rcu_read_lock();
    9849                 :          3 :                 sd = rcu_dereference_check_sched_domain(this_rq->sd);
    9850                 :          3 :                 if (sd)
    9851                 :          3 :                         update_next_balance(sd, &next_balance);
    9852                 :            :                 rcu_read_unlock();
    9853                 :            : 
    9854                 :          3 :                 nohz_newidle_balance(this_rq);
    9855                 :            : 
    9856                 :          3 :                 goto out;
    9857                 :            :         }
    9858                 :            : 
    9859                 :            :         raw_spin_unlock(&this_rq->lock);
    9860                 :            : 
    9861                 :          3 :         update_blocked_averages(this_cpu);
    9862                 :            :         rcu_read_lock();
    9863                 :          3 :         for_each_domain(this_cpu, sd) {
    9864                 :          3 :                 int continue_balancing = 1;
    9865                 :            :                 u64 t0, domain_cost;
    9866                 :            : 
    9867                 :          3 :                 if (!(sd->flags & SD_LOAD_BALANCE))
    9868                 :          3 :                         continue;
    9869                 :            : 
    9870                 :          3 :                 if (this_rq->avg_idle < curr_cost + sd->max_newidle_lb_cost) {
    9871                 :          3 :                         update_next_balance(sd, &next_balance);
    9872                 :          3 :                         break;
    9873                 :            :                 }
    9874                 :            : 
    9875                 :          3 :                 if (sd->flags & SD_BALANCE_NEWIDLE) {
    9876                 :          3 :                         t0 = sched_clock_cpu(this_cpu);
    9877                 :            : 
    9878                 :          3 :                         pulled_task = load_balance(this_cpu, this_rq,
    9879                 :            :                                                    sd, CPU_NEWLY_IDLE,
    9880                 :            :                                                    &continue_balancing);
    9881                 :            : 
    9882                 :          3 :                         domain_cost = sched_clock_cpu(this_cpu) - t0;
    9883                 :          3 :                         if (domain_cost > sd->max_newidle_lb_cost)
    9884                 :          3 :                                 sd->max_newidle_lb_cost = domain_cost;
    9885                 :            : 
    9886                 :          3 :                         curr_cost += domain_cost;
    9887                 :            :                 }
    9888                 :            : 
    9889                 :          3 :                 update_next_balance(sd, &next_balance);
    9890                 :            : 
    9891                 :            :                 /*
    9892                 :            :                  * Stop searching for tasks to pull if there are
    9893                 :            :                  * now runnable tasks on this rq.
    9894                 :            :                  */
    9895                 :          3 :                 if (pulled_task || this_rq->nr_running > 0)
    9896                 :            :                         break;
    9897                 :            :         }
    9898                 :            :         rcu_read_unlock();
    9899                 :            : 
    9900                 :          3 :         raw_spin_lock(&this_rq->lock);
    9901                 :            : 
    9902                 :          3 :         if (curr_cost > this_rq->max_idle_balance_cost)
    9903                 :          3 :                 this_rq->max_idle_balance_cost = curr_cost;
    9904                 :            : 
    9905                 :            : out:
    9906                 :            :         /*
    9907                 :            :          * While browsing the domains, we released the rq lock, a task could
    9908                 :            :          * have been enqueued in the meantime. Since we're not going idle,
    9909                 :            :          * pretend we pulled a task.
    9910                 :            :          */
    9911                 :          3 :         if (this_rq->cfs.h_nr_running && !pulled_task)
    9912                 :            :                 pulled_task = 1;
    9913                 :            : 
    9914                 :            :         /* Move the next balance forward */
    9915                 :          3 :         if (time_after(this_rq->next_balance, next_balance))
    9916                 :          3 :                 this_rq->next_balance = next_balance;
    9917                 :            : 
    9918                 :            :         /* Is there a task of a high priority class? */
    9919                 :          3 :         if (this_rq->nr_running != this_rq->cfs.h_nr_running)
    9920                 :            :                 pulled_task = -1;
    9921                 :            : 
    9922                 :          3 :         if (pulled_task)
    9923                 :          3 :                 this_rq->idle_stamp = 0;
    9924                 :            : 
    9925                 :            :         rq_repin_lock(this_rq, rf);
    9926                 :            : 
    9927                 :          3 :         return pulled_task;
    9928                 :            : }
    9929                 :            : 
    9930                 :            : /*
    9931                 :            :  * run_rebalance_domains is triggered when needed from the scheduler tick.
    9932                 :            :  * Also triggered for nohz idle balancing (with nohz_balancing_kick set).
    9933                 :            :  */
    9934                 :          3 : static __latent_entropy void run_rebalance_domains(struct softirq_action *h)
    9935                 :            : {
    9936                 :          3 :         struct rq *this_rq = this_rq();
    9937                 :          3 :         enum cpu_idle_type idle = this_rq->idle_balance ?
    9938                 :          3 :                                                 CPU_IDLE : CPU_NOT_IDLE;
    9939                 :            : 
    9940                 :            :         /*
    9941                 :            :          * If this CPU has a pending nohz_balance_kick, then do the
    9942                 :            :          * balancing on behalf of the other idle CPUs whose ticks are
    9943                 :            :          * stopped. Do nohz_idle_balance *before* rebalance_domains to
    9944                 :            :          * give the idle CPUs a chance to load balance. Else we may
    9945                 :            :          * load balance only within the local sched_domain hierarchy
    9946                 :            :          * and abort nohz_idle_balance altogether if we pull some load.
    9947                 :            :          */
    9948                 :          3 :         if (nohz_idle_balance(this_rq, idle))
    9949                 :          3 :                 return;
    9950                 :            : 
    9951                 :            :         /* normal load balance */
    9952                 :          3 :         update_blocked_averages(this_rq->cpu);
    9953                 :          3 :         rebalance_domains(this_rq, idle);
    9954                 :            : }
    9955                 :            : 
    9956                 :            : /*
    9957                 :            :  * Trigger the SCHED_SOFTIRQ if it is time to do periodic load balancing.
    9958                 :            :  */
    9959                 :          3 : void trigger_load_balance(struct rq *rq)
    9960                 :            : {
    9961                 :            :         /* Don't need to rebalance while attached to NULL domain */
    9962                 :          3 :         if (unlikely(on_null_domain(rq)))
    9963                 :          3 :                 return;
    9964                 :            : 
    9965                 :          3 :         if (time_after_eq(jiffies, rq->next_balance))
    9966                 :          3 :                 raise_softirq(SCHED_SOFTIRQ);
    9967                 :            : 
    9968                 :          3 :         nohz_balancer_kick(rq);
    9969                 :            : }
    9970                 :            : 
    9971                 :          3 : static void rq_online_fair(struct rq *rq)
    9972                 :            : {
    9973                 :          3 :         update_sysctl();
    9974                 :            : 
    9975                 :          3 :         update_runtime_enabled(rq);
    9976                 :          3 : }
    9977                 :            : 
    9978                 :          3 : static void rq_offline_fair(struct rq *rq)
    9979                 :            : {
    9980                 :          3 :         update_sysctl();
    9981                 :            : 
    9982                 :            :         /* Ensure any throttled groups are reachable by pick_next_task */
    9983                 :          3 :         unthrottle_offline_cfs_rqs(rq);
    9984                 :          3 : }
    9985                 :            : 
    9986                 :            : #endif /* CONFIG_SMP */
    9987                 :            : 
    9988                 :            : /*
    9989                 :            :  * scheduler tick hitting a task of our scheduling class.
    9990                 :            :  *
    9991                 :            :  * NOTE: This function can be called remotely by the tick offload that
    9992                 :            :  * goes along full dynticks. Therefore no local assumption can be made
    9993                 :            :  * and everything must be accessed through the @rq and @curr passed in
    9994                 :            :  * parameters.
    9995                 :            :  */
    9996                 :          3 : static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
    9997                 :            : {
    9998                 :            :         struct cfs_rq *cfs_rq;
    9999                 :          3 :         struct sched_entity *se = &curr->se;
   10000                 :            : 
   10001                 :          3 :         for_each_sched_entity(se) {
   10002                 :            :                 cfs_rq = cfs_rq_of(se);
   10003                 :          3 :                 entity_tick(cfs_rq, se, queued);
   10004                 :            :         }
   10005                 :            : 
   10006                 :            :         if (static_branch_unlikely(&sched_numa_balancing))
   10007                 :            :                 task_tick_numa(rq, curr);
   10008                 :            : 
   10009                 :          3 :         update_misfit_status(curr, rq);
   10010                 :          3 :         update_overutilized_status(task_rq(curr));
   10011                 :          3 : }
   10012                 :            : 
   10013                 :            : /*
   10014                 :            :  * called on fork with the child task as argument from the parent's context
   10015                 :            :  *  - child not yet on the tasklist
   10016                 :            :  *  - preemption disabled
   10017                 :            :  */
   10018                 :          3 : static void task_fork_fair(struct task_struct *p)
   10019                 :            : {
   10020                 :            :         struct cfs_rq *cfs_rq;
   10021                 :          3 :         struct sched_entity *se = &p->se, *curr;
   10022                 :          3 :         struct rq *rq = this_rq();
   10023                 :            :         struct rq_flags rf;
   10024                 :            : 
   10025                 :            :         rq_lock(rq, &rf);
   10026                 :          3 :         update_rq_clock(rq);
   10027                 :            : 
   10028                 :          3 :         cfs_rq = task_cfs_rq(current);
   10029                 :          3 :         curr = cfs_rq->curr;
   10030                 :          3 :         if (curr) {
   10031                 :          3 :                 update_curr(cfs_rq);
   10032                 :          3 :                 se->vruntime = curr->vruntime;
   10033                 :            :         }
   10034                 :          3 :         place_entity(cfs_rq, se, 1);
   10035                 :            : 
   10036                 :          3 :         if (sysctl_sched_child_runs_first && curr && entity_before(curr, se)) {
   10037                 :            :                 /*
   10038                 :            :                  * Upon rescheduling, sched_class::put_prev_task() will place
   10039                 :            :                  * 'current' within the tree based on its new key value.
   10040                 :            :                  */
   10041                 :          0 :                 swap(curr->vruntime, se->vruntime);
   10042                 :          0 :                 resched_curr(rq);
   10043                 :            :         }
   10044                 :            : 
   10045                 :          3 :         se->vruntime -= cfs_rq->min_vruntime;
   10046                 :            :         rq_unlock(rq, &rf);
   10047                 :          3 : }
   10048                 :            : 
   10049                 :            : /*
   10050                 :            :  * Priority of the task has changed. Check to see if we preempt
   10051                 :            :  * the current task.
   10052                 :            :  */
   10053                 :            : static void
   10054                 :          0 : prio_changed_fair(struct rq *rq, struct task_struct *p, int oldprio)
   10055                 :            : {
   10056                 :          0 :         if (!task_on_rq_queued(p))
   10057                 :          0 :                 return;
   10058                 :            : 
   10059                 :            :         /*
   10060                 :            :          * Reschedule if we are currently running on this runqueue and
   10061                 :            :          * our priority decreased, or if we are not currently running on
   10062                 :            :          * this runqueue and our priority is higher than the current's
   10063                 :            :          */
   10064                 :          0 :         if (rq->curr == p) {
   10065                 :          0 :                 if (p->prio > oldprio)
   10066                 :          0 :                         resched_curr(rq);
   10067                 :            :         } else
   10068                 :          0 :                 check_preempt_curr(rq, p, 0);
   10069                 :            : }
   10070                 :            : 
   10071                 :            : static inline bool vruntime_normalized(struct task_struct *p)
   10072                 :            : {
   10073                 :            :         struct sched_entity *se = &p->se;
   10074                 :            : 
   10075                 :            :         /*
   10076                 :            :          * In both the TASK_ON_RQ_QUEUED and TASK_ON_RQ_MIGRATING cases,
   10077                 :            :          * the dequeue_entity(.flags=0) will already have normalized the
   10078                 :            :          * vruntime.
   10079                 :            :          */
   10080                 :          3 :         if (p->on_rq)
   10081                 :            :                 return true;
   10082                 :            : 
   10083                 :            :         /*
   10084                 :            :          * When !on_rq, vruntime of the task has usually NOT been normalized.
   10085                 :            :          * But there are some cases where it has already been normalized:
   10086                 :            :          *
   10087                 :            :          * - A forked child which is waiting for being woken up by
   10088                 :            :          *   wake_up_new_task().
   10089                 :            :          * - A task which has been woken up by try_to_wake_up() and
   10090                 :            :          *   waiting for actually being woken up by sched_ttwu_pending().
   10091                 :            :          */
   10092                 :          3 :         if (!se->sum_exec_runtime ||
   10093                 :          3 :             (p->state == TASK_WAKING && p->sched_remote_wakeup))
   10094                 :            :                 return true;
   10095                 :            : 
   10096                 :            :         return false;
   10097                 :            : }
   10098                 :            : 
   10099                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
   10100                 :            : /*
   10101                 :            :  * Propagate the changes of the sched_entity across the tg tree to make it
   10102                 :            :  * visible to the root
   10103                 :            :  */
   10104                 :          3 : static void propagate_entity_cfs_rq(struct sched_entity *se)
   10105                 :            : {
   10106                 :            :         struct cfs_rq *cfs_rq;
   10107                 :            : 
   10108                 :            :         /* Start to propagate at parent */
   10109                 :          3 :         se = se->parent;
   10110                 :            : 
   10111                 :          3 :         for_each_sched_entity(se) {
   10112                 :            :                 cfs_rq = cfs_rq_of(se);
   10113                 :            : 
   10114                 :          3 :                 if (cfs_rq_throttled(cfs_rq))
   10115                 :            :                         break;
   10116                 :            : 
   10117                 :          3 :                 update_load_avg(cfs_rq, se, UPDATE_TG);
   10118                 :            :         }
   10119                 :          3 : }
   10120                 :            : #else
   10121                 :            : static void propagate_entity_cfs_rq(struct sched_entity *se) { }
   10122                 :            : #endif
   10123                 :            : 
   10124                 :          3 : static void detach_entity_cfs_rq(struct sched_entity *se)
   10125                 :            : {
   10126                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
   10127                 :            : 
   10128                 :            :         /* Catch up with the cfs_rq and remove our load when we leave */
   10129                 :          3 :         update_load_avg(cfs_rq, se, 0);
   10130                 :          3 :         detach_entity_load_avg(cfs_rq, se);
   10131                 :          3 :         update_tg_load_avg(cfs_rq, false);
   10132                 :          3 :         propagate_entity_cfs_rq(se);
   10133                 :          3 : }
   10134                 :            : 
   10135                 :          3 : static void attach_entity_cfs_rq(struct sched_entity *se)
   10136                 :            : {
   10137                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
   10138                 :            : 
   10139                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
   10140                 :            :         /*
   10141                 :            :          * Since the real-depth could have been changed (only FAIR
   10142                 :            :          * class maintain depth value), reset depth properly.
   10143                 :            :          */
   10144                 :          3 :         se->depth = se->parent ? se->parent->depth + 1 : 0;
   10145                 :            : #endif
   10146                 :            : 
   10147                 :            :         /* Synchronize entity with its cfs_rq */
   10148                 :          3 :         update_load_avg(cfs_rq, se, sched_feat(ATTACH_AGE_LOAD) ? 0 : SKIP_AGE_LOAD);
   10149                 :          3 :         attach_entity_load_avg(cfs_rq, se, 0);
   10150                 :          3 :         update_tg_load_avg(cfs_rq, false);
   10151                 :          3 :         propagate_entity_cfs_rq(se);
   10152                 :          3 : }
   10153                 :            : 
   10154                 :          3 : static void detach_task_cfs_rq(struct task_struct *p)
   10155                 :            : {
   10156                 :          3 :         struct sched_entity *se = &p->se;
   10157                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
   10158                 :            : 
   10159                 :          3 :         if (!vruntime_normalized(p)) {
   10160                 :            :                 /*
   10161                 :            :                  * Fix up our vruntime so that the current sleep doesn't
   10162                 :            :                  * cause 'unlimited' sleep bonus.
   10163                 :            :                  */
   10164                 :          3 :                 place_entity(cfs_rq, se, 0);
   10165                 :          3 :                 se->vruntime -= cfs_rq->min_vruntime;
   10166                 :            :         }
   10167                 :            : 
   10168                 :          3 :         detach_entity_cfs_rq(se);
   10169                 :          3 : }
   10170                 :            : 
   10171                 :          3 : static void attach_task_cfs_rq(struct task_struct *p)
   10172                 :            : {
   10173                 :          3 :         struct sched_entity *se = &p->se;
   10174                 :            :         struct cfs_rq *cfs_rq = cfs_rq_of(se);
   10175                 :            : 
   10176                 :          3 :         attach_entity_cfs_rq(se);
   10177                 :            : 
   10178                 :          3 :         if (!vruntime_normalized(p))
   10179                 :          0 :                 se->vruntime += cfs_rq->min_vruntime;
   10180                 :          3 : }
   10181                 :            : 
   10182                 :          3 : static void switched_from_fair(struct rq *rq, struct task_struct *p)
   10183                 :            : {
   10184                 :          3 :         detach_task_cfs_rq(p);
   10185                 :          3 : }
   10186                 :            : 
   10187                 :          0 : static void switched_to_fair(struct rq *rq, struct task_struct *p)
   10188                 :            : {
   10189                 :          0 :         attach_task_cfs_rq(p);
   10190                 :            : 
   10191                 :          0 :         if (task_on_rq_queued(p)) {
   10192                 :            :                 /*
   10193                 :            :                  * We were most likely switched from sched_rt, so
   10194                 :            :                  * kick off the schedule if running, otherwise just see
   10195                 :            :                  * if we can still preempt the current task.
   10196                 :            :                  */
   10197                 :          0 :                 if (rq->curr == p)
   10198                 :          0 :                         resched_curr(rq);
   10199                 :            :                 else
   10200                 :          0 :                         check_preempt_curr(rq, p, 0);
   10201                 :            :         }
   10202                 :          0 : }
   10203                 :            : 
   10204                 :            : /* Account for a task changing its policy or group.
   10205                 :            :  *
   10206                 :            :  * This routine is mostly called to set cfs_rq->curr field when a task
   10207                 :            :  * migrates between groups/classes.
   10208                 :            :  */
   10209                 :          3 : static void set_next_task_fair(struct rq *rq, struct task_struct *p, bool first)
   10210                 :            : {
   10211                 :          3 :         struct sched_entity *se = &p->se;
   10212                 :            : 
   10213                 :            : #ifdef CONFIG_SMP
   10214                 :          3 :         if (task_on_rq_queued(p)) {
   10215                 :            :                 /*
   10216                 :            :                  * Move the next running task to the front of the list, so our
   10217                 :            :                  * cfs_tasks list becomes MRU one.
   10218                 :            :                  */
   10219                 :          3 :                 list_move(&se->group_node, &rq->cfs_tasks);
   10220                 :            :         }
   10221                 :            : #endif
   10222                 :            : 
   10223                 :          3 :         for_each_sched_entity(se) {
   10224                 :            :                 struct cfs_rq *cfs_rq = cfs_rq_of(se);
   10225                 :            : 
   10226                 :          3 :                 set_next_entity(cfs_rq, se);
   10227                 :            :                 /* ensure bandwidth has been allocated on our new cfs_rq */
   10228                 :            :                 account_cfs_rq_runtime(cfs_rq, 0);
   10229                 :            :         }
   10230                 :          3 : }
   10231                 :            : 
   10232                 :          3 : void init_cfs_rq(struct cfs_rq *cfs_rq)
   10233                 :            : {
   10234                 :          3 :         cfs_rq->tasks_timeline = RB_ROOT_CACHED;
   10235                 :          3 :         cfs_rq->min_vruntime = (u64)(-(1LL << 20));
   10236                 :            : #ifndef CONFIG_64BIT
   10237                 :          3 :         cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;
   10238                 :            : #endif
   10239                 :            : #ifdef CONFIG_SMP
   10240                 :          3 :         raw_spin_lock_init(&cfs_rq->removed.lock);
   10241                 :            : #endif
   10242                 :          3 : }
   10243                 :            : 
   10244                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
   10245                 :          3 : static void task_set_group_fair(struct task_struct *p)
   10246                 :            : {
   10247                 :            :         struct sched_entity *se = &p->se;
   10248                 :            : 
   10249                 :          3 :         set_task_rq(p, task_cpu(p));
   10250                 :          3 :         se->depth = se->parent ? se->parent->depth + 1 : 0;
   10251                 :          3 : }
   10252                 :            : 
   10253                 :          3 : static void task_move_group_fair(struct task_struct *p)
   10254                 :            : {
   10255                 :          3 :         detach_task_cfs_rq(p);
   10256                 :          3 :         set_task_rq(p, task_cpu(p));
   10257                 :            : 
   10258                 :            : #ifdef CONFIG_SMP
   10259                 :            :         /* Tell se's cfs_rq has been changed -- migrated */
   10260                 :          3 :         p->se.avg.last_update_time = 0;
   10261                 :            : #endif
   10262                 :          3 :         attach_task_cfs_rq(p);
   10263                 :          3 : }
   10264                 :            : 
   10265                 :          3 : static void task_change_group_fair(struct task_struct *p, int type)
   10266                 :            : {
   10267                 :          3 :         switch (type) {
   10268                 :            :         case TASK_SET_GROUP:
   10269                 :          3 :                 task_set_group_fair(p);
   10270                 :          3 :                 break;
   10271                 :            : 
   10272                 :            :         case TASK_MOVE_GROUP:
   10273                 :          3 :                 task_move_group_fair(p);
   10274                 :          3 :                 break;
   10275                 :            :         }
   10276                 :          3 : }
   10277                 :            : 
   10278                 :          3 : void free_fair_sched_group(struct task_group *tg)
   10279                 :            : {
   10280                 :            :         int i;
   10281                 :            : 
   10282                 :          3 :         destroy_cfs_bandwidth(tg_cfs_bandwidth(tg));
   10283                 :            : 
   10284                 :          3 :         for_each_possible_cpu(i) {
   10285                 :          3 :                 if (tg->cfs_rq)
   10286                 :          3 :                         kfree(tg->cfs_rq[i]);
   10287                 :          3 :                 if (tg->se)
   10288                 :          3 :                         kfree(tg->se[i]);
   10289                 :            :         }
   10290                 :            : 
   10291                 :          3 :         kfree(tg->cfs_rq);
   10292                 :          3 :         kfree(tg->se);
   10293                 :          3 : }
   10294                 :            : 
   10295                 :          3 : int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
   10296                 :            : {
   10297                 :            :         struct sched_entity *se;
   10298                 :            :         struct cfs_rq *cfs_rq;
   10299                 :            :         int i;
   10300                 :            : 
   10301                 :          3 :         tg->cfs_rq = kcalloc(nr_cpu_ids, sizeof(cfs_rq), GFP_KERNEL);
   10302                 :          3 :         if (!tg->cfs_rq)
   10303                 :            :                 goto err;
   10304                 :          3 :         tg->se = kcalloc(nr_cpu_ids, sizeof(se), GFP_KERNEL);
   10305                 :          3 :         if (!tg->se)
   10306                 :            :                 goto err;
   10307                 :            : 
   10308                 :          3 :         tg->shares = NICE_0_LOAD;
   10309                 :            : 
   10310                 :          3 :         init_cfs_bandwidth(tg_cfs_bandwidth(tg));
   10311                 :            : 
   10312                 :          3 :         for_each_possible_cpu(i) {
   10313                 :          3 :                 cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
   10314                 :            :                                       GFP_KERNEL, cpu_to_node(i));
   10315                 :          3 :                 if (!cfs_rq)
   10316                 :            :                         goto err;
   10317                 :            : 
   10318                 :          3 :                 se = kzalloc_node(sizeof(struct sched_entity),
   10319                 :            :                                   GFP_KERNEL, cpu_to_node(i));
   10320                 :          3 :                 if (!se)
   10321                 :            :                         goto err_free_rq;
   10322                 :            : 
   10323                 :            :                 init_cfs_rq(cfs_rq);
   10324                 :          3 :                 init_tg_cfs_entry(tg, cfs_rq, se, i, parent->se[i]);
   10325                 :          3 :                 init_entity_runnable_average(se);
   10326                 :            :         }
   10327                 :            : 
   10328                 :            :         return 1;
   10329                 :            : 
   10330                 :            : err_free_rq:
   10331                 :          0 :         kfree(cfs_rq);
   10332                 :            : err:
   10333                 :            :         return 0;
   10334                 :            : }
   10335                 :            : 
   10336                 :          3 : void online_fair_sched_group(struct task_group *tg)
   10337                 :            : {
   10338                 :            :         struct sched_entity *se;
   10339                 :            :         struct rq_flags rf;
   10340                 :            :         struct rq *rq;
   10341                 :            :         int i;
   10342                 :            : 
   10343                 :          3 :         for_each_possible_cpu(i) {
   10344                 :          3 :                 rq = cpu_rq(i);
   10345                 :          3 :                 se = tg->se[i];
   10346                 :            :                 rq_lock_irq(rq, &rf);
   10347                 :          3 :                 update_rq_clock(rq);
   10348                 :          3 :                 attach_entity_cfs_rq(se);
   10349                 :          3 :                 sync_throttle(tg, i);
   10350                 :            :                 rq_unlock_irq(rq, &rf);
   10351                 :            :         }
   10352                 :          3 : }
   10353                 :            : 
   10354                 :          3 : void unregister_fair_sched_group(struct task_group *tg)
   10355                 :            : {
   10356                 :            :         unsigned long flags;
   10357                 :            :         struct rq *rq;
   10358                 :            :         int cpu;
   10359                 :            : 
   10360                 :          3 :         for_each_possible_cpu(cpu) {
   10361                 :          3 :                 if (tg->se[cpu])
   10362                 :          3 :                         remove_entity_load_avg(tg->se[cpu]);
   10363                 :            : 
   10364                 :            :                 /*
   10365                 :            :                  * Only empty task groups can be destroyed; so we can speculatively
   10366                 :            :                  * check on_list without danger of it being re-added.
   10367                 :            :                  */
   10368                 :          3 :                 if (!tg->cfs_rq[cpu]->on_list)
   10369                 :          3 :                         continue;
   10370                 :            : 
   10371                 :          3 :                 rq = cpu_rq(cpu);
   10372                 :            : 
   10373                 :          3 :                 raw_spin_lock_irqsave(&rq->lock, flags);
   10374                 :          3 :                 list_del_leaf_cfs_rq(tg->cfs_rq[cpu]);
   10375                 :          3 :                 raw_spin_unlock_irqrestore(&rq->lock, flags);
   10376                 :            :         }
   10377                 :          3 : }
   10378                 :            : 
   10379                 :          3 : void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
   10380                 :            :                         struct sched_entity *se, int cpu,
   10381                 :            :                         struct sched_entity *parent)
   10382                 :            : {
   10383                 :          3 :         struct rq *rq = cpu_rq(cpu);
   10384                 :            : 
   10385                 :          3 :         cfs_rq->tg = tg;
   10386                 :          3 :         cfs_rq->rq = rq;
   10387                 :            :         init_cfs_rq_runtime(cfs_rq);
   10388                 :            : 
   10389                 :          3 :         tg->cfs_rq[cpu] = cfs_rq;
   10390                 :          3 :         tg->se[cpu] = se;
   10391                 :            : 
   10392                 :            :         /* se could be NULL for root_task_group */
   10393                 :          3 :         if (!se)
   10394                 :          3 :                 return;
   10395                 :            : 
   10396                 :          3 :         if (!parent) {
   10397                 :          3 :                 se->cfs_rq = &rq->cfs;
   10398                 :          3 :                 se->depth = 0;
   10399                 :            :         } else {
   10400                 :          0 :                 se->cfs_rq = parent->my_q;
   10401                 :          0 :                 se->depth = parent->depth + 1;
   10402                 :            :         }
   10403                 :            : 
   10404                 :          3 :         se->my_q = cfs_rq;
   10405                 :            :         /* guarantee group entities always have weight */
   10406                 :            :         update_load_set(&se->load, NICE_0_LOAD);
   10407                 :          3 :         se->parent = parent;
   10408                 :            : }
   10409                 :            : 
   10410                 :            : static DEFINE_MUTEX(shares_mutex);
   10411                 :            : 
   10412                 :          0 : int sched_group_set_shares(struct task_group *tg, unsigned long shares)
   10413                 :            : {
   10414                 :            :         int i;
   10415                 :            : 
   10416                 :            :         /*
   10417                 :            :          * We can't change the weight of the root cgroup.
   10418                 :            :          */
   10419                 :          0 :         if (!tg->se[0])
   10420                 :            :                 return -EINVAL;
   10421                 :            : 
   10422                 :          0 :         shares = clamp(shares, scale_load(MIN_SHARES), scale_load(MAX_SHARES));
   10423                 :            : 
   10424                 :          0 :         mutex_lock(&shares_mutex);
   10425                 :          0 :         if (tg->shares == shares)
   10426                 :            :                 goto done;
   10427                 :            : 
   10428                 :          0 :         tg->shares = shares;
   10429                 :          0 :         for_each_possible_cpu(i) {
   10430                 :          0 :                 struct rq *rq = cpu_rq(i);
   10431                 :          0 :                 struct sched_entity *se = tg->se[i];
   10432                 :            :                 struct rq_flags rf;
   10433                 :            : 
   10434                 :            :                 /* Propagate contribution to hierarchy */
   10435                 :            :                 rq_lock_irqsave(rq, &rf);
   10436                 :          0 :                 update_rq_clock(rq);
   10437                 :          0 :                 for_each_sched_entity(se) {
   10438                 :          0 :                         update_load_avg(cfs_rq_of(se), se, UPDATE_TG);
   10439                 :          0 :                         update_cfs_group(se);
   10440                 :            :                 }
   10441                 :            :                 rq_unlock_irqrestore(rq, &rf);
   10442                 :            :         }
   10443                 :            : 
   10444                 :            : done:
   10445                 :          0 :         mutex_unlock(&shares_mutex);
   10446                 :          0 :         return 0;
   10447                 :            : }
   10448                 :            : #else /* CONFIG_FAIR_GROUP_SCHED */
   10449                 :            : 
   10450                 :            : void free_fair_sched_group(struct task_group *tg) { }
   10451                 :            : 
   10452                 :            : int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
   10453                 :            : {
   10454                 :            :         return 1;
   10455                 :            : }
   10456                 :            : 
   10457                 :            : void online_fair_sched_group(struct task_group *tg) { }
   10458                 :            : 
   10459                 :            : void unregister_fair_sched_group(struct task_group *tg) { }
   10460                 :            : 
   10461                 :            : #endif /* CONFIG_FAIR_GROUP_SCHED */
   10462                 :            : 
   10463                 :            : 
   10464                 :          0 : static unsigned int get_rr_interval_fair(struct rq *rq, struct task_struct *task)
   10465                 :            : {
   10466                 :          0 :         struct sched_entity *se = &task->se;
   10467                 :            :         unsigned int rr_interval = 0;
   10468                 :            : 
   10469                 :            :         /*
   10470                 :            :          * Time slice is 0 for SCHED_OTHER tasks that are on an otherwise
   10471                 :            :          * idle runqueue:
   10472                 :            :          */
   10473                 :          0 :         if (rq->cfs.load.weight)
   10474                 :          0 :                 rr_interval = NS_TO_JIFFIES(sched_slice(cfs_rq_of(se), se));
   10475                 :            : 
   10476                 :          0 :         return rr_interval;
   10477                 :            : }
   10478                 :            : 
   10479                 :            : /*
   10480                 :            :  * All the scheduling class methods:
   10481                 :            :  */
   10482                 :            : const struct sched_class fair_sched_class = {
   10483                 :            :         .next                   = &idle_sched_class,
   10484                 :            :         .enqueue_task           = enqueue_task_fair,
   10485                 :            :         .dequeue_task           = dequeue_task_fair,
   10486                 :            :         .yield_task             = yield_task_fair,
   10487                 :            :         .yield_to_task          = yield_to_task_fair,
   10488                 :            : 
   10489                 :            :         .check_preempt_curr     = check_preempt_wakeup,
   10490                 :            : 
   10491                 :            :         .pick_next_task         = pick_next_task_fair,
   10492                 :            :         .put_prev_task          = put_prev_task_fair,
   10493                 :            :         .set_next_task          = set_next_task_fair,
   10494                 :            : 
   10495                 :            : #ifdef CONFIG_SMP
   10496                 :            :         .balance                = balance_fair,
   10497                 :            :         .select_task_rq         = select_task_rq_fair,
   10498                 :            :         .migrate_task_rq        = migrate_task_rq_fair,
   10499                 :            : 
   10500                 :            :         .rq_online              = rq_online_fair,
   10501                 :            :         .rq_offline             = rq_offline_fair,
   10502                 :            : 
   10503                 :            :         .task_dead              = task_dead_fair,
   10504                 :            :         .set_cpus_allowed       = set_cpus_allowed_common,
   10505                 :            : #endif
   10506                 :            : 
   10507                 :            :         .task_tick              = task_tick_fair,
   10508                 :            :         .task_fork              = task_fork_fair,
   10509                 :            : 
   10510                 :            :         .prio_changed           = prio_changed_fair,
   10511                 :            :         .switched_from          = switched_from_fair,
   10512                 :            :         .switched_to            = switched_to_fair,
   10513                 :            : 
   10514                 :            :         .get_rr_interval        = get_rr_interval_fair,
   10515                 :            : 
   10516                 :            :         .update_curr            = update_curr_fair,
   10517                 :            : 
   10518                 :            : #ifdef CONFIG_FAIR_GROUP_SCHED
   10519                 :            :         .task_change_group      = task_change_group_fair,
   10520                 :            : #endif
   10521                 :            : 
   10522                 :            : #ifdef CONFIG_UCLAMP_TASK
   10523                 :            :         .uclamp_enabled         = 1,
   10524                 :            : #endif
   10525                 :            : };
   10526                 :            : 
   10527                 :            : #ifdef CONFIG_SCHED_DEBUG
   10528                 :          0 : void print_cfs_stats(struct seq_file *m, int cpu)
   10529                 :            : {
   10530                 :            :         struct cfs_rq *cfs_rq, *pos;
   10531                 :            : 
   10532                 :            :         rcu_read_lock();
   10533                 :          0 :         for_each_leaf_cfs_rq_safe(cpu_rq(cpu), cfs_rq, pos)
   10534                 :          0 :                 print_cfs_rq(m, cpu, cfs_rq);
   10535                 :            :         rcu_read_unlock();
   10536                 :          0 : }
   10537                 :            : 
   10538                 :            : #ifdef CONFIG_NUMA_BALANCING
   10539                 :            : void show_numa_stats(struct task_struct *p, struct seq_file *m)
   10540                 :            : {
   10541                 :            :         int node;
   10542                 :            :         unsigned long tsf = 0, tpf = 0, gsf = 0, gpf = 0;
   10543                 :            :         struct numa_group *ng;
   10544                 :            : 
   10545                 :            :         rcu_read_lock();
   10546                 :            :         ng = rcu_dereference(p->numa_group);
   10547                 :            :         for_each_online_node(node) {
   10548                 :            :                 if (p->numa_faults) {
   10549                 :            :                         tsf = p->numa_faults[task_faults_idx(NUMA_MEM, node, 0)];
   10550                 :            :                         tpf = p->numa_faults[task_faults_idx(NUMA_MEM, node, 1)];
   10551                 :            :                 }
   10552                 :            :                 if (ng) {
   10553                 :            :                         gsf = ng->faults[task_faults_idx(NUMA_MEM, node, 0)],
   10554                 :            :                         gpf = ng->faults[task_faults_idx(NUMA_MEM, node, 1)];
   10555                 :            :                 }
   10556                 :            :                 print_numa_stats(m, node, tsf, tpf, gsf, gpf);
   10557                 :            :         }
   10558                 :            :         rcu_read_unlock();
   10559                 :            : }
   10560                 :            : #endif /* CONFIG_NUMA_BALANCING */
   10561                 :            : #endif /* CONFIG_SCHED_DEBUG */
   10562                 :            : 
   10563                 :          3 : __init void init_sched_fair_class(void)
   10564                 :            : {
   10565                 :            : #ifdef CONFIG_SMP
   10566                 :          3 :         open_softirq(SCHED_SOFTIRQ, run_rebalance_domains);
   10567                 :            : 
   10568                 :            : #ifdef CONFIG_NO_HZ_COMMON
   10569                 :          3 :         nohz.next_balance = jiffies;
   10570                 :          3 :         nohz.next_blocked = jiffies;
   10571                 :            :         zalloc_cpumask_var(&nohz.idle_cpus_mask, GFP_NOWAIT);
   10572                 :            : #endif
   10573                 :            : #endif /* SMP */
   10574                 :            : 
   10575                 :          3 : }
   10576                 :            : 
   10577                 :            : /*
   10578                 :            :  * Helper functions to facilitate extracting info from tracepoints.
   10579                 :            :  */
   10580                 :            : 
   10581                 :          0 : const struct sched_avg *sched_trace_cfs_rq_avg(struct cfs_rq *cfs_rq)
   10582                 :            : {
   10583                 :            : #ifdef CONFIG_SMP
   10584                 :          0 :         return cfs_rq ? &cfs_rq->avg : NULL;
   10585                 :            : #else
   10586                 :            :         return NULL;
   10587                 :            : #endif
   10588                 :            : }
   10589                 :            : EXPORT_SYMBOL_GPL(sched_trace_cfs_rq_avg);
   10590                 :            : 
   10591                 :          0 : char *sched_trace_cfs_rq_path(struct cfs_rq *cfs_rq, char *str, int len)
   10592                 :            : {
   10593                 :          0 :         if (!cfs_rq) {
   10594                 :          0 :                 if (str)
   10595                 :          0 :                         strlcpy(str, "(null)", len);
   10596                 :            :                 else
   10597                 :            :                         return NULL;
   10598                 :            :         }
   10599                 :            : 
   10600                 :          0 :         cfs_rq_tg_path(cfs_rq, str, len);
   10601                 :          0 :         return str;
   10602                 :            : }
   10603                 :            : EXPORT_SYMBOL_GPL(sched_trace_cfs_rq_path);
   10604                 :            : 
   10605                 :          0 : int sched_trace_cfs_rq_cpu(struct cfs_rq *cfs_rq)
   10606                 :            : {
   10607                 :          0 :         return cfs_rq ? cpu_of(rq_of(cfs_rq)) : -1;
   10608                 :            : }
   10609                 :            : EXPORT_SYMBOL_GPL(sched_trace_cfs_rq_cpu);
   10610                 :            : 
   10611                 :          0 : const struct sched_avg *sched_trace_rq_avg_rt(struct rq *rq)
   10612                 :            : {
   10613                 :            : #ifdef CONFIG_SMP
   10614                 :          0 :         return rq ? &rq->avg_rt : NULL;
   10615                 :            : #else
   10616                 :            :         return NULL;
   10617                 :            : #endif
   10618                 :            : }
   10619                 :            : EXPORT_SYMBOL_GPL(sched_trace_rq_avg_rt);
   10620                 :            : 
   10621                 :          0 : const struct sched_avg *sched_trace_rq_avg_dl(struct rq *rq)
   10622                 :            : {
   10623                 :            : #ifdef CONFIG_SMP
   10624                 :          0 :         return rq ? &rq->avg_dl : NULL;
   10625                 :            : #else
   10626                 :            :         return NULL;
   10627                 :            : #endif
   10628                 :            : }
   10629                 :            : EXPORT_SYMBOL_GPL(sched_trace_rq_avg_dl);
   10630                 :            : 
   10631                 :          0 : const struct sched_avg *sched_trace_rq_avg_irq(struct rq *rq)
   10632                 :            : {
   10633                 :            : #if defined(CONFIG_SMP) && defined(CONFIG_HAVE_SCHED_AVG_IRQ)
   10634                 :            :         return rq ? &rq->avg_irq : NULL;
   10635                 :            : #else
   10636                 :          0 :         return NULL;
   10637                 :            : #endif
   10638                 :            : }
   10639                 :            : EXPORT_SYMBOL_GPL(sched_trace_rq_avg_irq);
   10640                 :            : 
   10641                 :          0 : int sched_trace_rq_cpu(struct rq *rq)
   10642                 :            : {
   10643                 :          0 :         return rq ? cpu_of(rq) : -1;
   10644                 :            : }
   10645                 :            : EXPORT_SYMBOL_GPL(sched_trace_rq_cpu);
   10646                 :            : 
   10647                 :          0 : const struct cpumask *sched_trace_rd_span(struct root_domain *rd)
   10648                 :            : {
   10649                 :            : #ifdef CONFIG_SMP
   10650                 :          0 :         return rd ? rd->span : NULL;
   10651                 :            : #else
   10652                 :            :         return NULL;
   10653                 :            : #endif
   10654                 :            : }
   10655                 :            : EXPORT_SYMBOL_GPL(sched_trace_rd_span);
    

Generated by: LCOV version 1.14