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