Branch data Line data Source code
1 : : /*
2 : : * Real-Time Scheduling Class (mapped to the SCHED_FIFO and SCHED_RR
3 : : * policies)
4 : : */
5 : :
6 : : #include "sched.h"
7 : :
8 : : #include <linux/slab.h>
9 : :
10 : : int sched_rr_timeslice = RR_TIMESLICE;
11 : :
12 : : static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun);
13 : :
14 : : struct rt_bandwidth def_rt_bandwidth;
15 : :
16 : 0 : static enum hrtimer_restart sched_rt_period_timer(struct hrtimer *timer)
17 : : {
18 : 3661 : struct rt_bandwidth *rt_b =
19 : : container_of(timer, struct rt_bandwidth, rt_period_timer);
20 : : ktime_t now;
21 : : int overrun;
22 : : int idle = 0;
23 : :
24 : : for (;;) {
25 : : now = hrtimer_cb_get_time(timer);
26 : 7322 : overrun = hrtimer_forward(timer, now, rt_b->rt_period);
27 : :
28 [ + + ]: 7322 : if (!overrun)
29 : : break;
30 : :
31 : 3661 : idle = do_sched_rt_period_timer(rt_b, overrun);
32 : 3661 : }
33 : :
34 : 3661 : return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
35 : : }
36 : :
37 : 0 : void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime)
38 : : {
39 : 0 : rt_b->rt_period = ns_to_ktime(period);
40 : 0 : rt_b->rt_runtime = runtime;
41 : :
42 : 0 : raw_spin_lock_init(&rt_b->rt_runtime_lock);
43 : :
44 : 0 : hrtimer_init(&rt_b->rt_period_timer,
45 : : CLOCK_MONOTONIC, HRTIMER_MODE_REL);
46 : 0 : rt_b->rt_period_timer.function = sched_rt_period_timer;
47 : 0 : }
48 : :
49 : 0 : static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
50 : : {
51 [ + + ][ + ]: 10600 : if (!rt_bandwidth_enabled() || rt_b->rt_runtime == RUNTIME_INF)
52 : : return;
53 : :
54 [ + + ]: 10603 : if (hrtimer_active(&rt_b->rt_period_timer))
55 : : return;
56 : :
57 : 3621 : raw_spin_lock(&rt_b->rt_runtime_lock);
58 : 3621 : start_bandwidth_timer(&rt_b->rt_period_timer, rt_b->rt_period);
59 : : raw_spin_unlock(&rt_b->rt_runtime_lock);
60 : : }
61 : :
62 : 0 : void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
63 : : {
64 : : struct rt_prio_array *array;
65 : : int i;
66 : :
67 : : array = &rt_rq->active;
68 [ # # ]: 0 : for (i = 0; i < MAX_RT_PRIO; i++) {
69 : 0 : INIT_LIST_HEAD(array->queue + i);
70 : 0 : __clear_bit(i, array->bitmap);
71 : : }
72 : : /* delimiter for bitsearch: */
73 : : __set_bit(MAX_RT_PRIO, array->bitmap);
74 : :
75 : : #if defined CONFIG_SMP
76 : 0 : rt_rq->highest_prio.curr = MAX_RT_PRIO;
77 : 0 : rt_rq->highest_prio.next = MAX_RT_PRIO;
78 : 0 : rt_rq->rt_nr_migratory = 0;
79 : 0 : rt_rq->overloaded = 0;
80 : : plist_head_init(&rt_rq->pushable_tasks);
81 : : #endif
82 : :
83 : 0 : rt_rq->rt_time = 0;
84 : 0 : rt_rq->rt_throttled = 0;
85 : 0 : rt_rq->rt_runtime = 0;
86 : 0 : raw_spin_lock_init(&rt_rq->rt_runtime_lock);
87 : 0 : }
88 : :
89 : : #ifdef CONFIG_RT_GROUP_SCHED
90 : : static void destroy_rt_bandwidth(struct rt_bandwidth *rt_b)
91 : : {
92 : : hrtimer_cancel(&rt_b->rt_period_timer);
93 : : }
94 : :
95 : : #define rt_entity_is_task(rt_se) (!(rt_se)->my_q)
96 : :
97 : : static inline struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
98 : : {
99 : : #ifdef CONFIG_SCHED_DEBUG
100 : : WARN_ON_ONCE(!rt_entity_is_task(rt_se));
101 : : #endif
102 : : return container_of(rt_se, struct task_struct, rt);
103 : : }
104 : :
105 : : static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
106 : : {
107 : : return rt_rq->rq;
108 : : }
109 : :
110 : : static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
111 : : {
112 : : return rt_se->rt_rq;
113 : : }
114 : :
115 : : void free_rt_sched_group(struct task_group *tg)
116 : : {
117 : : int i;
118 : :
119 : : if (tg->rt_se)
120 : : destroy_rt_bandwidth(&tg->rt_bandwidth);
121 : :
122 : : for_each_possible_cpu(i) {
123 : : if (tg->rt_rq)
124 : : kfree(tg->rt_rq[i]);
125 : : if (tg->rt_se)
126 : : kfree(tg->rt_se[i]);
127 : : }
128 : :
129 : : kfree(tg->rt_rq);
130 : : kfree(tg->rt_se);
131 : : }
132 : :
133 : : void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
134 : : struct sched_rt_entity *rt_se, int cpu,
135 : : struct sched_rt_entity *parent)
136 : : {
137 : : struct rq *rq = cpu_rq(cpu);
138 : :
139 : : rt_rq->highest_prio.curr = MAX_RT_PRIO;
140 : : rt_rq->rt_nr_boosted = 0;
141 : : rt_rq->rq = rq;
142 : : rt_rq->tg = tg;
143 : :
144 : : tg->rt_rq[cpu] = rt_rq;
145 : : tg->rt_se[cpu] = rt_se;
146 : :
147 : : if (!rt_se)
148 : : return;
149 : :
150 : : if (!parent)
151 : : rt_se->rt_rq = &rq->rt;
152 : : else
153 : : rt_se->rt_rq = parent->my_q;
154 : :
155 : : rt_se->my_q = rt_rq;
156 : : rt_se->parent = parent;
157 : : INIT_LIST_HEAD(&rt_se->run_list);
158 : : }
159 : :
160 : : int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
161 : : {
162 : : struct rt_rq *rt_rq;
163 : : struct sched_rt_entity *rt_se;
164 : : int i;
165 : :
166 : : tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL);
167 : : if (!tg->rt_rq)
168 : : goto err;
169 : : tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);
170 : : if (!tg->rt_se)
171 : : goto err;
172 : :
173 : : init_rt_bandwidth(&tg->rt_bandwidth,
174 : : ktime_to_ns(def_rt_bandwidth.rt_period), 0);
175 : :
176 : : for_each_possible_cpu(i) {
177 : : rt_rq = kzalloc_node(sizeof(struct rt_rq),
178 : : GFP_KERNEL, cpu_to_node(i));
179 : : if (!rt_rq)
180 : : goto err;
181 : :
182 : : rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
183 : : GFP_KERNEL, cpu_to_node(i));
184 : : if (!rt_se)
185 : : goto err_free_rq;
186 : :
187 : : init_rt_rq(rt_rq, cpu_rq(i));
188 : : rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;
189 : : init_tg_rt_entry(tg, rt_rq, rt_se, i, parent->rt_se[i]);
190 : : }
191 : :
192 : : return 1;
193 : :
194 : : err_free_rq:
195 : : kfree(rt_rq);
196 : : err:
197 : : return 0;
198 : : }
199 : :
200 : : #else /* CONFIG_RT_GROUP_SCHED */
201 : :
202 : : #define rt_entity_is_task(rt_se) (1)
203 : :
204 : : static inline struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
205 : : {
206 : : return container_of(rt_se, struct task_struct, rt);
207 : : }
208 : :
209 : : static inline struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
210 : : {
211 : : return container_of(rt_rq, struct rq, rt);
212 : : }
213 : :
214 : : static inline struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
215 : : {
216 : : struct task_struct *p = rt_task_of(rt_se);
217 : 240991 : struct rq *rq = task_rq(p);
218 : :
219 : : return &rq->rt;
220 : : }
221 : :
222 : 0 : void free_rt_sched_group(struct task_group *tg) { }
223 : :
224 : 0 : int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
225 : : {
226 : 0 : return 1;
227 : : }
228 : : #endif /* CONFIG_RT_GROUP_SCHED */
229 : :
230 : : #ifdef CONFIG_SMP
231 : :
232 : : static inline int rt_overloaded(struct rq *rq)
233 : : {
234 : 10238 : return atomic_read(&rq->rd->rto_count);
235 : : }
236 : :
237 : : static inline void rt_set_overload(struct rq *rq)
238 : : {
239 [ # # ][ + - ]: 141 : if (!rq->online)
240 : : return;
241 : :
242 : 141 : cpumask_set_cpu(rq->cpu, rq->rd->rto_mask);
243 : : /*
244 : : * Make sure the mask is visible before we set
245 : : * the overload count. That is checked to determine
246 : : * if we should look at the mask. It would be a shame
247 : : * if we looked at the mask, but the mask was not
248 : : * updated yet.
249 : : *
250 : : * Matched by the barrier in pull_rt_task().
251 : : */
252 : 141 : smp_wmb();
253 : 141 : atomic_inc(&rq->rd->rto_count);
254 : : }
255 : :
256 : : static inline void rt_clear_overload(struct rq *rq)
257 : : {
258 [ # # ][ + - ]: 141 : if (!rq->online)
259 : : return;
260 : :
261 : : /* the order here really doesn't matter */
262 : 141 : atomic_dec(&rq->rd->rto_count);
263 : 141 : cpumask_clear_cpu(rq->cpu, rq->rd->rto_mask);
264 : : }
265 : :
266 : 0 : static void update_rt_migration(struct rt_rq *rt_rq)
267 : : {
268 [ + + ][ + + ]: 21198 : if (rt_rq->rt_nr_migratory && rt_rq->rt_nr_total > 1) {
269 [ + + ]: 1257 : if (!rt_rq->overloaded) {
270 : : rt_set_overload(rq_of_rt_rq(rt_rq));
271 : 141 : rt_rq->overloaded = 1;
272 : : }
273 [ + + ]: 19941 : } else if (rt_rq->overloaded) {
274 : : rt_clear_overload(rq_of_rt_rq(rt_rq));
275 : 141 : rt_rq->overloaded = 0;
276 : : }
277 : 0 : }
278 : :
279 : 0 : static void inc_rt_migration(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
280 : : {
281 : : struct task_struct *p;
282 : :
283 : : if (!rt_entity_is_task(rt_se))
284 : 10591 : return;
285 : :
286 : : p = rt_task_of(rt_se);
287 : 10603 : rt_rq = &rq_of_rt_rq(rt_rq)->rt;
288 : :
289 : 10603 : rt_rq->rt_nr_total++;
290 [ + + ]: 10603 : if (p->nr_cpus_allowed > 1)
291 : 851 : rt_rq->rt_nr_migratory++;
292 : :
293 : 10603 : update_rt_migration(rt_rq);
294 : : }
295 : :
296 : 0 : static void dec_rt_migration(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
297 : : {
298 : : struct task_struct *p;
299 : :
300 : : if (!rt_entity_is_task(rt_se))
301 : 10588 : return;
302 : :
303 : : p = rt_task_of(rt_se);
304 : 10586 : rt_rq = &rq_of_rt_rq(rt_rq)->rt;
305 : :
306 : 10586 : rt_rq->rt_nr_total--;
307 [ + + ]: 10586 : if (p->nr_cpus_allowed > 1)
308 : 850 : rt_rq->rt_nr_migratory--;
309 : :
310 : 10586 : update_rt_migration(rt_rq);
311 : : }
312 : :
313 : : static inline int has_pushable_tasks(struct rq *rq)
314 : : {
315 : 5720707 : return !plist_head_empty(&rq->rt.pushable_tasks);
316 : : }
317 : :
318 : 0 : static void enqueue_pushable_task(struct rq *rq, struct task_struct *p)
319 : : {
320 : 32134 : plist_del(&p->pushable_tasks, &rq->rt.pushable_tasks);
321 : 32132 : plist_node_init(&p->pushable_tasks, p->prio);
322 : 32132 : plist_add(&p->pushable_tasks, &rq->rt.pushable_tasks);
323 : :
324 : : /* Update the highest prio pushable task */
325 [ + + ]: 32134 : if (p->prio < rq->rt.highest_prio.next)
326 : 31768 : rq->rt.highest_prio.next = p->prio;
327 : 0 : }
328 : :
329 : : static void dequeue_pushable_task(struct rq *rq, struct task_struct *p)
330 : : {
331 : 52285 : plist_del(&p->pushable_tasks, &rq->rt.pushable_tasks);
332 : :
333 : : /* Update the new highest prio pushable task */
334 [ + + # # : 5783446 : if (has_pushable_tasks(rq)) {
+ + + + ]
335 : : p = plist_first_entry(&rq->rt.pushable_tasks,
336 : : struct task_struct, pushable_tasks);
337 : 1697 : rq->rt.highest_prio.next = p->prio;
338 : : } else
339 : 50604 : rq->rt.highest_prio.next = MAX_RT_PRIO;
340 : : }
341 : :
342 : : #else
343 : :
344 : : static inline void enqueue_pushable_task(struct rq *rq, struct task_struct *p)
345 : : {
346 : : }
347 : :
348 : : static inline void dequeue_pushable_task(struct rq *rq, struct task_struct *p)
349 : : {
350 : : }
351 : :
352 : : static inline
353 : : void inc_rt_migration(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
354 : : {
355 : : }
356 : :
357 : : static inline
358 : : void dec_rt_migration(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
359 : : {
360 : : }
361 : :
362 : : #endif /* CONFIG_SMP */
363 : :
364 : : static inline int on_rt_rq(struct sched_rt_entity *rt_se)
365 : : {
366 : 93918 : return !list_empty(&rt_se->run_list);
367 : : }
368 : :
369 : : #ifdef CONFIG_RT_GROUP_SCHED
370 : :
371 : : static inline u64 sched_rt_runtime(struct rt_rq *rt_rq)
372 : : {
373 : : if (!rt_rq->tg)
374 : : return RUNTIME_INF;
375 : :
376 : : return rt_rq->rt_runtime;
377 : : }
378 : :
379 : : static inline u64 sched_rt_period(struct rt_rq *rt_rq)
380 : : {
381 : : return ktime_to_ns(rt_rq->tg->rt_bandwidth.rt_period);
382 : : }
383 : :
384 : : typedef struct task_group *rt_rq_iter_t;
385 : :
386 : : static inline struct task_group *next_task_group(struct task_group *tg)
387 : : {
388 : : do {
389 : : tg = list_entry_rcu(tg->list.next,
390 : : typeof(struct task_group), list);
391 : : } while (&tg->list != &task_groups && task_group_is_autogroup(tg));
392 : :
393 : : if (&tg->list == &task_groups)
394 : : tg = NULL;
395 : :
396 : : return tg;
397 : : }
398 : :
399 : : #define for_each_rt_rq(rt_rq, iter, rq) \
400 : : for (iter = container_of(&task_groups, typeof(*iter), list); \
401 : : (iter = next_task_group(iter)) && \
402 : : (rt_rq = iter->rt_rq[cpu_of(rq)]);)
403 : :
404 : : #define for_each_sched_rt_entity(rt_se) \
405 : : for (; rt_se; rt_se = rt_se->parent)
406 : :
407 : : static inline struct rt_rq *group_rt_rq(struct sched_rt_entity *rt_se)
408 : : {
409 : : return rt_se->my_q;
410 : : }
411 : :
412 : : static void enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head);
413 : : static void dequeue_rt_entity(struct sched_rt_entity *rt_se);
414 : :
415 : : static void sched_rt_rq_enqueue(struct rt_rq *rt_rq)
416 : : {
417 : : struct task_struct *curr = rq_of_rt_rq(rt_rq)->curr;
418 : : struct sched_rt_entity *rt_se;
419 : :
420 : : int cpu = cpu_of(rq_of_rt_rq(rt_rq));
421 : :
422 : : rt_se = rt_rq->tg->rt_se[cpu];
423 : :
424 : : if (rt_rq->rt_nr_running) {
425 : : if (rt_se && !on_rt_rq(rt_se))
426 : : enqueue_rt_entity(rt_se, false);
427 : : if (rt_rq->highest_prio.curr < curr->prio)
428 : : resched_task(curr);
429 : : }
430 : : }
431 : :
432 : : static void sched_rt_rq_dequeue(struct rt_rq *rt_rq)
433 : : {
434 : : struct sched_rt_entity *rt_se;
435 : : int cpu = cpu_of(rq_of_rt_rq(rt_rq));
436 : :
437 : : rt_se = rt_rq->tg->rt_se[cpu];
438 : :
439 : : if (rt_se && on_rt_rq(rt_se))
440 : : dequeue_rt_entity(rt_se);
441 : : }
442 : :
443 : : static inline int rt_rq_throttled(struct rt_rq *rt_rq)
444 : : {
445 : : return rt_rq->rt_throttled && !rt_rq->rt_nr_boosted;
446 : : }
447 : :
448 : : static int rt_se_boosted(struct sched_rt_entity *rt_se)
449 : : {
450 : : struct rt_rq *rt_rq = group_rt_rq(rt_se);
451 : : struct task_struct *p;
452 : :
453 : : if (rt_rq)
454 : : return !!rt_rq->rt_nr_boosted;
455 : :
456 : : p = rt_task_of(rt_se);
457 : : return p->prio != p->normal_prio;
458 : : }
459 : :
460 : : #ifdef CONFIG_SMP
461 : : static inline const struct cpumask *sched_rt_period_mask(void)
462 : : {
463 : : return this_rq()->rd->span;
464 : : }
465 : : #else
466 : : static inline const struct cpumask *sched_rt_period_mask(void)
467 : : {
468 : : return cpu_online_mask;
469 : : }
470 : : #endif
471 : :
472 : : static inline
473 : : struct rt_rq *sched_rt_period_rt_rq(struct rt_bandwidth *rt_b, int cpu)
474 : : {
475 : : return container_of(rt_b, struct task_group, rt_bandwidth)->rt_rq[cpu];
476 : : }
477 : :
478 : : static inline struct rt_bandwidth *sched_rt_bandwidth(struct rt_rq *rt_rq)
479 : : {
480 : : return &rt_rq->tg->rt_bandwidth;
481 : : }
482 : :
483 : : #else /* !CONFIG_RT_GROUP_SCHED */
484 : :
485 : : static inline u64 sched_rt_runtime(struct rt_rq *rt_rq)
486 : : {
487 : : return rt_rq->rt_runtime;
488 : : }
489 : :
490 : : static inline u64 sched_rt_period(struct rt_rq *rt_rq)
491 : : {
492 : 42125 : return ktime_to_ns(def_rt_bandwidth.rt_period);
493 : : }
494 : :
495 : : typedef struct rt_rq *rt_rq_iter_t;
496 : :
497 : : #define for_each_rt_rq(rt_rq, iter, rq) \
498 : : for ((void) iter, rt_rq = &rq->rt; rt_rq; rt_rq = NULL)
499 : :
500 : : #define for_each_sched_rt_entity(rt_se) \
501 : : for (; rt_se; rt_se = NULL)
502 : :
503 : : static inline struct rt_rq *group_rt_rq(struct sched_rt_entity *rt_se)
504 : : {
505 : : return NULL;
506 : : }
507 : :
508 : : static inline void sched_rt_rq_enqueue(struct rt_rq *rt_rq)
509 : : {
510 [ + - ]: 1 : if (rt_rq->rt_nr_running)
511 : 1 : resched_task(rq_of_rt_rq(rt_rq)->curr);
512 : : }
513 : :
514 : : static inline void sched_rt_rq_dequeue(struct rt_rq *rt_rq)
515 : : {
516 : : }
517 : :
518 : : static inline int rt_rq_throttled(struct rt_rq *rt_rq)
519 : : {
520 : : return rt_rq->rt_throttled;
521 : : }
522 : :
523 : : static inline const struct cpumask *sched_rt_period_mask(void)
524 : : {
525 : 3661 : return cpu_online_mask;
526 : : }
527 : :
528 : : static inline
529 : : struct rt_rq *sched_rt_period_rt_rq(struct rt_bandwidth *rt_b, int cpu)
530 : : {
531 : 7322 : return &cpu_rq(cpu)->rt;
532 : : }
533 : :
534 : : static inline struct rt_bandwidth *sched_rt_bandwidth(struct rt_rq *rt_rq)
535 : : {
536 : : return &def_rt_bandwidth;
537 : : }
538 : :
539 : : #endif /* CONFIG_RT_GROUP_SCHED */
540 : :
541 : : #ifdef CONFIG_SMP
542 : : /*
543 : : * We ran out of runtime, see if we can borrow some from our neighbours.
544 : : */
545 : 0 : static int do_balance_runtime(struct rt_rq *rt_rq)
546 : : {
547 : : struct rt_bandwidth *rt_b = sched_rt_bandwidth(rt_rq);
548 : 0 : struct root_domain *rd = rq_of_rt_rq(rt_rq)->rd;
549 : : int i, weight, more = 0;
550 : : u64 rt_period;
551 : :
552 : : weight = cpumask_weight(rd->span);
553 : :
554 : 0 : raw_spin_lock(&rt_b->rt_runtime_lock);
555 : 0 : rt_period = ktime_to_ns(rt_b->rt_period);
556 [ # # ]: 0 : for_each_cpu(i, rd->span) {
557 : 0 : struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);
558 : : s64 diff;
559 : :
560 [ # # ]: 0 : if (iter == rt_rq)
561 : 0 : continue;
562 : :
563 : 0 : raw_spin_lock(&iter->rt_runtime_lock);
564 : : /*
565 : : * Either all rqs have inf runtime and there's nothing to steal
566 : : * or __disable_runtime() below sets a specific rq to inf to
567 : : * indicate its been disabled and disalow stealing.
568 : : */
569 [ # # ]: 0 : if (iter->rt_runtime == RUNTIME_INF)
570 : : goto next;
571 : :
572 : : /*
573 : : * From runqueues with spare time, take 1/n part of their
574 : : * spare time, but no more than our period.
575 : : */
576 : 0 : diff = iter->rt_runtime - iter->rt_time;
577 [ # # ]: 0 : if (diff > 0) {
578 : 0 : diff = div_u64((u64)diff, weight);
579 [ # # ]: 0 : if (rt_rq->rt_runtime + diff > rt_period)
580 : 0 : diff = rt_period - rt_rq->rt_runtime;
581 : 0 : iter->rt_runtime -= diff;
582 : 0 : rt_rq->rt_runtime += diff;
583 : : more = 1;
584 [ # # ]: 0 : if (rt_rq->rt_runtime == rt_period) {
585 : : raw_spin_unlock(&iter->rt_runtime_lock);
586 : : break;
587 : : }
588 : : }
589 : : next:
590 : : raw_spin_unlock(&iter->rt_runtime_lock);
591 : : }
592 : : raw_spin_unlock(&rt_b->rt_runtime_lock);
593 : :
594 : 0 : return more;
595 : : }
596 : :
597 : : /*
598 : : * Ensure this RQ takes back all the runtime it lend to its neighbours.
599 : : */
600 : 0 : static void __disable_runtime(struct rq *rq)
601 : : {
602 : 0 : struct root_domain *rd = rq->rd;
603 : : rt_rq_iter_t iter;
604 : : struct rt_rq *rt_rq;
605 : :
606 [ # # ]: 0 : if (unlikely(!scheduler_running))
607 : 0 : return;
608 : :
609 [ # # ]: 0 : for_each_rt_rq(rt_rq, iter, rq) {
610 : : struct rt_bandwidth *rt_b = sched_rt_bandwidth(rt_rq);
611 : : s64 want;
612 : : int i;
613 : :
614 : 0 : raw_spin_lock(&rt_b->rt_runtime_lock);
615 : 0 : raw_spin_lock(&rt_rq->rt_runtime_lock);
616 : : /*
617 : : * Either we're all inf and nobody needs to borrow, or we're
618 : : * already disabled and thus have nothing to do, or we have
619 : : * exactly the right amount of runtime to take out.
620 : : */
621 [ # # ][ # # ]: 0 : if (rt_rq->rt_runtime == RUNTIME_INF ||
622 : 0 : rt_rq->rt_runtime == rt_b->rt_runtime)
623 : : goto balanced;
624 : : raw_spin_unlock(&rt_rq->rt_runtime_lock);
625 : :
626 : : /*
627 : : * Calculate the difference between what we started out with
628 : : * and what we current have, that's the amount of runtime
629 : : * we lend and now have to reclaim.
630 : : */
631 : 0 : want = rt_b->rt_runtime - rt_rq->rt_runtime;
632 : :
633 : : /*
634 : : * Greedy reclaim, take back as much as we can.
635 : : */
636 [ # # ]: 0 : for_each_cpu(i, rd->span) {
637 : 0 : struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);
638 : : s64 diff;
639 : :
640 : : /*
641 : : * Can't reclaim from ourselves or disabled runqueues.
642 : : */
643 [ # # ][ # # ]: 0 : if (iter == rt_rq || iter->rt_runtime == RUNTIME_INF)
644 : 0 : continue;
645 : :
646 : 0 : raw_spin_lock(&iter->rt_runtime_lock);
647 [ # # ]: 0 : if (want > 0) {
648 : 0 : diff = min_t(s64, iter->rt_runtime, want);
649 : 0 : iter->rt_runtime -= diff;
650 : 0 : want -= diff;
651 : : } else {
652 : 0 : iter->rt_runtime -= want;
653 : : want -= want;
654 : : }
655 : : raw_spin_unlock(&iter->rt_runtime_lock);
656 : :
657 [ # # ]: 0 : if (!want)
658 : : break;
659 : : }
660 : :
661 : 0 : raw_spin_lock(&rt_rq->rt_runtime_lock);
662 : : /*
663 : : * We cannot be left wanting - that would mean some runtime
664 : : * leaked out of the system.
665 : : */
666 [ # # ]: 0 : BUG_ON(want);
667 : : balanced:
668 : : /*
669 : : * Disable all the borrow logic by pretending we have inf
670 : : * runtime - in which case borrowing doesn't make sense.
671 : : */
672 : 0 : rt_rq->rt_runtime = RUNTIME_INF;
673 : 0 : rt_rq->rt_throttled = 0;
674 : : raw_spin_unlock(&rt_rq->rt_runtime_lock);
675 : : raw_spin_unlock(&rt_b->rt_runtime_lock);
676 : : }
677 : : }
678 : :
679 : 0 : static void __enable_runtime(struct rq *rq)
680 : : {
681 : : rt_rq_iter_t iter;
682 : : struct rt_rq *rt_rq;
683 : :
684 [ # # ]: 0 : if (unlikely(!scheduler_running))
685 : 0 : return;
686 : :
687 : : /*
688 : : * Reset each runqueue's bandwidth settings
689 : : */
690 [ # # ]: 0 : for_each_rt_rq(rt_rq, iter, rq) {
691 : : struct rt_bandwidth *rt_b = sched_rt_bandwidth(rt_rq);
692 : :
693 : 0 : raw_spin_lock(&rt_b->rt_runtime_lock);
694 : 0 : raw_spin_lock(&rt_rq->rt_runtime_lock);
695 : 0 : rt_rq->rt_runtime = rt_b->rt_runtime;
696 : 0 : rt_rq->rt_time = 0;
697 : 0 : rt_rq->rt_throttled = 0;
698 : : raw_spin_unlock(&rt_rq->rt_runtime_lock);
699 : : raw_spin_unlock(&rt_b->rt_runtime_lock);
700 : : }
701 : : }
702 : :
703 : 0 : static int balance_runtime(struct rt_rq *rt_rq)
704 : : {
705 : : int more = 0;
706 : :
707 [ + ]: 42132 : if (!sched_feat(RT_RUNTIME_SHARE))
708 : : return more;
709 : :
710 [ - + ]: 42139 : if (rt_rq->rt_time > rt_rq->rt_runtime) {
711 : : raw_spin_unlock(&rt_rq->rt_runtime_lock);
712 : 0 : more = do_balance_runtime(rt_rq);
713 : 0 : raw_spin_lock(&rt_rq->rt_runtime_lock);
714 : : }
715 : :
716 : 42142 : return more;
717 : : }
718 : : #else /* !CONFIG_SMP */
719 : : static inline int balance_runtime(struct rt_rq *rt_rq)
720 : : {
721 : : return 0;
722 : : }
723 : : #endif /* CONFIG_SMP */
724 : :
725 : 3661 : static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun)
726 : : {
727 : : int i, idle = 1, throttled = 0;
728 : : const struct cpumask *span;
729 : :
730 : : span = sched_rt_period_mask();
731 : : #ifdef CONFIG_RT_GROUP_SCHED
732 : : /*
733 : : * FIXME: isolated CPUs should really leave the root task group,
734 : : * whether they are isolcpus or were isolated via cpusets, lest
735 : : * the timer run on a CPU which does not service all runqueues,
736 : : * potentially leaving other CPUs indefinitely throttled. If
737 : : * isolation is really required, the user will turn the throttle
738 : : * off to kill the perturbations it causes anyway. Meanwhile,
739 : : * this maintains functionality for boot and/or troubleshooting.
740 : : */
741 : : if (rt_b == &root_task_group.rt_bandwidth)
742 : : span = cpu_online_mask;
743 : : #endif
744 [ + + ]: 10983 : for_each_cpu(i, span) {
745 : : int enqueue = 0;
746 : 7323 : struct rt_rq *rt_rq = sched_rt_period_rt_rq(rt_b, i);
747 : : struct rq *rq = rq_of_rt_rq(rt_rq);
748 : :
749 : 7322 : raw_spin_lock(&rq->lock);
750 [ + + ]: 7322 : if (rt_rq->rt_time) {
751 : : u64 runtime;
752 : :
753 : 4339 : raw_spin_lock(&rt_rq->rt_runtime_lock);
754 [ - + ]: 4339 : if (rt_rq->rt_throttled)
755 : 0 : balance_runtime(rt_rq);
756 : 4339 : runtime = rt_rq->rt_runtime;
757 : 4339 : rt_rq->rt_time -= min(rt_rq->rt_time, overrun*runtime);
758 [ - + ][ # # ]: 8000 : if (rt_rq->rt_throttled && rt_rq->rt_time < runtime) {
759 : 0 : rt_rq->rt_throttled = 0;
760 : : enqueue = 1;
761 : :
762 : : /*
763 : : * Force a clock update if the CPU was idle,
764 : : * lest wakeup -> unthrottle time accumulate.
765 : : */
766 [ # # ][ # # ]: 0 : if (rt_rq->rt_nr_running && rq->curr == rq->idle)
767 : 0 : rq->skip_clock_update = -1;
768 : : }
769 [ + - ][ + + ]: 4339 : if (rt_rq->rt_time || rt_rq->rt_nr_running)
770 : : idle = 0;
771 : : raw_spin_unlock(&rt_rq->rt_runtime_lock);
772 [ + + ]: 2983 : } else if (rt_rq->rt_nr_running) {
773 : : idle = 0;
774 [ + - ]: 1 : if (!rt_rq_throttled(rt_rq))
775 : : enqueue = 1;
776 : : }
777 [ - + ]: 7322 : if (rt_rq->rt_throttled)
778 : : throttled = 1;
779 : :
780 [ + + ]: 7322 : if (enqueue)
781 : : sched_rt_rq_enqueue(rt_rq);
782 : : raw_spin_unlock(&rq->lock);
783 : : }
784 : :
785 [ + - ][ + - ]: 3661 : if (!throttled && (!rt_bandwidth_enabled() || rt_b->rt_runtime == RUNTIME_INF))
[ + - ]
786 : : return 1;
787 : :
788 : : return idle;
789 : : }
790 : :
791 : : static inline int rt_se_prio(struct sched_rt_entity *rt_se)
792 : : {
793 : : #ifdef CONFIG_RT_GROUP_SCHED
794 : : struct rt_rq *rt_rq = group_rt_rq(rt_se);
795 : :
796 : : if (rt_rq)
797 : : return rt_rq->highest_prio.curr;
798 : : #endif
799 : :
800 : 94606 : return rt_task_of(rt_se)->prio;
801 : : }
802 : :
803 : 0 : static int sched_rt_runtime_exceeded(struct rt_rq *rt_rq)
804 : : {
805 : : u64 runtime = sched_rt_runtime(rt_rq);
806 : :
807 [ + ]: 42124 : if (rt_rq->rt_throttled)
808 : : return rt_rq_throttled(rt_rq);
809 : :
810 [ + ]: 42125 : if (runtime >= sched_rt_period(rt_rq))
811 : : return 0;
812 : :
813 : 42141 : balance_runtime(rt_rq);
814 : : runtime = sched_rt_runtime(rt_rq);
815 [ + + ]: 42127 : if (runtime == RUNTIME_INF)
816 : : return 0;
817 : :
818 [ - + ]: 42116 : if (rt_rq->rt_time > runtime) {
819 : : struct rt_bandwidth *rt_b = sched_rt_bandwidth(rt_rq);
820 : :
821 : : /*
822 : : * Don't actually throttle groups that have no runtime assigned
823 : : * but accrue some time due to boosting.
824 : : */
825 [ # # ]: 0 : if (likely(rt_b->rt_runtime)) {
826 : : static bool once = false;
827 : :
828 : 0 : rt_rq->rt_throttled = 1;
829 : :
830 [ # # ]: 0 : if (!once) {
831 : 0 : once = true;
832 : 0 : printk_sched("sched: RT throttling activated\n");
833 : : }
834 : : } else {
835 : : /*
836 : : * In case we did anyway, make it go away,
837 : : * replenishment is a joke, since it will replenish us
838 : : * with exactly 0 ns.
839 : : */
840 : 0 : rt_rq->rt_time = 0;
841 : : }
842 : :
843 [ # # ]: 0 : if (rt_rq_throttled(rt_rq)) {
844 : : sched_rt_rq_dequeue(rt_rq);
845 : : return 1;
846 : : }
847 : : }
848 : :
849 : : return 0;
850 : : }
851 : :
852 : : /*
853 : : * Update the current task's runtime statistics. Skip current tasks that
854 : : * are not in our scheduling class.
855 : : */
856 : 0 : static void update_curr_rt(struct rq *rq)
857 : : {
858 : 52327 : struct task_struct *curr = rq->curr;
859 : 52327 : struct sched_rt_entity *rt_se = &curr->rt;
860 : 42124 : struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
861 : : u64 delta_exec;
862 : :
863 [ + + ]: 52327 : if (curr->sched_class != &rt_sched_class)
864 : : return;
865 : :
866 : 52326 : delta_exec = rq_clock_task(rq) - curr->se.exec_start;
867 [ + + ]: 52326 : if (unlikely((s64)delta_exec <= 0))
868 : : return;
869 : :
870 : 42114 : schedstat_set(curr->se.statistics.exec_max,
871 : : max(curr->se.statistics.exec_max, delta_exec));
872 : :
873 : 42114 : curr->se.sum_exec_runtime += delta_exec;
874 : : account_group_exec_runtime(curr, delta_exec);
875 : :
876 : 42114 : curr->se.exec_start = rq_clock_task(rq);
877 : : cpuacct_charge(curr, delta_exec);
878 : :
879 : : sched_rt_avg_update(rq, delta_exec);
880 : :
881 [ + + ]: 42126 : if (!rt_bandwidth_enabled())
882 : : return;
883 : :
884 [ + + ]: 84059 : for_each_sched_rt_entity(rt_se) {
885 : 42124 : rt_rq = rt_rq_of_se(rt_se);
886 : :
887 [ + + ]: 42124 : if (sched_rt_runtime(rt_rq) != RUNTIME_INF) {
888 : 42114 : raw_spin_lock(&rt_rq->rt_runtime_lock);
889 : 42137 : rt_rq->rt_time += delta_exec;
890 [ - + ]: 42137 : if (sched_rt_runtime_exceeded(rt_rq))
891 : 0 : resched_task(curr);
892 : : raw_spin_unlock(&rt_rq->rt_runtime_lock);
893 : : }
894 : : }
895 : : }
896 : :
897 : : #if defined CONFIG_SMP
898 : :
899 : : static void
900 : 0 : inc_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
901 : : {
902 : : struct rq *rq = rq_of_rt_rq(rt_rq);
903 : :
904 : : #ifdef CONFIG_RT_GROUP_SCHED
905 : : /*
906 : : * Change rq's cpupri only if rt_rq is the top queue.
907 : : */
908 : : if (&rq->rt != rt_rq)
909 : : return;
910 : : #endif
911 [ + ][ + + ]: 10602 : if (rq->online && prio < prev_prio)
912 : 10356 : cpupri_set(&rq->rd->cpupri, rq->cpu, prio);
913 : 2 : }
914 : :
915 : : static void
916 : 10594 : dec_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
917 : : {
918 : : struct rq *rq = rq_of_rt_rq(rt_rq);
919 : :
920 : : #ifdef CONFIG_RT_GROUP_SCHED
921 : : /*
922 : : * Change rq's cpupri only if rt_rq is the top queue.
923 : : */
924 : : if (&rq->rt != rt_rq)
925 : : return;
926 : : #endif
927 [ + + ][ + + ]: 10594 : if (rq->online && rt_rq->highest_prio.curr != prev_prio)
928 : 10239 : cpupri_set(&rq->rd->cpupri, rq->cpu, rt_rq->highest_prio.curr);
929 : 19 : }
930 : :
931 : : #else /* CONFIG_SMP */
932 : :
933 : : static inline
934 : : void inc_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio) {}
935 : : static inline
936 : : void dec_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio) {}
937 : :
938 : : #endif /* CONFIG_SMP */
939 : :
940 : : #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
941 : : static void
942 : 0 : inc_rt_prio(struct rt_rq *rt_rq, int prio)
943 : : {
944 : 10605 : int prev_prio = rt_rq->highest_prio.curr;
945 : :
946 [ + + ]: 10605 : if (prio < prev_prio)
947 : 10359 : rt_rq->highest_prio.curr = prio;
948 : :
949 : 10605 : inc_rt_prio_smp(rt_rq, prio, prev_prio);
950 : 10601 : }
951 : :
952 : : static void
953 : 0 : dec_rt_prio(struct rt_rq *rt_rq, int prio)
954 : : {
955 : 10604 : int prev_prio = rt_rq->highest_prio.curr;
956 : :
957 [ + + ]: 10604 : if (rt_rq->rt_nr_running) {
958 : :
959 [ - + ]: 699 : WARN_ON(prio < prev_prio);
960 : :
961 : : /*
962 : : * This may have been our highest task, and therefore
963 : : * we may have some recomputation to do
964 : : */
965 [ + + ]: 11303 : if (prio == prev_prio) {
966 : : struct rt_prio_array *array = &rt_rq->active;
967 : :
968 : 562 : rt_rq->highest_prio.curr =
969 : : sched_find_first_bit(array->bitmap);
970 : : }
971 : :
972 : : } else
973 : 9905 : rt_rq->highest_prio.curr = MAX_RT_PRIO;
974 : :
975 : 10604 : dec_rt_prio_smp(rt_rq, prio, prev_prio);
976 : 10599 : }
977 : :
978 : : #else
979 : :
980 : : static inline void inc_rt_prio(struct rt_rq *rt_rq, int prio) {}
981 : : static inline void dec_rt_prio(struct rt_rq *rt_rq, int prio) {}
982 : :
983 : : #endif /* CONFIG_SMP || CONFIG_RT_GROUP_SCHED */
984 : :
985 : : #ifdef CONFIG_RT_GROUP_SCHED
986 : :
987 : : static void
988 : : inc_rt_group(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
989 : : {
990 : : if (rt_se_boosted(rt_se))
991 : : rt_rq->rt_nr_boosted++;
992 : :
993 : : if (rt_rq->tg)
994 : : start_rt_bandwidth(&rt_rq->tg->rt_bandwidth);
995 : : }
996 : :
997 : : static void
998 : : dec_rt_group(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
999 : : {
1000 : : if (rt_se_boosted(rt_se))
1001 : : rt_rq->rt_nr_boosted--;
1002 : :
1003 : : WARN_ON(!rt_rq->rt_nr_running && rt_rq->rt_nr_boosted);
1004 : : }
1005 : :
1006 : : #else /* CONFIG_RT_GROUP_SCHED */
1007 : :
1008 : : static void
1009 : 10593 : inc_rt_group(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
1010 : : {
1011 : 10593 : start_rt_bandwidth(&def_rt_bandwidth);
1012 : 10598 : }
1013 : :
1014 : : static inline
1015 : : void dec_rt_group(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq) {}
1016 : :
1017 : : #endif /* CONFIG_RT_GROUP_SCHED */
1018 : :
1019 : : static inline
1020 : : void inc_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
1021 : : {
1022 : : int prio = rt_se_prio(rt_se);
1023 : :
1024 [ - + ]: 10604 : WARN_ON(!rt_prio(prio));
1025 : 0 : rt_rq->rt_nr_running++;
1026 : :
1027 : 10604 : inc_rt_prio(rt_rq, prio);
1028 : 10600 : inc_rt_migration(rt_se, rt_rq);
1029 : 10591 : inc_rt_group(rt_se, rt_rq);
1030 : : }
1031 : :
1032 : : static inline
1033 : : void dec_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
1034 : : {
1035 [ # # ]: 10597 : WARN_ON(!rt_prio(rt_se_prio(rt_se)));
1036 [ - + ]: 10597 : WARN_ON(!rt_rq->rt_nr_running);
1037 : 10597 : rt_rq->rt_nr_running--;
1038 : :
1039 : 10597 : dec_rt_prio(rt_rq, rt_se_prio(rt_se));
1040 : 10603 : dec_rt_migration(rt_se, rt_rq);
1041 : : dec_rt_group(rt_se, rt_rq);
1042 : : }
1043 : :
1044 : 0 : static void __enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head)
1045 : : {
1046 : 10604 : struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
1047 : : struct rt_prio_array *array = &rt_rq->active;
1048 : : struct rt_rq *group_rq = group_rt_rq(rt_se);
1049 : 10604 : struct list_head *queue = array->queue + rt_se_prio(rt_se);
1050 : :
1051 : : /*
1052 : : * Don't enqueue the group if its throttled, or when empty.
1053 : : * The latter is a consequence of the former when a child group
1054 : : * get throttled and the current group doesn't have any other
1055 : : * active members.
1056 : : */
1057 : : if (group_rq && (rt_rq_throttled(group_rq) || !group_rq->rt_nr_running))
1058 : 10599 : return;
1059 : :
1060 [ - + ]: 10604 : if (head)
1061 : 0 : list_add(&rt_se->run_list, queue);
1062 : : else
1063 : 10604 : list_add_tail(&rt_se->run_list, queue);
1064 : : __set_bit(rt_se_prio(rt_se), array->bitmap);
1065 : :
1066 : : inc_rt_tasks(rt_se, rt_rq);
1067 : : }
1068 : :
1069 : 0 : static void __dequeue_rt_entity(struct sched_rt_entity *rt_se)
1070 : : {
1071 : 10597 : struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
1072 : : struct rt_prio_array *array = &rt_rq->active;
1073 : :
1074 : 10597 : list_del_init(&rt_se->run_list);
1075 [ + + ]: 10597 : if (list_empty(array->queue + rt_se_prio(rt_se)))
1076 : : __clear_bit(rt_se_prio(rt_se), array->bitmap);
1077 : :
1078 : : dec_rt_tasks(rt_se, rt_rq);
1079 : 10592 : }
1080 : :
1081 : : /*
1082 : : * Because the prio of an upper entry depends on the lower
1083 : : * entries, we must remove entries top - down.
1084 : : */
1085 : 0 : static void dequeue_rt_stack(struct sched_rt_entity *rt_se)
1086 : : {
1087 : : struct sched_rt_entity *back = NULL;
1088 : :
1089 [ + + ]: 42398 : for_each_sched_rt_entity(rt_se) {
1090 : 21199 : rt_se->back = back;
1091 : : back = rt_se;
1092 : : }
1093 : :
1094 [ + + ]: 42391 : for (rt_se = back; rt_se; rt_se = rt_se->back) {
1095 [ + + ]: 21203 : if (on_rt_rq(rt_se))
1096 : 10597 : __dequeue_rt_entity(rt_se);
1097 : : }
1098 : 21188 : }
1099 : :
1100 : 0 : static void enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head)
1101 : : {
1102 : 10607 : dequeue_rt_stack(rt_se);
1103 [ + + ]: 21207 : for_each_sched_rt_entity(rt_se)
1104 : 10606 : __enqueue_rt_entity(rt_se, head);
1105 : 10601 : }
1106 : :
1107 : : static void dequeue_rt_entity(struct sched_rt_entity *rt_se)
1108 : : {
1109 : 10602 : dequeue_rt_stack(rt_se);
1110 : :
1111 [ + + ]: 21194 : for_each_sched_rt_entity(rt_se) {
1112 : : struct rt_rq *rt_rq = group_rt_rq(rt_se);
1113 : :
1114 : : if (rt_rq && rt_rq->rt_nr_running)
1115 : : __enqueue_rt_entity(rt_se, false);
1116 : : }
1117 : : }
1118 : :
1119 : : /*
1120 : : * Adding/removing a task to/from a priority array:
1121 : : */
1122 : : static void
1123 : 0 : enqueue_task_rt(struct rq *rq, struct task_struct *p, int flags)
1124 : : {
1125 : 10607 : struct sched_rt_entity *rt_se = &p->rt;
1126 : :
1127 [ + + ]: 10607 : if (flags & ENQUEUE_WAKEUP)
1128 : 10245 : rt_se->timeout = 0;
1129 : :
1130 : 10607 : enqueue_rt_entity(rt_se, flags & ENQUEUE_HEAD);
1131 : :
1132 [ + + ][ + + ]: 10598 : if (!task_current(rq, p) && p->nr_cpus_allowed > 1)
1133 : 810 : enqueue_pushable_task(rq, p);
1134 : :
1135 : : inc_nr_running(rq);
1136 : 10598 : }
1137 : :
1138 : 0 : static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int flags)
1139 : : {
1140 : 10590 : struct sched_rt_entity *rt_se = &p->rt;
1141 : :
1142 : 10590 : update_curr_rt(rq);
1143 : : dequeue_rt_entity(rt_se);
1144 : :
1145 : : dequeue_pushable_task(rq, p);
1146 : :
1147 : : dec_nr_running(rq);
1148 : 10601 : }
1149 : :
1150 : : /*
1151 : : * Put task to the head or the end of the run list without the overhead of
1152 : : * dequeue followed by enqueue.
1153 : : */
1154 : : static void
1155 : 0 : requeue_rt_entity(struct rt_rq *rt_rq, struct sched_rt_entity *rt_se, int head)
1156 : : {
1157 [ + ]: 31010 : if (on_rt_rq(rt_se)) {
1158 : : struct rt_prio_array *array = &rt_rq->active;
1159 : 31003 : struct list_head *queue = array->queue + rt_se_prio(rt_se);
1160 : :
1161 [ + + ]: 62013 : if (head)
1162 : : list_move(&rt_se->run_list, queue);
1163 : : else
1164 : : list_move_tail(&rt_se->run_list, queue);
1165 : : }
1166 : 0 : }
1167 : :
1168 : 31014 : static void requeue_task_rt(struct rq *rq, struct task_struct *p, int head)
1169 : : {
1170 : 31014 : struct sched_rt_entity *rt_se = &p->rt;
1171 : : struct rt_rq *rt_rq;
1172 : :
1173 [ + + ]: 62018 : for_each_sched_rt_entity(rt_se) {
1174 : 31007 : rt_rq = rt_rq_of_se(rt_se);
1175 : 31007 : requeue_rt_entity(rt_rq, rt_se, head);
1176 : : }
1177 : 31011 : }
1178 : :
1179 : 0 : static void yield_task_rt(struct rq *rq)
1180 : : {
1181 : 31005 : requeue_task_rt(rq, rq->curr, 0);
1182 : 31008 : }
1183 : :
1184 : : #ifdef CONFIG_SMP
1185 : : static int find_lowest_rq(struct task_struct *task);
1186 : :
1187 : : static int
1188 : 0 : select_task_rq_rt(struct task_struct *p, int cpu, int sd_flag, int flags)
1189 : : {
1190 : : struct task_struct *curr;
1191 : : struct rq *rq;
1192 : :
1193 [ + + ]: 10346 : if (p->nr_cpus_allowed == 1)
1194 : : goto out;
1195 : :
1196 : : /* For anything but wake ups, just return the task_cpu */
1197 [ + - ]: 591 : if (sd_flag != SD_BALANCE_WAKE && sd_flag != SD_BALANCE_FORK)
1198 : : goto out;
1199 : :
1200 : 591 : rq = cpu_rq(cpu);
1201 : :
1202 : : rcu_read_lock();
1203 : 591 : curr = ACCESS_ONCE(rq->curr); /* unlocked access */
1204 : :
1205 : : /*
1206 : : * If the current task on @p's runqueue is an RT task, then
1207 : : * try to see if we can wake this RT task up on another
1208 : : * runqueue. Otherwise simply start this RT task
1209 : : * on its current runqueue.
1210 : : *
1211 : : * We want to avoid overloading runqueues. If the woken
1212 : : * task is a higher priority, then it will stay on this CPU
1213 : : * and the lower prio task should be moved to another CPU.
1214 : : * Even though this will probably make the lower prio task
1215 : : * lose its cache, we do not want to bounce a higher task
1216 : : * around just because it gave up its CPU, perhaps for a
1217 : : * lock?
1218 : : *
1219 : : * For equal prio tasks, we just let the scheduler sort it out.
1220 : : *
1221 : : * Otherwise, just let it ride on the affined RQ and the
1222 : : * post-schedule router will push the preempted task away
1223 : : *
1224 : : * This test is optimistic, if we get it wrong the load-balancer
1225 : : * will have to sort it out.
1226 : : */
1227 [ + - ][ + + ]: 1182 : if (curr && unlikely(rt_task(curr)) &&
[ + - ]
1228 [ + + ]: 471 : (curr->nr_cpus_allowed < 2 ||
1229 : 471 : curr->prio <= p->prio)) {
1230 : 259 : int target = find_lowest_rq(p);
1231 : :
1232 [ + + ]: 259 : if (target != -1)
1233 : : cpu = target;
1234 : : }
1235 : : rcu_read_unlock();
1236 : :
1237 : : out:
1238 : 10346 : return cpu;
1239 : : }
1240 : :
1241 : 240 : static void check_preempt_equal_prio(struct rq *rq, struct task_struct *p)
1242 : : {
1243 [ + - ]: 240 : if (rq->curr->nr_cpus_allowed == 1)
1244 : : return;
1245 : :
1246 [ + - ]: 240 : if (p->nr_cpus_allowed != 1
1247 [ + + ]: 240 : && cpupri_find(&rq->rd->cpupri, p, NULL))
1248 : : return;
1249 : :
1250 [ + + ]: 219 : if (!cpupri_find(&rq->rd->cpupri, rq->curr, NULL))
1251 : : return;
1252 : :
1253 : : /*
1254 : : * There appears to be other cpus that can accept
1255 : : * current and none to run 'p', so lets reschedule
1256 : : * to try and push current away:
1257 : : */
1258 : 4 : requeue_task_rt(rq, p, 1);
1259 : 4 : resched_task(rq->curr);
1260 : : }
1261 : :
1262 : : #endif /* CONFIG_SMP */
1263 : :
1264 : : /*
1265 : : * Preempt the current task with a newly woken task if needed:
1266 : : */
1267 : 0 : static void check_preempt_curr_rt(struct rq *rq, struct task_struct *p, int flags)
1268 : : {
1269 [ + + ]: 519 : if (p->prio < rq->curr->prio) {
1270 : 260 : resched_task(rq->curr);
1271 : 260 : return;
1272 : : }
1273 : :
1274 : : #ifdef CONFIG_SMP
1275 : : /*
1276 : : * If:
1277 : : *
1278 : : * - the newly woken task is of equal priority to the current task
1279 : : * - the newly woken task is non-migratable while current is migratable
1280 : : * - current will be preempted on the next reschedule
1281 : : *
1282 : : * we should check to see if current can readily move to a different
1283 : : * cpu. If so, we will reschedule to allow the push logic to try
1284 : : * to move current somewhere else, making room for our non-migratable
1285 : : * task.
1286 : : */
1287 [ + + ][ + + ]: 259 : if (p->prio == rq->curr->prio && !test_tsk_need_resched(rq->curr))
1288 : 240 : check_preempt_equal_prio(rq, p);
1289 : : #endif
1290 : : }
1291 : :
1292 : 0 : static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq,
1293 : : struct rt_rq *rt_rq)
1294 : : {
1295 : : struct rt_prio_array *array = &rt_rq->active;
1296 : : struct sched_rt_entity *next = NULL;
1297 : : struct list_head *queue;
1298 : : int idx;
1299 : :
1300 : : idx = sched_find_first_bit(array->bitmap);
1301 [ - + ]: 41667 : BUG_ON(idx >= MAX_RT_PRIO);
1302 : :
1303 : 41667 : queue = array->queue + idx;
1304 : 41667 : next = list_entry(queue->next, struct sched_rt_entity, run_list);
1305 : :
1306 : 41667 : return next;
1307 : : }
1308 : :
1309 : 0 : static struct task_struct *_pick_next_task_rt(struct rq *rq)
1310 : : {
1311 : : struct sched_rt_entity *rt_se;
1312 : : struct task_struct *p;
1313 : 41667 : struct rt_rq *rt_rq;
1314 : :
1315 : 5720752 : rt_rq = &rq->rt;
1316 : :
1317 [ + + ]: 5720752 : if (!rt_rq->rt_nr_running)
1318 : : return NULL;
1319 : :
1320 [ + + ]: 41667 : if (rt_rq_throttled(rt_rq))
1321 : : return NULL;
1322 : :
1323 : : do {
1324 : 41663 : rt_se = pick_next_rt_entity(rq, rt_rq);
1325 [ - + ]: 5762407 : BUG_ON(!rt_se);
1326 : : rt_rq = group_rt_rq(rt_se);
1327 : : } while (rt_rq);
1328 : :
1329 : 41655 : p = rt_task_of(rt_se);
1330 : 41655 : p->se.exec_start = rq_clock_task(rq);
1331 : :
1332 : 41655 : return p;
1333 : : }
1334 : :
1335 : 0 : static struct task_struct *pick_next_task_rt(struct rq *rq)
1336 : : {
1337 : 5720514 : struct task_struct *p = _pick_next_task_rt(rq);
1338 : :
1339 : : /* The running task is never eligible for pushing */
1340 [ + + ]: 5720696 : if (p)
1341 : : dequeue_pushable_task(rq, p);
1342 : :
1343 : : #ifdef CONFIG_SMP
1344 : : /*
1345 : : * We detect this state here so that we can avoid taking the RQ
1346 : : * lock again later if there is no need to push
1347 : : */
1348 : 5720707 : rq->post_schedule = has_pushable_tasks(rq);
1349 : : #endif
1350 : :
1351 : 5720707 : return p;
1352 : : }
1353 : :
1354 : 0 : static void put_prev_task_rt(struct rq *rq, struct task_struct *p)
1355 : : {
1356 : 41712 : update_curr_rt(rq);
1357 : :
1358 : : /*
1359 : : * The previous task needs to be made eligible for pushing
1360 : : * if it is still active
1361 : : */
1362 [ + + ][ + - ]: 41705 : if (on_rt_rq(&p->rt) && p->nr_cpus_allowed > 1)
1363 : 31327 : enqueue_pushable_task(rq, p);
1364 : 0 : }
1365 : :
1366 : : #ifdef CONFIG_SMP
1367 : :
1368 : : /* Only try algorithms three times */
1369 : : #define RT_MAX_TRIES 3
1370 : :
1371 : : static int pick_rt_task(struct rq *rq, struct task_struct *p, int cpu)
1372 : : {
1373 [ + - ][ - + ]: 210 : if (!task_running(rq, p) &&
1374 : 210 : cpumask_test_cpu(cpu, tsk_cpus_allowed(p)))
1375 : : return 1;
1376 : : return 0;
1377 : : }
1378 : :
1379 : : /*
1380 : : * Return the highest pushable rq's task, which is suitable to be executed
1381 : : * on the cpu, NULL otherwise
1382 : : */
1383 : 0 : static struct task_struct *pick_highest_pushable_task(struct rq *rq, int cpu)
1384 : : {
1385 : : struct plist_head *head = &rq->rt.pushable_tasks;
1386 : : struct task_struct *p;
1387 : :
1388 [ + - ]: 210 : if (!has_pushable_tasks(rq))
1389 : : return NULL;
1390 : :
1391 [ + - ]: 210 : plist_for_each_entry(p, head, pushable_tasks) {
1392 [ - - ]: 210 : if (pick_rt_task(rq, p, cpu))
1393 : : return p;
1394 : : }
1395 : :
1396 : : return NULL;
1397 : : }
1398 : :
1399 : : static DEFINE_PER_CPU(cpumask_var_t, local_cpu_mask);
1400 : :
1401 : 0 : static int find_lowest_rq(struct task_struct *task)
1402 : : {
1403 : : struct sched_domain *sd;
1404 : 2674 : struct cpumask *lowest_mask = __get_cpu_var(local_cpu_mask);
1405 : 1337 : int this_cpu = smp_processor_id();
1406 : 1337 : int cpu = task_cpu(task);
1407 : :
1408 : : /* Make sure the mask is initialized first */
1409 [ + + ]: 1337 : if (unlikely(!lowest_mask))
1410 : : return -1;
1411 : :
1412 [ + ]: 1336 : if (task->nr_cpus_allowed == 1)
1413 : : return -1; /* No other targets possible */
1414 : :
1415 [ + + ]: 1337 : if (!cpupri_find(&task_rq(task)->rd->cpupri, task, lowest_mask))
1416 : : return -1; /* No targets found */
1417 : :
1418 : : /*
1419 : : * At this point we have built a mask of cpus representing the
1420 : : * lowest priority tasks in the system. Now we want to elect
1421 : : * the best one based on our affinity and topology.
1422 : : *
1423 : : * We prioritize the last cpu that the task executed on since
1424 : : * it is most likely cache-hot in that location.
1425 : : */
1426 [ + - ]: 100 : if (cpumask_test_cpu(cpu, lowest_mask))
1427 : : return cpu;
1428 : :
1429 : : /*
1430 : : * Otherwise, we consult the sched_domains span maps to figure
1431 : : * out which cpu is logically closest to our hot cache data.
1432 : : */
1433 [ + - ]: 100 : if (!cpumask_test_cpu(this_cpu, lowest_mask))
1434 : : this_cpu = -1; /* Skip this_cpu opt if not among lowest */
1435 : :
1436 : : rcu_read_lock();
1437 [ + - ]: 100 : for_each_domain(cpu, sd) {
1438 [ + - ]: 100 : if (sd->flags & SD_WAKE_AFFINE) {
1439 : : int best_cpu;
1440 : :
1441 : : /*
1442 : : * "this_cpu" is cheaper to preempt than a
1443 : : * remote processor.
1444 : : */
1445 [ - + ][ # # ]: 100 : if (this_cpu != -1 &&
1446 : 0 : cpumask_test_cpu(this_cpu, sched_domain_span(sd))) {
1447 : : rcu_read_unlock();
1448 : 0 : return this_cpu;
1449 : : }
1450 : :
1451 : 100 : best_cpu = cpumask_first_and(lowest_mask,
1452 : : sched_domain_span(sd));
1453 [ + - ]: 100 : if (best_cpu < nr_cpu_ids) {
1454 : : rcu_read_unlock();
1455 : 100 : return best_cpu;
1456 : : }
1457 : : }
1458 : : }
1459 : : rcu_read_unlock();
1460 : :
1461 : : /*
1462 : : * And finally, if there were no matches within the domains
1463 : : * just give the caller *something* to work with from the compatible
1464 : : * locations.
1465 : : */
1466 [ # # ]: 0 : if (this_cpu != -1)
1467 : : return this_cpu;
1468 : :
1469 : : cpu = cpumask_any(lowest_mask);
1470 [ # # ]: 0 : if (cpu < nr_cpu_ids)
1471 : 0 : return cpu;
1472 : : return -1;
1473 : : }
1474 : :
1475 : : /* Will lock the rq it finds */
1476 : 0 : static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
1477 : : {
1478 : : struct rq *lowest_rq = NULL;
1479 : : int tries;
1480 : : int cpu;
1481 : :
1482 [ + ]: 1077 : for (tries = 0; tries < RT_MAX_TRIES; tries++) {
1483 : 1078 : cpu = find_lowest_rq(task);
1484 : :
1485 [ + + ][ + - ]: 1077 : if ((cpu == -1) || (cpu == rq->cpu))
1486 : : break;
1487 : :
1488 : 48 : lowest_rq = cpu_rq(cpu);
1489 : :
1490 : : /* if the prio of this runqueue changed, try again */
1491 [ + + ]: 48 : if (double_lock_balance(rq, lowest_rq)) {
1492 : : /*
1493 : : * We had to unlock the run queue. In
1494 : : * the mean time, task could have
1495 : : * migrated already or had its affinity changed.
1496 : : * Also make sure that it wasn't scheduled on its rq.
1497 : : */
1498 [ + + ][ - + ]: 15 : if (unlikely(task_rq(task) != rq ||
[ + + ][ + - ]
[ + + ][ - + ]
1499 : : !cpumask_test_cpu(lowest_rq->cpu,
1500 : : tsk_cpus_allowed(task)) ||
1501 : : task_running(rq, task) ||
1502 : : !task->on_rq)) {
1503 : :
1504 : : double_unlock_balance(rq, lowest_rq);
1505 : : lowest_rq = NULL;
1506 : 12 : break;
1507 : : }
1508 : : }
1509 : :
1510 : : /* If this rq is still suitable use it. */
1511 [ + + ]: 36 : if (lowest_rq->rt.highest_prio.curr > task->prio)
1512 : : break;
1513 : :
1514 : : /* try again */
1515 : : double_unlock_balance(rq, lowest_rq);
1516 : : lowest_rq = NULL;
1517 : : }
1518 : :
1519 : 1074 : return lowest_rq;
1520 : : }
1521 : :
1522 : 0 : static struct task_struct *pick_next_pushable_task(struct rq *rq)
1523 : : {
1524 : : struct task_struct *p;
1525 : :
1526 [ + ]: 2263 : if (!has_pushable_tasks(rq))
1527 : : return NULL;
1528 : :
1529 : 4525 : p = plist_first_entry(&rq->rt.pushable_tasks,
1530 : : struct task_struct, pushable_tasks);
1531 : :
1532 [ - + ]: 4525 : BUG_ON(rq->cpu != task_cpu(p));
1533 [ - + ]: 2262 : BUG_ON(task_current(rq, p));
1534 [ - + ]: 2262 : BUG_ON(p->nr_cpus_allowed <= 1);
1535 : :
1536 [ - + ]: 2262 : BUG_ON(!p->on_rq);
1537 [ - + ]: 2262 : BUG_ON(!rt_task(p));
1538 : :
1539 : : return p;
1540 : : }
1541 : :
1542 : : /*
1543 : : * If the current CPU has more than one RT task, see if the non
1544 : : * running task can migrate over to a CPU that is running a task
1545 : : * of lesser priority.
1546 : : */
1547 : 0 : static int push_rt_task(struct rq *rq)
1548 : : {
1549 : : struct task_struct *next_task;
1550 : : struct rq *lowest_rq;
1551 : : int ret = 0;
1552 : :
1553 [ + + ]: 1226 : if (!rq->rt.overloaded)
1554 : : return 0;
1555 : :
1556 : 1224 : next_task = pick_next_pushable_task(rq);
1557 [ + + ]: 1235 : if (!next_task)
1558 : : return 0;
1559 : :
1560 : : retry:
1561 [ - + ]: 1233 : if (unlikely(next_task == rq->curr)) {
1562 : 0 : WARN_ON(1);
1563 : 0 : return 0;
1564 : : }
1565 : :
1566 : : /*
1567 : : * It's possible that the next_task slipped in of
1568 : : * higher priority than current. If that's the case
1569 : : * just reschedule current.
1570 : : */
1571 [ + + ]: 1233 : if (unlikely(next_task->prio < rq->curr->prio)) {
1572 : 160 : resched_task(rq->curr);
1573 : 160 : return 0;
1574 : : }
1575 : :
1576 : : /* We might release rq lock */
1577 : 1073 : get_task_struct(next_task);
1578 : :
1579 : : /* find_lock_lowest_rq locks the rq if found */
1580 : 1075 : lowest_rq = find_lock_lowest_rq(next_task, rq);
1581 [ + + ]: 1075 : if (!lowest_rq) {
1582 : : struct task_struct *task;
1583 : : /*
1584 : : * find_lock_lowest_rq releases rq->lock
1585 : : * so it is possible that next_task has migrated.
1586 : : *
1587 : : * We need to make sure that the task is still on the same
1588 : : * run-queue and is also still the next task eligible for
1589 : : * pushing.
1590 : : */
1591 : 1041 : task = pick_next_pushable_task(rq);
1592 [ + + ][ - + ]: 1042 : if (task_cpu(next_task) == rq->cpu && task == next_task) {
1593 : : /*
1594 : : * The task hasn't migrated, and is still the next
1595 : : * eligible task, but we failed to find a run-queue
1596 : : * to push it to. Do not retry in this case, since
1597 : : * other cpus will pull from us when ready.
1598 : : */
1599 : : goto out;
1600 : : }
1601 : :
1602 [ + + ]: 12 : if (!task)
1603 : : /* No more tasks, just exit */
1604 : : goto out;
1605 : :
1606 : : /*
1607 : : * Something has shifted, try again.
1608 : : */
1609 : : put_task_struct(next_task);
1610 : : next_task = task;
1611 : : goto retry;
1612 : : }
1613 : :
1614 : 34 : deactivate_task(rq, next_task, 0);
1615 : 34 : set_task_cpu(next_task, lowest_rq->cpu);
1616 : 34 : activate_task(lowest_rq, next_task, 0);
1617 : : ret = 1;
1618 : :
1619 : 34 : resched_task(lowest_rq->curr);
1620 : :
1621 : : double_unlock_balance(rq, lowest_rq);
1622 : :
1623 : : out:
1624 : : put_task_struct(next_task);
1625 : :
1626 : 1065 : return ret;
1627 : : }
1628 : :
1629 : : static void push_rt_tasks(struct rq *rq)
1630 : : {
1631 : : /* push_rt_task will return true if it moved an RT */
1632 [ + + ][ + + ]: 1227 : while (push_rt_task(rq))
1633 : : ;
1634 : : }
1635 : :
1636 : 0 : static int pull_rt_task(struct rq *this_rq)
1637 : : {
1638 : 10238 : int this_cpu = this_rq->cpu, ret = 0, cpu;
1639 : : struct task_struct *p;
1640 : : struct rq *src_rq;
1641 : :
1642 [ + + ]: 10238 : if (likely(!rt_overloaded(this_rq)))
1643 : : return 0;
1644 : :
1645 : : /*
1646 : : * Match the barrier from rt_set_overloaded; this guarantees that if we
1647 : : * see overloaded we must also see the rto_mask bit.
1648 : : */
1649 : 361 : smp_rmb();
1650 : :
1651 [ + + ]: 1356 : for_each_cpu(cpu, this_rq->rd->rto_mask) {
1652 [ + + ]: 634 : if (this_cpu == cpu)
1653 : 279 : continue;
1654 : :
1655 : 355 : src_rq = cpu_rq(cpu);
1656 : :
1657 : : /*
1658 : : * Don't bother taking the src_rq->lock if the next highest
1659 : : * task is known to be lower-priority than our current task.
1660 : : * This may look racy, but if this value is about to go
1661 : : * logically higher, the src_rq will push this task away.
1662 : : * And if its going logically lower, we do not care
1663 : : */
1664 [ + + ]: 355 : if (src_rq->rt.highest_prio.next >=
1665 : 355 : this_rq->rt.highest_prio.curr)
1666 : 145 : continue;
1667 : :
1668 : : /*
1669 : : * We can potentially drop this_rq's lock in
1670 : : * double_lock_balance, and another CPU could
1671 : : * alter this_rq
1672 : : */
1673 : : double_lock_balance(this_rq, src_rq);
1674 : :
1675 : : /*
1676 : : * We can pull only a task, which is pushable
1677 : : * on its rq, and no others.
1678 : : */
1679 : 210 : p = pick_highest_pushable_task(src_rq, this_cpu);
1680 : :
1681 : : /*
1682 : : * Do we have an RT task that preempts
1683 : : * the to-be-scheduled task?
1684 : : */
1685 [ + - ][ + + ]: 210 : if (p && (p->prio < this_rq->rt.highest_prio.curr)) {
1686 [ - + ]: 188 : WARN_ON(p == src_rq->curr);
1687 [ - + ]: 188 : WARN_ON(!p->on_rq);
1688 : :
1689 : : /*
1690 : : * There's a chance that p is higher in priority
1691 : : * than what's currently running on its cpu.
1692 : : * This is just that p is wakeing up and hasn't
1693 : : * had a chance to schedule. We only pull
1694 : : * p if it is lower in priority than the
1695 : : * current task on the run queue
1696 : : */
1697 [ + + ]: 188 : if (p->prio < src_rq->curr->prio)
1698 : : goto skip;
1699 : :
1700 : : ret = 1;
1701 : :
1702 : 157 : deactivate_task(src_rq, p, 0);
1703 : 157 : set_task_cpu(p, this_cpu);
1704 : 157 : activate_task(this_rq, p, 0);
1705 : : /*
1706 : : * We continue with the search, just in
1707 : : * case there's an even higher prio task
1708 : : * in another runqueue. (low likelihood
1709 : : * but possible)
1710 : : */
1711 : : }
1712 : : skip:
1713 : : double_unlock_balance(this_rq, src_rq);
1714 : : }
1715 : :
1716 : : return ret;
1717 : : }
1718 : :
1719 : 0 : static void pre_schedule_rt(struct rq *rq, struct task_struct *prev)
1720 : : {
1721 : : /* Try to pull RT tasks here if we lower this rq's prio */
1722 [ + + ]: 41666 : if (rq->rt.highest_prio.curr > prev->prio)
1723 : 10219 : pull_rt_task(rq);
1724 : 0 : }
1725 : :
1726 : 992 : static void post_schedule_rt(struct rq *rq)
1727 : : {
1728 : : push_rt_tasks(rq);
1729 : 992 : }
1730 : :
1731 : : /*
1732 : : * If we are not running and we are not going to reschedule soon, we should
1733 : : * try to push tasks away now
1734 : : */
1735 : 0 : static void task_woken_rt(struct rq *rq, struct task_struct *p)
1736 : : {
1737 [ + + ][ + + ]: 10398 : if (!task_running(rq, p) &&
1738 [ + - ]: 201 : !test_tsk_need_resched(rq->curr) &&
1739 [ + - ]: 201 : has_pushable_tasks(rq) &&
1740 [ + - ]: 201 : p->nr_cpus_allowed > 1 &&
1741 [ + - ]: 201 : rt_task(rq->curr) &&
1742 [ + - ]: 201 : (rq->curr->nr_cpus_allowed < 2 ||
1743 : 201 : rq->curr->prio <= p->prio))
1744 : : push_rt_tasks(rq);
1745 : 0 : }
1746 : :
1747 : 0 : static void set_cpus_allowed_rt(struct task_struct *p,
1748 : : const struct cpumask *new_mask)
1749 : : {
1750 : 0 : struct rq *rq;
1751 : : int weight;
1752 : :
1753 [ # # ]: 0 : BUG_ON(!rt_task(p));
1754 : :
1755 [ # # ]: 0 : if (!p->on_rq)
1756 : : return;
1757 : :
1758 : 0 : weight = cpumask_weight(new_mask);
1759 : :
1760 : : /*
1761 : : * Only update if the process changes its state from whether it
1762 : : * can migrate or not.
1763 : : */
1764 [ # # ]: 0 : if ((p->nr_cpus_allowed > 1) == (weight > 1))
1765 : : return;
1766 : :
1767 : 0 : rq = task_rq(p);
1768 : :
1769 : : /*
1770 : : * The process used to be able to migrate OR it can now migrate
1771 : : */
1772 [ # # ]: 0 : if (weight <= 1) {
1773 [ # # ]: 0 : if (!task_current(rq, p))
1774 : : dequeue_pushable_task(rq, p);
1775 [ # # ]: 0 : BUG_ON(!rq->rt.rt_nr_migratory);
1776 : 0 : rq->rt.rt_nr_migratory--;
1777 : : } else {
1778 [ # # ]: 0 : if (!task_current(rq, p))
1779 : 0 : enqueue_pushable_task(rq, p);
1780 : 0 : rq->rt.rt_nr_migratory++;
1781 : : }
1782 : :
1783 : 0 : update_rt_migration(&rq->rt);
1784 : : }
1785 : :
1786 : : /* Assumes rq->lock is held */
1787 : 0 : static void rq_online_rt(struct rq *rq)
1788 : : {
1789 [ # # ]: 0 : if (rq->rt.overloaded)
1790 : : rt_set_overload(rq);
1791 : :
1792 : 0 : __enable_runtime(rq);
1793 : :
1794 : 0 : cpupri_set(&rq->rd->cpupri, rq->cpu, rq->rt.highest_prio.curr);
1795 : 0 : }
1796 : :
1797 : : /* Assumes rq->lock is held */
1798 : 0 : static void rq_offline_rt(struct rq *rq)
1799 : : {
1800 [ # # ]: 0 : if (rq->rt.overloaded)
1801 : : rt_clear_overload(rq);
1802 : :
1803 : 0 : __disable_runtime(rq);
1804 : :
1805 : 0 : cpupri_set(&rq->rd->cpupri, rq->cpu, CPUPRI_INVALID);
1806 : 0 : }
1807 : :
1808 : : /*
1809 : : * When switch from the rt queue, we bring ourselves to a position
1810 : : * that we might want to pull RT tasks from other runqueues.
1811 : : */
1812 : 0 : static void switched_from_rt(struct rq *rq, struct task_struct *p)
1813 : : {
1814 : : /*
1815 : : * If there are other RT tasks then we will reschedule
1816 : : * and the scheduling of the other RT tasks will handle
1817 : : * the balancing. But if we are the last RT task
1818 : : * we may need to handle the pulling of RT tasks
1819 : : * now.
1820 : : */
1821 [ + - ][ + - ]: 2 : if (!p->on_rq || rq->rt.rt_nr_running)
1822 : 0 : return;
1823 : :
1824 [ - + ]: 2 : if (pull_rt_task(rq))
1825 : 0 : resched_task(rq->curr);
1826 : : }
1827 : :
1828 : 0 : void init_sched_rt_class(void)
1829 : : {
1830 : : unsigned int i;
1831 : :
1832 [ # # ]: 0 : for_each_possible_cpu(i) {
1833 : 0 : zalloc_cpumask_var_node(&per_cpu(local_cpu_mask, i),
1834 : : GFP_KERNEL, cpu_to_node(i));
1835 : : }
1836 : 0 : }
1837 : : #endif /* CONFIG_SMP */
1838 : :
1839 : : /*
1840 : : * When switching a task to RT, we may overload the runqueue
1841 : : * with RT tasks. In this case we try to push them off to
1842 : : * other runqueues.
1843 : : */
1844 : 0 : static void switched_to_rt(struct rq *rq, struct task_struct *p)
1845 : : {
1846 : : int check_resched = 1;
1847 : :
1848 : : /*
1849 : : * If we are already running, then there's nothing
1850 : : * that needs to be done. But if we are not running
1851 : : * we may need to preempt the current running task.
1852 : : * If that current running task is also an RT task
1853 : : * then see if we can move to another run queue.
1854 : : */
1855 [ + + ][ - + ]: 9 : if (p->on_rq && rq->curr != p) {
1856 : : #ifdef CONFIG_SMP
1857 [ # # ][ # # ]: 0 : if (rq->rt.overloaded && push_rt_task(rq) &&
[ # # ]
1858 : : /* Don't resched if we changed runqueues */
1859 : 0 : rq != task_rq(p))
1860 : : check_resched = 0;
1861 : : #endif /* CONFIG_SMP */
1862 [ # # ][ # # ]: 0 : if (check_resched && p->prio < rq->curr->prio)
1863 : 0 : resched_task(rq->curr);
1864 : : }
1865 : 0 : }
1866 : :
1867 : : /*
1868 : : * Priority of the task has changed. This may cause
1869 : : * us to initiate a push or pull.
1870 : : */
1871 : : static void
1872 : 0 : prio_changed_rt(struct rq *rq, struct task_struct *p, int oldprio)
1873 : : {
1874 [ + + ]: 66 : if (!p->on_rq)
1875 : 0 : return;
1876 : :
1877 [ + + ]: 61 : if (rq->curr == p) {
1878 : : #ifdef CONFIG_SMP
1879 : : /*
1880 : : * If our priority decreases while running, we
1881 : : * may need to pull tasks to this runqueue.
1882 : : */
1883 [ + + ]: 33 : if (oldprio < p->prio)
1884 : 17 : pull_rt_task(rq);
1885 : : /*
1886 : : * If there's a higher priority task waiting to run
1887 : : * then reschedule. Note, the above pull_rt_task
1888 : : * can release the rq lock and p could migrate.
1889 : : * Only reschedule if p is still on the same runqueue.
1890 : : */
1891 [ + + ][ + - ]: 33 : if (p->prio > rq->rt.highest_prio.curr && rq->curr == p)
1892 : 11 : resched_task(p);
1893 : : #else
1894 : : /* For UP simply resched on drop of prio */
1895 : : if (oldprio < p->prio)
1896 : : resched_task(p);
1897 : : #endif /* CONFIG_SMP */
1898 : : } else {
1899 : : /*
1900 : : * This task is not running, but if it is
1901 : : * greater than the current running task
1902 : : * then reschedule.
1903 : : */
1904 [ + + ]: 28 : if (p->prio < rq->curr->prio)
1905 : 12 : resched_task(rq->curr);
1906 : : }
1907 : : }
1908 : :
1909 : 39 : static void watchdog(struct rq *rq, struct task_struct *p)
1910 : : {
1911 : : unsigned long soft, hard;
1912 : :
1913 : : /* max may change after cur was read, this will be fixed next tick */
1914 : : soft = task_rlimit(p, RLIMIT_RTTIME);
1915 : : hard = task_rlimit_max(p, RLIMIT_RTTIME);
1916 : :
1917 [ - + ]: 39 : if (soft != RLIM_INFINITY) {
1918 : : unsigned long next;
1919 : :
1920 [ # # ]: 0 : if (p->rt.watchdog_stamp != jiffies) {
1921 : 0 : p->rt.timeout++;
1922 : 0 : p->rt.watchdog_stamp = jiffies;
1923 : : }
1924 : :
1925 : 0 : next = DIV_ROUND_UP(min(soft, hard), USEC_PER_SEC/HZ);
1926 [ # # ]: 0 : if (p->rt.timeout > next)
1927 : 0 : p->cputime_expires.sched_exp = p->se.sum_exec_runtime;
1928 : : }
1929 : 0 : }
1930 : :
1931 : 0 : static void task_tick_rt(struct rq *rq, struct task_struct *p, int queued)
1932 : : {
1933 : 39 : struct sched_rt_entity *rt_se = &p->rt;
1934 : :
1935 : 39 : update_curr_rt(rq);
1936 : :
1937 : 39 : watchdog(rq, p);
1938 : :
1939 : : /*
1940 : : * RR tasks need a special form of timeslice management.
1941 : : * FIFO tasks have no timeslices.
1942 : : */
1943 [ + + ]: 39 : if (p->policy != SCHED_RR)
1944 : : return;
1945 : :
1946 [ - + ]: 1 : if (--p->rt.time_slice)
1947 : : return;
1948 : :
1949 : 0 : p->rt.time_slice = sched_rr_timeslice;
1950 : :
1951 : : /*
1952 : : * Requeue to the end of queue if we (and all of our ancestors) are not
1953 : : * the only element on the queue
1954 : : */
1955 [ # # ]: 0 : for_each_sched_rt_entity(rt_se) {
1956 [ # # ]: 0 : if (rt_se->run_list.prev != rt_se->run_list.next) {
1957 : 0 : requeue_task_rt(rq, p, 0);
1958 : : set_tsk_need_resched(p);
1959 : : return;
1960 : : }
1961 : : }
1962 : : }
1963 : :
1964 : 0 : static void set_curr_task_rt(struct rq *rq)
1965 : : {
1966 : 41 : struct task_struct *p = rq->curr;
1967 : :
1968 : 41 : p->se.exec_start = rq_clock_task(rq);
1969 : :
1970 : : /* The running task is never eligible for pushing */
1971 : : dequeue_pushable_task(rq, p);
1972 : 41 : }
1973 : :
1974 : 0 : static unsigned int get_rr_interval_rt(struct rq *rq, struct task_struct *task)
1975 : : {
1976 : : /*
1977 : : * Time slice is 0 for SCHED_FIFO tasks
1978 : : */
1979 [ + + ]: 3 : if (task->policy == SCHED_RR)
1980 : 2 : return sched_rr_timeslice;
1981 : : else
1982 : : return 0;
1983 : : }
1984 : :
1985 : : const struct sched_class rt_sched_class = {
1986 : : .next = &fair_sched_class,
1987 : : .enqueue_task = enqueue_task_rt,
1988 : : .dequeue_task = dequeue_task_rt,
1989 : : .yield_task = yield_task_rt,
1990 : :
1991 : : .check_preempt_curr = check_preempt_curr_rt,
1992 : :
1993 : : .pick_next_task = pick_next_task_rt,
1994 : : .put_prev_task = put_prev_task_rt,
1995 : :
1996 : : #ifdef CONFIG_SMP
1997 : : .select_task_rq = select_task_rq_rt,
1998 : :
1999 : : .set_cpus_allowed = set_cpus_allowed_rt,
2000 : : .rq_online = rq_online_rt,
2001 : : .rq_offline = rq_offline_rt,
2002 : : .pre_schedule = pre_schedule_rt,
2003 : : .post_schedule = post_schedule_rt,
2004 : : .task_woken = task_woken_rt,
2005 : : .switched_from = switched_from_rt,
2006 : : #endif
2007 : :
2008 : : .set_curr_task = set_curr_task_rt,
2009 : : .task_tick = task_tick_rt,
2010 : :
2011 : : .get_rr_interval = get_rr_interval_rt,
2012 : :
2013 : : .prio_changed = prio_changed_rt,
2014 : : .switched_to = switched_to_rt,
2015 : : };
2016 : :
2017 : : #ifdef CONFIG_SCHED_DEBUG
2018 : : extern void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq);
2019 : :
2020 : 0 : void print_rt_stats(struct seq_file *m, int cpu)
2021 : : {
2022 : : rt_rq_iter_t iter;
2023 : : struct rt_rq *rt_rq;
2024 : :
2025 : : rcu_read_lock();
2026 [ + + ]: 8 : for_each_rt_rq(rt_rq, iter, cpu_rq(cpu))
2027 : 4 : print_rt_rq(m, cpu, rt_rq);
2028 : : rcu_read_unlock();
2029 : 4 : }
2030 : : #endif /* CONFIG_SCHED_DEBUG */
|
