Merge branch 'akpm' (patches from Andrew)
[sfrench/cifs-2.6.git] / kernel / sched / fair.c
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 int __weak arch_asym_cpu_priority(int cpu)
94 {
95         return -cpu;
96 }
97
98 /*
99  * The margin used when comparing utilization with CPU capacity:
100  * util * margin < capacity * 1024
101  *
102  * (default: ~20%)
103  */
104 static unsigned int capacity_margin                     = 1280;
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         lw->weight += inc;
124         lw->inv_weight = 0;
125 }
126
127 static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
128 {
129         lw->weight -= dec;
130         lw->inv_weight = 0;
131 }
132
133 static inline void update_load_set(struct load_weight *lw, unsigned long w)
134 {
135         lw->weight = w;
136         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 static unsigned int get_update_sysctl_factor(void)
149 {
150         unsigned int cpus = min_t(unsigned int, num_online_cpus(), 8);
151         unsigned int factor;
152
153         switch (sysctl_sched_tunable_scaling) {
154         case SCHED_TUNABLESCALING_NONE:
155                 factor = 1;
156                 break;
157         case SCHED_TUNABLESCALING_LINEAR:
158                 factor = cpus;
159                 break;
160         case SCHED_TUNABLESCALING_LOG:
161         default:
162                 factor = 1 + ilog2(cpus);
163                 break;
164         }
165
166         return factor;
167 }
168
169 static void update_sysctl(void)
170 {
171         unsigned int factor = get_update_sysctl_factor();
172
173 #define SET_SYSCTL(name) \
174         (sysctl_##name = (factor) * normalized_sysctl_##name)
175         SET_SYSCTL(sched_min_granularity);
176         SET_SYSCTL(sched_latency);
177         SET_SYSCTL(sched_wakeup_granularity);
178 #undef SET_SYSCTL
179 }
180
181 void sched_init_granularity(void)
182 {
183         update_sysctl();
184 }
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         if (likely(lw->inv_weight))
194                 return;
195
196         w = scale_load_down(lw->weight);
197
198         if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
199                 lw->inv_weight = 1;
200         else if (unlikely(!w))
201                 lw->inv_weight = WMULT_CONST;
202         else
203                 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 static u64 __calc_delta(u64 delta_exec, unsigned long weight, struct load_weight *lw)
219 {
220         u64 fact = scale_load_down(weight);
221         int shift = WMULT_SHIFT;
222
223         __update_inv_weight(lw);
224
225         if (unlikely(fact >> 32)) {
226                 while (fact >> 32) {
227                         fact >>= 1;
228                         shift--;
229                 }
230         }
231
232         /* hint to use a 32x32->64 mul */
233         fact = (u64)(u32)fact * lw->inv_weight;
234
235         while (fact >> 32) {
236                 fact >>= 1;
237                 shift--;
238         }
239
240         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 static inline struct task_struct *task_of(struct sched_entity *se)
252 {
253         SCHED_WARN_ON(!entity_is_task(se));
254         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         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         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         return grp->my_q;
276 }
277
278 static inline bool list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq)
279 {
280         struct rq *rq = rq_of(cfs_rq);
281         int cpu = cpu_of(rq);
282
283         if (cfs_rq->on_list)
284                 return rq->tmp_alone_branch == &rq->leaf_cfs_rq_list;
285
286         cfs_rq->on_list = 1;
287
288         /*
289          * Ensure we either appear before our parent (if already
290          * enqueued) or force our parent to appear after us when it is
291          * enqueued. The fact that we always enqueue bottom-up
292          * reduces this to two cases and a special case for the root
293          * cfs_rq. Furthermore, it also means that we will always reset
294          * tmp_alone_branch either when the branch is connected
295          * to a tree or when we reach the top of the tree
296          */
297         if (cfs_rq->tg->parent &&
298             cfs_rq->tg->parent->cfs_rq[cpu]->on_list) {
299                 /*
300                  * If parent is already on the list, we add the child
301                  * just before. Thanks to circular linked property of
302                  * the list, this means to put the child at the tail
303                  * of the list that starts by parent.
304                  */
305                 list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list,
306                         &(cfs_rq->tg->parent->cfs_rq[cpu]->leaf_cfs_rq_list));
307                 /*
308                  * The branch is now connected to its tree so we can
309                  * reset tmp_alone_branch to the beginning of the
310                  * list.
311                  */
312                 rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
313                 return true;
314         }
315
316         if (!cfs_rq->tg->parent) {
317                 /*
318                  * cfs rq without parent should be put
319                  * at the tail of the list.
320                  */
321                 list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list,
322                         &rq->leaf_cfs_rq_list);
323                 /*
324                  * We have reach the top of a tree so we can reset
325                  * tmp_alone_branch to the beginning of the list.
326                  */
327                 rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
328                 return true;
329         }
330
331         /*
332          * The parent has not already been added so we want to
333          * make sure that it will be put after us.
334          * tmp_alone_branch points to the begin of the branch
335          * where we will add parent.
336          */
337         list_add_rcu(&cfs_rq->leaf_cfs_rq_list, rq->tmp_alone_branch);
338         /*
339          * update tmp_alone_branch to points to the new begin
340          * of the branch
341          */
342         rq->tmp_alone_branch = &cfs_rq->leaf_cfs_rq_list;
343         return false;
344 }
345
346 static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
347 {
348         if (cfs_rq->on_list) {
349                 struct rq *rq = rq_of(cfs_rq);
350
351                 /*
352                  * With cfs_rq being unthrottled/throttled during an enqueue,
353                  * it can happen the tmp_alone_branch points the a leaf that
354                  * we finally want to del. In this case, tmp_alone_branch moves
355                  * to the prev element but it will point to rq->leaf_cfs_rq_list
356                  * at the end of the enqueue.
357                  */
358                 if (rq->tmp_alone_branch == &cfs_rq->leaf_cfs_rq_list)
359                         rq->tmp_alone_branch = cfs_rq->leaf_cfs_rq_list.prev;
360
361                 list_del_rcu(&cfs_rq->leaf_cfs_rq_list);
362                 cfs_rq->on_list = 0;
363         }
364 }
365
366 static inline void assert_list_leaf_cfs_rq(struct rq *rq)
367 {
368         SCHED_WARN_ON(rq->tmp_alone_branch != &rq->leaf_cfs_rq_list);
369 }
370
371 /* Iterate thr' all leaf cfs_rq's on a runqueue */
372 #define for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos)                      \
373         list_for_each_entry_safe(cfs_rq, pos, &rq->leaf_cfs_rq_list,    \
374                                  leaf_cfs_rq_list)
375
376 /* Do the two (enqueued) entities belong to the same group ? */
377 static inline struct cfs_rq *
378 is_same_group(struct sched_entity *se, struct sched_entity *pse)
379 {
380         if (se->cfs_rq == pse->cfs_rq)
381                 return se->cfs_rq;
382
383         return NULL;
384 }
385
386 static inline struct sched_entity *parent_entity(struct sched_entity *se)
387 {
388         return se->parent;
389 }
390
391 static void
392 find_matching_se(struct sched_entity **se, struct sched_entity **pse)
393 {
394         int se_depth, pse_depth;
395
396         /*
397          * preemption test can be made between sibling entities who are in the
398          * same cfs_rq i.e who have a common parent. Walk up the hierarchy of
399          * both tasks until we find their ancestors who are siblings of common
400          * parent.
401          */
402
403         /* First walk up until both entities are at same depth */
404         se_depth = (*se)->depth;
405         pse_depth = (*pse)->depth;
406
407         while (se_depth > pse_depth) {
408                 se_depth--;
409                 *se = parent_entity(*se);
410         }
411
412         while (pse_depth > se_depth) {
413                 pse_depth--;
414                 *pse = parent_entity(*pse);
415         }
416
417         while (!is_same_group(*se, *pse)) {
418                 *se = parent_entity(*se);
419                 *pse = parent_entity(*pse);
420         }
421 }
422
423 #else   /* !CONFIG_FAIR_GROUP_SCHED */
424
425 static inline struct task_struct *task_of(struct sched_entity *se)
426 {
427         return container_of(se, struct task_struct, se);
428 }
429
430 #define for_each_sched_entity(se) \
431                 for (; se; se = NULL)
432
433 static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
434 {
435         return &task_rq(p)->cfs;
436 }
437
438 static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
439 {
440         struct task_struct *p = task_of(se);
441         struct rq *rq = task_rq(p);
442
443         return &rq->cfs;
444 }
445
446 /* runqueue "owned" by this group */
447 static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
448 {
449         return NULL;
450 }
451
452 static inline bool list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq)
453 {
454         return true;
455 }
456
457 static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
458 {
459 }
460
461 static inline void assert_list_leaf_cfs_rq(struct rq *rq)
462 {
463 }
464
465 #define for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos)      \
466                 for (cfs_rq = &rq->cfs, pos = NULL; cfs_rq; cfs_rq = pos)
467
468 static inline struct sched_entity *parent_entity(struct sched_entity *se)
469 {
470         return NULL;
471 }
472
473 static inline void
474 find_matching_se(struct sched_entity **se, struct sched_entity **pse)
475 {
476 }
477
478 #endif  /* CONFIG_FAIR_GROUP_SCHED */
479
480 static __always_inline
481 void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec);
482
483 /**************************************************************
484  * Scheduling class tree data structure manipulation methods:
485  */
486
487 static inline u64 max_vruntime(u64 max_vruntime, u64 vruntime)
488 {
489         s64 delta = (s64)(vruntime - max_vruntime);
490         if (delta > 0)
491                 max_vruntime = vruntime;
492
493         return max_vruntime;
494 }
495
496 static inline u64 min_vruntime(u64 min_vruntime, u64 vruntime)
497 {
498         s64 delta = (s64)(vruntime - min_vruntime);
499         if (delta < 0)
500                 min_vruntime = vruntime;
501
502         return min_vruntime;
503 }
504
505 static inline int entity_before(struct sched_entity *a,
506                                 struct sched_entity *b)
507 {
508         return (s64)(a->vruntime - b->vruntime) < 0;
509 }
510
511 static void update_min_vruntime(struct cfs_rq *cfs_rq)
512 {
513         struct sched_entity *curr = cfs_rq->curr;
514         struct rb_node *leftmost = rb_first_cached(&cfs_rq->tasks_timeline);
515
516         u64 vruntime = cfs_rq->min_vruntime;
517
518         if (curr) {
519                 if (curr->on_rq)
520                         vruntime = curr->vruntime;
521                 else
522                         curr = NULL;
523         }
524
525         if (leftmost) { /* non-empty tree */
526                 struct sched_entity *se;
527                 se = rb_entry(leftmost, struct sched_entity, run_node);
528
529                 if (!curr)
530                         vruntime = se->vruntime;
531                 else
532                         vruntime = min_vruntime(vruntime, se->vruntime);
533         }
534
535         /* ensure we never gain time by being placed backwards. */
536         cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime);
537 #ifndef CONFIG_64BIT
538         smp_wmb();
539         cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;
540 #endif
541 }
542
543 /*
544  * Enqueue an entity into the rb-tree:
545  */
546 static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
547 {
548         struct rb_node **link = &cfs_rq->tasks_timeline.rb_root.rb_node;
549         struct rb_node *parent = NULL;
550         struct sched_entity *entry;
551         bool leftmost = true;
552
553         /*
554          * Find the right place in the rbtree:
555          */
556         while (*link) {
557                 parent = *link;
558                 entry = rb_entry(parent, struct sched_entity, run_node);
559                 /*
560                  * We dont care about collisions. Nodes with
561                  * the same key stay together.
562                  */
563                 if (entity_before(se, entry)) {
564                         link = &parent->rb_left;
565                 } else {
566                         link = &parent->rb_right;
567                         leftmost = false;
568                 }
569         }
570
571         rb_link_node(&se->run_node, parent, link);
572         rb_insert_color_cached(&se->run_node,
573                                &cfs_rq->tasks_timeline, leftmost);
574 }
575
576 static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
577 {
578         rb_erase_cached(&se->run_node, &cfs_rq->tasks_timeline);
579 }
580
581 struct sched_entity *__pick_first_entity(struct cfs_rq *cfs_rq)
582 {
583         struct rb_node *left = rb_first_cached(&cfs_rq->tasks_timeline);
584
585         if (!left)
586                 return NULL;
587
588         return rb_entry(left, struct sched_entity, run_node);
589 }
590
591 static struct sched_entity *__pick_next_entity(struct sched_entity *se)
592 {
593         struct rb_node *next = rb_next(&se->run_node);
594
595         if (!next)
596                 return NULL;
597
598         return rb_entry(next, struct sched_entity, run_node);
599 }
600
601 #ifdef CONFIG_SCHED_DEBUG
602 struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
603 {
604         struct rb_node *last = rb_last(&cfs_rq->tasks_timeline.rb_root);
605
606         if (!last)
607                 return NULL;
608
609         return rb_entry(last, struct sched_entity, run_node);
610 }
611
612 /**************************************************************
613  * Scheduling class statistics methods:
614  */
615
616 int sched_proc_update_handler(struct ctl_table *table, int write,
617                 void __user *buffer, size_t *lenp,
618                 loff_t *ppos)
619 {
620         int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
621         unsigned int factor = get_update_sysctl_factor();
622
623         if (ret || !write)
624                 return ret;
625
626         sched_nr_latency = DIV_ROUND_UP(sysctl_sched_latency,
627                                         sysctl_sched_min_granularity);
628
629 #define WRT_SYSCTL(name) \
630         (normalized_sysctl_##name = sysctl_##name / (factor))
631         WRT_SYSCTL(sched_min_granularity);
632         WRT_SYSCTL(sched_latency);
633         WRT_SYSCTL(sched_wakeup_granularity);
634 #undef WRT_SYSCTL
635
636         return 0;
637 }
638 #endif
639
640 /*
641  * delta /= w
642  */
643 static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se)
644 {
645         if (unlikely(se->load.weight != NICE_0_LOAD))
646                 delta = __calc_delta(delta, NICE_0_LOAD, &se->load);
647
648         return delta;
649 }
650
651 /*
652  * The idea is to set a period in which each task runs once.
653  *
654  * When there are too many tasks (sched_nr_latency) we have to stretch
655  * this period because otherwise the slices get too small.
656  *
657  * p = (nr <= nl) ? l : l*nr/nl
658  */
659 static u64 __sched_period(unsigned long nr_running)
660 {
661         if (unlikely(nr_running > sched_nr_latency))
662                 return nr_running * sysctl_sched_min_granularity;
663         else
664                 return sysctl_sched_latency;
665 }
666
667 /*
668  * We calculate the wall-time slice from the period by taking a part
669  * proportional to the weight.
670  *
671  * s = p*P[w/rw]
672  */
673 static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
674 {
675         u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq);
676
677         for_each_sched_entity(se) {
678                 struct load_weight *load;
679                 struct load_weight lw;
680
681                 cfs_rq = cfs_rq_of(se);
682                 load = &cfs_rq->load;
683
684                 if (unlikely(!se->on_rq)) {
685                         lw = cfs_rq->load;
686
687                         update_load_add(&lw, se->load.weight);
688                         load = &lw;
689                 }
690                 slice = __calc_delta(slice, se->load.weight, load);
691         }
692         return slice;
693 }
694
695 /*
696  * We calculate the vruntime slice of a to-be-inserted task.
697  *
698  * vs = s/w
699  */
700 static u64 sched_vslice(struct cfs_rq *cfs_rq, struct sched_entity *se)
701 {
702         return calc_delta_fair(sched_slice(cfs_rq, se), se);
703 }
704
705 #include "pelt.h"
706 #ifdef CONFIG_SMP
707
708 static int select_idle_sibling(struct task_struct *p, int prev_cpu, int cpu);
709 static unsigned long task_h_load(struct task_struct *p);
710 static unsigned long capacity_of(int cpu);
711
712 /* Give new sched_entity start runnable values to heavy its load in infant time */
713 void init_entity_runnable_average(struct sched_entity *se)
714 {
715         struct sched_avg *sa = &se->avg;
716
717         memset(sa, 0, sizeof(*sa));
718
719         /*
720          * Tasks are initialized with full load to be seen as heavy tasks until
721          * they get a chance to stabilize to their real load level.
722          * Group entities are initialized with zero load to reflect the fact that
723          * nothing has been attached to the task group yet.
724          */
725         if (entity_is_task(se))
726                 sa->runnable_load_avg = sa->load_avg = scale_load_down(se->load.weight);
727
728         se->runnable_weight = se->load.weight;
729
730         /* when this task enqueue'ed, it will contribute to its cfs_rq's load_avg */
731 }
732
733 static inline u64 cfs_rq_clock_task(struct cfs_rq *cfs_rq);
734 static void attach_entity_cfs_rq(struct sched_entity *se);
735
736 /*
737  * With new tasks being created, their initial util_avgs are extrapolated
738  * based on the cfs_rq's current util_avg:
739  *
740  *   util_avg = cfs_rq->util_avg / (cfs_rq->load_avg + 1) * se.load.weight
741  *
742  * However, in many cases, the above util_avg does not give a desired
743  * value. Moreover, the sum of the util_avgs may be divergent, such
744  * as when the series is a harmonic series.
745  *
746  * To solve this problem, we also cap the util_avg of successive tasks to
747  * only 1/2 of the left utilization budget:
748  *
749  *   util_avg_cap = (cpu_scale - cfs_rq->avg.util_avg) / 2^n
750  *
751  * where n denotes the nth task and cpu_scale the CPU capacity.
752  *
753  * For example, for a CPU with 1024 of capacity, a simplest series from
754  * the beginning would be like:
755  *
756  *  task  util_avg: 512, 256, 128,  64,  32,   16,    8, ...
757  * cfs_rq util_avg: 512, 768, 896, 960, 992, 1008, 1016, ...
758  *
759  * Finally, that extrapolated util_avg is clamped to the cap (util_avg_cap)
760  * if util_avg > util_avg_cap.
761  */
762 void post_init_entity_util_avg(struct task_struct *p)
763 {
764         struct sched_entity *se = &p->se;
765         struct cfs_rq *cfs_rq = cfs_rq_of(se);
766         struct sched_avg *sa = &se->avg;
767         long cpu_scale = arch_scale_cpu_capacity(NULL, cpu_of(rq_of(cfs_rq)));
768         long cap = (long)(cpu_scale - cfs_rq->avg.util_avg) / 2;
769
770         if (cap > 0) {
771                 if (cfs_rq->avg.util_avg != 0) {
772                         sa->util_avg  = cfs_rq->avg.util_avg * se->load.weight;
773                         sa->util_avg /= (cfs_rq->avg.load_avg + 1);
774
775                         if (sa->util_avg > cap)
776                                 sa->util_avg = cap;
777                 } else {
778                         sa->util_avg = cap;
779                 }
780         }
781
782         if (p->sched_class != &fair_sched_class) {
783                 /*
784                  * For !fair tasks do:
785                  *
786                 update_cfs_rq_load_avg(now, cfs_rq);
787                 attach_entity_load_avg(cfs_rq, se, 0);
788                 switched_from_fair(rq, p);
789                  *
790                  * such that the next switched_to_fair() has the
791                  * expected state.
792                  */
793                 se->avg.last_update_time = cfs_rq_clock_pelt(cfs_rq);
794                 return;
795         }
796
797         attach_entity_cfs_rq(se);
798 }
799
800 #else /* !CONFIG_SMP */
801 void init_entity_runnable_average(struct sched_entity *se)
802 {
803 }
804 void post_init_entity_util_avg(struct task_struct *p)
805 {
806 }
807 static void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
808 {
809 }
810 #endif /* CONFIG_SMP */
811
812 /*
813  * Update the current task's runtime statistics.
814  */
815 static void update_curr(struct cfs_rq *cfs_rq)
816 {
817         struct sched_entity *curr = cfs_rq->curr;
818         u64 now = rq_clock_task(rq_of(cfs_rq));
819         u64 delta_exec;
820
821         if (unlikely(!curr))
822                 return;
823
824         delta_exec = now - curr->exec_start;
825         if (unlikely((s64)delta_exec <= 0))
826                 return;
827
828         curr->exec_start = now;
829
830         schedstat_set(curr->statistics.exec_max,
831                       max(delta_exec, curr->statistics.exec_max));
832
833         curr->sum_exec_runtime += delta_exec;
834         schedstat_add(cfs_rq->exec_clock, delta_exec);
835
836         curr->vruntime += calc_delta_fair(delta_exec, curr);
837         update_min_vruntime(cfs_rq);
838
839         if (entity_is_task(curr)) {
840                 struct task_struct *curtask = task_of(curr);
841
842                 trace_sched_stat_runtime(curtask, delta_exec, curr->vruntime);
843                 cgroup_account_cputime(curtask, delta_exec);
844                 account_group_exec_runtime(curtask, delta_exec);
845         }
846
847         account_cfs_rq_runtime(cfs_rq, delta_exec);
848 }
849
850 static void update_curr_fair(struct rq *rq)
851 {
852         update_curr(cfs_rq_of(&rq->curr->se));
853 }
854
855 static inline void
856 update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
857 {
858         u64 wait_start, prev_wait_start;
859
860         if (!schedstat_enabled())
861                 return;
862
863         wait_start = rq_clock(rq_of(cfs_rq));
864         prev_wait_start = schedstat_val(se->statistics.wait_start);
865
866         if (entity_is_task(se) && task_on_rq_migrating(task_of(se)) &&
867             likely(wait_start > prev_wait_start))
868                 wait_start -= prev_wait_start;
869
870         __schedstat_set(se->statistics.wait_start, wait_start);
871 }
872
873 static inline void
874 update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
875 {
876         struct task_struct *p;
877         u64 delta;
878
879         if (!schedstat_enabled())
880                 return;
881
882         delta = rq_clock(rq_of(cfs_rq)) - schedstat_val(se->statistics.wait_start);
883
884         if (entity_is_task(se)) {
885                 p = task_of(se);
886                 if (task_on_rq_migrating(p)) {
887                         /*
888                          * Preserve migrating task's wait time so wait_start
889                          * time stamp can be adjusted to accumulate wait time
890                          * prior to migration.
891                          */
892                         __schedstat_set(se->statistics.wait_start, delta);
893                         return;
894                 }
895                 trace_sched_stat_wait(p, delta);
896         }
897
898         __schedstat_set(se->statistics.wait_max,
899                       max(schedstat_val(se->statistics.wait_max), delta));
900         __schedstat_inc(se->statistics.wait_count);
901         __schedstat_add(se->statistics.wait_sum, delta);
902         __schedstat_set(se->statistics.wait_start, 0);
903 }
904
905 static inline void
906 update_stats_enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
907 {
908         struct task_struct *tsk = NULL;
909         u64 sleep_start, block_start;
910
911         if (!schedstat_enabled())
912                 return;
913
914         sleep_start = schedstat_val(se->statistics.sleep_start);
915         block_start = schedstat_val(se->statistics.block_start);
916
917         if (entity_is_task(se))
918                 tsk = task_of(se);
919
920         if (sleep_start) {
921                 u64 delta = rq_clock(rq_of(cfs_rq)) - sleep_start;
922
923                 if ((s64)delta < 0)
924                         delta = 0;
925
926                 if (unlikely(delta > schedstat_val(se->statistics.sleep_max)))
927                         __schedstat_set(se->statistics.sleep_max, delta);
928
929                 __schedstat_set(se->statistics.sleep_start, 0);
930                 __schedstat_add(se->statistics.sum_sleep_runtime, delta);
931
932                 if (tsk) {
933                         account_scheduler_latency(tsk, delta >> 10, 1);
934                         trace_sched_stat_sleep(tsk, delta);
935                 }
936         }
937         if (block_start) {
938                 u64 delta = rq_clock(rq_of(cfs_rq)) - block_start;
939
940                 if ((s64)delta < 0)
941                         delta = 0;
942
943                 if (unlikely(delta > schedstat_val(se->statistics.block_max)))
944                         __schedstat_set(se->statistics.block_max, delta);
945
946                 __schedstat_set(se->statistics.block_start, 0);
947                 __schedstat_add(se->statistics.sum_sleep_runtime, delta);
948
949                 if (tsk) {
950                         if (tsk->in_iowait) {
951                                 __schedstat_add(se->statistics.iowait_sum, delta);
952                                 __schedstat_inc(se->statistics.iowait_count);
953                                 trace_sched_stat_iowait(tsk, delta);
954                         }
955
956                         trace_sched_stat_blocked(tsk, delta);
957
958                         /*
959                          * Blocking time is in units of nanosecs, so shift by
960                          * 20 to get a milliseconds-range estimation of the
961                          * amount of time that the task spent sleeping:
962                          */
963                         if (unlikely(prof_on == SLEEP_PROFILING)) {
964                                 profile_hits(SLEEP_PROFILING,
965                                                 (void *)get_wchan(tsk),
966                                                 delta >> 20);
967                         }
968                         account_scheduler_latency(tsk, delta >> 10, 0);
969                 }
970         }
971 }
972
973 /*
974  * Task is being enqueued - update stats:
975  */
976 static inline void
977 update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
978 {
979         if (!schedstat_enabled())
980                 return;
981
982         /*
983          * Are we enqueueing a waiting task? (for current tasks
984          * a dequeue/enqueue event is a NOP)
985          */
986         if (se != cfs_rq->curr)
987                 update_stats_wait_start(cfs_rq, se);
988
989         if (flags & ENQUEUE_WAKEUP)
990                 update_stats_enqueue_sleeper(cfs_rq, se);
991 }
992
993 static inline void
994 update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
995 {
996
997         if (!schedstat_enabled())
998                 return;
999
1000         /*
1001          * Mark the end of the wait period if dequeueing a
1002          * waiting task:
1003          */
1004         if (se != cfs_rq->curr)
1005                 update_stats_wait_end(cfs_rq, se);
1006
1007         if ((flags & DEQUEUE_SLEEP) && entity_is_task(se)) {
1008                 struct task_struct *tsk = task_of(se);
1009
1010                 if (tsk->state & TASK_INTERRUPTIBLE)
1011                         __schedstat_set(se->statistics.sleep_start,
1012                                       rq_clock(rq_of(cfs_rq)));
1013                 if (tsk->state & TASK_UNINTERRUPTIBLE)
1014                         __schedstat_set(se->statistics.block_start,
1015                                       rq_clock(rq_of(cfs_rq)));
1016         }
1017 }
1018
1019 /*
1020  * We are picking a new current task - update its stats:
1021  */
1022 static inline void
1023 update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
1024 {
1025         /*
1026          * We are starting a new run period:
1027          */
1028         se->exec_start = rq_clock_task(rq_of(cfs_rq));
1029 }
1030
1031 /**************************************************
1032  * Scheduling class queueing methods:
1033  */
1034
1035 #ifdef CONFIG_NUMA_BALANCING
1036 /*
1037  * Approximate time to scan a full NUMA task in ms. The task scan period is
1038  * calculated based on the tasks virtual memory size and
1039  * numa_balancing_scan_size.
1040  */
1041 unsigned int sysctl_numa_balancing_scan_period_min = 1000;
1042 unsigned int sysctl_numa_balancing_scan_period_max = 60000;
1043
1044 /* Portion of address space to scan in MB */
1045 unsigned int sysctl_numa_balancing_scan_size = 256;
1046
1047 /* Scan @scan_size MB every @scan_period after an initial @scan_delay in ms */
1048 unsigned int sysctl_numa_balancing_scan_delay = 1000;
1049
1050 struct numa_group {
1051         refcount_t refcount;
1052
1053         spinlock_t lock; /* nr_tasks, tasks */
1054         int nr_tasks;
1055         pid_t gid;
1056         int active_nodes;
1057
1058         struct rcu_head rcu;
1059         unsigned long total_faults;
1060         unsigned long max_faults_cpu;
1061         /*
1062          * Faults_cpu is used to decide whether memory should move
1063          * towards the CPU. As a consequence, these stats are weighted
1064          * more by CPU use than by memory faults.
1065          */
1066         unsigned long *faults_cpu;
1067         unsigned long faults[0];
1068 };
1069
1070 static inline unsigned long group_faults_priv(struct numa_group *ng);
1071 static inline unsigned long group_faults_shared(struct numa_group *ng);
1072
1073 static unsigned int task_nr_scan_windows(struct task_struct *p)
1074 {
1075         unsigned long rss = 0;
1076         unsigned long nr_scan_pages;
1077
1078         /*
1079          * Calculations based on RSS as non-present and empty pages are skipped
1080          * by the PTE scanner and NUMA hinting faults should be trapped based
1081          * on resident pages
1082          */
1083         nr_scan_pages = sysctl_numa_balancing_scan_size << (20 - PAGE_SHIFT);
1084         rss = get_mm_rss(p->mm);
1085         if (!rss)
1086                 rss = nr_scan_pages;
1087
1088         rss = round_up(rss, nr_scan_pages);
1089         return rss / nr_scan_pages;
1090 }
1091
1092 /* For sanitys sake, never scan more PTEs than MAX_SCAN_WINDOW MB/sec. */
1093 #define MAX_SCAN_WINDOW 2560
1094
1095 static unsigned int task_scan_min(struct task_struct *p)
1096 {
1097         unsigned int scan_size = READ_ONCE(sysctl_numa_balancing_scan_size);
1098         unsigned int scan, floor;
1099         unsigned int windows = 1;
1100
1101         if (scan_size < MAX_SCAN_WINDOW)
1102                 windows = MAX_SCAN_WINDOW / scan_size;
1103         floor = 1000 / windows;
1104
1105         scan = sysctl_numa_balancing_scan_period_min / task_nr_scan_windows(p);
1106         return max_t(unsigned int, floor, scan);
1107 }
1108
1109 static unsigned int task_scan_start(struct task_struct *p)
1110 {
1111         unsigned long smin = task_scan_min(p);
1112         unsigned long period = smin;
1113
1114         /* Scale the maximum scan period with the amount of shared memory. */
1115         if (p->numa_group) {
1116                 struct numa_group *ng = p->numa_group;
1117                 unsigned long shared = group_faults_shared(ng);
1118                 unsigned long private = group_faults_priv(ng);
1119
1120                 period *= refcount_read(&ng->refcount);
1121                 period *= shared + 1;
1122                 period /= private + shared + 1;
1123         }
1124
1125         return max(smin, period);
1126 }
1127
1128 static unsigned int task_scan_max(struct task_struct *p)
1129 {
1130         unsigned long smin = task_scan_min(p);
1131         unsigned long smax;
1132
1133         /* Watch for min being lower than max due to floor calculations */
1134         smax = sysctl_numa_balancing_scan_period_max / task_nr_scan_windows(p);
1135
1136         /* Scale the maximum scan period with the amount of shared memory. */
1137         if (p->numa_group) {
1138                 struct numa_group *ng = p->numa_group;
1139                 unsigned long shared = group_faults_shared(ng);
1140                 unsigned long private = group_faults_priv(ng);
1141                 unsigned long period = smax;
1142
1143                 period *= refcount_read(&ng->refcount);
1144                 period *= shared + 1;
1145                 period /= private + shared + 1;
1146
1147                 smax = max(smax, period);
1148         }
1149
1150         return max(smin, smax);
1151 }
1152
1153 void init_numa_balancing(unsigned long clone_flags, struct task_struct *p)
1154 {
1155         int mm_users = 0;
1156         struct mm_struct *mm = p->mm;
1157
1158         if (mm) {
1159                 mm_users = atomic_read(&mm->mm_users);
1160                 if (mm_users == 1) {
1161                         mm->numa_next_scan = jiffies + msecs_to_jiffies(sysctl_numa_balancing_scan_delay);
1162                         mm->numa_scan_seq = 0;
1163                 }
1164         }
1165         p->node_stamp                   = 0;
1166         p->numa_scan_seq                = mm ? mm->numa_scan_seq : 0;
1167         p->numa_scan_period             = sysctl_numa_balancing_scan_delay;
1168         p->numa_work.next               = &p->numa_work;
1169         p->numa_faults                  = NULL;
1170         p->numa_group                   = NULL;
1171         p->last_task_numa_placement     = 0;
1172         p->last_sum_exec_runtime        = 0;
1173
1174         /* New address space, reset the preferred nid */
1175         if (!(clone_flags & CLONE_VM)) {
1176                 p->numa_preferred_nid = NUMA_NO_NODE;
1177                 return;
1178         }
1179
1180         /*
1181          * New thread, keep existing numa_preferred_nid which should be copied
1182          * already by arch_dup_task_struct but stagger when scans start.
1183          */
1184         if (mm) {
1185                 unsigned int delay;
1186
1187                 delay = min_t(unsigned int, task_scan_max(current),
1188                         current->numa_scan_period * mm_users * NSEC_PER_MSEC);
1189                 delay += 2 * TICK_NSEC;
1190                 p->node_stamp = delay;
1191         }
1192 }
1193
1194 static void account_numa_enqueue(struct rq *rq, struct task_struct *p)
1195 {
1196         rq->nr_numa_running += (p->numa_preferred_nid != NUMA_NO_NODE);
1197         rq->nr_preferred_running += (p->numa_preferred_nid == task_node(p));
1198 }
1199
1200 static void account_numa_dequeue(struct rq *rq, struct task_struct *p)
1201 {
1202         rq->nr_numa_running -= (p->numa_preferred_nid != NUMA_NO_NODE);
1203         rq->nr_preferred_running -= (p->numa_preferred_nid == task_node(p));
1204 }
1205
1206 /* Shared or private faults. */
1207 #define NR_NUMA_HINT_FAULT_TYPES 2
1208
1209 /* Memory and CPU locality */
1210 #define NR_NUMA_HINT_FAULT_STATS (NR_NUMA_HINT_FAULT_TYPES * 2)
1211
1212 /* Averaged statistics, and temporary buffers. */
1213 #define NR_NUMA_HINT_FAULT_BUCKETS (NR_NUMA_HINT_FAULT_STATS * 2)
1214
1215 pid_t task_numa_group_id(struct task_struct *p)
1216 {
1217         return p->numa_group ? p->numa_group->gid : 0;
1218 }
1219
1220 /*
1221  * The averaged statistics, shared & private, memory & CPU,
1222  * occupy the first half of the array. The second half of the
1223  * array is for current counters, which are averaged into the
1224  * first set by task_numa_placement.
1225  */
1226 static inline int task_faults_idx(enum numa_faults_stats s, int nid, int priv)
1227 {
1228         return NR_NUMA_HINT_FAULT_TYPES * (s * nr_node_ids + nid) + priv;
1229 }
1230
1231 static inline unsigned long task_faults(struct task_struct *p, int nid)
1232 {
1233         if (!p->numa_faults)
1234                 return 0;
1235
1236         return p->numa_faults[task_faults_idx(NUMA_MEM, nid, 0)] +
1237                 p->numa_faults[task_faults_idx(NUMA_MEM, nid, 1)];
1238 }
1239
1240 static inline unsigned long group_faults(struct task_struct *p, int nid)
1241 {
1242         if (!p->numa_group)
1243                 return 0;
1244
1245         return p->numa_group->faults[task_faults_idx(NUMA_MEM, nid, 0)] +
1246                 p->numa_group->faults[task_faults_idx(NUMA_MEM, nid, 1)];
1247 }
1248
1249 static inline unsigned long group_faults_cpu(struct numa_group *group, int nid)
1250 {
1251         return group->faults_cpu[task_faults_idx(NUMA_MEM, nid, 0)] +
1252                 group->faults_cpu[task_faults_idx(NUMA_MEM, nid, 1)];
1253 }
1254
1255 static inline unsigned long group_faults_priv(struct numa_group *ng)
1256 {
1257         unsigned long faults = 0;
1258         int node;
1259
1260         for_each_online_node(node) {
1261                 faults += ng->faults[task_faults_idx(NUMA_MEM, node, 1)];
1262         }
1263
1264         return faults;
1265 }
1266
1267 static inline unsigned long group_faults_shared(struct numa_group *ng)
1268 {
1269         unsigned long faults = 0;
1270         int node;
1271
1272         for_each_online_node(node) {
1273                 faults += ng->faults[task_faults_idx(NUMA_MEM, node, 0)];
1274         }
1275
1276         return faults;
1277 }
1278
1279 /*
1280  * A node triggering more than 1/3 as many NUMA faults as the maximum is
1281  * considered part of a numa group's pseudo-interleaving set. Migrations
1282  * between these nodes are slowed down, to allow things to settle down.
1283  */
1284 #define ACTIVE_NODE_FRACTION 3
1285
1286 static bool numa_is_active_node(int nid, struct numa_group *ng)
1287 {
1288         return group_faults_cpu(ng, nid) * ACTIVE_NODE_FRACTION > ng->max_faults_cpu;
1289 }
1290
1291 /* Handle placement on systems where not all nodes are directly connected. */
1292 static unsigned long score_nearby_nodes(struct task_struct *p, int nid,
1293                                         int maxdist, bool task)
1294 {
1295         unsigned long score = 0;
1296         int node;
1297
1298         /*
1299          * All nodes are directly connected, and the same distance
1300          * from each other. No need for fancy placement algorithms.
1301          */
1302         if (sched_numa_topology_type == NUMA_DIRECT)
1303                 return 0;
1304
1305         /*
1306          * This code is called for each node, introducing N^2 complexity,
1307          * which should be ok given the number of nodes rarely exceeds 8.
1308          */
1309         for_each_online_node(node) {
1310                 unsigned long faults;
1311                 int dist = node_distance(nid, node);
1312
1313                 /*
1314                  * The furthest away nodes in the system are not interesting
1315                  * for placement; nid was already counted.
1316                  */
1317                 if (dist == sched_max_numa_distance || node == nid)
1318                         continue;
1319
1320                 /*
1321                  * On systems with a backplane NUMA topology, compare groups
1322                  * of nodes, and move tasks towards the group with the most
1323                  * memory accesses. When comparing two nodes at distance
1324                  * "hoplimit", only nodes closer by than "hoplimit" are part
1325                  * of each group. Skip other nodes.
1326                  */
1327                 if (sched_numa_topology_type == NUMA_BACKPLANE &&
1328                                         dist >= maxdist)
1329                         continue;
1330
1331                 /* Add up the faults from nearby nodes. */
1332                 if (task)
1333                         faults = task_faults(p, node);
1334                 else
1335                         faults = group_faults(p, node);
1336
1337                 /*
1338                  * On systems with a glueless mesh NUMA topology, there are
1339                  * no fixed "groups of nodes". Instead, nodes that are not
1340                  * directly connected bounce traffic through intermediate
1341                  * nodes; a numa_group can occupy any set of nodes.
1342                  * The further away a node is, the less the faults count.
1343                  * This seems to result in good task placement.
1344                  */
1345                 if (sched_numa_topology_type == NUMA_GLUELESS_MESH) {
1346                         faults *= (sched_max_numa_distance - dist);
1347                         faults /= (sched_max_numa_distance - LOCAL_DISTANCE);
1348                 }
1349
1350                 score += faults;
1351         }
1352
1353         return score;
1354 }
1355
1356 /*
1357  * These return the fraction of accesses done by a particular task, or
1358  * task group, on a particular numa node.  The group weight is given a
1359  * larger multiplier, in order to group tasks together that are almost
1360  * evenly spread out between numa nodes.
1361  */
1362 static inline unsigned long task_weight(struct task_struct *p, int nid,
1363                                         int dist)
1364 {
1365         unsigned long faults, total_faults;
1366
1367         if (!p->numa_faults)
1368                 return 0;
1369
1370         total_faults = p->total_numa_faults;
1371
1372         if (!total_faults)
1373                 return 0;
1374
1375         faults = task_faults(p, nid);
1376         faults += score_nearby_nodes(p, nid, dist, true);
1377
1378         return 1000 * faults / total_faults;
1379 }
1380
1381 static inline unsigned long group_weight(struct task_struct *p, int nid,
1382                                          int dist)
1383 {
1384         unsigned long faults, total_faults;
1385
1386         if (!p->numa_group)
1387                 return 0;
1388
1389         total_faults = p->numa_group->total_faults;
1390
1391         if (!total_faults)
1392                 return 0;
1393
1394         faults = group_faults(p, nid);
1395         faults += score_nearby_nodes(p, nid, dist, false);
1396
1397         return 1000 * faults / total_faults;
1398 }
1399
1400 bool should_numa_migrate_memory(struct task_struct *p, struct page * page,
1401                                 int src_nid, int dst_cpu)
1402 {
1403         struct numa_group *ng = p->numa_group;
1404         int dst_nid = cpu_to_node(dst_cpu);
1405         int last_cpupid, this_cpupid;
1406
1407         this_cpupid = cpu_pid_to_cpupid(dst_cpu, current->pid);
1408         last_cpupid = page_cpupid_xchg_last(page, this_cpupid);
1409
1410         /*
1411          * Allow first faults or private faults to migrate immediately early in
1412          * the lifetime of a task. The magic number 4 is based on waiting for
1413          * two full passes of the "multi-stage node selection" test that is
1414          * executed below.
1415          */
1416         if ((p->numa_preferred_nid == NUMA_NO_NODE || p->numa_scan_seq <= 4) &&
1417             (cpupid_pid_unset(last_cpupid) || cpupid_match_pid(p, last_cpupid)))
1418                 return true;
1419
1420         /*
1421          * Multi-stage node selection is used in conjunction with a periodic
1422          * migration fault to build a temporal task<->page relation. By using
1423          * a two-stage filter we remove short/unlikely relations.
1424          *
1425          * Using P(p) ~ n_p / n_t as per frequentist probability, we can equate
1426          * a task's usage of a particular page (n_p) per total usage of this
1427          * page (n_t) (in a given time-span) to a probability.
1428          *
1429          * Our periodic faults will sample this probability and getting the
1430          * same result twice in a row, given these samples are fully
1431          * independent, is then given by P(n)^2, provided our sample period
1432          * is sufficiently short compared to the usage pattern.
1433          *
1434          * This quadric squishes small probabilities, making it less likely we
1435          * act on an unlikely task<->page relation.
1436          */
1437         if (!cpupid_pid_unset(last_cpupid) &&
1438                                 cpupid_to_nid(last_cpupid) != dst_nid)
1439                 return false;
1440
1441         /* Always allow migrate on private faults */
1442         if (cpupid_match_pid(p, last_cpupid))
1443                 return true;
1444
1445         /* A shared fault, but p->numa_group has not been set up yet. */
1446         if (!ng)
1447                 return true;
1448
1449         /*
1450          * Destination node is much more heavily used than the source
1451          * node? Allow migration.
1452          */
1453         if (group_faults_cpu(ng, dst_nid) > group_faults_cpu(ng, src_nid) *
1454                                         ACTIVE_NODE_FRACTION)
1455                 return true;
1456
1457         /*
1458          * Distribute memory according to CPU & memory use on each node,
1459          * with 3/4 hysteresis to avoid unnecessary memory migrations:
1460          *
1461          * faults_cpu(dst)   3   faults_cpu(src)
1462          * --------------- * - > ---------------
1463          * faults_mem(dst)   4   faults_mem(src)
1464          */
1465         return group_faults_cpu(ng, dst_nid) * group_faults(p, src_nid) * 3 >
1466                group_faults_cpu(ng, src_nid) * group_faults(p, dst_nid) * 4;
1467 }
1468
1469 static unsigned long weighted_cpuload(struct rq *rq);
1470 static unsigned long source_load(int cpu, int type);
1471 static unsigned long target_load(int cpu, int type);
1472
1473 /* Cached statistics for all CPUs within a node */
1474 struct numa_stats {
1475         unsigned long load;
1476
1477         /* Total compute capacity of CPUs on a node */
1478         unsigned long compute_capacity;
1479 };
1480
1481 /*
1482  * XXX borrowed from update_sg_lb_stats
1483  */
1484 static void update_numa_stats(struct numa_stats *ns, int nid)
1485 {
1486         int cpu;
1487
1488         memset(ns, 0, sizeof(*ns));
1489         for_each_cpu(cpu, cpumask_of_node(nid)) {
1490                 struct rq *rq = cpu_rq(cpu);
1491
1492                 ns->load += weighted_cpuload(rq);
1493                 ns->compute_capacity += capacity_of(cpu);
1494         }
1495
1496 }
1497
1498 struct task_numa_env {
1499         struct task_struct *p;
1500
1501         int src_cpu, src_nid;
1502         int dst_cpu, dst_nid;
1503
1504         struct numa_stats src_stats, dst_stats;
1505
1506         int imbalance_pct;
1507         int dist;
1508
1509         struct task_struct *best_task;
1510         long best_imp;
1511         int best_cpu;
1512 };
1513
1514 static void task_numa_assign(struct task_numa_env *env,
1515                              struct task_struct *p, long imp)
1516 {
1517         struct rq *rq = cpu_rq(env->dst_cpu);
1518
1519         /* Bail out if run-queue part of active NUMA balance. */
1520         if (xchg(&rq->numa_migrate_on, 1))
1521                 return;
1522
1523         /*
1524          * Clear previous best_cpu/rq numa-migrate flag, since task now
1525          * found a better CPU to move/swap.
1526          */
1527         if (env->best_cpu != -1) {
1528                 rq = cpu_rq(env->best_cpu);
1529                 WRITE_ONCE(rq->numa_migrate_on, 0);
1530         }
1531
1532         if (env->best_task)
1533                 put_task_struct(env->best_task);
1534         if (p)
1535                 get_task_struct(p);
1536
1537         env->best_task = p;
1538         env->best_imp = imp;
1539         env->best_cpu = env->dst_cpu;
1540 }
1541
1542 static bool load_too_imbalanced(long src_load, long dst_load,
1543                                 struct task_numa_env *env)
1544 {
1545         long imb, old_imb;
1546         long orig_src_load, orig_dst_load;
1547         long src_capacity, dst_capacity;
1548
1549         /*
1550          * The load is corrected for the CPU capacity available on each node.
1551          *
1552          * src_load        dst_load
1553          * ------------ vs ---------
1554          * src_capacity    dst_capacity
1555          */
1556         src_capacity = env->src_stats.compute_capacity;
1557         dst_capacity = env->dst_stats.compute_capacity;
1558
1559         imb = abs(dst_load * src_capacity - src_load * dst_capacity);
1560
1561         orig_src_load = env->src_stats.load;
1562         orig_dst_load = env->dst_stats.load;
1563
1564         old_imb = abs(orig_dst_load * src_capacity - orig_src_load * dst_capacity);
1565
1566         /* Would this change make things worse? */
1567         return (imb > old_imb);
1568 }
1569
1570 /*
1571  * Maximum NUMA importance can be 1998 (2*999);
1572  * SMALLIMP @ 30 would be close to 1998/64.
1573  * Used to deter task migration.
1574  */
1575 #define SMALLIMP        30
1576
1577 /*
1578  * This checks if the overall compute and NUMA accesses of the system would
1579  * be improved if the source tasks was migrated to the target dst_cpu taking
1580  * into account that it might be best if task running on the dst_cpu should
1581  * be exchanged with the source task
1582  */
1583 static void task_numa_compare(struct task_numa_env *env,
1584                               long taskimp, long groupimp, bool maymove)
1585 {
1586         struct rq *dst_rq = cpu_rq(env->dst_cpu);
1587         struct task_struct *cur;
1588         long src_load, dst_load;
1589         long load;
1590         long imp = env->p->numa_group ? groupimp : taskimp;
1591         long moveimp = imp;
1592         int dist = env->dist;
1593
1594         if (READ_ONCE(dst_rq->numa_migrate_on))
1595                 return;
1596
1597         rcu_read_lock();
1598         cur = task_rcu_dereference(&dst_rq->curr);
1599         if (cur && ((cur->flags & PF_EXITING) || is_idle_task(cur)))
1600                 cur = NULL;
1601
1602         /*
1603          * Because we have preemption enabled we can get migrated around and
1604          * end try selecting ourselves (current == env->p) as a swap candidate.
1605          */
1606         if (cur == env->p)
1607                 goto unlock;
1608
1609         if (!cur) {
1610                 if (maymove && moveimp >= env->best_imp)
1611                         goto assign;
1612                 else
1613                         goto unlock;
1614         }
1615
1616         /*
1617          * "imp" is the fault differential for the source task between the
1618          * source and destination node. Calculate the total differential for
1619          * the source task and potential destination task. The more negative
1620          * the value is, the more remote accesses that would be expected to
1621          * be incurred if the tasks were swapped.
1622          */
1623         /* Skip this swap candidate if cannot move to the source cpu */
1624         if (!cpumask_test_cpu(env->src_cpu, &cur->cpus_allowed))
1625                 goto unlock;
1626
1627         /*
1628          * If dst and source tasks are in the same NUMA group, or not
1629          * in any group then look only at task weights.
1630          */
1631         if (cur->numa_group == env->p->numa_group) {
1632                 imp = taskimp + task_weight(cur, env->src_nid, dist) -
1633                       task_weight(cur, env->dst_nid, dist);
1634                 /*
1635                  * Add some hysteresis to prevent swapping the
1636                  * tasks within a group over tiny differences.
1637                  */
1638                 if (cur->numa_group)
1639                         imp -= imp / 16;
1640         } else {
1641                 /*
1642                  * Compare the group weights. If a task is all by itself
1643                  * (not part of a group), use the task weight instead.
1644                  */
1645                 if (cur->numa_group && env->p->numa_group)
1646                         imp += group_weight(cur, env->src_nid, dist) -
1647                                group_weight(cur, env->dst_nid, dist);
1648                 else
1649                         imp += task_weight(cur, env->src_nid, dist) -
1650                                task_weight(cur, env->dst_nid, dist);
1651         }
1652
1653         if (maymove && moveimp > imp && moveimp > env->best_imp) {
1654                 imp = moveimp;
1655                 cur = NULL;
1656                 goto assign;
1657         }
1658
1659         /*
1660          * If the NUMA importance is less than SMALLIMP,
1661          * task migration might only result in ping pong
1662          * of tasks and also hurt performance due to cache
1663          * misses.
1664          */
1665         if (imp < SMALLIMP || imp <= env->best_imp + SMALLIMP / 2)
1666                 goto unlock;
1667
1668         /*
1669          * In the overloaded case, try and keep the load balanced.
1670          */
1671         load = task_h_load(env->p) - task_h_load(cur);
1672         if (!load)
1673                 goto assign;
1674
1675         dst_load = env->dst_stats.load + load;
1676         src_load = env->src_stats.load - load;
1677
1678         if (load_too_imbalanced(src_load, dst_load, env))
1679                 goto unlock;
1680
1681 assign:
1682         /*
1683          * One idle CPU per node is evaluated for a task numa move.
1684          * Call select_idle_sibling to maybe find a better one.
1685          */
1686         if (!cur) {
1687                 /*
1688                  * select_idle_siblings() uses an per-CPU cpumask that
1689                  * can be used from IRQ context.
1690                  */
1691                 local_irq_disable();
1692                 env->dst_cpu = select_idle_sibling(env->p, env->src_cpu,
1693                                                    env->dst_cpu);
1694                 local_irq_enable();
1695         }
1696
1697         task_numa_assign(env, cur, imp);
1698 unlock:
1699         rcu_read_unlock();
1700 }
1701
1702 static void task_numa_find_cpu(struct task_numa_env *env,
1703                                 long taskimp, long groupimp)
1704 {
1705         long src_load, dst_load, load;
1706         bool maymove = false;
1707         int cpu;
1708
1709         load = task_h_load(env->p);
1710         dst_load = env->dst_stats.load + load;
1711         src_load = env->src_stats.load - load;
1712
1713         /*
1714          * If the improvement from just moving env->p direction is better
1715          * than swapping tasks around, check if a move is possible.
1716          */
1717         maymove = !load_too_imbalanced(src_load, dst_load, env);
1718
1719         for_each_cpu(cpu, cpumask_of_node(env->dst_nid)) {
1720                 /* Skip this CPU if the source task cannot migrate */
1721                 if (!cpumask_test_cpu(cpu, &env->p->cpus_allowed))
1722                         continue;
1723
1724                 env->dst_cpu = cpu;
1725                 task_numa_compare(env, taskimp, groupimp, maymove);
1726         }
1727 }
1728
1729 static int task_numa_migrate(struct task_struct *p)
1730 {
1731         struct task_numa_env env = {
1732                 .p = p,
1733
1734                 .src_cpu = task_cpu(p),
1735                 .src_nid = task_node(p),
1736
1737                 .imbalance_pct = 112,
1738
1739                 .best_task = NULL,
1740                 .best_imp = 0,
1741                 .best_cpu = -1,
1742         };
1743         struct sched_domain *sd;
1744         struct rq *best_rq;
1745         unsigned long taskweight, groupweight;
1746         int nid, ret, dist;
1747         long taskimp, groupimp;
1748
1749         /*
1750          * Pick the lowest SD_NUMA domain, as that would have the smallest
1751          * imbalance and would be the first to start moving tasks about.
1752          *
1753          * And we want to avoid any moving of tasks about, as that would create
1754          * random movement of tasks -- counter the numa conditions we're trying
1755          * to satisfy here.
1756          */
1757         rcu_read_lock();
1758         sd = rcu_dereference(per_cpu(sd_numa, env.src_cpu));
1759         if (sd)
1760                 env.imbalance_pct = 100 + (sd->imbalance_pct - 100) / 2;
1761         rcu_read_unlock();
1762
1763         /*
1764          * Cpusets can break the scheduler domain tree into smaller
1765          * balance domains, some of which do not cross NUMA boundaries.
1766          * Tasks that are "trapped" in such domains cannot be migrated
1767          * elsewhere, so there is no point in (re)trying.
1768          */
1769         if (unlikely(!sd)) {
1770                 sched_setnuma(p, task_node(p));
1771                 return -EINVAL;
1772         }
1773
1774         env.dst_nid = p->numa_preferred_nid;
1775         dist = env.dist = node_distance(env.src_nid, env.dst_nid);
1776         taskweight = task_weight(p, env.src_nid, dist);
1777         groupweight = group_weight(p, env.src_nid, dist);
1778         update_numa_stats(&env.src_stats, env.src_nid);
1779         taskimp = task_weight(p, env.dst_nid, dist) - taskweight;
1780         groupimp = group_weight(p, env.dst_nid, dist) - groupweight;
1781         update_numa_stats(&env.dst_stats, env.dst_nid);
1782
1783         /* Try to find a spot on the preferred nid. */
1784         task_numa_find_cpu(&env, taskimp, groupimp);
1785
1786         /*
1787          * Look at other nodes in these cases:
1788          * - there is no space available on the preferred_nid
1789          * - the task is part of a numa_group that is interleaved across
1790          *   multiple NUMA nodes; in order to better consolidate the group,
1791          *   we need to check other locations.
1792          */
1793         if (env.best_cpu == -1 || (p->numa_group && p->numa_group->active_nodes > 1)) {
1794                 for_each_online_node(nid) {
1795                         if (nid == env.src_nid || nid == p->numa_preferred_nid)
1796                                 continue;
1797
1798                         dist = node_distance(env.src_nid, env.dst_nid);
1799                         if (sched_numa_topology_type == NUMA_BACKPLANE &&
1800                                                 dist != env.dist) {
1801                                 taskweight = task_weight(p, env.src_nid, dist);
1802                                 groupweight = group_weight(p, env.src_nid, dist);
1803                         }
1804
1805                         /* Only consider nodes where both task and groups benefit */
1806                         taskimp = task_weight(p, nid, dist) - taskweight;
1807                         groupimp = group_weight(p, nid, dist) - groupweight;
1808                         if (taskimp < 0 && groupimp < 0)
1809                                 continue;
1810
1811                         env.dist = dist;
1812                         env.dst_nid = nid;
1813                         update_numa_stats(&env.dst_stats, env.dst_nid);
1814                         task_numa_find_cpu(&env, taskimp, groupimp);
1815                 }
1816         }
1817
1818         /*
1819          * If the task is part of a workload that spans multiple NUMA nodes,
1820          * and is migrating into one of the workload's active nodes, remember
1821          * this node as the task's preferred numa node, so the workload can
1822          * settle down.
1823          * A task that migrated to a second choice node will be better off
1824          * trying for a better one later. Do not set the preferred node here.
1825          */
1826         if (p->numa_group) {
1827                 if (env.best_cpu == -1)
1828                         nid = env.src_nid;
1829                 else
1830                         nid = cpu_to_node(env.best_cpu);
1831
1832                 if (nid != p->numa_preferred_nid)
1833                         sched_setnuma(p, nid);
1834         }
1835
1836         /* No better CPU than the current one was found. */
1837         if (env.best_cpu == -1)
1838                 return -EAGAIN;
1839
1840         best_rq = cpu_rq(env.best_cpu);
1841         if (env.best_task == NULL) {
1842                 ret = migrate_task_to(p, env.best_cpu);
1843                 WRITE_ONCE(best_rq->numa_migrate_on, 0);
1844                 if (ret != 0)
1845                         trace_sched_stick_numa(p, env.src_cpu, env.best_cpu);
1846                 return ret;
1847         }
1848
1849         ret = migrate_swap(p, env.best_task, env.best_cpu, env.src_cpu);
1850         WRITE_ONCE(best_rq->numa_migrate_on, 0);
1851
1852         if (ret != 0)
1853                 trace_sched_stick_numa(p, env.src_cpu, task_cpu(env.best_task));
1854         put_task_struct(env.best_task);
1855         return ret;
1856 }
1857
1858 /* Attempt to migrate a task to a CPU on the preferred node. */
1859 static void numa_migrate_preferred(struct task_struct *p)
1860 {
1861         unsigned long interval = HZ;
1862
1863         /* This task has no NUMA fault statistics yet */
1864         if (unlikely(p->numa_preferred_nid == NUMA_NO_NODE || !p->numa_faults))
1865                 return;
1866
1867         /* Periodically retry migrating the task to the preferred node */
1868         interval = min(interval, msecs_to_jiffies(p->numa_scan_period) / 16);
1869         p->numa_migrate_retry = jiffies + interval;
1870
1871         /* Success if task is already running on preferred CPU */
1872         if (task_node(p) == p->numa_preferred_nid)
1873                 return;
1874
1875         /* Otherwise, try migrate to a CPU on the preferred node */
1876         task_numa_migrate(p);
1877 }
1878
1879 /*
1880  * Find out how many nodes on the workload is actively running on. Do this by
1881  * tracking the nodes from which NUMA hinting faults are triggered. This can
1882  * be different from the set of nodes where the workload's memory is currently
1883  * located.
1884  */
1885 static void numa_group_count_active_nodes(struct numa_group *numa_group)
1886 {
1887         unsigned long faults, max_faults = 0;
1888         int nid, active_nodes = 0;
1889
1890         for_each_online_node(nid) {
1891                 faults = group_faults_cpu(numa_group, nid);
1892                 if (faults > max_faults)
1893                         max_faults = faults;
1894         }
1895
1896         for_each_online_node(nid) {
1897                 faults = group_faults_cpu(numa_group, nid);
1898                 if (faults * ACTIVE_NODE_FRACTION > max_faults)
1899                         active_nodes++;
1900         }
1901
1902         numa_group->max_faults_cpu = max_faults;
1903         numa_group->active_nodes = active_nodes;
1904 }
1905
1906 /*
1907  * When adapting the scan rate, the period is divided into NUMA_PERIOD_SLOTS
1908  * increments. The more local the fault statistics are, the higher the scan
1909  * period will be for the next scan window. If local/(local+remote) ratio is
1910  * below NUMA_PERIOD_THRESHOLD (where range of ratio is 1..NUMA_PERIOD_SLOTS)
1911  * the scan period will decrease. Aim for 70% local accesses.
1912  */
1913 #define NUMA_PERIOD_SLOTS 10
1914 #define NUMA_PERIOD_THRESHOLD 7
1915
1916 /*
1917  * Increase the scan period (slow down scanning) if the majority of
1918  * our memory is already on our local node, or if the majority of
1919  * the page accesses are shared with other processes.
1920  * Otherwise, decrease the scan period.
1921  */
1922 static void update_task_scan_period(struct task_struct *p,
1923                         unsigned long shared, unsigned long private)
1924 {
1925         unsigned int period_slot;
1926         int lr_ratio, ps_ratio;
1927         int diff;
1928
1929         unsigned long remote = p->numa_faults_locality[0];
1930         unsigned long local = p->numa_faults_locality[1];
1931
1932         /*
1933          * If there were no record hinting faults then either the task is
1934          * completely idle or all activity is areas that are not of interest
1935          * to automatic numa balancing. Related to that, if there were failed
1936          * migration then it implies we are migrating too quickly or the local
1937          * node is overloaded. In either case, scan slower
1938          */
1939         if (local + shared == 0 || p->numa_faults_locality[2]) {
1940                 p->numa_scan_period = min(p->numa_scan_period_max,
1941                         p->numa_scan_period << 1);
1942
1943                 p->mm->numa_next_scan = jiffies +
1944                         msecs_to_jiffies(p->numa_scan_period);
1945
1946                 return;
1947         }
1948
1949         /*
1950          * Prepare to scale scan period relative to the current period.
1951          *       == NUMA_PERIOD_THRESHOLD scan period stays the same
1952          *       <  NUMA_PERIOD_THRESHOLD scan period decreases (scan faster)
1953          *       >= NUMA_PERIOD_THRESHOLD scan period increases (scan slower)
1954          */
1955         period_slot = DIV_ROUND_UP(p->numa_scan_period, NUMA_PERIOD_SLOTS);
1956         lr_ratio = (local * NUMA_PERIOD_SLOTS) / (local + remote);
1957         ps_ratio = (private * NUMA_PERIOD_SLOTS) / (private + shared);
1958
1959         if (ps_ratio >= NUMA_PERIOD_THRESHOLD) {
1960                 /*
1961                  * Most memory accesses are local. There is no need to
1962                  * do fast NUMA scanning, since memory is already local.
1963                  */
1964                 int slot = ps_ratio - NUMA_PERIOD_THRESHOLD;
1965                 if (!slot)
1966                         slot = 1;
1967                 diff = slot * period_slot;
1968         } else if (lr_ratio >= NUMA_PERIOD_THRESHOLD) {
1969                 /*
1970                  * Most memory accesses are shared with other tasks.
1971                  * There is no point in continuing fast NUMA scanning,
1972                  * since other tasks may just move the memory elsewhere.
1973                  */
1974                 int slot = lr_ratio - NUMA_PERIOD_THRESHOLD;
1975                 if (!slot)
1976                         slot = 1;
1977                 diff = slot * period_slot;
1978         } else {
1979                 /*
1980                  * Private memory faults exceed (SLOTS-THRESHOLD)/SLOTS,
1981                  * yet they are not on the local NUMA node. Speed up
1982                  * NUMA scanning to get the memory moved over.
1983                  */
1984                 int ratio = max(lr_ratio, ps_ratio);
1985                 diff = -(NUMA_PERIOD_THRESHOLD - ratio) * period_slot;
1986         }
1987
1988         p->numa_scan_period = clamp(p->numa_scan_period + diff,
1989                         task_scan_min(p), task_scan_max(p));
1990         memset(p->numa_faults_locality, 0, sizeof(p->numa_faults_locality));
1991 }
1992
1993 /*
1994  * Get the fraction of time the task has been running since the last
1995  * NUMA placement cycle. The scheduler keeps similar statistics, but
1996  * decays those on a 32ms period, which is orders of magnitude off
1997  * from the dozens-of-seconds NUMA balancing period. Use the scheduler
1998  * stats only if the task is so new there are no NUMA statistics yet.
1999  */
2000 static u64 numa_get_avg_runtime(struct task_struct *p, u64 *period)
2001 {
2002         u64 runtime, delta, now;
2003         /* Use the start of this time slice to avoid calculations. */
2004         now = p->se.exec_start;
2005         runtime = p->se.sum_exec_runtime;
2006
2007         if (p->last_task_numa_placement) {
2008                 delta = runtime - p->last_sum_exec_runtime;
2009                 *period = now - p->last_task_numa_placement;
2010         } else {
2011                 delta = p->se.avg.load_sum;
2012                 *period = LOAD_AVG_MAX;
2013         }
2014
2015         p->last_sum_exec_runtime = runtime;
2016         p->last_task_numa_placement = now;
2017
2018         return delta;
2019 }
2020
2021 /*
2022  * Determine the preferred nid for a task in a numa_group. This needs to
2023  * be done in a way that produces consistent results with group_weight,
2024  * otherwise workloads might not converge.
2025  */
2026 static int preferred_group_nid(struct task_struct *p, int nid)
2027 {
2028         nodemask_t nodes;
2029         int dist;
2030
2031         /* Direct connections between all NUMA nodes. */
2032         if (sched_numa_topology_type == NUMA_DIRECT)
2033                 return nid;
2034
2035         /*
2036          * On a system with glueless mesh NUMA topology, group_weight
2037          * scores nodes according to the number of NUMA hinting faults on
2038          * both the node itself, and on nearby nodes.
2039          */
2040         if (sched_numa_topology_type == NUMA_GLUELESS_MESH) {
2041                 unsigned long score, max_score = 0;
2042                 int node, max_node = nid;
2043
2044                 dist = sched_max_numa_distance;
2045
2046                 for_each_online_node(node) {
2047                         score = group_weight(p, node, dist);
2048                         if (score > max_score) {
2049                                 max_score = score;
2050                                 max_node = node;
2051                         }
2052                 }
2053                 return max_node;
2054         }
2055
2056         /*
2057          * Finding the preferred nid in a system with NUMA backplane
2058          * interconnect topology is more involved. The goal is to locate
2059          * tasks from numa_groups near each other in the system, and
2060          * untangle workloads from different sides of the system. This requires
2061          * searching down the hierarchy of node groups, recursively searching
2062          * inside the highest scoring group of nodes. The nodemask tricks
2063          * keep the complexity of the search down.
2064          */
2065         nodes = node_online_map;
2066         for (dist = sched_max_numa_distance; dist > LOCAL_DISTANCE; dist--) {
2067                 unsigned long max_faults = 0;
2068                 nodemask_t max_group = NODE_MASK_NONE;
2069                 int a, b;
2070
2071                 /* Are there nodes at this distance from each other? */
2072                 if (!find_numa_distance(dist))
2073                         continue;
2074
2075                 for_each_node_mask(a, nodes) {
2076                         unsigned long faults = 0;
2077                         nodemask_t this_group;
2078                         nodes_clear(this_group);
2079
2080                         /* Sum group's NUMA faults; includes a==b case. */
2081                         for_each_node_mask(b, nodes) {
2082                                 if (node_distance(a, b) < dist) {
2083                                         faults += group_faults(p, b);
2084                                         node_set(b, this_group);
2085                                         node_clear(b, nodes);
2086                                 }
2087                         }
2088
2089                         /* Remember the top group. */
2090                         if (faults > max_faults) {
2091                                 max_faults = faults;
2092                                 max_group = this_group;
2093                                 /*
2094                                  * subtle: at the smallest distance there is
2095                                  * just one node left in each "group", the
2096                                  * winner is the preferred nid.
2097                                  */
2098                                 nid = a;
2099                         }
2100                 }
2101                 /* Next round, evaluate the nodes within max_group. */
2102                 if (!max_faults)
2103                         break;
2104                 nodes = max_group;
2105         }
2106         return nid;
2107 }
2108
2109 static void task_numa_placement(struct task_struct *p)
2110 {
2111         int seq, nid, max_nid = NUMA_NO_NODE;
2112         unsigned long max_faults = 0;
2113         unsigned long fault_types[2] = { 0, 0 };
2114         unsigned long total_faults;
2115         u64 runtime, period;
2116         spinlock_t *group_lock = NULL;
2117
2118         /*
2119          * The p->mm->numa_scan_seq field gets updated without
2120          * exclusive access. Use READ_ONCE() here to ensure
2121          * that the field is read in a single access:
2122          */
2123         seq = READ_ONCE(p->mm->numa_scan_seq);
2124         if (p->numa_scan_seq == seq)
2125                 return;
2126         p->numa_scan_seq = seq;
2127         p->numa_scan_period_max = task_scan_max(p);
2128
2129         total_faults = p->numa_faults_locality[0] +
2130                        p->numa_faults_locality[1];
2131         runtime = numa_get_avg_runtime(p, &period);
2132
2133         /* If the task is part of a group prevent parallel updates to group stats */
2134         if (p->numa_group) {
2135                 group_lock = &p->numa_group->lock;
2136                 spin_lock_irq(group_lock);
2137         }
2138
2139         /* Find the node with the highest number of faults */
2140         for_each_online_node(nid) {
2141                 /* Keep track of the offsets in numa_faults array */
2142                 int mem_idx, membuf_idx, cpu_idx, cpubuf_idx;
2143                 unsigned long faults = 0, group_faults = 0;
2144                 int priv;
2145
2146                 for (priv = 0; priv < NR_NUMA_HINT_FAULT_TYPES; priv++) {
2147                         long diff, f_diff, f_weight;
2148
2149                         mem_idx = task_faults_idx(NUMA_MEM, nid, priv);
2150                         membuf_idx = task_faults_idx(NUMA_MEMBUF, nid, priv);
2151                         cpu_idx = task_faults_idx(NUMA_CPU, nid, priv);
2152                         cpubuf_idx = task_faults_idx(NUMA_CPUBUF, nid, priv);
2153
2154                         /* Decay existing window, copy faults since last scan */
2155                         diff = p->numa_faults[membuf_idx] - p->numa_faults[mem_idx] / 2;
2156                         fault_types[priv] += p->numa_faults[membuf_idx];
2157                         p->numa_faults[membuf_idx] = 0;
2158
2159                         /*
2160                          * Normalize the faults_from, so all tasks in a group
2161                          * count according to CPU use, instead of by the raw
2162                          * number of faults. Tasks with little runtime have
2163                          * little over-all impact on throughput, and thus their
2164                          * faults are less important.
2165                          */
2166                         f_weight = div64_u64(runtime << 16, period + 1);
2167                         f_weight = (f_weight * p->numa_faults[cpubuf_idx]) /
2168                                    (total_faults + 1);
2169                         f_diff = f_weight - p->numa_faults[cpu_idx] / 2;
2170                         p->numa_faults[cpubuf_idx] = 0;
2171
2172                         p->numa_faults[mem_idx] += diff;
2173                         p->numa_faults[cpu_idx] += f_diff;
2174                         faults += p->numa_faults[mem_idx];
2175                         p->total_numa_faults += diff;
2176                         if (p->numa_group) {
2177                                 /*
2178                                  * safe because we can only change our own group
2179                                  *
2180                                  * mem_idx represents the offset for a given
2181                                  * nid and priv in a specific region because it
2182                                  * is at the beginning of the numa_faults array.
2183                                  */
2184                                 p->numa_group->faults[mem_idx] += diff;
2185                                 p->numa_group->faults_cpu[mem_idx] += f_diff;
2186                                 p->numa_group->total_faults += diff;
2187                                 group_faults += p->numa_group->faults[mem_idx];
2188                         }
2189                 }
2190
2191                 if (!p->numa_group) {
2192                         if (faults > max_faults) {
2193                                 max_faults = faults;
2194                                 max_nid = nid;
2195                         }
2196                 } else if (group_faults > max_faults) {
2197                         max_faults = group_faults;
2198                         max_nid = nid;
2199                 }
2200         }
2201
2202         if (p->numa_group) {
2203                 numa_group_count_active_nodes(p->numa_group);
2204                 spin_unlock_irq(group_lock);
2205                 max_nid = preferred_group_nid(p, max_nid);
2206         }
2207
2208         if (max_faults) {
2209                 /* Set the new preferred node */
2210                 if (max_nid != p->numa_preferred_nid)
2211                         sched_setnuma(p, max_nid);
2212         }
2213
2214         update_task_scan_period(p, fault_types[0], fault_types[1]);
2215 }
2216
2217 static inline int get_numa_group(struct numa_group *grp)
2218 {
2219         return refcount_inc_not_zero(&grp->refcount);
2220 }
2221
2222 static inline void put_numa_group(struct numa_group *grp)
2223 {
2224         if (refcount_dec_and_test(&grp->refcount))
2225                 kfree_rcu(grp, rcu);
2226 }
2227
2228 static void task_numa_group(struct task_struct *p, int cpupid, int flags,
2229                         int *priv)
2230 {
2231         struct numa_group *grp, *my_grp;
2232         struct task_struct *tsk;
2233         bool join = false;
2234         int cpu = cpupid_to_cpu(cpupid);
2235         int i;
2236
2237         if (unlikely(!p->numa_group)) {
2238                 unsigned int size = sizeof(struct numa_group) +
2239                                     4*nr_node_ids*sizeof(unsigned long);
2240
2241                 grp = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
2242                 if (!grp)
2243                         return;
2244
2245                 refcount_set(&grp->refcount, 1);
2246                 grp->active_nodes = 1;
2247                 grp->max_faults_cpu = 0;
2248                 spin_lock_init(&grp->lock);
2249                 grp->gid = p->pid;
2250                 /* Second half of the array tracks nids where faults happen */
2251                 grp->faults_cpu = grp->faults + NR_NUMA_HINT_FAULT_TYPES *
2252                                                 nr_node_ids;
2253
2254                 for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++)
2255                         grp->faults[i] = p->numa_faults[i];
2256
2257                 grp->total_faults = p->total_numa_faults;
2258
2259                 grp->nr_tasks++;
2260                 rcu_assign_pointer(p->numa_group, grp);
2261         }
2262
2263         rcu_read_lock();
2264         tsk = READ_ONCE(cpu_rq(cpu)->curr);
2265
2266         if (!cpupid_match_pid(tsk, cpupid))
2267                 goto no_join;
2268
2269         grp = rcu_dereference(tsk->numa_group);
2270         if (!grp)
2271                 goto no_join;
2272
2273         my_grp = p->numa_group;
2274         if (grp == my_grp)
2275                 goto no_join;
2276
2277         /*
2278          * Only join the other group if its bigger; if we're the bigger group,
2279          * the other task will join us.
2280          */
2281         if (my_grp->nr_tasks > grp->nr_tasks)
2282                 goto no_join;
2283
2284         /*
2285          * Tie-break on the grp address.
2286          */
2287         if (my_grp->nr_tasks == grp->nr_tasks && my_grp > grp)
2288                 goto no_join;
2289
2290         /* Always join threads in the same process. */
2291         if (tsk->mm == current->mm)
2292                 join = true;
2293
2294         /* Simple filter to avoid false positives due to PID collisions */
2295         if (flags & TNF_SHARED)
2296                 join = true;
2297
2298         /* Update priv based on whether false sharing was detected */
2299         *priv = !join;
2300
2301         if (join && !get_numa_group(grp))
2302                 goto no_join;
2303
2304         rcu_read_unlock();
2305
2306         if (!join)
2307                 return;
2308
2309         BUG_ON(irqs_disabled());
2310         double_lock_irq(&my_grp->lock, &grp->lock);
2311
2312         for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++) {
2313                 my_grp->faults[i] -= p->numa_faults[i];
2314                 grp->faults[i] += p->numa_faults[i];
2315         }
2316         my_grp->total_faults -= p->total_numa_faults;
2317         grp->total_faults += p->total_numa_faults;
2318
2319         my_grp->nr_tasks--;
2320         grp->nr_tasks++;
2321
2322         spin_unlock(&my_grp->lock);
2323         spin_unlock_irq(&grp->lock);
2324
2325         rcu_assign_pointer(p->numa_group, grp);
2326
2327         put_numa_group(my_grp);
2328         return;
2329
2330 no_join:
2331         rcu_read_unlock();
2332         return;
2333 }
2334
2335 void task_numa_free(struct task_struct *p)
2336 {
2337         struct numa_group *grp = p->numa_group;
2338         void *numa_faults = p->numa_faults;
2339         unsigned long flags;
2340         int i;
2341
2342         if (grp) {
2343                 spin_lock_irqsave(&grp->lock, flags);
2344                 for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++)
2345                         grp->faults[i] -= p->numa_faults[i];
2346                 grp->total_faults -= p->total_numa_faults;
2347
2348                 grp->nr_tasks--;
2349                 spin_unlock_irqrestore(&grp->lock, flags);
2350                 RCU_INIT_POINTER(p->numa_group, NULL);
2351                 put_numa_group(grp);
2352         }
2353
2354         p->numa_faults = NULL;
2355         kfree(numa_faults);
2356 }
2357
2358 /*
2359  * Got a PROT_NONE fault for a page on @node.
2360  */
2361 void task_numa_fault(int last_cpupid, int mem_node, int pages, int flags)
2362 {
2363         struct task_struct *p = current;
2364         bool migrated = flags & TNF_MIGRATED;
2365         int cpu_node = task_node(current);
2366         int local = !!(flags & TNF_FAULT_LOCAL);
2367         struct numa_group *ng;
2368         int priv;
2369
2370         if (!static_branch_likely(&sched_numa_balancing))
2371                 return;
2372
2373         /* for example, ksmd faulting in a user's mm */
2374         if (!p->mm)
2375                 return;
2376
2377         /* Allocate buffer to track faults on a per-node basis */
2378         if (unlikely(!p->numa_faults)) {
2379                 int size = sizeof(*p->numa_faults) *
2380                            NR_NUMA_HINT_FAULT_BUCKETS * nr_node_ids;
2381
2382                 p->numa_faults = kzalloc(size, GFP_KERNEL|__GFP_NOWARN);
2383                 if (!p->numa_faults)
2384                         return;
2385
2386                 p->total_numa_faults = 0;
2387                 memset(p->numa_faults_locality, 0, sizeof(p->numa_faults_locality));
2388         }
2389
2390         /*
2391          * First accesses are treated as private, otherwise consider accesses
2392          * to be private if the accessing pid has not changed
2393          */
2394         if (unlikely(last_cpupid == (-1 & LAST_CPUPID_MASK))) {
2395                 priv = 1;
2396         } else {
2397                 priv = cpupid_match_pid(p, last_cpupid);
2398                 if (!priv && !(flags & TNF_NO_GROUP))
2399                         task_numa_group(p, last_cpupid, flags, &priv);
2400         }
2401
2402         /*
2403          * If a workload spans multiple NUMA nodes, a shared fault that
2404          * occurs wholly within the set of nodes that the workload is
2405          * actively using should be counted as local. This allows the
2406          * scan rate to slow down when a workload has settled down.
2407          */
2408         ng = p->numa_group;
2409         if (!priv && !local && ng && ng->active_nodes > 1 &&
2410                                 numa_is_active_node(cpu_node, ng) &&
2411                                 numa_is_active_node(mem_node, ng))
2412                 local = 1;
2413
2414         /*
2415          * Retry to migrate task to preferred node periodically, in case it
2416          * previously failed, or the scheduler moved us.
2417          */
2418         if (time_after(jiffies, p->numa_migrate_retry)) {
2419                 task_numa_placement(p);
2420                 numa_migrate_preferred(p);
2421         }
2422
2423         if (migrated)
2424                 p->numa_pages_migrated += pages;
2425         if (flags & TNF_MIGRATE_FAIL)
2426                 p->numa_faults_locality[2] += pages;
2427
2428         p->numa_faults[task_faults_idx(NUMA_MEMBUF, mem_node, priv)] += pages;
2429         p->numa_faults[task_faults_idx(NUMA_CPUBUF, cpu_node, priv)] += pages;
2430         p->numa_faults_locality[local] += pages;
2431 }
2432
2433 static void reset_ptenuma_scan(struct task_struct *p)
2434 {
2435         /*
2436          * We only did a read acquisition of the mmap sem, so
2437          * p->mm->numa_scan_seq is written to without exclusive access
2438          * and the update is not guaranteed to be atomic. That's not
2439          * much of an issue though, since this is just used for
2440          * statistical sampling. Use READ_ONCE/WRITE_ONCE, which are not
2441          * expensive, to avoid any form of compiler optimizations:
2442          */
2443         WRITE_ONCE(p->mm->numa_scan_seq, READ_ONCE(p->mm->numa_scan_seq) + 1);
2444         p->mm->numa_scan_offset = 0;
2445 }
2446
2447 /*
2448  * The expensive part of numa migration is done from task_work context.
2449  * Triggered from task_tick_numa().
2450  */
2451 void task_numa_work(struct callback_head *work)
2452 {
2453         unsigned long migrate, next_scan, now = jiffies;
2454         struct task_struct *p = current;
2455         struct mm_struct *mm = p->mm;
2456         u64 runtime = p->se.sum_exec_runtime;
2457         struct vm_area_struct *vma;
2458         unsigned long start, end;
2459         unsigned long nr_pte_updates = 0;
2460         long pages, virtpages;
2461
2462         SCHED_WARN_ON(p != container_of(work, struct task_struct, numa_work));
2463
2464         work->next = work; /* protect against double add */
2465         /*
2466          * Who cares about NUMA placement when they're dying.
2467          *
2468          * NOTE: make sure not to dereference p->mm before this check,
2469          * exit_task_work() happens _after_ exit_mm() so we could be called
2470          * without p->mm even though we still had it when we enqueued this
2471          * work.
2472          */
2473         if (p->flags & PF_EXITING)
2474                 return;
2475
2476         if (!mm->numa_next_scan) {
2477                 mm->numa_next_scan = now +
2478                         msecs_to_jiffies(sysctl_numa_balancing_scan_delay);
2479         }
2480
2481         /*
2482          * Enforce maximal scan/migration frequency..
2483          */
2484         migrate = mm->numa_next_scan;
2485         if (time_before(now, migrate))
2486                 return;
2487
2488         if (p->numa_scan_period == 0) {
2489                 p->numa_scan_period_max = task_scan_max(p);
2490                 p->numa_scan_period = task_scan_start(p);
2491         }
2492
2493         next_scan = now + msecs_to_jiffies(p->numa_scan_period);
2494         if (cmpxchg(&mm->numa_next_scan, migrate, next_scan) != migrate)
2495                 return;
2496
2497         /*
2498          * Delay this task enough that another task of this mm will likely win
2499          * the next time around.
2500          */
2501         p->node_stamp += 2 * TICK_NSEC;
2502
2503         start = mm->numa_scan_offset;
2504         pages = sysctl_numa_balancing_scan_size;
2505         pages <<= 20 - PAGE_SHIFT; /* MB in pages */
2506         virtpages = pages * 8;     /* Scan up to this much virtual space */
2507         if (!pages)
2508                 return;
2509
2510
2511         if (!down_read_trylock(&mm->mmap_sem))
2512                 return;
2513         vma = find_vma(mm, start);
2514         if (!vma) {
2515                 reset_ptenuma_scan(p);
2516                 start = 0;
2517                 vma = mm->mmap;
2518         }
2519         for (; vma; vma = vma->vm_next) {
2520                 if (!vma_migratable(vma) || !vma_policy_mof(vma) ||
2521                         is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_MIXEDMAP)) {
2522                         continue;
2523                 }
2524
2525                 /*
2526                  * Shared library pages mapped by multiple processes are not
2527                  * migrated as it is expected they are cache replicated. Avoid
2528                  * hinting faults in read-only file-backed mappings or the vdso
2529                  * as migrating the pages will be of marginal benefit.
2530                  */
2531                 if (!vma->vm_mm ||
2532                     (vma->vm_file && (vma->vm_flags & (VM_READ|VM_WRITE)) == (VM_READ)))
2533                         continue;
2534
2535                 /*
2536                  * Skip inaccessible VMAs to avoid any confusion between
2537                  * PROT_NONE and NUMA hinting ptes
2538                  */
2539                 if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
2540                         continue;
2541
2542                 do {
2543                         start = max(start, vma->vm_start);
2544                         end = ALIGN(start + (pages << PAGE_SHIFT), HPAGE_SIZE);
2545                         end = min(end, vma->vm_end);
2546                         nr_pte_updates = change_prot_numa(vma, start, end);
2547
2548                         /*
2549                          * Try to scan sysctl_numa_balancing_size worth of
2550                          * hpages that have at least one present PTE that
2551                          * is not already pte-numa. If the VMA contains
2552                          * areas that are unused or already full of prot_numa
2553                          * PTEs, scan up to virtpages, to skip through those
2554                          * areas faster.
2555                          */
2556                         if (nr_pte_updates)
2557                                 pages -= (end - start) >> PAGE_SHIFT;
2558                         virtpages -= (end - start) >> PAGE_SHIFT;
2559
2560                         start = end;
2561                         if (pages <= 0 || virtpages <= 0)
2562                                 goto out;
2563
2564                         cond_resched();
2565                 } while (end != vma->vm_end);
2566         }
2567
2568 out:
2569         /*
2570          * It is possible to reach the end of the VMA list but the last few
2571          * VMAs are not guaranteed to the vma_migratable. If they are not, we
2572          * would find the !migratable VMA on the next scan but not reset the
2573          * scanner to the start so check it now.
2574          */
2575         if (vma)
2576                 mm->numa_scan_offset = start;
2577         else
2578                 reset_ptenuma_scan(p);
2579         up_read(&mm->mmap_sem);
2580
2581         /*
2582          * Make sure tasks use at least 32x as much time to run other code
2583          * than they used here, to limit NUMA PTE scanning overhead to 3% max.
2584          * Usually update_task_scan_period slows down scanning enough; on an
2585          * overloaded system we need to limit overhead on a per task basis.
2586          */
2587         if (unlikely(p->se.sum_exec_runtime != runtime)) {
2588                 u64 diff = p->se.sum_exec_runtime - runtime;
2589                 p->node_stamp += 32 * diff;
2590         }
2591 }
2592
2593 /*
2594  * Drive the periodic memory faults..
2595  */
2596 void task_tick_numa(struct rq *rq, struct task_struct *curr)
2597 {
2598         struct callback_head *work = &curr->numa_work;
2599         u64 period, now;
2600
2601         /*
2602          * We don't care about NUMA placement if we don't have memory.
2603          */
2604         if (!curr->mm || (curr->flags & PF_EXITING) || work->next != work)
2605                 return;
2606
2607         /*
2608          * Using runtime rather than walltime has the dual advantage that
2609          * we (mostly) drive the selection from busy threads and that the
2610          * task needs to have done some actual work before we bother with
2611          * NUMA placement.
2612          */
2613         now = curr->se.sum_exec_runtime;
2614         period = (u64)curr->numa_scan_period * NSEC_PER_MSEC;
2615
2616         if (now > curr->node_stamp + period) {
2617                 if (!curr->node_stamp)
2618                         curr->numa_scan_period = task_scan_start(curr);
2619                 curr->node_stamp += period;
2620
2621                 if (!time_before(jiffies, curr->mm->numa_next_scan)) {
2622                         init_task_work(work, task_numa_work); /* TODO: move this into sched_fork() */
2623                         task_work_add(curr, work, true);
2624                 }
2625         }
2626 }
2627
2628 static void update_scan_period(struct task_struct *p, int new_cpu)
2629 {
2630         int src_nid = cpu_to_node(task_cpu(p));
2631         int dst_nid = cpu_to_node(new_cpu);
2632
2633         if (!static_branch_likely(&sched_numa_balancing))
2634                 return;
2635
2636         if (!p->mm || !p->numa_faults || (p->flags & PF_EXITING))
2637                 return;
2638
2639         if (src_nid == dst_nid)
2640                 return;
2641
2642         /*
2643          * Allow resets if faults have been trapped before one scan
2644          * has completed. This is most likely due to a new task that
2645          * is pulled cross-node due to wakeups or load balancing.
2646          */
2647         if (p->numa_scan_seq) {
2648                 /*
2649                  * Avoid scan adjustments if moving to the preferred
2650                  * node or if the task was not previously running on
2651                  * the preferred node.
2652                  */
2653                 if (dst_nid == p->numa_preferred_nid ||
2654                     (p->numa_preferred_nid != NUMA_NO_NODE &&
2655                         src_nid != p->numa_preferred_nid))
2656                         return;
2657         }
2658
2659         p->numa_scan_period = task_scan_start(p);
2660 }
2661
2662 #else
2663 static void task_tick_numa(struct rq *rq, struct task_struct *curr)
2664 {
2665 }
2666
2667 static inline void account_numa_enqueue(struct rq *rq, struct task_struct *p)
2668 {
2669 }
2670
2671 static inline void account_numa_dequeue(struct rq *rq, struct task_struct *p)
2672 {
2673 }
2674
2675 static inline void update_scan_period(struct task_struct *p, int new_cpu)
2676 {
2677 }
2678
2679 #endif /* CONFIG_NUMA_BALANCING */
2680
2681 static void
2682 account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
2683 {
2684         update_load_add(&cfs_rq->load, se->load.weight);
2685         if (!parent_entity(se))
2686                 update_load_add(&rq_of(cfs_rq)->load, se->load.weight);
2687 #ifdef CONFIG_SMP
2688         if (entity_is_task(se)) {
2689                 struct rq *rq = rq_of(cfs_rq);
2690
2691                 account_numa_enqueue(rq, task_of(se));
2692                 list_add(&se->group_node, &rq->cfs_tasks);
2693         }
2694 #endif
2695         cfs_rq->nr_running++;
2696 }
2697
2698 static void
2699 account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
2700 {
2701         update_load_sub(&cfs_rq->load, se->load.weight);
2702         if (!parent_entity(se))
2703                 update_load_sub(&rq_of(cfs_rq)->load, se->load.weight);
2704 #ifdef CONFIG_SMP
2705         if (entity_is_task(se)) {
2706                 account_numa_dequeue(rq_of(cfs_rq), task_of(se));
2707                 list_del_init(&se->group_node);
2708         }
2709 #endif
2710         cfs_rq->nr_running--;
2711 }
2712
2713 /*
2714  * Signed add and clamp on underflow.
2715  *
2716  * Explicitly do a load-store to ensure the intermediate value never hits
2717  * memory. This allows lockless observations without ever seeing the negative
2718  * values.
2719  */
2720 #define add_positive(_ptr, _val) do {                           \
2721         typeof(_ptr) ptr = (_ptr);                              \
2722         typeof(_val) val = (_val);                              \
2723         typeof(*ptr) res, var = READ_ONCE(*ptr);                \
2724                                                                 \
2725         res = var + val;                                        \
2726                                                                 \
2727         if (val < 0 && res > var)                               \
2728                 res = 0;                                        \
2729                                                                 \
2730         WRITE_ONCE(*ptr, res);                                  \
2731 } while (0)
2732
2733 /*
2734  * Unsigned subtract and clamp on underflow.
2735  *
2736  * Explicitly do a load-store to ensure the intermediate value never hits
2737  * memory. This allows lockless observations without ever seeing the negative
2738  * values.
2739  */
2740 #define sub_positive(_ptr, _val) do {                           \
2741         typeof(_ptr) ptr = (_ptr);                              \
2742         typeof(*ptr) val = (_val);                              \
2743         typeof(*ptr) res, var = READ_ONCE(*ptr);                \
2744         res = var - val;                                        \
2745         if (res > var)                                          \
2746                 res = 0;                                        \
2747         WRITE_ONCE(*ptr, res);                                  \
2748 } while (0)
2749
2750 /*
2751  * Remove and clamp on negative, from a local variable.
2752  *
2753  * A variant of sub_positive(), which does not use explicit load-store
2754  * and is thus optimized for local variable updates.
2755  */
2756 #define lsub_positive(_ptr, _val) do {                          \
2757         typeof(_ptr) ptr = (_ptr);                              \
2758         *ptr -= min_t(typeof(*ptr), *ptr, _val);                \
2759 } while (0)
2760
2761 #ifdef CONFIG_SMP
2762 static inline void
2763 enqueue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
2764 {
2765         cfs_rq->runnable_weight += se->runnable_weight;
2766
2767         cfs_rq->avg.runnable_load_avg += se->avg.runnable_load_avg;
2768         cfs_rq->avg.runnable_load_sum += se_runnable(se) * se->avg.runnable_load_sum;
2769 }
2770
2771 static inline void
2772 dequeue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
2773 {
2774         cfs_rq->runnable_weight -= se->runnable_weight;
2775
2776         sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg);
2777         sub_positive(&cfs_rq->avg.runnable_load_sum,
2778                      se_runnable(se) * se->avg.runnable_load_sum);
2779 }
2780
2781 static inline void
2782 enqueue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
2783 {
2784         cfs_rq->avg.load_avg += se->avg.load_avg;
2785         cfs_rq->avg.load_sum += se_weight(se) * se->avg.load_sum;
2786 }
2787
2788 static inline void
2789 dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
2790 {
2791         sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg);
2792         sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum);
2793 }
2794 #else
2795 static inline void
2796 enqueue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
2797 static inline void
2798 dequeue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
2799 static inline void
2800 enqueue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
2801 static inline void
2802 dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
2803 #endif
2804
2805 static void reweight_entity(struct cfs_rq *cfs_rq, struct sched_entity *se,
2806                             unsigned long weight, unsigned long runnable)
2807 {
2808         if (se->on_rq) {
2809                 /* commit outstanding execution time */
2810                 if (cfs_rq->curr == se)
2811                         update_curr(cfs_rq);
2812                 account_entity_dequeue(cfs_rq, se);
2813                 dequeue_runnable_load_avg(cfs_rq, se);
2814         }
2815         dequeue_load_avg(cfs_rq, se);
2816
2817         se->runnable_weight = runnable;
2818         update_load_set(&se->load, weight);
2819
2820 #ifdef CONFIG_SMP
2821         do {
2822                 u32 divider = LOAD_AVG_MAX - 1024 + se->avg.period_contrib;
2823
2824                 se->avg.load_avg = div_u64(se_weight(se) * se->avg.load_sum, divider);
2825                 se->avg.runnable_load_avg =
2826                         div_u64(se_runnable(se) * se->avg.runnable_load_sum, divider);
2827         } while (0);
2828 #endif
2829
2830         enqueue_load_avg(cfs_rq, se);
2831         if (se->on_rq) {
2832                 account_entity_enqueue(cfs_rq, se);
2833                 enqueue_runnable_load_avg(cfs_rq, se);
2834         }
2835 }
2836
2837 void reweight_task(struct task_struct *p, int prio)
2838 {
2839         struct sched_entity *se = &p->se;
2840         struct cfs_rq *cfs_rq = cfs_rq_of(se);
2841         struct load_weight *load = &se->load;
2842         unsigned long weight = scale_load(sched_prio_to_weight[prio]);
2843
2844         reweight_entity(cfs_rq, se, weight, weight);
2845         load->inv_weight = sched_prio_to_wmult[prio];
2846 }
2847
2848 #ifdef CONFIG_FAIR_GROUP_SCHED
2849 #ifdef CONFIG_SMP
2850 /*
2851  * All this does is approximate the hierarchical proportion which includes that
2852  * global sum we all love to hate.
2853  *
2854  * That is, the weight of a group entity, is the proportional share of the
2855  * group weight based on the group runqueue weights. That is:
2856  *
2857  *                     tg->weight * grq->load.weight
2858  *   ge->load.weight = -----------------------------               (1)
2859  *                        \Sum grq->load.weight
2860  *
2861  * Now, because computing that sum is prohibitively expensive to compute (been
2862  * there, done that) we approximate it with this average stuff. The average
2863  * moves slower and therefore the approximation is cheaper and more stable.
2864  *
2865  * So instead of the above, we substitute:
2866  *
2867  *   grq->load.weight -> grq->avg.load_avg                         (2)
2868  *
2869  * which yields the following:
2870  *
2871  *                     tg->weight * grq->avg.load_avg
2872  *   ge->load.weight = ------------------------------              (3)
2873  *                              tg->load_avg
2874  *
2875  * Where: tg->load_avg ~= \Sum grq->avg.load_avg
2876  *
2877  * That is shares_avg, and it is right (given the approximation (2)).
2878  *
2879  * The problem with it is that because the average is slow -- it was designed
2880  * to be exactly that of course -- this leads to transients in boundary
2881  * conditions. In specific, the case where the group was idle and we start the
2882  * one task. It takes time for our CPU's grq->avg.load_avg to build up,
2883  * yielding bad latency etc..
2884  *
2885  * Now, in that special case (1) reduces to:
2886  *
2887  *                     tg->weight * grq->load.weight
2888  *   ge->load.weight = ----------------------------- = tg->weight   (4)
2889  *                          grp->load.weight
2890  *
2891  * That is, the sum collapses because all other CPUs are idle; the UP scenario.
2892  *
2893  * So what we do is modify our approximation (3) to approach (4) in the (near)
2894  * UP case, like:
2895  *
2896  *   ge->load.weight =
2897  *
2898  *              tg->weight * grq->load.weight
2899  *     ---------------------------------------------------         (5)
2900  *     tg->load_avg - grq->avg.load_avg + grq->load.weight
2901  *
2902  * But because grq->load.weight can drop to 0, resulting in a divide by zero,
2903  * we need to use grq->avg.load_avg as its lower bound, which then gives:
2904  *
2905  *
2906  *                     tg->weight * grq->load.weight
2907  *   ge->load.weight = -----------------------------               (6)
2908  *                              tg_load_avg'
2909  *
2910  * Where:
2911  *
2912  *   tg_load_avg' = tg->load_avg - grq->avg.load_avg +
2913  *                  max(grq->load.weight, grq->avg.load_avg)
2914  *
2915  * And that is shares_weight and is icky. In the (near) UP case it approaches
2916  * (4) while in the normal case it approaches (3). It consistently
2917  * overestimates the ge->load.weight and therefore:
2918  *
2919  *   \Sum ge->load.weight >= tg->weight
2920  *
2921  * hence icky!
2922  */
2923 static long calc_group_shares(struct cfs_rq *cfs_rq)
2924 {
2925         long tg_weight, tg_shares, load, shares;
2926         struct task_group *tg = cfs_rq->tg;
2927
2928         tg_shares = READ_ONCE(tg->shares);
2929
2930         load = max(scale_load_down(cfs_rq->load.weight), cfs_rq->avg.load_avg);
2931
2932         tg_weight = atomic_long_read(&tg->load_avg);
2933
2934         /* Ensure tg_weight >= load */
2935         tg_weight -= cfs_rq->tg_load_avg_contrib;
2936         tg_weight += load;
2937
2938         shares = (tg_shares * load);
2939         if (tg_weight)
2940                 shares /= tg_weight;
2941
2942         /*
2943          * MIN_SHARES has to be unscaled here to support per-CPU partitioning
2944          * of a group with small tg->shares value. It is a floor value which is
2945          * assigned as a minimum load.weight to the sched_entity representing
2946          * the group on a CPU.
2947          *
2948          * E.g. on 64-bit for a group with tg->shares of scale_load(15)=15*1024
2949          * on an 8-core system with 8 tasks each runnable on one CPU shares has
2950          * to be 15*1024*1/8=1920 instead of scale_load(MIN_SHARES)=2*1024. In
2951          * case no task is runnable on a CPU MIN_SHARES=2 should be returned
2952          * instead of 0.
2953          */
2954         return clamp_t(long, shares, MIN_SHARES, tg_shares);
2955 }
2956
2957 /*
2958  * This calculates the effective runnable weight for a group entity based on
2959  * the group entity weight calculated above.
2960  *
2961  * Because of the above approximation (2), our group entity weight is
2962  * an load_avg based ratio (3). This means that it includes blocked load and
2963  * does not represent the runnable weight.
2964  *
2965  * Approximate the group entity's runnable weight per ratio from the group
2966  * runqueue:
2967  *
2968  *                                           grq->avg.runnable_load_avg
2969  *   ge->runnable_weight = ge->load.weight * -------------------------- (7)
2970  *                                               grq->avg.load_avg
2971  *
2972  * However, analogous to above, since the avg numbers are slow, this leads to
2973  * transients in the from-idle case. Instead we use:
2974  *
2975  *   ge->runnable_weight = ge->load.weight *
2976  *
2977  *              max(grq->avg.runnable_load_avg, grq->runnable_weight)
2978  *              -----------------------------------------------------   (8)
2979  *                    max(grq->avg.load_avg, grq->load.weight)
2980  *
2981  * Where these max() serve both to use the 'instant' values to fix the slow
2982  * from-idle and avoid the /0 on to-idle, similar to (6).
2983  */
2984 static long calc_group_runnable(struct cfs_rq *cfs_rq, long shares)
2985 {
2986         long runnable, load_avg;
2987
2988         load_avg = max(cfs_rq->avg.load_avg,
2989                        scale_load_down(cfs_rq->load.weight));
2990
2991         runnable = max(cfs_rq->avg.runnable_load_avg,
2992                        scale_load_down(cfs_rq->runnable_weight));
2993
2994         runnable *= shares;
2995         if (load_avg)
2996                 runnable /= load_avg;
2997
2998         return clamp_t(long, runnable, MIN_SHARES, shares);
2999 }
3000 #endif /* CONFIG_SMP */
3001
3002 static inline int throttled_hierarchy(struct cfs_rq *cfs_rq);
3003
3004 /*
3005  * Recomputes the group entity based on the current state of its group
3006  * runqueue.
3007  */
3008 static void update_cfs_group(struct sched_entity *se)
3009 {
3010         struct cfs_rq *gcfs_rq = group_cfs_rq(se);
3011         long shares, runnable;
3012
3013         if (!gcfs_rq)
3014                 return;
3015
3016         if (throttled_hierarchy(gcfs_rq))
3017                 return;
3018
3019 #ifndef CONFIG_SMP
3020         runnable = shares = READ_ONCE(gcfs_rq->tg->shares);
3021
3022         if (likely(se->load.weight == shares))
3023                 return;
3024 #else
3025         shares   = calc_group_shares(gcfs_rq);
3026         runnable = calc_group_runnable(gcfs_rq, shares);
3027 #endif
3028
3029         reweight_entity(cfs_rq_of(se), se, shares, runnable);
3030 }
3031
3032 #else /* CONFIG_FAIR_GROUP_SCHED */
3033 static inline void update_cfs_group(struct sched_entity *se)
3034 {
3035 }
3036 #endif /* CONFIG_FAIR_GROUP_SCHED */
3037
3038 static inline void cfs_rq_util_change(struct cfs_rq *cfs_rq, int flags)
3039 {
3040         struct rq *rq = rq_of(cfs_rq);
3041
3042         if (&rq->cfs == cfs_rq || (flags & SCHED_CPUFREQ_MIGRATION)) {
3043                 /*
3044                  * There are a few boundary cases this might miss but it should
3045                  * get called often enough that that should (hopefully) not be
3046                  * a real problem.
3047                  *
3048                  * It will not get called when we go idle, because the idle
3049                  * thread is a different class (!fair), nor will the utilization
3050                  * number include things like RT tasks.
3051                  *
3052                  * As is, the util number is not freq-invariant (we'd have to
3053                  * implement arch_scale_freq_capacity() for that).
3054                  *
3055                  * See cpu_util().
3056                  */
3057                 cpufreq_update_util(rq, flags);
3058         }
3059 }
3060
3061 #ifdef CONFIG_SMP
3062 #ifdef CONFIG_FAIR_GROUP_SCHED
3063 /**
3064  * update_tg_load_avg - update the tg's load avg
3065  * @cfs_rq: the cfs_rq whose avg changed
3066  * @force: update regardless of how small the difference
3067  *
3068  * This function 'ensures': tg->load_avg := \Sum tg->cfs_rq[]->avg.load.
3069  * However, because tg->load_avg is a global value there are performance
3070  * considerations.
3071  *
3072  * In order to avoid having to look at the other cfs_rq's, we use a
3073  * differential update where we store the last value we propagated. This in
3074  * turn allows skipping updates if the differential is 'small'.
3075  *
3076  * Updating tg's load_avg is necessary before update_cfs_share().
3077  */
3078 static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
3079 {
3080         long delta = cfs_rq->avg.load_avg - cfs_rq->tg_load_avg_contrib;
3081
3082         /*
3083          * No need to update load_avg for root_task_group as it is not used.
3084          */
3085         if (cfs_rq->tg == &root_task_group)
3086                 return;
3087
3088         if (force || abs(delta) > cfs_rq->tg_load_avg_contrib / 64) {
3089                 atomic_long_add(delta, &cfs_rq->tg->load_avg);
3090                 cfs_rq->tg_load_avg_contrib = cfs_rq->avg.load_avg;
3091         }
3092 }
3093
3094 /*
3095  * Called within set_task_rq() right before setting a task's CPU. The
3096  * caller only guarantees p->pi_lock is held; no other assumptions,
3097  * including the state of rq->lock, should be made.
3098  */
3099 void set_task_rq_fair(struct sched_entity *se,
3100                       struct cfs_rq *prev, struct cfs_rq *next)
3101 {
3102         u64 p_last_update_time;
3103         u64 n_last_update_time;
3104
3105         if (!sched_feat(ATTACH_AGE_LOAD))
3106                 return;
3107
3108         /*
3109          * We are supposed to update the task to "current" time, then its up to
3110          * date and ready to go to new CPU/cfs_rq. But we have difficulty in
3111          * getting what current time is, so simply throw away the out-of-date
3112          * time. This will result in the wakee task is less decayed, but giving
3113          * the wakee more load sounds not bad.
3114          */
3115         if (!(se->avg.last_update_time && prev))
3116                 return;
3117
3118 #ifndef CONFIG_64BIT
3119         {
3120                 u64 p_last_update_time_copy;
3121                 u64 n_last_update_time_copy;
3122
3123                 do {
3124                         p_last_update_time_copy = prev->load_last_update_time_copy;
3125                         n_last_update_time_copy = next->load_last_update_time_copy;
3126
3127                         smp_rmb();
3128
3129                         p_last_update_time = prev->avg.last_update_time;
3130                         n_last_update_time = next->avg.last_update_time;
3131
3132                 } while (p_last_update_time != p_last_update_time_copy ||
3133                          n_last_update_time != n_last_update_time_copy);
3134         }
3135 #else
3136         p_last_update_time = prev->avg.last_update_time;
3137         n_last_update_time = next->avg.last_update_time;
3138 #endif
3139         __update_load_avg_blocked_se(p_last_update_time, se);
3140         se->avg.last_update_time = n_last_update_time;
3141 }
3142
3143
3144 /*
3145  * When on migration a sched_entity joins/leaves the PELT hierarchy, we need to
3146  * propagate its contribution. The key to this propagation is the invariant
3147  * that for each group:
3148  *
3149  *   ge->avg == grq->avg                                                (1)
3150  *
3151  * _IFF_ we look at the pure running and runnable sums. Because they
3152  * represent the very same entity, just at different points in the hierarchy.
3153  *
3154  * Per the above update_tg_cfs_util() is trivial and simply copies the running
3155  * sum over (but still wrong, because the group entity and group rq do not have
3156  * their PELT windows aligned).
3157  *
3158  * However, update_tg_cfs_runnable() is more complex. So we have:
3159  *
3160  *   ge->avg.load_avg = ge->load.weight * ge->avg.runnable_avg          (2)
3161  *
3162  * And since, like util, the runnable part should be directly transferable,
3163  * the following would _appear_ to be the straight forward approach:
3164  *
3165  *   grq->avg.load_avg = grq->load.weight * grq->avg.runnable_avg       (3)
3166  *
3167  * And per (1) we have:
3168  *
3169  *   ge->avg.runnable_avg == grq->avg.runnable_avg
3170  *
3171  * Which gives:
3172  *
3173  *                      ge->load.weight * grq->avg.load_avg
3174  *   ge->avg.load_avg = -----------------------------------             (4)
3175  *                               grq->load.weight
3176  *
3177  * Except that is wrong!
3178  *
3179  * Because while for entities historical weight is not important and we
3180  * really only care about our future and therefore can consider a pure
3181  * runnable sum, runqueues can NOT do this.
3182  *
3183  * We specifically want runqueues to have a load_avg that includes
3184  * historical weights. Those represent the blocked load, the load we expect
3185  * to (shortly) return to us. This only works by keeping the weights as
3186  * integral part of the sum. We therefore cannot decompose as per (3).
3187  *
3188  * Another reason this doesn't work is that runnable isn't a 0-sum entity.
3189  * Imagine a rq with 2 tasks that each are runnable 2/3 of the time. Then the
3190  * rq itself is runnable anywhere between 2/3 and 1 depending on how the
3191  * runnable section of these tasks overlap (or not). If they were to perfectly
3192  * align the rq as a whole would be runnable 2/3 of the time. If however we
3193  * always have at least 1 runnable task, the rq as a whole is always runnable.
3194  *
3195  * So we'll have to approximate.. :/
3196  *
3197  * Given the constraint:
3198  *
3199  *   ge->avg.running_sum <= ge->avg.runnable_sum <= LOAD_AVG_MAX
3200  *
3201  * We can construct a rule that adds runnable to a rq by assuming minimal
3202  * overlap.
3203  *
3204  * On removal, we'll assume each task is equally runnable; which yields:
3205  *
3206  *   grq->avg.runnable_sum = grq->avg.load_sum / grq->load.weight
3207  *
3208  * XXX: only do this for the part of runnable > running ?
3209  *
3210  */
3211
3212 static inline void
3213 update_tg_cfs_util(struct cfs_rq *cfs_rq, struct sched_entity *se, struct cfs_rq *gcfs_rq)
3214 {
3215         long delta = gcfs_rq->avg.util_avg - se->avg.util_avg;
3216
3217         /* Nothing to update */
3218         if (!delta)
3219                 return;
3220
3221         /*
3222          * The relation between sum and avg is:
3223          *
3224          *   LOAD_AVG_MAX - 1024 + sa->period_contrib
3225          *
3226          * however, the PELT windows are not aligned between grq and gse.
3227          */
3228
3229         /* Set new sched_entity's utilization */
3230         se->avg.util_avg = gcfs_rq->avg.util_avg;
3231         se->avg.util_sum = se->avg.util_avg * LOAD_AVG_MAX;
3232
3233         /* Update parent cfs_rq utilization */
3234         add_positive(&cfs_rq->avg.util_avg, delta);
3235         cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX;
3236 }
3237
3238 static inline void
3239 update_tg_cfs_runnable(struct cfs_rq *cfs_rq, struct sched_entity *se, struct cfs_rq *gcfs_rq)
3240 {
3241         long delta_avg, running_sum, runnable_sum = gcfs_rq->prop_runnable_sum;
3242         unsigned long runnable_load_avg, load_avg;
3243         u64 runnable_load_sum, load_sum = 0;
3244         s64 delta_sum;
3245
3246         if (!runnable_sum)
3247                 return;
3248
3249         gcfs_rq->prop_runnable_sum = 0;
3250
3251         if (runnable_sum >= 0) {
3252                 /*
3253                  * Add runnable; clip at LOAD_AVG_MAX. Reflects that until
3254                  * the CPU is saturated running == runnable.
3255                  */
3256                 runnable_sum += se->avg.load_sum;
3257                 runnable_sum = min(runnable_sum, (long)LOAD_AVG_MAX);
3258         } else {
3259                 /*
3260                  * Estimate the new unweighted runnable_sum of the gcfs_rq by
3261                  * assuming all tasks are equally runnable.
3262                  */
3263                 if (scale_load_down(gcfs_rq->load.weight)) {
3264                         load_sum = div_s64(gcfs_rq->avg.load_sum,
3265                                 scale_load_down(gcfs_rq->load.weight));
3266                 }
3267
3268                 /* But make sure to not inflate se's runnable */
3269                 runnable_sum = min(se->avg.load_sum, load_sum);
3270         }
3271
3272         /*
3273          * runnable_sum can't be lower than running_sum
3274          * Rescale running sum to be in the same range as runnable sum
3275          * running_sum is in [0 : LOAD_AVG_MAX <<  SCHED_CAPACITY_SHIFT]
3276          * runnable_sum is in [0 : LOAD_AVG_MAX]
3277          */
3278         running_sum = se->avg.util_sum >> SCHED_CAPACITY_SHIFT;
3279         runnable_sum = max(runnable_sum, running_sum);
3280
3281         load_sum = (s64)se_weight(se) * runnable_sum;
3282         load_avg = div_s64(load_sum, LOAD_AVG_MAX);
3283
3284         delta_sum = load_sum - (s64)se_weight(se) * se->avg.load_sum;
3285         delta_avg = load_avg - se->avg.load_avg;
3286
3287         se->avg.load_sum = runnable_sum;
3288         se->avg.load_avg = load_avg;
3289         add_positive(&cfs_rq->avg.load_avg, delta_avg);
3290         add_positive(&cfs_rq->avg.load_sum, delta_sum);
3291
3292         runnable_load_sum = (s64)se_runnable(se) * runnable_sum;
3293         runnable_load_avg = div_s64(runnable_load_sum, LOAD_AVG_MAX);
3294         delta_sum = runnable_load_sum - se_weight(se) * se->avg.runnable_load_sum;
3295         delta_avg = runnable_load_avg - se->avg.runnable_load_avg;
3296
3297         se->avg.runnable_load_sum = runnable_sum;
3298         se->avg.runnable_load_avg = runnable_load_avg;
3299
3300         if (se->on_rq) {
3301                 add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg);
3302                 add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum);
3303         }
3304 }
3305
3306 static inline void add_tg_cfs_propagate(struct cfs_rq *cfs_rq, long runnable_sum)
3307 {
3308         cfs_rq->propagate = 1;
3309         cfs_rq->prop_runnable_sum += runnable_sum;
3310 }
3311
3312 /* Update task and its cfs_rq load average */
3313 static inline int propagate_entity_load_avg(struct sched_entity *se)
3314 {
3315         struct cfs_rq *cfs_rq, *gcfs_rq;
3316
3317         if (entity_is_task(se))
3318                 return 0;
3319
3320         gcfs_rq = group_cfs_rq(se);
3321         if (!gcfs_rq->propagate)
3322                 return 0;
3323
3324         gcfs_rq->propagate = 0;
3325
3326         cfs_rq = cfs_rq_of(se);
3327
3328         add_tg_cfs_propagate(cfs_rq, gcfs_rq->prop_runnable_sum);
3329
3330         update_tg_cfs_util(cfs_rq, se, gcfs_rq);
3331         update_tg_cfs_runnable(cfs_rq, se, gcfs_rq);
3332
3333         return 1;
3334 }
3335
3336 /*
3337  * Check if we need to update the load and the utilization of a blocked
3338  * group_entity:
3339  */
3340 static inline bool skip_blocked_update(struct sched_entity *se)
3341 {