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