Merge branch 'stable-3.2' into pandora-3.2
[pandora-kernel.git] / kernel / sched.c
1 /*
2  *  kernel/sched.c
3  *
4  *  Kernel scheduler and related syscalls
5  *
6  *  Copyright (C) 1991-2002  Linus Torvalds
7  *
8  *  1996-12-23  Modified by Dave Grothe to fix bugs in semaphores and
9  *              make semaphores SMP safe
10  *  1998-11-19  Implemented schedule_timeout() and related stuff
11  *              by Andrea Arcangeli
12  *  2002-01-04  New ultra-scalable O(1) scheduler by Ingo Molnar:
13  *              hybrid priority-list and round-robin design with
14  *              an array-switch method of distributing timeslices
15  *              and per-CPU runqueues.  Cleanups and useful suggestions
16  *              by Davide Libenzi, preemptible kernel bits by Robert Love.
17  *  2003-09-03  Interactivity tuning by Con Kolivas.
18  *  2004-04-02  Scheduler domains code by Nick Piggin
19  *  2007-04-15  Work begun on replacing all interactivity tuning with a
20  *              fair scheduling design by Con Kolivas.
21  *  2007-05-05  Load balancing (smp-nice) and other improvements
22  *              by Peter Williams
23  *  2007-05-06  Interactivity improvements to CFS by Mike Galbraith
24  *  2007-07-01  Group scheduling enhancements by Srivatsa Vaddagiri
25  *  2007-11-29  RT balancing improvements by Steven Rostedt, Gregory Haskins,
26  *              Thomas Gleixner, Mike Kravetz
27  */
28
29 #include <linux/mm.h>
30 #include <linux/module.h>
31 #include <linux/nmi.h>
32 #include <linux/init.h>
33 #include <linux/uaccess.h>
34 #include <linux/highmem.h>
35 #include <linux/mmu_context.h>
36 #include <linux/interrupt.h>
37 #include <linux/capability.h>
38 #include <linux/completion.h>
39 #include <linux/kernel_stat.h>
40 #include <linux/debug_locks.h>
41 #include <linux/perf_event.h>
42 #include <linux/security.h>
43 #include <linux/notifier.h>
44 #include <linux/profile.h>
45 #include <linux/freezer.h>
46 #include <linux/vmalloc.h>
47 #include <linux/blkdev.h>
48 #include <linux/delay.h>
49 #include <linux/pid_namespace.h>
50 #include <linux/smp.h>
51 #include <linux/threads.h>
52 #include <linux/timer.h>
53 #include <linux/rcupdate.h>
54 #include <linux/cpu.h>
55 #include <linux/cpuset.h>
56 #include <linux/percpu.h>
57 #include <linux/proc_fs.h>
58 #include <linux/seq_file.h>
59 #include <linux/stop_machine.h>
60 #include <linux/sysctl.h>
61 #include <linux/syscalls.h>
62 #include <linux/times.h>
63 #include <linux/tsacct_kern.h>
64 #include <linux/kprobes.h>
65 #include <linux/delayacct.h>
66 #include <linux/unistd.h>
67 #include <linux/pagemap.h>
68 #include <linux/hrtimer.h>
69 #include <linux/tick.h>
70 #include <linux/debugfs.h>
71 #include <linux/ctype.h>
72 #include <linux/ftrace.h>
73 #include <linux/slab.h>
74 #include <linux/init_task.h>
75
76 #include <asm/tlb.h>
77 #include <asm/irq_regs.h>
78 #include <asm/mutex.h>
79 #ifdef CONFIG_PARAVIRT
80 #include <asm/paravirt.h>
81 #endif
82
83 #include "sched_cpupri.h"
84 #include "workqueue_sched.h"
85 #include "sched_autogroup.h"
86
87 #define CREATE_TRACE_POINTS
88 #include <trace/events/sched.h>
89
90 /*
91  * Convert user-nice values [ -20 ... 0 ... 19 ]
92  * to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
93  * and back.
94  */
95 #define NICE_TO_PRIO(nice)      (MAX_RT_PRIO + (nice) + 20)
96 #define PRIO_TO_NICE(prio)      ((prio) - MAX_RT_PRIO - 20)
97 #define TASK_NICE(p)            PRIO_TO_NICE((p)->static_prio)
98
99 /*
100  * 'User priority' is the nice value converted to something we
101  * can work with better when scaling various scheduler parameters,
102  * it's a [ 0 ... 39 ] range.
103  */
104 #define USER_PRIO(p)            ((p)-MAX_RT_PRIO)
105 #define TASK_USER_PRIO(p)       USER_PRIO((p)->static_prio)
106 #define MAX_USER_PRIO           (USER_PRIO(MAX_PRIO))
107
108 /*
109  * Helpers for converting nanosecond timing to jiffy resolution
110  */
111 #define NS_TO_JIFFIES(TIME)     ((unsigned long)(TIME) / (NSEC_PER_SEC / HZ))
112
113 #define NICE_0_LOAD             SCHED_LOAD_SCALE
114 #define NICE_0_SHIFT            SCHED_LOAD_SHIFT
115
116 /*
117  * These are the 'tuning knobs' of the scheduler:
118  *
119  * default timeslice is 100 msecs (used only for SCHED_RR tasks).
120  * Timeslices get refilled after they expire.
121  */
122 #define DEF_TIMESLICE           (100 * HZ / 1000)
123
124 /*
125  * single value that denotes runtime == period, ie unlimited time.
126  */
127 #define RUNTIME_INF     ((u64)~0ULL)
128
129 static inline int rt_policy(int policy)
130 {
131         if (policy == SCHED_FIFO || policy == SCHED_RR)
132                 return 1;
133         return 0;
134 }
135
136 static inline int task_has_rt_policy(struct task_struct *p)
137 {
138         return rt_policy(p->policy);
139 }
140
141 /*
142  * This is the priority-queue data structure of the RT scheduling class:
143  */
144 struct rt_prio_array {
145         DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); /* include 1 bit for delimiter */
146         struct list_head queue[MAX_RT_PRIO];
147 };
148
149 struct rt_bandwidth {
150         /* nests inside the rq lock: */
151         raw_spinlock_t          rt_runtime_lock;
152         ktime_t                 rt_period;
153         u64                     rt_runtime;
154         struct hrtimer          rt_period_timer;
155 };
156
157 static struct rt_bandwidth def_rt_bandwidth;
158
159 static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun);
160
161 static enum hrtimer_restart sched_rt_period_timer(struct hrtimer *timer)
162 {
163         struct rt_bandwidth *rt_b =
164                 container_of(timer, struct rt_bandwidth, rt_period_timer);
165         ktime_t now;
166         int overrun;
167         int idle = 0;
168
169         for (;;) {
170                 now = hrtimer_cb_get_time(timer);
171                 overrun = hrtimer_forward(timer, now, rt_b->rt_period);
172
173                 if (!overrun)
174                         break;
175
176                 idle = do_sched_rt_period_timer(rt_b, overrun);
177         }
178
179         return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
180 }
181
182 static
183 void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime)
184 {
185         rt_b->rt_period = ns_to_ktime(period);
186         rt_b->rt_runtime = runtime;
187
188         raw_spin_lock_init(&rt_b->rt_runtime_lock);
189
190         hrtimer_init(&rt_b->rt_period_timer,
191                         CLOCK_MONOTONIC, HRTIMER_MODE_REL);
192         rt_b->rt_period_timer.function = sched_rt_period_timer;
193 }
194
195 static inline int rt_bandwidth_enabled(void)
196 {
197         return sysctl_sched_rt_runtime >= 0;
198 }
199
200 static void start_bandwidth_timer(struct hrtimer *period_timer, ktime_t period)
201 {
202         unsigned long delta;
203         ktime_t soft, hard, now;
204
205         for (;;) {
206                 if (hrtimer_active(period_timer))
207                         break;
208
209                 now = hrtimer_cb_get_time(period_timer);
210                 hrtimer_forward(period_timer, now, period);
211
212                 soft = hrtimer_get_softexpires(period_timer);
213                 hard = hrtimer_get_expires(period_timer);
214                 delta = ktime_to_ns(ktime_sub(hard, soft));
215                 __hrtimer_start_range_ns(period_timer, soft, delta,
216                                          HRTIMER_MODE_ABS_PINNED, 0);
217         }
218 }
219
220 static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
221 {
222         if (!rt_bandwidth_enabled() || rt_b->rt_runtime == RUNTIME_INF)
223                 return;
224
225         if (hrtimer_active(&rt_b->rt_period_timer))
226                 return;
227
228         raw_spin_lock(&rt_b->rt_runtime_lock);
229         start_bandwidth_timer(&rt_b->rt_period_timer, rt_b->rt_period);
230         raw_spin_unlock(&rt_b->rt_runtime_lock);
231 }
232
233 #ifdef CONFIG_RT_GROUP_SCHED
234 static void destroy_rt_bandwidth(struct rt_bandwidth *rt_b)
235 {
236         hrtimer_cancel(&rt_b->rt_period_timer);
237 }
238 #endif
239
240 /*
241  * sched_domains_mutex serializes calls to init_sched_domains,
242  * detach_destroy_domains and partition_sched_domains.
243  */
244 static DEFINE_MUTEX(sched_domains_mutex);
245
246 #ifdef CONFIG_CGROUP_SCHED
247
248 #include <linux/cgroup.h>
249
250 struct cfs_rq;
251
252 static LIST_HEAD(task_groups);
253
254 struct cfs_bandwidth {
255 #ifdef CONFIG_CFS_BANDWIDTH
256         raw_spinlock_t lock;
257         ktime_t period;
258         u64 quota, runtime;
259         s64 hierarchal_quota;
260         u64 runtime_expires;
261
262         int idle, timer_active;
263         struct hrtimer period_timer, slack_timer;
264         struct list_head throttled_cfs_rq;
265
266         /* statistics */
267         int nr_periods, nr_throttled;
268         u64 throttled_time;
269 #endif
270 };
271
272 /* task group related information */
273 struct task_group {
274         struct cgroup_subsys_state css;
275
276 #ifdef CONFIG_FAIR_GROUP_SCHED
277         /* schedulable entities of this group on each cpu */
278         struct sched_entity **se;
279         /* runqueue "owned" by this group on each cpu */
280         struct cfs_rq **cfs_rq;
281         unsigned long shares;
282
283         atomic_t load_weight;
284 #endif
285
286 #ifdef CONFIG_RT_GROUP_SCHED
287         struct sched_rt_entity **rt_se;
288         struct rt_rq **rt_rq;
289
290         struct rt_bandwidth rt_bandwidth;
291 #endif
292
293         struct rcu_head rcu;
294         struct list_head list;
295
296         struct task_group *parent;
297         struct list_head siblings;
298         struct list_head children;
299
300 #ifdef CONFIG_SCHED_AUTOGROUP
301         struct autogroup *autogroup;
302 #endif
303
304         struct cfs_bandwidth cfs_bandwidth;
305 };
306
307 /* task_group_lock serializes the addition/removal of task groups */
308 static DEFINE_SPINLOCK(task_group_lock);
309
310 #ifdef CONFIG_FAIR_GROUP_SCHED
311
312 # define ROOT_TASK_GROUP_LOAD   NICE_0_LOAD
313
314 /*
315  * A weight of 0 or 1 can cause arithmetics problems.
316  * A weight of a cfs_rq is the sum of weights of which entities
317  * are queued on this cfs_rq, so a weight of a entity should not be
318  * too large, so as the shares value of a task group.
319  * (The default weight is 1024 - so there's no practical
320  *  limitation from this.)
321  */
322 #define MIN_SHARES      (1UL <<  1)
323 #define MAX_SHARES      (1UL << 18)
324
325 static int root_task_group_load = ROOT_TASK_GROUP_LOAD;
326 #endif
327
328 /* Default task group.
329  *      Every task in system belong to this group at bootup.
330  */
331 struct task_group root_task_group;
332
333 #endif  /* CONFIG_CGROUP_SCHED */
334
335 /* CFS-related fields in a runqueue */
336 struct cfs_rq {
337         struct load_weight load;
338         unsigned long nr_running, h_nr_running;
339
340         u64 exec_clock;
341         u64 min_vruntime;
342 #ifndef CONFIG_64BIT
343         u64 min_vruntime_copy;
344 #endif
345
346         struct rb_root tasks_timeline;
347         struct rb_node *rb_leftmost;
348
349         struct list_head tasks;
350         struct list_head *balance_iterator;
351
352         /*
353          * 'curr' points to currently running entity on this cfs_rq.
354          * It is set to NULL otherwise (i.e when none are currently running).
355          */
356         struct sched_entity *curr, *next, *last, *skip;
357
358 #ifdef  CONFIG_SCHED_DEBUG
359         unsigned int nr_spread_over;
360 #endif
361
362 #ifdef CONFIG_FAIR_GROUP_SCHED
363         struct rq *rq;  /* cpu runqueue to which this cfs_rq is attached */
364
365         /*
366          * leaf cfs_rqs are those that hold tasks (lowest schedulable entity in
367          * a hierarchy). Non-leaf lrqs hold other higher schedulable entities
368          * (like users, containers etc.)
369          *
370          * leaf_cfs_rq_list ties together list of leaf cfs_rq's in a cpu. This
371          * list is used during load balance.
372          */
373         int on_list;
374         struct list_head leaf_cfs_rq_list;
375         struct task_group *tg;  /* group that "owns" this runqueue */
376
377 #ifdef CONFIG_SMP
378         /*
379          * the part of load.weight contributed by tasks
380          */
381         unsigned long task_weight;
382
383         /*
384          *   h_load = weight * f(tg)
385          *
386          * Where f(tg) is the recursive weight fraction assigned to
387          * this group.
388          */
389         unsigned long h_load;
390
391         /*
392          * Maintaining per-cpu shares distribution for group scheduling
393          *
394          * load_stamp is the last time we updated the load average
395          * load_last is the last time we updated the load average and saw load
396          * load_unacc_exec_time is currently unaccounted execution time
397          */
398         u64 load_avg;
399         u64 load_period;
400         u64 load_stamp, load_last, load_unacc_exec_time;
401
402         unsigned long load_contribution;
403 #endif
404 #ifdef CONFIG_CFS_BANDWIDTH
405         int runtime_enabled;
406         u64 runtime_expires;
407         s64 runtime_remaining;
408
409         u64 throttled_timestamp;
410         int throttled, throttle_count;
411         struct list_head throttled_list;
412 #endif
413 #endif
414 };
415
416 #ifdef CONFIG_FAIR_GROUP_SCHED
417 #ifdef CONFIG_CFS_BANDWIDTH
418 static inline struct cfs_bandwidth *tg_cfs_bandwidth(struct task_group *tg)
419 {
420         return &tg->cfs_bandwidth;
421 }
422
423 static inline u64 default_cfs_period(void);
424 static int do_sched_cfs_period_timer(struct cfs_bandwidth *cfs_b, int overrun);
425 static void do_sched_cfs_slack_timer(struct cfs_bandwidth *cfs_b);
426
427 static enum hrtimer_restart sched_cfs_slack_timer(struct hrtimer *timer)
428 {
429         struct cfs_bandwidth *cfs_b =
430                 container_of(timer, struct cfs_bandwidth, slack_timer);
431         do_sched_cfs_slack_timer(cfs_b);
432
433         return HRTIMER_NORESTART;
434 }
435
436 static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)
437 {
438         struct cfs_bandwidth *cfs_b =
439                 container_of(timer, struct cfs_bandwidth, period_timer);
440         ktime_t now;
441         int overrun;
442         int idle = 0;
443
444         for (;;) {
445                 now = hrtimer_cb_get_time(timer);
446                 overrun = hrtimer_forward(timer, now, cfs_b->period);
447
448                 if (!overrun)
449                         break;
450
451                 idle = do_sched_cfs_period_timer(cfs_b, overrun);
452         }
453
454         return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
455 }
456
457 static void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
458 {
459         raw_spin_lock_init(&cfs_b->lock);
460         cfs_b->runtime = 0;
461         cfs_b->quota = RUNTIME_INF;
462         cfs_b->period = ns_to_ktime(default_cfs_period());
463
464         INIT_LIST_HEAD(&cfs_b->throttled_cfs_rq);
465         hrtimer_init(&cfs_b->period_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
466         cfs_b->period_timer.function = sched_cfs_period_timer;
467         hrtimer_init(&cfs_b->slack_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
468         cfs_b->slack_timer.function = sched_cfs_slack_timer;
469 }
470
471 static void init_cfs_rq_runtime(struct cfs_rq *cfs_rq)
472 {
473         cfs_rq->runtime_enabled = 0;
474         INIT_LIST_HEAD(&cfs_rq->throttled_list);
475 }
476
477 /* requires cfs_b->lock, may release to reprogram timer */
478 static void __start_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
479 {
480         /*
481          * The timer may be active because we're trying to set a new bandwidth
482          * period or because we're racing with the tear-down path
483          * (timer_active==0 becomes visible before the hrtimer call-back
484          * terminates).  In either case we ensure that it's re-programmed
485          */
486         while (unlikely(hrtimer_active(&cfs_b->period_timer))) {
487                 raw_spin_unlock(&cfs_b->lock);
488                 /* ensure cfs_b->lock is available while we wait */
489                 hrtimer_cancel(&cfs_b->period_timer);
490
491                 raw_spin_lock(&cfs_b->lock);
492                 /* if someone else restarted the timer then we're done */
493                 if (cfs_b->timer_active)
494                         return;
495         }
496
497         cfs_b->timer_active = 1;
498         start_bandwidth_timer(&cfs_b->period_timer, cfs_b->period);
499 }
500
501 static void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
502 {
503         hrtimer_cancel(&cfs_b->period_timer);
504         hrtimer_cancel(&cfs_b->slack_timer);
505 }
506 #else
507 static void init_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
508 static void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b) {}
509 static void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b) {}
510
511 static inline struct cfs_bandwidth *tg_cfs_bandwidth(struct task_group *tg)
512 {
513         return NULL;
514 }
515 #endif /* CONFIG_CFS_BANDWIDTH */
516 #endif /* CONFIG_FAIR_GROUP_SCHED */
517
518 /* Real-Time classes' related field in a runqueue: */
519 struct rt_rq {
520         struct rt_prio_array active;
521         unsigned long rt_nr_running;
522 #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
523         struct {
524                 int curr; /* highest queued rt task prio */
525 #ifdef CONFIG_SMP
526                 int next; /* next highest */
527 #endif
528         } highest_prio;
529 #endif
530 #ifdef CONFIG_SMP
531         unsigned long rt_nr_migratory;
532         unsigned long rt_nr_total;
533         int overloaded;
534         struct plist_head pushable_tasks;
535 #endif
536         int rt_throttled;
537         u64 rt_time;
538         u64 rt_runtime;
539         /* Nests inside the rq lock: */
540         raw_spinlock_t rt_runtime_lock;
541
542 #ifdef CONFIG_RT_GROUP_SCHED
543         unsigned long rt_nr_boosted;
544
545         struct rq *rq;
546         struct list_head leaf_rt_rq_list;
547         struct task_group *tg;
548 #endif
549 };
550
551 #ifdef CONFIG_SMP
552
553 /*
554  * We add the notion of a root-domain which will be used to define per-domain
555  * variables. Each exclusive cpuset essentially defines an island domain by
556  * fully partitioning the member cpus from any other cpuset. Whenever a new
557  * exclusive cpuset is created, we also create and attach a new root-domain
558  * object.
559  *
560  */
561 struct root_domain {
562         atomic_t refcount;
563         atomic_t rto_count;
564         struct rcu_head rcu;
565         cpumask_var_t span;
566         cpumask_var_t online;
567
568         /*
569          * The "RT overload" flag: it gets set if a CPU has more than
570          * one runnable RT task.
571          */
572         cpumask_var_t rto_mask;
573         struct cpupri cpupri;
574 };
575
576 /*
577  * By default the system creates a single root-domain with all cpus as
578  * members (mimicking the global state we have today).
579  */
580 static struct root_domain def_root_domain;
581
582 #endif /* CONFIG_SMP */
583
584 /*
585  * This is the main, per-CPU runqueue data structure.
586  *
587  * Locking rule: those places that want to lock multiple runqueues
588  * (such as the load balancing or the thread migration code), lock
589  * acquire operations must be ordered by ascending &runqueue.
590  */
591 struct rq {
592         /* runqueue lock: */
593         raw_spinlock_t lock;
594
595         /*
596          * nr_running and cpu_load should be in the same cacheline because
597          * remote CPUs use both these fields when doing load calculation.
598          */
599         unsigned long nr_running;
600         #define CPU_LOAD_IDX_MAX 5
601         unsigned long cpu_load[CPU_LOAD_IDX_MAX];
602         unsigned long last_load_update_tick;
603 #ifdef CONFIG_NO_HZ
604         u64 nohz_stamp;
605         unsigned char nohz_balance_kick;
606 #endif
607         int skip_clock_update;
608
609         /* capture load from *all* tasks on this cpu: */
610         struct load_weight load;
611         unsigned long nr_load_updates;
612         u64 nr_switches;
613
614         struct cfs_rq cfs;
615         struct rt_rq rt;
616
617 #ifdef CONFIG_FAIR_GROUP_SCHED
618         /* list of leaf cfs_rq on this cpu: */
619         struct list_head leaf_cfs_rq_list;
620 #endif
621 #ifdef CONFIG_RT_GROUP_SCHED
622         struct list_head leaf_rt_rq_list;
623 #endif
624
625         /*
626          * This is part of a global counter where only the total sum
627          * over all CPUs matters. A task can increase this counter on
628          * one CPU and if it got migrated afterwards it may decrease
629          * it on another CPU. Always updated under the runqueue lock:
630          */
631         unsigned long nr_uninterruptible;
632
633         struct task_struct *curr, *idle, *stop;
634         unsigned long next_balance;
635         struct mm_struct *prev_mm;
636
637         u64 clock;
638         u64 clock_task;
639
640         atomic_t nr_iowait;
641
642 #ifdef CONFIG_SMP
643         struct root_domain *rd;
644         struct sched_domain *sd;
645
646         unsigned long cpu_power;
647
648         unsigned char idle_balance;
649         /* For active balancing */
650         int post_schedule;
651         int active_balance;
652         int push_cpu;
653         struct cpu_stop_work active_balance_work;
654         /* cpu of this runqueue: */
655         int cpu;
656         int online;
657
658         u64 rt_avg;
659         u64 age_stamp;
660         u64 idle_stamp;
661         u64 avg_idle;
662 #endif
663
664 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
665         u64 prev_irq_time;
666 #endif
667 #ifdef CONFIG_PARAVIRT
668         u64 prev_steal_time;
669 #endif
670 #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
671         u64 prev_steal_time_rq;
672 #endif
673
674         /* calc_load related fields */
675         unsigned long calc_load_update;
676         long calc_load_active;
677
678 #ifdef CONFIG_SCHED_HRTICK
679 #ifdef CONFIG_SMP
680         int hrtick_csd_pending;
681         struct call_single_data hrtick_csd;
682 #endif
683         struct hrtimer hrtick_timer;
684 #endif
685
686 #ifdef CONFIG_SCHEDSTATS
687         /* latency stats */
688         struct sched_info rq_sched_info;
689         unsigned long long rq_cpu_time;
690         /* could above be rq->cfs_rq.exec_clock + rq->rt_rq.rt_runtime ? */
691
692         /* sys_sched_yield() stats */
693         unsigned int yld_count;
694
695         /* schedule() stats */
696         unsigned int sched_switch;
697         unsigned int sched_count;
698         unsigned int sched_goidle;
699
700         /* try_to_wake_up() stats */
701         unsigned int ttwu_count;
702         unsigned int ttwu_local;
703 #endif
704
705 #ifdef CONFIG_SMP
706         struct llist_head wake_list;
707 #endif
708 };
709
710 static DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
711
712
713 static void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags);
714
715 static inline int cpu_of(struct rq *rq)
716 {
717 #ifdef CONFIG_SMP
718         return rq->cpu;
719 #else
720         return 0;
721 #endif
722 }
723
724 #define rcu_dereference_check_sched_domain(p) \
725         rcu_dereference_check((p), \
726                               lockdep_is_held(&sched_domains_mutex))
727
728 /*
729  * The domain tree (rq->sd) is protected by RCU's quiescent state transition.
730  * See detach_destroy_domains: synchronize_sched for details.
731  *
732  * The domain tree of any CPU may only be accessed from within
733  * preempt-disabled sections.
734  */
735 #define for_each_domain(cpu, __sd) \
736         for (__sd = rcu_dereference_check_sched_domain(cpu_rq(cpu)->sd); __sd; __sd = __sd->parent)
737
738 #define cpu_rq(cpu)             (&per_cpu(runqueues, (cpu)))
739 #define this_rq()               (&__get_cpu_var(runqueues))
740 #define task_rq(p)              cpu_rq(task_cpu(p))
741 #define cpu_curr(cpu)           (cpu_rq(cpu)->curr)
742 #define raw_rq()                (&__raw_get_cpu_var(runqueues))
743
744 #ifdef CONFIG_CGROUP_SCHED
745
746 /*
747  * Return the group to which this tasks belongs.
748  *
749  * We cannot use task_subsys_state() and friends because the cgroup
750  * subsystem changes that value before the cgroup_subsys::attach() method
751  * is called, therefore we cannot pin it and might observe the wrong value.
752  *
753  * The same is true for autogroup's p->signal->autogroup->tg, the autogroup
754  * core changes this before calling sched_move_task().
755  *
756  * Instead we use a 'copy' which is updated from sched_move_task() while
757  * holding both task_struct::pi_lock and rq::lock.
758  */
759 static inline struct task_group *task_group(struct task_struct *p)
760 {
761         return p->sched_task_group;
762 }
763
764 /* Change a task's cfs_rq and parent entity if it moves across CPUs/groups */
765 static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
766 {
767 #ifdef CONFIG_FAIR_GROUP_SCHED
768         p->se.cfs_rq = task_group(p)->cfs_rq[cpu];
769         p->se.parent = task_group(p)->se[cpu];
770 #endif
771
772 #ifdef CONFIG_RT_GROUP_SCHED
773         p->rt.rt_rq  = task_group(p)->rt_rq[cpu];
774         p->rt.parent = task_group(p)->rt_se[cpu];
775 #endif
776 }
777
778 #else /* CONFIG_CGROUP_SCHED */
779
780 static inline void set_task_rq(struct task_struct *p, unsigned int cpu) { }
781 static inline struct task_group *task_group(struct task_struct *p)
782 {
783         return NULL;
784 }
785
786 #endif /* CONFIG_CGROUP_SCHED */
787
788 static void update_rq_clock_task(struct rq *rq, s64 delta);
789
790 static void update_rq_clock(struct rq *rq)
791 {
792         s64 delta;
793
794         if (rq->skip_clock_update > 0)
795                 return;
796
797         delta = sched_clock_cpu(cpu_of(rq)) - rq->clock;
798         rq->clock += delta;
799         update_rq_clock_task(rq, delta);
800 }
801
802 /*
803  * Tunables that become constants when CONFIG_SCHED_DEBUG is off:
804  */
805 #ifdef CONFIG_SCHED_DEBUG
806 # define const_debug __read_mostly
807 #else
808 # define const_debug static const
809 #endif
810
811 /**
812  * runqueue_is_locked - Returns true if the current cpu runqueue is locked
813  * @cpu: the processor in question.
814  *
815  * This interface allows printk to be called with the runqueue lock
816  * held and know whether or not it is OK to wake up the klogd.
817  */
818 int runqueue_is_locked(int cpu)
819 {
820         return raw_spin_is_locked(&cpu_rq(cpu)->lock);
821 }
822
823 /*
824  * Debugging: various feature bits
825  */
826
827 #define SCHED_FEAT(name, enabled)       \
828         __SCHED_FEAT_##name ,
829
830 enum {
831 #include "sched_features.h"
832 };
833
834 #undef SCHED_FEAT
835
836 #define SCHED_FEAT(name, enabled)       \
837         (1UL << __SCHED_FEAT_##name) * enabled |
838
839 const_debug unsigned int sysctl_sched_features =
840 #include "sched_features.h"
841         0;
842
843 #undef SCHED_FEAT
844
845 #ifdef CONFIG_SCHED_DEBUG
846 #define SCHED_FEAT(name, enabled)       \
847         #name ,
848
849 static __read_mostly char *sched_feat_names[] = {
850 #include "sched_features.h"
851         NULL
852 };
853
854 #undef SCHED_FEAT
855
856 static int sched_feat_show(struct seq_file *m, void *v)
857 {
858         int i;
859
860         for (i = 0; sched_feat_names[i]; i++) {
861                 if (!(sysctl_sched_features & (1UL << i)))
862                         seq_puts(m, "NO_");
863                 seq_printf(m, "%s ", sched_feat_names[i]);
864         }
865         seq_puts(m, "\n");
866
867         return 0;
868 }
869
870 static ssize_t
871 sched_feat_write(struct file *filp, const char __user *ubuf,
872                 size_t cnt, loff_t *ppos)
873 {
874         char buf[64];
875         char *cmp;
876         int neg = 0;
877         int i;
878
879         if (cnt > 63)
880                 cnt = 63;
881
882         if (copy_from_user(&buf, ubuf, cnt))
883                 return -EFAULT;
884
885         buf[cnt] = 0;
886         cmp = strstrip(buf);
887
888         if (strncmp(cmp, "NO_", 3) == 0) {
889                 neg = 1;
890                 cmp += 3;
891         }
892
893         for (i = 0; sched_feat_names[i]; i++) {
894                 if (strcmp(cmp, sched_feat_names[i]) == 0) {
895                         if (neg)
896                                 sysctl_sched_features &= ~(1UL << i);
897                         else
898                                 sysctl_sched_features |= (1UL << i);
899                         break;
900                 }
901         }
902
903         if (!sched_feat_names[i])
904                 return -EINVAL;
905
906         *ppos += cnt;
907
908         return cnt;
909 }
910
911 static int sched_feat_open(struct inode *inode, struct file *filp)
912 {
913         return single_open(filp, sched_feat_show, NULL);
914 }
915
916 static const struct file_operations sched_feat_fops = {
917         .open           = sched_feat_open,
918         .write          = sched_feat_write,
919         .read           = seq_read,
920         .llseek         = seq_lseek,
921         .release        = single_release,
922 };
923
924 static __init int sched_init_debug(void)
925 {
926         debugfs_create_file("sched_features", 0644, NULL, NULL,
927                         &sched_feat_fops);
928
929         return 0;
930 }
931 late_initcall(sched_init_debug);
932
933 #endif
934
935 #define sched_feat(x) (sysctl_sched_features & (1UL << __SCHED_FEAT_##x))
936
937 /*
938  * Number of tasks to iterate in a single balance run.
939  * Limited because this is done with IRQs disabled.
940  */
941 const_debug unsigned int sysctl_sched_nr_migrate = 32;
942
943 /*
944  * period over which we average the RT time consumption, measured
945  * in ms.
946  *
947  * default: 1s
948  */
949 const_debug unsigned int sysctl_sched_time_avg = MSEC_PER_SEC;
950
951 /*
952  * period over which we measure -rt task cpu usage in us.
953  * default: 1s
954  */
955 unsigned int sysctl_sched_rt_period = 1000000;
956
957 static __read_mostly int scheduler_running;
958
959 /*
960  * part of the period that we allow rt tasks to run in us.
961  * default: 0.95s
962  */
963 int sysctl_sched_rt_runtime = 950000;
964
965 static inline u64 global_rt_period(void)
966 {
967         return (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
968 }
969
970 static inline u64 global_rt_runtime(void)
971 {
972         if (sysctl_sched_rt_runtime < 0)
973                 return RUNTIME_INF;
974
975         return (u64)sysctl_sched_rt_runtime * NSEC_PER_USEC;
976 }
977
978 #ifndef prepare_arch_switch
979 # define prepare_arch_switch(next)      do { } while (0)
980 #endif
981 #ifndef finish_arch_switch
982 # define finish_arch_switch(prev)       do { } while (0)
983 #endif
984
985 static inline int task_current(struct rq *rq, struct task_struct *p)
986 {
987         return rq->curr == p;
988 }
989
990 static inline int task_running(struct rq *rq, struct task_struct *p)
991 {
992 #ifdef CONFIG_SMP
993         return p->on_cpu;
994 #else
995         return task_current(rq, p);
996 #endif
997 }
998
999 #ifndef __ARCH_WANT_UNLOCKED_CTXSW
1000 static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
1001 {
1002 #ifdef CONFIG_SMP
1003         /*
1004          * We can optimise this out completely for !SMP, because the
1005          * SMP rebalancing from interrupt is the only thing that cares
1006          * here.
1007          */
1008         next->on_cpu = 1;
1009 #endif
1010 }
1011
1012 static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
1013 {
1014 #ifdef CONFIG_SMP
1015         /*
1016          * After ->on_cpu is cleared, the task can be moved to a different CPU.
1017          * We must ensure this doesn't happen until the switch is completely
1018          * finished.
1019          *
1020          * Pairs with the control dependency and rmb in try_to_wake_up().
1021          */
1022         smp_mb();
1023         prev->on_cpu = 0;
1024 #endif
1025 #ifdef CONFIG_DEBUG_SPINLOCK
1026         /* this is a valid case when another task releases the spinlock */
1027         rq->lock.owner = current;
1028 #endif
1029         /*
1030          * If we are tracking spinlock dependencies then we have to
1031          * fix up the runqueue lock - which gets 'carried over' from
1032          * prev into current:
1033          */
1034         spin_acquire(&rq->lock.dep_map, 0, 0, _THIS_IP_);
1035
1036         raw_spin_unlock_irq(&rq->lock);
1037 }
1038
1039 #else /* __ARCH_WANT_UNLOCKED_CTXSW */
1040 static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
1041 {
1042 #ifdef CONFIG_SMP
1043         /*
1044          * We can optimise this out completely for !SMP, because the
1045          * SMP rebalancing from interrupt is the only thing that cares
1046          * here.
1047          */
1048         next->on_cpu = 1;
1049 #endif
1050 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
1051         raw_spin_unlock_irq(&rq->lock);
1052 #else
1053         raw_spin_unlock(&rq->lock);
1054 #endif
1055 }
1056
1057 static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
1058 {
1059 #ifdef CONFIG_SMP
1060         /*
1061          * After ->on_cpu is cleared, the task can be moved to a different CPU.
1062          * We must ensure this doesn't happen until the switch is completely
1063          * finished.
1064          */
1065         smp_wmb();
1066         prev->on_cpu = 0;
1067 #endif
1068 #ifndef __ARCH_WANT_INTERRUPTS_ON_CTXSW
1069         local_irq_enable();
1070 #endif
1071 }
1072 #endif /* __ARCH_WANT_UNLOCKED_CTXSW */
1073
1074 /*
1075  * __task_rq_lock - lock the rq @p resides on.
1076  */
1077 static inline struct rq *__task_rq_lock(struct task_struct *p)
1078         __acquires(rq->lock)
1079 {
1080         struct rq *rq;
1081
1082         lockdep_assert_held(&p->pi_lock);
1083
1084         for (;;) {
1085                 rq = task_rq(p);
1086                 raw_spin_lock(&rq->lock);
1087                 if (likely(rq == task_rq(p)))
1088                         return rq;
1089                 raw_spin_unlock(&rq->lock);
1090         }
1091 }
1092
1093 /*
1094  * task_rq_lock - lock p->pi_lock and lock the rq @p resides on.
1095  */
1096 static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
1097         __acquires(p->pi_lock)
1098         __acquires(rq->lock)
1099 {
1100         struct rq *rq;
1101
1102         for (;;) {
1103                 raw_spin_lock_irqsave(&p->pi_lock, *flags);
1104                 rq = task_rq(p);
1105                 raw_spin_lock(&rq->lock);
1106                 if (likely(rq == task_rq(p)))
1107                         return rq;
1108                 raw_spin_unlock(&rq->lock);
1109                 raw_spin_unlock_irqrestore(&p->pi_lock, *flags);
1110         }
1111 }
1112
1113 static void __task_rq_unlock(struct rq *rq)
1114         __releases(rq->lock)
1115 {
1116         raw_spin_unlock(&rq->lock);
1117 }
1118
1119 static inline void
1120 task_rq_unlock(struct rq *rq, struct task_struct *p, unsigned long *flags)
1121         __releases(rq->lock)
1122         __releases(p->pi_lock)
1123 {
1124         raw_spin_unlock(&rq->lock);
1125         raw_spin_unlock_irqrestore(&p->pi_lock, *flags);
1126 }
1127
1128 /*
1129  * this_rq_lock - lock this runqueue and disable interrupts.
1130  */
1131 static struct rq *this_rq_lock(void)
1132         __acquires(rq->lock)
1133 {
1134         struct rq *rq;
1135
1136         local_irq_disable();
1137         rq = this_rq();
1138         raw_spin_lock(&rq->lock);
1139
1140         return rq;
1141 }
1142
1143 #ifdef CONFIG_SCHED_HRTICK
1144 /*
1145  * Use HR-timers to deliver accurate preemption points.
1146  *
1147  * Its all a bit involved since we cannot program an hrt while holding the
1148  * rq->lock. So what we do is store a state in in rq->hrtick_* and ask for a
1149  * reschedule event.
1150  *
1151  * When we get rescheduled we reprogram the hrtick_timer outside of the
1152  * rq->lock.
1153  */
1154
1155 /*
1156  * Use hrtick when:
1157  *  - enabled by features
1158  *  - hrtimer is actually high res
1159  */
1160 static inline int hrtick_enabled(struct rq *rq)
1161 {
1162         if (!sched_feat(HRTICK))
1163                 return 0;
1164         if (!cpu_active(cpu_of(rq)))
1165                 return 0;
1166         return hrtimer_is_hres_active(&rq->hrtick_timer);
1167 }
1168
1169 static void hrtick_clear(struct rq *rq)
1170 {
1171         if (hrtimer_active(&rq->hrtick_timer))
1172                 hrtimer_cancel(&rq->hrtick_timer);
1173 }
1174
1175 /*
1176  * High-resolution timer tick.
1177  * Runs from hardirq context with interrupts disabled.
1178  */
1179 static enum hrtimer_restart hrtick(struct hrtimer *timer)
1180 {
1181         struct rq *rq = container_of(timer, struct rq, hrtick_timer);
1182
1183         WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());
1184
1185         raw_spin_lock(&rq->lock);
1186         update_rq_clock(rq);
1187         rq->curr->sched_class->task_tick(rq, rq->curr, 1);
1188         raw_spin_unlock(&rq->lock);
1189
1190         return HRTIMER_NORESTART;
1191 }
1192
1193 #ifdef CONFIG_SMP
1194 /*
1195  * called from hardirq (IPI) context
1196  */
1197 static void __hrtick_start(void *arg)
1198 {
1199         struct rq *rq = arg;
1200
1201         raw_spin_lock(&rq->lock);
1202         hrtimer_restart(&rq->hrtick_timer);
1203         rq->hrtick_csd_pending = 0;
1204         raw_spin_unlock(&rq->lock);
1205 }
1206
1207 /*
1208  * Called to set the hrtick timer state.
1209  *
1210  * called with rq->lock held and irqs disabled
1211  */
1212 static void hrtick_start(struct rq *rq, u64 delay)
1213 {
1214         struct hrtimer *timer = &rq->hrtick_timer;
1215         ktime_t time = ktime_add_ns(timer->base->get_time(), delay);
1216
1217         hrtimer_set_expires(timer, time);
1218
1219         if (rq == this_rq()) {
1220                 hrtimer_restart(timer);
1221         } else if (!rq->hrtick_csd_pending) {
1222                 __smp_call_function_single(cpu_of(rq), &rq->hrtick_csd, 0);
1223                 rq->hrtick_csd_pending = 1;
1224         }
1225 }
1226
1227 static int
1228 hotplug_hrtick(struct notifier_block *nfb, unsigned long action, void *hcpu)
1229 {
1230         int cpu = (int)(long)hcpu;
1231
1232         switch (action) {
1233         case CPU_UP_CANCELED:
1234         case CPU_UP_CANCELED_FROZEN:
1235         case CPU_DOWN_PREPARE:
1236         case CPU_DOWN_PREPARE_FROZEN:
1237         case CPU_DEAD:
1238         case CPU_DEAD_FROZEN:
1239                 hrtick_clear(cpu_rq(cpu));
1240                 return NOTIFY_OK;
1241         }
1242
1243         return NOTIFY_DONE;
1244 }
1245
1246 static __init void init_hrtick(void)
1247 {
1248         hotcpu_notifier(hotplug_hrtick, 0);
1249 }
1250 #else
1251 /*
1252  * Called to set the hrtick timer state.
1253  *
1254  * called with rq->lock held and irqs disabled
1255  */
1256 static void hrtick_start(struct rq *rq, u64 delay)
1257 {
1258         __hrtimer_start_range_ns(&rq->hrtick_timer, ns_to_ktime(delay), 0,
1259                         HRTIMER_MODE_REL_PINNED, 0);
1260 }
1261
1262 static inline void init_hrtick(void)
1263 {
1264 }
1265 #endif /* CONFIG_SMP */
1266
1267 static void init_rq_hrtick(struct rq *rq)
1268 {
1269 #ifdef CONFIG_SMP
1270         rq->hrtick_csd_pending = 0;
1271
1272         rq->hrtick_csd.flags = 0;
1273         rq->hrtick_csd.func = __hrtick_start;
1274         rq->hrtick_csd.info = rq;
1275 #endif
1276
1277         hrtimer_init(&rq->hrtick_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1278         rq->hrtick_timer.function = hrtick;
1279 }
1280 #else   /* CONFIG_SCHED_HRTICK */
1281 static inline void hrtick_clear(struct rq *rq)
1282 {
1283 }
1284
1285 static inline void init_rq_hrtick(struct rq *rq)
1286 {
1287 }
1288
1289 static inline void init_hrtick(void)
1290 {
1291 }
1292 #endif  /* CONFIG_SCHED_HRTICK */
1293
1294 /*
1295  * resched_task - mark a task 'to be rescheduled now'.
1296  *
1297  * On UP this means the setting of the need_resched flag, on SMP it
1298  * might also involve a cross-CPU call to trigger the scheduler on
1299  * the target CPU.
1300  */
1301 #ifdef CONFIG_SMP
1302
1303 #ifndef tsk_is_polling
1304 #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG)
1305 #endif
1306
1307 static void resched_task(struct task_struct *p)
1308 {
1309         int cpu;
1310
1311         assert_raw_spin_locked(&task_rq(p)->lock);
1312
1313         if (test_tsk_need_resched(p))
1314                 return;
1315
1316         set_tsk_need_resched(p);
1317
1318         cpu = task_cpu(p);
1319         if (cpu == smp_processor_id())
1320                 return;
1321
1322         /* NEED_RESCHED must be visible before we test polling */
1323         smp_mb();
1324         if (!tsk_is_polling(p))
1325                 smp_send_reschedule(cpu);
1326 }
1327
1328 static void resched_cpu(int cpu)
1329 {
1330         struct rq *rq = cpu_rq(cpu);
1331         unsigned long flags;
1332
1333         if (!raw_spin_trylock_irqsave(&rq->lock, flags))
1334                 return;
1335         resched_task(cpu_curr(cpu));
1336         raw_spin_unlock_irqrestore(&rq->lock, flags);
1337 }
1338
1339 #ifdef CONFIG_NO_HZ
1340 /*
1341  * In the semi idle case, use the nearest busy cpu for migrating timers
1342  * from an idle cpu.  This is good for power-savings.
1343  *
1344  * We don't do similar optimization for completely idle system, as
1345  * selecting an idle cpu will add more delays to the timers than intended
1346  * (as that cpu's timer base may not be uptodate wrt jiffies etc).
1347  */
1348 int get_nohz_timer_target(void)
1349 {
1350         int cpu = smp_processor_id();
1351         int i;
1352         struct sched_domain *sd;
1353
1354         rcu_read_lock();
1355         for_each_domain(cpu, sd) {
1356                 for_each_cpu(i, sched_domain_span(sd)) {
1357                         if (!idle_cpu(i)) {
1358                                 cpu = i;
1359                                 goto unlock;
1360                         }
1361                 }
1362         }
1363 unlock:
1364         rcu_read_unlock();
1365         return cpu;
1366 }
1367 /*
1368  * When add_timer_on() enqueues a timer into the timer wheel of an
1369  * idle CPU then this timer might expire before the next timer event
1370  * which is scheduled to wake up that CPU. In case of a completely
1371  * idle system the next event might even be infinite time into the
1372  * future. wake_up_idle_cpu() ensures that the CPU is woken up and
1373  * leaves the inner idle loop so the newly added timer is taken into
1374  * account when the CPU goes back to idle and evaluates the timer
1375  * wheel for the next timer event.
1376  */
1377 void wake_up_idle_cpu(int cpu)
1378 {
1379         struct rq *rq = cpu_rq(cpu);
1380
1381         if (cpu == smp_processor_id())
1382                 return;
1383
1384         /*
1385          * This is safe, as this function is called with the timer
1386          * wheel base lock of (cpu) held. When the CPU is on the way
1387          * to idle and has not yet set rq->curr to idle then it will
1388          * be serialized on the timer wheel base lock and take the new
1389          * timer into account automatically.
1390          */
1391         if (rq->curr != rq->idle)
1392                 return;
1393
1394         /*
1395          * We can set TIF_RESCHED on the idle task of the other CPU
1396          * lockless. The worst case is that the other CPU runs the
1397          * idle task through an additional NOOP schedule()
1398          */
1399         set_tsk_need_resched(rq->idle);
1400
1401         /* NEED_RESCHED must be visible before we test polling */
1402         smp_mb();
1403         if (!tsk_is_polling(rq->idle))
1404                 smp_send_reschedule(cpu);
1405 }
1406
1407 static inline bool got_nohz_idle_kick(void)
1408 {
1409         return idle_cpu(smp_processor_id()) && this_rq()->nohz_balance_kick;
1410 }
1411
1412 #else /* CONFIG_NO_HZ */
1413
1414 static inline bool got_nohz_idle_kick(void)
1415 {
1416         return false;
1417 }
1418
1419 #endif /* CONFIG_NO_HZ */
1420
1421 static u64 sched_avg_period(void)
1422 {
1423         return (u64)sysctl_sched_time_avg * NSEC_PER_MSEC / 2;
1424 }
1425
1426 static void sched_avg_update(struct rq *rq)
1427 {
1428         s64 period = sched_avg_period();
1429
1430         while ((s64)(rq->clock - rq->age_stamp) > period) {
1431                 /*
1432                  * Inline assembly required to prevent the compiler
1433                  * optimising this loop into a divmod call.
1434                  * See __iter_div_u64_rem() for another example of this.
1435                  */
1436                 asm("" : "+rm" (rq->age_stamp));
1437                 rq->age_stamp += period;
1438                 rq->rt_avg /= 2;
1439         }
1440 }
1441
1442 static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
1443 {
1444         rq->rt_avg += rt_delta;
1445         sched_avg_update(rq);
1446 }
1447
1448 #else /* !CONFIG_SMP */
1449 static void resched_task(struct task_struct *p)
1450 {
1451         assert_raw_spin_locked(&task_rq(p)->lock);
1452         set_tsk_need_resched(p);
1453 }
1454
1455 static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
1456 {
1457 }
1458
1459 static void sched_avg_update(struct rq *rq)
1460 {
1461 }
1462 #endif /* CONFIG_SMP */
1463
1464 #if BITS_PER_LONG == 32
1465 # define WMULT_CONST    (~0UL)
1466 #else
1467 # define WMULT_CONST    (1UL << 32)
1468 #endif
1469
1470 #define WMULT_SHIFT     32
1471
1472 /*
1473  * Shift right and round:
1474  */
1475 #define SRR(x, y) (((x) + (1UL << ((y) - 1))) >> (y))
1476
1477 /*
1478  * delta *= weight / lw
1479  */
1480 static unsigned long
1481 calc_delta_mine(unsigned long delta_exec, unsigned long weight,
1482                 struct load_weight *lw)
1483 {
1484         u64 tmp;
1485
1486         /*
1487          * weight can be less than 2^SCHED_LOAD_RESOLUTION for task group sched
1488          * entities since MIN_SHARES = 2. Treat weight as 1 if less than
1489          * 2^SCHED_LOAD_RESOLUTION.
1490          */
1491         if (likely(weight > (1UL << SCHED_LOAD_RESOLUTION)))
1492                 tmp = (u64)delta_exec * scale_load_down(weight);
1493         else
1494                 tmp = (u64)delta_exec;
1495
1496         if (!lw->inv_weight) {
1497                 unsigned long w = scale_load_down(lw->weight);
1498
1499                 if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
1500                         lw->inv_weight = 1;
1501                 else if (unlikely(!w))
1502                         lw->inv_weight = WMULT_CONST;
1503                 else
1504                         lw->inv_weight = WMULT_CONST / w;
1505         }
1506
1507         /*
1508          * Check whether we'd overflow the 64-bit multiplication:
1509          */
1510         if (unlikely(tmp > WMULT_CONST))
1511                 tmp = SRR(SRR(tmp, WMULT_SHIFT/2) * lw->inv_weight,
1512                         WMULT_SHIFT/2);
1513         else
1514                 tmp = SRR(tmp * lw->inv_weight, WMULT_SHIFT);
1515
1516         return (unsigned long)min(tmp, (u64)(unsigned long)LONG_MAX);
1517 }
1518
1519 static inline void update_load_add(struct load_weight *lw, unsigned long inc)
1520 {
1521         lw->weight += inc;
1522         lw->inv_weight = 0;
1523 }
1524
1525 static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
1526 {
1527         lw->weight -= dec;
1528         lw->inv_weight = 0;
1529 }
1530
1531 static inline void update_load_set(struct load_weight *lw, unsigned long w)
1532 {
1533         lw->weight = w;
1534         lw->inv_weight = 0;
1535 }
1536
1537 /*
1538  * To aid in avoiding the subversion of "niceness" due to uneven distribution
1539  * of tasks with abnormal "nice" values across CPUs the contribution that
1540  * each task makes to its run queue's load is weighted according to its
1541  * scheduling class and "nice" value. For SCHED_NORMAL tasks this is just a
1542  * scaled version of the new time slice allocation that they receive on time
1543  * slice expiry etc.
1544  */
1545
1546 #define WEIGHT_IDLEPRIO                3
1547 #define WMULT_IDLEPRIO         1431655765
1548
1549 /*
1550  * Nice levels are multiplicative, with a gentle 10% change for every
1551  * nice level changed. I.e. when a CPU-bound task goes from nice 0 to
1552  * nice 1, it will get ~10% less CPU time than another CPU-bound task
1553  * that remained on nice 0.
1554  *
1555  * The "10% effect" is relative and cumulative: from _any_ nice level,
1556  * if you go up 1 level, it's -10% CPU usage, if you go down 1 level
1557  * it's +10% CPU usage. (to achieve that we use a multiplier of 1.25.
1558  * If a task goes up by ~10% and another task goes down by ~10% then
1559  * the relative distance between them is ~25%.)
1560  */
1561 static const int prio_to_weight[40] = {
1562  /* -20 */     88761,     71755,     56483,     46273,     36291,
1563  /* -15 */     29154,     23254,     18705,     14949,     11916,
1564  /* -10 */      9548,      7620,      6100,      4904,      3906,
1565  /*  -5 */      3121,      2501,      1991,      1586,      1277,
1566  /*   0 */      1024,       820,       655,       526,       423,
1567  /*   5 */       335,       272,       215,       172,       137,
1568  /*  10 */       110,        87,        70,        56,        45,
1569  /*  15 */        36,        29,        23,        18,        15,
1570 };
1571
1572 /*
1573  * Inverse (2^32/x) values of the prio_to_weight[] array, precalculated.
1574  *
1575  * In cases where the weight does not change often, we can use the
1576  * precalculated inverse to speed up arithmetics by turning divisions
1577  * into multiplications:
1578  */
1579 static const u32 prio_to_wmult[40] = {
1580  /* -20 */     48388,     59856,     76040,     92818,    118348,
1581  /* -15 */    147320,    184698,    229616,    287308,    360437,
1582  /* -10 */    449829,    563644,    704093,    875809,   1099582,
1583  /*  -5 */   1376151,   1717300,   2157191,   2708050,   3363326,
1584  /*   0 */   4194304,   5237765,   6557202,   8165337,  10153587,
1585  /*   5 */  12820798,  15790321,  19976592,  24970740,  31350126,
1586  /*  10 */  39045157,  49367440,  61356676,  76695844,  95443717,
1587  /*  15 */ 119304647, 148102320, 186737708, 238609294, 286331153,
1588 };
1589
1590 /* Time spent by the tasks of the cpu accounting group executing in ... */
1591 enum cpuacct_stat_index {
1592         CPUACCT_STAT_USER,      /* ... user mode */
1593         CPUACCT_STAT_SYSTEM,    /* ... kernel mode */
1594
1595         CPUACCT_STAT_NSTATS,
1596 };
1597
1598 #ifdef CONFIG_CGROUP_CPUACCT
1599 static void cpuacct_charge(struct task_struct *tsk, u64 cputime);
1600 static void cpuacct_update_stats(struct task_struct *tsk,
1601                 enum cpuacct_stat_index idx, cputime_t val);
1602 #else
1603 static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}
1604 static inline void cpuacct_update_stats(struct task_struct *tsk,
1605                 enum cpuacct_stat_index idx, cputime_t val) {}
1606 #endif
1607
1608 static inline void inc_cpu_load(struct rq *rq, unsigned long load)
1609 {
1610         update_load_add(&rq->load, load);
1611 }
1612
1613 static inline void dec_cpu_load(struct rq *rq, unsigned long load)
1614 {
1615         update_load_sub(&rq->load, load);
1616 }
1617
1618 #if defined(CONFIG_RT_GROUP_SCHED) || (defined(CONFIG_FAIR_GROUP_SCHED) && \
1619                         (defined(CONFIG_SMP) || defined(CONFIG_CFS_BANDWIDTH)))
1620 typedef int (*tg_visitor)(struct task_group *, void *);
1621
1622 /*
1623  * Iterate task_group tree rooted at *from, calling @down when first entering a
1624  * node and @up when leaving it for the final time.
1625  *
1626  * Caller must hold rcu_lock or sufficient equivalent.
1627  */
1628 static int walk_tg_tree_from(struct task_group *from,
1629                              tg_visitor down, tg_visitor up, void *data)
1630 {
1631         struct task_group *parent, *child;
1632         int ret;
1633
1634         parent = from;
1635
1636 down:
1637         ret = (*down)(parent, data);
1638         if (ret)
1639                 goto out;
1640         list_for_each_entry_rcu(child, &parent->children, siblings) {
1641                 parent = child;
1642                 goto down;
1643
1644 up:
1645                 continue;
1646         }
1647         ret = (*up)(parent, data);
1648         if (ret || parent == from)
1649                 goto out;
1650
1651         child = parent;
1652         parent = parent->parent;
1653         if (parent)
1654                 goto up;
1655 out:
1656         return ret;
1657 }
1658
1659 /*
1660  * Iterate the full tree, calling @down when first entering a node and @up when
1661  * leaving it for the final time.
1662  *
1663  * Caller must hold rcu_lock or sufficient equivalent.
1664  */
1665
1666 static inline int walk_tg_tree(tg_visitor down, tg_visitor up, void *data)
1667 {
1668         return walk_tg_tree_from(&root_task_group, down, up, data);
1669 }
1670
1671 static int tg_nop(struct task_group *tg, void *data)
1672 {
1673         return 0;
1674 }
1675 #endif
1676
1677 #ifdef CONFIG_SMP
1678 /* Used instead of source_load when we know the type == 0 */
1679 static unsigned long weighted_cpuload(const int cpu)
1680 {
1681         return cpu_rq(cpu)->load.weight;
1682 }
1683
1684 /*
1685  * Return a low guess at the load of a migration-source cpu weighted
1686  * according to the scheduling class and "nice" value.
1687  *
1688  * We want to under-estimate the load of migration sources, to
1689  * balance conservatively.
1690  */
1691 static unsigned long source_load(int cpu, int type)
1692 {
1693         struct rq *rq = cpu_rq(cpu);
1694         unsigned long total = weighted_cpuload(cpu);
1695
1696         if (type == 0 || !sched_feat(LB_BIAS))
1697                 return total;
1698
1699         return min(rq->cpu_load[type-1], total);
1700 }
1701
1702 /*
1703  * Return a high guess at the load of a migration-target cpu weighted
1704  * according to the scheduling class and "nice" value.
1705  */
1706 static unsigned long target_load(int cpu, int type)
1707 {
1708         struct rq *rq = cpu_rq(cpu);
1709         unsigned long total = weighted_cpuload(cpu);
1710
1711         if (type == 0 || !sched_feat(LB_BIAS))
1712                 return total;
1713
1714         return max(rq->cpu_load[type-1], total);
1715 }
1716
1717 static unsigned long power_of(int cpu)
1718 {
1719         return cpu_rq(cpu)->cpu_power;
1720 }
1721
1722 static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd);
1723
1724 static unsigned long cpu_avg_load_per_task(int cpu)
1725 {
1726         struct rq *rq = cpu_rq(cpu);
1727         unsigned long nr_running = ACCESS_ONCE(rq->nr_running);
1728
1729         if (nr_running)
1730                 return rq->load.weight / nr_running;
1731
1732         return 0;
1733 }
1734
1735 #ifdef CONFIG_PREEMPT
1736
1737 static void double_rq_lock(struct rq *rq1, struct rq *rq2);
1738
1739 /*
1740  * fair double_lock_balance: Safely acquires both rq->locks in a fair
1741  * way at the expense of forcing extra atomic operations in all
1742  * invocations.  This assures that the double_lock is acquired using the
1743  * same underlying policy as the spinlock_t on this architecture, which
1744  * reduces latency compared to the unfair variant below.  However, it
1745  * also adds more overhead and therefore may reduce throughput.
1746  */
1747 static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
1748         __releases(this_rq->lock)
1749         __acquires(busiest->lock)
1750         __acquires(this_rq->lock)
1751 {
1752         raw_spin_unlock(&this_rq->lock);
1753         double_rq_lock(this_rq, busiest);
1754
1755         return 1;
1756 }
1757
1758 #else
1759 /*
1760  * Unfair double_lock_balance: Optimizes throughput at the expense of
1761  * latency by eliminating extra atomic operations when the locks are
1762  * already in proper order on entry.  This favors lower cpu-ids and will
1763  * grant the double lock to lower cpus over higher ids under contention,
1764  * regardless of entry order into the function.
1765  */
1766 static int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
1767         __releases(this_rq->lock)
1768         __acquires(busiest->lock)
1769         __acquires(this_rq->lock)
1770 {
1771         int ret = 0;
1772
1773         if (unlikely(!raw_spin_trylock(&busiest->lock))) {
1774                 if (busiest < this_rq) {
1775                         raw_spin_unlock(&this_rq->lock);
1776                         raw_spin_lock(&busiest->lock);
1777                         raw_spin_lock_nested(&this_rq->lock,
1778                                               SINGLE_DEPTH_NESTING);
1779                         ret = 1;
1780                 } else
1781                         raw_spin_lock_nested(&busiest->lock,
1782                                               SINGLE_DEPTH_NESTING);
1783         }
1784         return ret;
1785 }
1786
1787 #endif /* CONFIG_PREEMPT */
1788
1789 /*
1790  * double_lock_balance - lock the busiest runqueue, this_rq is locked already.
1791  */
1792 static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
1793 {
1794         if (unlikely(!irqs_disabled())) {
1795                 /* printk() doesn't work good under rq->lock */
1796                 raw_spin_unlock(&this_rq->lock);
1797                 BUG_ON(1);
1798         }
1799
1800         return _double_lock_balance(this_rq, busiest);
1801 }
1802
1803 static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
1804         __releases(busiest->lock)
1805 {
1806         raw_spin_unlock(&busiest->lock);
1807         lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
1808 }
1809
1810 /*
1811  * double_rq_lock - safely lock two runqueues
1812  *
1813  * Note this does not disable interrupts like task_rq_lock,
1814  * you need to do so manually before calling.
1815  */
1816 static void double_rq_lock(struct rq *rq1, struct rq *rq2)
1817         __acquires(rq1->lock)
1818         __acquires(rq2->lock)
1819 {
1820         BUG_ON(!irqs_disabled());
1821         if (rq1 == rq2) {
1822                 raw_spin_lock(&rq1->lock);
1823                 __acquire(rq2->lock);   /* Fake it out ;) */
1824         } else {
1825                 if (rq1 < rq2) {
1826                         raw_spin_lock(&rq1->lock);
1827                         raw_spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
1828                 } else {
1829                         raw_spin_lock(&rq2->lock);
1830                         raw_spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
1831                 }
1832         }
1833 }
1834
1835 /*
1836  * double_rq_unlock - safely unlock two runqueues
1837  *
1838  * Note this does not restore interrupts like task_rq_unlock,
1839  * you need to do so manually after calling.
1840  */
1841 static void double_rq_unlock(struct rq *rq1, struct rq *rq2)
1842         __releases(rq1->lock)
1843         __releases(rq2->lock)
1844 {
1845         raw_spin_unlock(&rq1->lock);
1846         if (rq1 != rq2)
1847                 raw_spin_unlock(&rq2->lock);
1848         else
1849                 __release(rq2->lock);
1850 }
1851
1852 #else /* CONFIG_SMP */
1853
1854 /*
1855  * double_rq_lock - safely lock two runqueues
1856  *
1857  * Note this does not disable interrupts like task_rq_lock,
1858  * you need to do so manually before calling.
1859  */
1860 static void double_rq_lock(struct rq *rq1, struct rq *rq2)
1861         __acquires(rq1->lock)
1862         __acquires(rq2->lock)
1863 {
1864         BUG_ON(!irqs_disabled());
1865         BUG_ON(rq1 != rq2);
1866         raw_spin_lock(&rq1->lock);
1867         __acquire(rq2->lock);   /* Fake it out ;) */
1868 }
1869
1870 /*
1871  * double_rq_unlock - safely unlock two runqueues
1872  *
1873  * Note this does not restore interrupts like task_rq_unlock,
1874  * you need to do so manually after calling.
1875  */
1876 static void double_rq_unlock(struct rq *rq1, struct rq *rq2)
1877         __releases(rq1->lock)
1878         __releases(rq2->lock)
1879 {
1880         BUG_ON(rq1 != rq2);
1881         raw_spin_unlock(&rq1->lock);
1882         __release(rq2->lock);
1883 }
1884
1885 #endif
1886
1887 static void update_sysctl(void);
1888 static int get_update_sysctl_factor(void);
1889 static void update_idle_cpu_load(struct rq *this_rq);
1890
1891 static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
1892 {
1893         set_task_rq(p, cpu);
1894 #ifdef CONFIG_SMP
1895         /*
1896          * After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
1897          * successfully executed on another CPU. We must ensure that updates of
1898          * per-task data have been completed by this moment.
1899          */
1900         smp_wmb();
1901         task_thread_info(p)->cpu = cpu;
1902 #endif
1903 }
1904
1905 static const struct sched_class rt_sched_class;
1906
1907 #define sched_class_highest (&stop_sched_class)
1908 #define for_each_class(class) \
1909    for (class = sched_class_highest; class; class = class->next)
1910
1911 #include "sched_stats.h"
1912
1913 static void inc_nr_running(struct rq *rq)
1914 {
1915         rq->nr_running++;
1916 }
1917
1918 static void dec_nr_running(struct rq *rq)
1919 {
1920         rq->nr_running--;
1921 }
1922
1923 static void set_load_weight(struct task_struct *p)
1924 {
1925         int prio = p->static_prio - MAX_RT_PRIO;
1926         struct load_weight *load = &p->se.load;
1927
1928         /*
1929          * SCHED_IDLE tasks get minimal weight:
1930          */
1931         if (p->policy == SCHED_IDLE) {
1932                 load->weight = scale_load(WEIGHT_IDLEPRIO);
1933                 load->inv_weight = WMULT_IDLEPRIO;
1934                 return;
1935         }
1936
1937         load->weight = scale_load(prio_to_weight[prio]);
1938         load->inv_weight = prio_to_wmult[prio];
1939 }
1940
1941 static void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
1942 {
1943         update_rq_clock(rq);
1944         sched_info_queued(p);
1945         p->sched_class->enqueue_task(rq, p, flags);
1946 }
1947
1948 static void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
1949 {
1950         update_rq_clock(rq);
1951         sched_info_dequeued(p);
1952         p->sched_class->dequeue_task(rq, p, flags);
1953 }
1954
1955 /*
1956  * activate_task - move a task to the runqueue.
1957  */
1958 static void activate_task(struct rq *rq, struct task_struct *p, int flags)
1959 {
1960         if (task_contributes_to_load(p))
1961                 rq->nr_uninterruptible--;
1962
1963         enqueue_task(rq, p, flags);
1964 }
1965
1966 /*
1967  * deactivate_task - remove a task from the runqueue.
1968  */
1969 static void deactivate_task(struct rq *rq, struct task_struct *p, int flags)
1970 {
1971         if (task_contributes_to_load(p))
1972                 rq->nr_uninterruptible++;
1973
1974         dequeue_task(rq, p, flags);
1975 }
1976
1977 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
1978
1979 /*
1980  * There are no locks covering percpu hardirq/softirq time.
1981  * They are only modified in account_system_vtime, on corresponding CPU
1982  * with interrupts disabled. So, writes are safe.
1983  * They are read and saved off onto struct rq in update_rq_clock().
1984  * This may result in other CPU reading this CPU's irq time and can
1985  * race with irq/account_system_vtime on this CPU. We would either get old
1986  * or new value with a side effect of accounting a slice of irq time to wrong
1987  * task when irq is in progress while we read rq->clock. That is a worthy
1988  * compromise in place of having locks on each irq in account_system_time.
1989  */
1990 static DEFINE_PER_CPU(u64, cpu_hardirq_time);
1991 static DEFINE_PER_CPU(u64, cpu_softirq_time);
1992
1993 static DEFINE_PER_CPU(u64, irq_start_time);
1994 static int sched_clock_irqtime;
1995
1996 void enable_sched_clock_irqtime(void)
1997 {
1998         sched_clock_irqtime = 1;
1999 }
2000
2001 void disable_sched_clock_irqtime(void)
2002 {
2003         sched_clock_irqtime = 0;
2004 }
2005
2006 #ifndef CONFIG_64BIT
2007 static DEFINE_PER_CPU(seqcount_t, irq_time_seq);
2008
2009 static inline void irq_time_write_begin(void)
2010 {
2011         __this_cpu_inc(irq_time_seq.sequence);
2012         smp_wmb();
2013 }
2014
2015 static inline void irq_time_write_end(void)
2016 {
2017         smp_wmb();
2018         __this_cpu_inc(irq_time_seq.sequence);
2019 }
2020
2021 static inline u64 irq_time_read(int cpu)
2022 {
2023         u64 irq_time;
2024         unsigned seq;
2025
2026         do {
2027                 seq = read_seqcount_begin(&per_cpu(irq_time_seq, cpu));
2028                 irq_time = per_cpu(cpu_softirq_time, cpu) +
2029                            per_cpu(cpu_hardirq_time, cpu);
2030         } while (read_seqcount_retry(&per_cpu(irq_time_seq, cpu), seq));
2031
2032         return irq_time;
2033 }
2034 #else /* CONFIG_64BIT */
2035 static inline void irq_time_write_begin(void)
2036 {
2037 }
2038
2039 static inline void irq_time_write_end(void)
2040 {
2041 }
2042
2043 static inline u64 irq_time_read(int cpu)
2044 {
2045         return per_cpu(cpu_softirq_time, cpu) + per_cpu(cpu_hardirq_time, cpu);
2046 }
2047 #endif /* CONFIG_64BIT */
2048
2049 /*
2050  * Called before incrementing preempt_count on {soft,}irq_enter
2051  * and before decrementing preempt_count on {soft,}irq_exit.
2052  */
2053 void account_system_vtime(struct task_struct *curr)
2054 {
2055         unsigned long flags;
2056         s64 delta;
2057         int cpu;
2058
2059         if (!sched_clock_irqtime)
2060                 return;
2061
2062         local_irq_save(flags);
2063
2064         cpu = smp_processor_id();
2065         delta = sched_clock_cpu(cpu) - __this_cpu_read(irq_start_time);
2066         __this_cpu_add(irq_start_time, delta);
2067
2068         irq_time_write_begin();
2069         /*
2070          * We do not account for softirq time from ksoftirqd here.
2071          * We want to continue accounting softirq time to ksoftirqd thread
2072          * in that case, so as not to confuse scheduler with a special task
2073          * that do not consume any time, but still wants to run.
2074          */
2075         if (hardirq_count())
2076                 __this_cpu_add(cpu_hardirq_time, delta);
2077         else if (in_serving_softirq() && curr != this_cpu_ksoftirqd())
2078                 __this_cpu_add(cpu_softirq_time, delta);
2079
2080         irq_time_write_end();
2081         local_irq_restore(flags);
2082 }
2083 EXPORT_SYMBOL_GPL(account_system_vtime);
2084
2085 #endif /* CONFIG_IRQ_TIME_ACCOUNTING */
2086
2087 #ifdef CONFIG_PARAVIRT
2088 static inline u64 steal_ticks(u64 steal)
2089 {
2090         if (unlikely(steal > NSEC_PER_SEC))
2091                 return div_u64(steal, TICK_NSEC);
2092
2093         return __iter_div_u64_rem(steal, TICK_NSEC, &steal);
2094 }
2095 #endif
2096
2097 static void update_rq_clock_task(struct rq *rq, s64 delta)
2098 {
2099 /*
2100  * In theory, the compile should just see 0 here, and optimize out the call
2101  * to sched_rt_avg_update. But I don't trust it...
2102  */
2103 #if defined(CONFIG_IRQ_TIME_ACCOUNTING) || defined(CONFIG_PARAVIRT_TIME_ACCOUNTING)
2104         s64 steal = 0, irq_delta = 0;
2105 #endif
2106 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
2107         irq_delta = irq_time_read(cpu_of(rq)) - rq->prev_irq_time;
2108
2109         /*
2110          * Since irq_time is only updated on {soft,}irq_exit, we might run into
2111          * this case when a previous update_rq_clock() happened inside a
2112          * {soft,}irq region.
2113          *
2114          * When this happens, we stop ->clock_task and only update the
2115          * prev_irq_time stamp to account for the part that fit, so that a next
2116          * update will consume the rest. This ensures ->clock_task is
2117          * monotonic.
2118          *
2119          * It does however cause some slight miss-attribution of {soft,}irq
2120          * time, a more accurate solution would be to update the irq_time using
2121          * the current rq->clock timestamp, except that would require using
2122          * atomic ops.
2123          */
2124         if (irq_delta > delta)
2125                 irq_delta = delta;
2126
2127         rq->prev_irq_time += irq_delta;
2128         delta -= irq_delta;
2129 #endif
2130 #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
2131         if (static_branch((&paravirt_steal_rq_enabled))) {
2132                 u64 st;
2133
2134                 steal = paravirt_steal_clock(cpu_of(rq));
2135                 steal -= rq->prev_steal_time_rq;
2136
2137                 if (unlikely(steal > delta))
2138                         steal = delta;
2139
2140                 st = steal_ticks(steal);
2141                 steal = st * TICK_NSEC;
2142
2143                 rq->prev_steal_time_rq += steal;
2144
2145                 delta -= steal;
2146         }
2147 #endif
2148
2149         rq->clock_task += delta;
2150
2151 #if defined(CONFIG_IRQ_TIME_ACCOUNTING) || defined(CONFIG_PARAVIRT_TIME_ACCOUNTING)
2152         if ((irq_delta + steal) && sched_feat(NONTASK_POWER))
2153                 sched_rt_avg_update(rq, irq_delta + steal);
2154 #endif
2155 }
2156
2157 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
2158 static int irqtime_account_hi_update(void)
2159 {
2160         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
2161         unsigned long flags;
2162         u64 latest_ns;
2163         int ret = 0;
2164
2165         local_irq_save(flags);
2166         latest_ns = this_cpu_read(cpu_hardirq_time);
2167         if (cputime64_gt(nsecs_to_cputime64(latest_ns), cpustat->irq))
2168                 ret = 1;
2169         local_irq_restore(flags);
2170         return ret;
2171 }
2172
2173 static int irqtime_account_si_update(void)
2174 {
2175         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
2176         unsigned long flags;
2177         u64 latest_ns;
2178         int ret = 0;
2179
2180         local_irq_save(flags);
2181         latest_ns = this_cpu_read(cpu_softirq_time);
2182         if (cputime64_gt(nsecs_to_cputime64(latest_ns), cpustat->softirq))
2183                 ret = 1;
2184         local_irq_restore(flags);
2185         return ret;
2186 }
2187
2188 #else /* CONFIG_IRQ_TIME_ACCOUNTING */
2189
2190 #define sched_clock_irqtime     (0)
2191
2192 #endif
2193
2194 #ifdef CONFIG_SMP
2195 static void unthrottle_offline_cfs_rqs(struct rq *rq);
2196 #endif
2197
2198 #include "sched_idletask.c"
2199 #include "sched_fair.c"
2200 #include "sched_rt.c"
2201 #include "sched_autogroup.c"
2202 #include "sched_stoptask.c"
2203 #ifdef CONFIG_SCHED_DEBUG
2204 # include "sched_debug.c"
2205 #endif
2206
2207 void sched_set_stop_task(int cpu, struct task_struct *stop)
2208 {
2209         struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
2210         struct task_struct *old_stop = cpu_rq(cpu)->stop;
2211
2212         if (stop) {
2213                 /*
2214                  * Make it appear like a SCHED_FIFO task, its something
2215                  * userspace knows about and won't get confused about.
2216                  *
2217                  * Also, it will make PI more or less work without too
2218                  * much confusion -- but then, stop work should not
2219                  * rely on PI working anyway.
2220                  */
2221                 sched_setscheduler_nocheck(stop, SCHED_FIFO, &param);
2222
2223                 stop->sched_class = &stop_sched_class;
2224         }
2225
2226         cpu_rq(cpu)->stop = stop;
2227
2228         if (old_stop) {
2229                 /*
2230                  * Reset it back to a normal scheduling class so that
2231                  * it can die in pieces.
2232                  */
2233                 old_stop->sched_class = &rt_sched_class;
2234         }
2235 }
2236
2237 /*
2238  * __normal_prio - return the priority that is based on the static prio
2239  */
2240 static inline int __normal_prio(struct task_struct *p)
2241 {
2242         return p->static_prio;
2243 }
2244
2245 /*
2246  * Calculate the expected normal priority: i.e. priority
2247  * without taking RT-inheritance into account. Might be
2248  * boosted by interactivity modifiers. Changes upon fork,
2249  * setprio syscalls, and whenever the interactivity
2250  * estimator recalculates.
2251  */
2252 static inline int normal_prio(struct task_struct *p)
2253 {
2254         int prio;
2255
2256         if (task_has_rt_policy(p))
2257                 prio = MAX_RT_PRIO-1 - p->rt_priority;
2258         else
2259                 prio = __normal_prio(p);
2260         return prio;
2261 }
2262
2263 /*
2264  * Calculate the current priority, i.e. the priority
2265  * taken into account by the scheduler. This value might
2266  * be boosted by RT tasks, or might be boosted by
2267  * interactivity modifiers. Will be RT if the task got
2268  * RT-boosted. If not then it returns p->normal_prio.
2269  */
2270 static int effective_prio(struct task_struct *p)
2271 {
2272         p->normal_prio = normal_prio(p);
2273         /*
2274          * If we are RT tasks or we were boosted to RT priority,
2275          * keep the priority unchanged. Otherwise, update priority
2276          * to the normal priority:
2277          */
2278         if (!rt_prio(p->prio))
2279                 return p->normal_prio;
2280         return p->prio;
2281 }
2282
2283 /**
2284  * task_curr - is this task currently executing on a CPU?
2285  * @p: the task in question.
2286  */
2287 inline int task_curr(const struct task_struct *p)
2288 {
2289         return cpu_curr(task_cpu(p)) == p;
2290 }
2291
2292 static inline void check_class_changed(struct rq *rq, struct task_struct *p,
2293                                        const struct sched_class *prev_class,
2294                                        int oldprio)
2295 {
2296         if (prev_class != p->sched_class) {
2297                 if (prev_class->switched_from)
2298                         prev_class->switched_from(rq, p);
2299                 p->sched_class->switched_to(rq, p);
2300         } else if (oldprio != p->prio)
2301                 p->sched_class->prio_changed(rq, p, oldprio);
2302 }
2303
2304 static void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags)
2305 {
2306         const struct sched_class *class;
2307
2308         if (p->sched_class == rq->curr->sched_class) {
2309                 rq->curr->sched_class->check_preempt_curr(rq, p, flags);
2310         } else {
2311                 for_each_class(class) {
2312                         if (class == rq->curr->sched_class)
2313                                 break;
2314                         if (class == p->sched_class) {
2315                                 resched_task(rq->curr);
2316                                 break;
2317                         }
2318                 }
2319         }
2320
2321         /*
2322          * A queue event has occurred, and we're going to schedule.  In
2323          * this case, we can save a useless back to back clock update.
2324          */
2325         if (rq->curr->on_rq && test_tsk_need_resched(rq->curr))
2326                 rq->skip_clock_update = 1;
2327 }
2328
2329 #ifdef CONFIG_SMP
2330 /*
2331  * Is this task likely cache-hot:
2332  */
2333 static int
2334 task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
2335 {
2336         s64 delta;
2337
2338         if (p->sched_class != &fair_sched_class)
2339                 return 0;
2340
2341         if (unlikely(p->policy == SCHED_IDLE))
2342                 return 0;
2343
2344         /*
2345          * Buddy candidates are cache hot:
2346          */
2347         if (sched_feat(CACHE_HOT_BUDDY) && this_rq()->nr_running &&
2348                         (&p->se == cfs_rq_of(&p->se)->next ||
2349                          &p->se == cfs_rq_of(&p->se)->last))
2350                 return 1;
2351
2352         if (sysctl_sched_migration_cost == -1)
2353                 return 1;
2354         if (sysctl_sched_migration_cost == 0)
2355                 return 0;
2356
2357         delta = now - p->se.exec_start;
2358
2359         return delta < (s64)sysctl_sched_migration_cost;
2360 }
2361
2362 void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
2363 {
2364 #ifdef CONFIG_SCHED_DEBUG
2365         /*
2366          * We should never call set_task_cpu() on a blocked task,
2367          * ttwu() will sort out the placement.
2368          */
2369         WARN_ON_ONCE(p->state != TASK_RUNNING && p->state != TASK_WAKING &&
2370                         !(task_thread_info(p)->preempt_count & PREEMPT_ACTIVE));
2371
2372 #ifdef CONFIG_LOCKDEP
2373         /*
2374          * The caller should hold either p->pi_lock or rq->lock, when changing
2375          * a task's CPU. ->pi_lock for waking tasks, rq->lock for runnable tasks.
2376          *
2377          * sched_move_task() holds both and thus holding either pins the cgroup,
2378          * see task_group().
2379          *
2380          * Furthermore, all task_rq users should acquire both locks, see
2381          * task_rq_lock().
2382          */
2383         WARN_ON_ONCE(debug_locks && !(lockdep_is_held(&p->pi_lock) ||
2384                                       lockdep_is_held(&task_rq(p)->lock)));
2385 #endif
2386 #endif
2387
2388         trace_sched_migrate_task(p, new_cpu);
2389
2390         if (task_cpu(p) != new_cpu) {
2391                 p->se.nr_migrations++;
2392                 perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, NULL, 0);
2393         }
2394
2395         __set_task_cpu(p, new_cpu);
2396 }
2397
2398 struct migration_arg {
2399         struct task_struct *task;
2400         int dest_cpu;
2401 };
2402
2403 static int migration_cpu_stop(void *data);
2404
2405 /*
2406  * wait_task_inactive - wait for a thread to unschedule.
2407  *
2408  * If @match_state is nonzero, it's the @p->state value just checked and
2409  * not expected to change.  If it changes, i.e. @p might have woken up,
2410  * then return zero.  When we succeed in waiting for @p to be off its CPU,
2411  * we return a positive number (its total switch count).  If a second call
2412  * a short while later returns the same number, the caller can be sure that
2413  * @p has remained unscheduled the whole time.
2414  *
2415  * The caller must ensure that the task *will* unschedule sometime soon,
2416  * else this function might spin for a *long* time. This function can't
2417  * be called with interrupts off, or it may introduce deadlock with
2418  * smp_call_function() if an IPI is sent by the same process we are
2419  * waiting to become inactive.
2420  */
2421 unsigned long wait_task_inactive(struct task_struct *p, long match_state)
2422 {
2423         unsigned long flags;
2424         int running, on_rq;
2425         unsigned long ncsw;
2426         struct rq *rq;
2427
2428         for (;;) {
2429                 /*
2430                  * We do the initial early heuristics without holding
2431                  * any task-queue locks at all. We'll only try to get
2432                  * the runqueue lock when things look like they will
2433                  * work out!
2434                  */
2435                 rq = task_rq(p);
2436
2437                 /*
2438                  * If the task is actively running on another CPU
2439                  * still, just relax and busy-wait without holding
2440                  * any locks.
2441                  *
2442                  * NOTE! Since we don't hold any locks, it's not
2443                  * even sure that "rq" stays as the right runqueue!
2444                  * But we don't care, since "task_running()" will
2445                  * return false if the runqueue has changed and p
2446                  * is actually now running somewhere else!
2447                  */
2448                 while (task_running(rq, p)) {
2449                         if (match_state && unlikely(p->state != match_state))
2450                                 return 0;
2451                         cpu_relax();
2452                 }
2453
2454                 /*
2455                  * Ok, time to look more closely! We need the rq
2456                  * lock now, to be *sure*. If we're wrong, we'll
2457                  * just go back and repeat.
2458                  */
2459                 rq = task_rq_lock(p, &flags);
2460                 trace_sched_wait_task(p);
2461                 running = task_running(rq, p);
2462                 on_rq = p->on_rq;
2463                 ncsw = 0;
2464                 if (!match_state || p->state == match_state)
2465                         ncsw = p->nvcsw | LONG_MIN; /* sets MSB */
2466                 task_rq_unlock(rq, p, &flags);
2467
2468                 /*
2469                  * If it changed from the expected state, bail out now.
2470                  */
2471                 if (unlikely(!ncsw))
2472                         break;
2473
2474                 /*
2475                  * Was it really running after all now that we
2476                  * checked with the proper locks actually held?
2477                  *
2478                  * Oops. Go back and try again..
2479                  */
2480                 if (unlikely(running)) {
2481                         cpu_relax();
2482                         continue;
2483                 }
2484
2485                 /*
2486                  * It's not enough that it's not actively running,
2487                  * it must be off the runqueue _entirely_, and not
2488                  * preempted!
2489                  *
2490                  * So if it was still runnable (but just not actively
2491                  * running right now), it's preempted, and we should
2492                  * yield - it could be a while.
2493                  */
2494                 if (unlikely(on_rq)) {
2495                         ktime_t to = ktime_set(0, NSEC_PER_SEC/HZ);
2496
2497                         set_current_state(TASK_UNINTERRUPTIBLE);
2498                         schedule_hrtimeout(&to, HRTIMER_MODE_REL);
2499                         continue;
2500                 }
2501
2502                 /*
2503                  * Ahh, all good. It wasn't running, and it wasn't
2504                  * runnable, which means that it will never become
2505                  * running in the future either. We're all done!
2506                  */
2507                 break;
2508         }
2509
2510         return ncsw;
2511 }
2512
2513 /***
2514  * kick_process - kick a running thread to enter/exit the kernel
2515  * @p: the to-be-kicked thread
2516  *
2517  * Cause a process which is running on another CPU to enter
2518  * kernel-mode, without any delay. (to get signals handled.)
2519  *
2520  * NOTE: this function doesn't have to take the runqueue lock,
2521  * because all it wants to ensure is that the remote task enters
2522  * the kernel. If the IPI races and the task has been migrated
2523  * to another CPU then no harm is done and the purpose has been
2524  * achieved as well.
2525  */
2526 void kick_process(struct task_struct *p)
2527 {
2528         int cpu;
2529
2530         preempt_disable();
2531         cpu = task_cpu(p);
2532         if ((cpu != smp_processor_id()) && task_curr(p))
2533                 smp_send_reschedule(cpu);
2534         preempt_enable();
2535 }
2536 EXPORT_SYMBOL_GPL(kick_process);
2537 #endif /* CONFIG_SMP */
2538
2539 #ifdef CONFIG_SMP
2540 /*
2541  * ->cpus_allowed is protected by both rq->lock and p->pi_lock
2542  */
2543 static int select_fallback_rq(int cpu, struct task_struct *p)
2544 {
2545         int dest_cpu;
2546         const struct cpumask *nodemask = cpumask_of_node(cpu_to_node(cpu));
2547
2548         /* Look for allowed, online CPU in same node. */
2549         for_each_cpu_and(dest_cpu, nodemask, cpu_active_mask)
2550                 if (cpumask_test_cpu(dest_cpu, tsk_cpus_allowed(p)))
2551                         return dest_cpu;
2552
2553         /* Any allowed, online CPU? */
2554         dest_cpu = cpumask_any_and(tsk_cpus_allowed(p), cpu_active_mask);
2555         if (dest_cpu < nr_cpu_ids)
2556                 return dest_cpu;
2557
2558         /* No more Mr. Nice Guy. */
2559         dest_cpu = cpuset_cpus_allowed_fallback(p);
2560         /*
2561          * Don't tell them about moving exiting tasks or
2562          * kernel threads (both mm NULL), since they never
2563          * leave kernel.
2564          */
2565         if (p->mm && printk_ratelimit()) {
2566                 printk(KERN_INFO "process %d (%s) no longer affine to cpu%d\n",
2567                                 task_pid_nr(p), p->comm, cpu);
2568         }
2569
2570         return dest_cpu;
2571 }
2572
2573 /*
2574  * The caller (fork, wakeup) owns p->pi_lock, ->cpus_allowed is stable.
2575  */
2576 static inline
2577 int select_task_rq(struct task_struct *p, int sd_flags, int wake_flags)
2578 {
2579         int cpu = p->sched_class->select_task_rq(p, sd_flags, wake_flags);
2580
2581         /*
2582          * In order not to call set_task_cpu() on a blocking task we need
2583          * to rely on ttwu() to place the task on a valid ->cpus_allowed
2584          * cpu.
2585          *
2586          * Since this is common to all placement strategies, this lives here.
2587          *
2588          * [ this allows ->select_task() to simply return task_cpu(p) and
2589          *   not worry about this generic constraint ]
2590          */
2591         if (unlikely(!cpumask_test_cpu(cpu, tsk_cpus_allowed(p)) ||
2592                      !cpu_online(cpu)))
2593                 cpu = select_fallback_rq(task_cpu(p), p);
2594
2595         return cpu;
2596 }
2597
2598 static void update_avg(u64 *avg, u64 sample)
2599 {
2600         s64 diff = sample - *avg;
2601         *avg += diff >> 3;
2602 }
2603 #endif
2604
2605 static void
2606 ttwu_stat(struct task_struct *p, int cpu, int wake_flags)
2607 {
2608 #ifdef CONFIG_SCHEDSTATS
2609         struct rq *rq = this_rq();
2610
2611 #ifdef CONFIG_SMP
2612         int this_cpu = smp_processor_id();
2613
2614         if (cpu == this_cpu) {
2615                 schedstat_inc(rq, ttwu_local);
2616                 schedstat_inc(p, se.statistics.nr_wakeups_local);
2617         } else {
2618                 struct sched_domain *sd;
2619
2620                 schedstat_inc(p, se.statistics.nr_wakeups_remote);
2621                 rcu_read_lock();
2622                 for_each_domain(this_cpu, sd) {
2623                         if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
2624                                 schedstat_inc(sd, ttwu_wake_remote);
2625                                 break;
2626                         }
2627                 }
2628                 rcu_read_unlock();
2629         }
2630
2631         if (wake_flags & WF_MIGRATED)
2632                 schedstat_inc(p, se.statistics.nr_wakeups_migrate);
2633
2634 #endif /* CONFIG_SMP */
2635
2636         schedstat_inc(rq, ttwu_count);
2637         schedstat_inc(p, se.statistics.nr_wakeups);
2638
2639         if (wake_flags & WF_SYNC)
2640                 schedstat_inc(p, se.statistics.nr_wakeups_sync);
2641
2642 #endif /* CONFIG_SCHEDSTATS */
2643 }
2644
2645 static void ttwu_activate(struct rq *rq, struct task_struct *p, int en_flags)
2646 {
2647         activate_task(rq, p, en_flags);
2648         p->on_rq = 1;
2649
2650         /* if a worker is waking up, notify workqueue */
2651         if (p->flags & PF_WQ_WORKER)
2652                 wq_worker_waking_up(p, cpu_of(rq));
2653 }
2654
2655 /*
2656  * Mark the task runnable and perform wakeup-preemption.
2657  */
2658 static void
2659 ttwu_do_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
2660 {
2661         trace_sched_wakeup(p, true);
2662         check_preempt_curr(rq, p, wake_flags);
2663
2664         p->state = TASK_RUNNING;
2665 #ifdef CONFIG_SMP
2666         if (p->sched_class->task_woken)
2667                 p->sched_class->task_woken(rq, p);
2668
2669         if (rq->idle_stamp) {
2670                 u64 delta = rq->clock - rq->idle_stamp;
2671                 u64 max = 2*sysctl_sched_migration_cost;
2672
2673                 if (delta > max)
2674                         rq->avg_idle = max;
2675                 else
2676                         update_avg(&rq->avg_idle, delta);
2677                 rq->idle_stamp = 0;
2678         }
2679 #endif
2680 }
2681
2682 static void
2683 ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags)
2684 {
2685 #ifdef CONFIG_SMP
2686         if (p->sched_contributes_to_load)
2687                 rq->nr_uninterruptible--;
2688 #endif
2689
2690         ttwu_activate(rq, p, ENQUEUE_WAKEUP | ENQUEUE_WAKING);
2691         ttwu_do_wakeup(rq, p, wake_flags);
2692 }
2693
2694 /*
2695  * Called in case the task @p isn't fully descheduled from its runqueue,
2696  * in this case we must do a remote wakeup. Its a 'light' wakeup though,
2697  * since all we need to do is flip p->state to TASK_RUNNING, since
2698  * the task is still ->on_rq.
2699  */
2700 static int ttwu_remote(struct task_struct *p, int wake_flags)
2701 {
2702         struct rq *rq;
2703         int ret = 0;
2704
2705         rq = __task_rq_lock(p);
2706         if (p->on_rq) {
2707                 ttwu_do_wakeup(rq, p, wake_flags);
2708                 ret = 1;
2709         }
2710         __task_rq_unlock(rq);
2711
2712         return ret;
2713 }
2714
2715 #ifdef CONFIG_SMP
2716 static void sched_ttwu_pending(void)
2717 {
2718         struct rq *rq = this_rq();
2719         struct llist_node *llist = llist_del_all(&rq->wake_list);
2720         struct task_struct *p;
2721
2722         raw_spin_lock(&rq->lock);
2723
2724         while (llist) {
2725                 p = llist_entry(llist, struct task_struct, wake_entry);
2726                 llist = llist_next(llist);
2727                 ttwu_do_activate(rq, p, 0);
2728         }
2729
2730         raw_spin_unlock(&rq->lock);
2731 }
2732
2733 void scheduler_ipi(void)
2734 {
2735         if (llist_empty(&this_rq()->wake_list) && !got_nohz_idle_kick())
2736                 return;
2737
2738         /*
2739          * Not all reschedule IPI handlers call irq_enter/irq_exit, since
2740          * traditionally all their work was done from the interrupt return
2741          * path. Now that we actually do some work, we need to make sure
2742          * we do call them.
2743          *
2744          * Some archs already do call them, luckily irq_enter/exit nest
2745          * properly.
2746          *
2747          * Arguably we should visit all archs and update all handlers,
2748          * however a fair share of IPIs are still resched only so this would
2749          * somewhat pessimize the simple resched case.
2750          */
2751         irq_enter();
2752         sched_ttwu_pending();
2753
2754         /*
2755          * Check if someone kicked us for doing the nohz idle load balance.
2756          */
2757         if (unlikely(got_nohz_idle_kick() && !need_resched())) {
2758                 this_rq()->idle_balance = 1;
2759                 raise_softirq_irqoff(SCHED_SOFTIRQ);
2760         }
2761         irq_exit();
2762 }
2763
2764 static void ttwu_queue_remote(struct task_struct *p, int cpu)
2765 {
2766         if (llist_add(&p->wake_entry, &cpu_rq(cpu)->wake_list))
2767                 smp_send_reschedule(cpu);
2768 }
2769
2770 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
2771 static int ttwu_activate_remote(struct task_struct *p, int wake_flags)
2772 {
2773         struct rq *rq;
2774         int ret = 0;
2775
2776         rq = __task_rq_lock(p);
2777         if (p->on_cpu) {
2778                 ttwu_activate(rq, p, ENQUEUE_WAKEUP);
2779                 ttwu_do_wakeup(rq, p, wake_flags);
2780                 ret = 1;
2781         }
2782         __task_rq_unlock(rq);
2783
2784         return ret;
2785
2786 }
2787 #endif /* __ARCH_WANT_INTERRUPTS_ON_CTXSW */
2788 #endif /* CONFIG_SMP */
2789
2790 static void ttwu_queue(struct task_struct *p, int cpu)
2791 {
2792         struct rq *rq = cpu_rq(cpu);
2793
2794 #if defined(CONFIG_SMP)
2795         if (sched_feat(TTWU_QUEUE) && cpu != smp_processor_id()) {
2796                 sched_clock_cpu(cpu); /* sync clocks x-cpu */
2797                 ttwu_queue_remote(p, cpu);
2798                 return;
2799         }
2800 #endif
2801
2802         raw_spin_lock(&rq->lock);
2803         ttwu_do_activate(rq, p, 0);
2804         raw_spin_unlock(&rq->lock);
2805 }
2806
2807 /**
2808  * try_to_wake_up - wake up a thread
2809  * @p: the thread to be awakened
2810  * @state: the mask of task states that can be woken
2811  * @wake_flags: wake modifier flags (WF_*)
2812  *
2813  * Put it on the run-queue if it's not already there. The "current"
2814  * thread is always on the run-queue (except when the actual
2815  * re-schedule is in progress), and as such you're allowed to do
2816  * the simpler "current->state = TASK_RUNNING" to mark yourself
2817  * runnable without the overhead of this.
2818  *
2819  * Returns %true if @p was woken up, %false if it was already running
2820  * or @state didn't match @p's state.
2821  */
2822 static int
2823 try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
2824 {
2825         unsigned long flags;
2826         int cpu, success = 0;
2827
2828         smp_wmb();
2829         raw_spin_lock_irqsave(&p->pi_lock, flags);
2830         if (!(p->state & state))
2831                 goto out;
2832
2833         success = 1; /* we're going to change ->state */
2834         cpu = task_cpu(p);
2835
2836         /*
2837          * Ensure we load p->on_rq _after_ p->state, otherwise it would
2838          * be possible to, falsely, observe p->on_rq == 0 and get stuck
2839          * in smp_cond_load_acquire() below.
2840          *
2841          * sched_ttwu_pending()                 try_to_wake_up()
2842          *   [S] p->on_rq = 1;                  [L] P->state
2843          *       UNLOCK rq->lock  -----.
2844          *                              \
2845          *                               +---   RMB
2846          * schedule()                   /
2847          *       LOCK rq->lock    -----'
2848          *       UNLOCK rq->lock
2849          *
2850          * [task p]
2851          *   [S] p->state = UNINTERRUPTIBLE     [L] p->on_rq
2852          *
2853          * Pairs with the UNLOCK+LOCK on rq->lock from the
2854          * last wakeup of our task and the schedule that got our task
2855          * current.
2856          */
2857         smp_rmb();
2858         if (p->on_rq && ttwu_remote(p, wake_flags))
2859                 goto stat;
2860
2861 #ifdef CONFIG_SMP
2862         /*
2863          * If the owning (remote) cpu is still in the middle of schedule() with
2864          * this task as prev, wait until its done referencing the task.
2865          */
2866         while (p->on_cpu) {
2867 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
2868                 /*
2869                  * In case the architecture enables interrupts in
2870                  * context_switch(), we cannot busy wait, since that
2871                  * would lead to deadlocks when an interrupt hits and
2872                  * tries to wake up @prev. So bail and do a complete
2873                  * remote wakeup.
2874                  */
2875                 if (ttwu_activate_remote(p, wake_flags))
2876                         goto stat;
2877 #else
2878                 cpu_relax();
2879 #endif
2880         }
2881         /*
2882          * Pairs with the smp_wmb() in finish_lock_switch().
2883          */
2884         smp_rmb();
2885
2886         p->sched_contributes_to_load = !!task_contributes_to_load(p);
2887         p->state = TASK_WAKING;
2888
2889         if (p->sched_class->task_waking)
2890                 p->sched_class->task_waking(p);
2891
2892         cpu = select_task_rq(p, SD_BALANCE_WAKE, wake_flags);
2893         if (task_cpu(p) != cpu) {
2894                 wake_flags |= WF_MIGRATED;
2895                 set_task_cpu(p, cpu);
2896         }
2897 #endif /* CONFIG_SMP */
2898
2899         ttwu_queue(p, cpu);
2900 stat:
2901         ttwu_stat(p, cpu, wake_flags);
2902 out:
2903         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
2904
2905         return success;
2906 }
2907
2908 /**
2909  * try_to_wake_up_local - try to wake up a local task with rq lock held
2910  * @p: the thread to be awakened
2911  *
2912  * Put @p on the run-queue if it's not already there. The caller must
2913  * ensure that this_rq() is locked, @p is bound to this_rq() and not
2914  * the current task.
2915  */
2916 static void try_to_wake_up_local(struct task_struct *p)
2917 {
2918         struct rq *rq = task_rq(p);
2919
2920         if (WARN_ON_ONCE(rq != this_rq()) ||
2921             WARN_ON_ONCE(p == current))
2922                 return;
2923
2924         lockdep_assert_held(&rq->lock);
2925
2926         if (!raw_spin_trylock(&p->pi_lock)) {
2927                 raw_spin_unlock(&rq->lock);
2928                 raw_spin_lock(&p->pi_lock);
2929                 raw_spin_lock(&rq->lock);
2930         }
2931
2932         if (!(p->state & TASK_NORMAL))
2933                 goto out;
2934
2935         if (!p->on_rq)
2936                 ttwu_activate(rq, p, ENQUEUE_WAKEUP);
2937
2938         ttwu_do_wakeup(rq, p, 0);
2939         ttwu_stat(p, smp_processor_id(), 0);
2940 out:
2941         raw_spin_unlock(&p->pi_lock);
2942 }
2943
2944 /**
2945  * wake_up_process - Wake up a specific process
2946  * @p: The process to be woken up.
2947  *
2948  * Attempt to wake up the nominated process and move it to the set of runnable
2949  * processes.  Returns 1 if the process was woken up, 0 if it was already
2950  * running.
2951  *
2952  * It may be assumed that this function implies a write memory barrier before
2953  * changing the task state if and only if any tasks are woken up.
2954  */
2955 int wake_up_process(struct task_struct *p)
2956 {
2957         return try_to_wake_up(p, TASK_NORMAL, 0);
2958 }
2959 EXPORT_SYMBOL(wake_up_process);
2960
2961 int wake_up_state(struct task_struct *p, unsigned int state)
2962 {
2963         return try_to_wake_up(p, state, 0);
2964 }
2965
2966 /*
2967  * Perform scheduler related setup for a newly forked process p.
2968  * p is forked by current.
2969  *
2970  * __sched_fork() is basic setup used by init_idle() too:
2971  */
2972 static void __sched_fork(struct task_struct *p)
2973 {
2974         p->on_rq                        = 0;
2975
2976         p->se.on_rq                     = 0;
2977         p->se.exec_start                = 0;
2978         p->se.sum_exec_runtime          = 0;
2979         p->se.prev_sum_exec_runtime     = 0;
2980         p->se.nr_migrations             = 0;
2981         p->se.vruntime                  = 0;
2982         INIT_LIST_HEAD(&p->se.group_node);
2983
2984 #ifdef CONFIG_SCHEDSTATS
2985         memset(&p->se.statistics, 0, sizeof(p->se.statistics));
2986 #endif
2987
2988         INIT_LIST_HEAD(&p->rt.run_list);
2989
2990 #ifdef CONFIG_PREEMPT_NOTIFIERS
2991         INIT_HLIST_HEAD(&p->preempt_notifiers);
2992 #endif
2993 }
2994
2995 /*
2996  * fork()/clone()-time setup:
2997  */
2998 void sched_fork(struct task_struct *p)
2999 {
3000         unsigned long flags;
3001         int cpu = get_cpu();
3002
3003         __sched_fork(p);
3004         /*
3005          * We mark the process as running here. This guarantees that
3006          * nobody will actually run it, and a signal or other external
3007          * event cannot wake it up and insert it on the runqueue either.
3008          */
3009         p->state = TASK_RUNNING;
3010
3011         /*
3012          * Make sure we do not leak PI boosting priority to the child.
3013          */
3014         p->prio = current->normal_prio;
3015
3016         /*
3017          * Revert to default priority/policy on fork if requested.
3018          */
3019         if (unlikely(p->sched_reset_on_fork)) {
3020                 if (task_has_rt_policy(p)) {
3021                         p->policy = SCHED_NORMAL;
3022                         p->static_prio = NICE_TO_PRIO(0);
3023                         p->rt_priority = 0;
3024                 } else if (PRIO_TO_NICE(p->static_prio) < 0)
3025                         p->static_prio = NICE_TO_PRIO(0);
3026
3027                 p->prio = p->normal_prio = __normal_prio(p);
3028                 set_load_weight(p);
3029
3030                 /*
3031                  * We don't need the reset flag anymore after the fork. It has
3032                  * fulfilled its duty:
3033                  */
3034                 p->sched_reset_on_fork = 0;
3035         }
3036
3037         if (!rt_prio(p->prio))
3038                 p->sched_class = &fair_sched_class;
3039
3040         if (p->sched_class->task_fork)
3041                 p->sched_class->task_fork(p);
3042
3043         /*
3044          * The child is not yet in the pid-hash so no cgroup attach races,
3045          * and the cgroup is pinned to this child due to cgroup_fork()
3046          * is ran before sched_fork().
3047          *
3048          * Silence PROVE_RCU.
3049          */
3050         raw_spin_lock_irqsave(&p->pi_lock, flags);
3051         set_task_cpu(p, cpu);
3052         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
3053
3054 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
3055         if (likely(sched_info_on()))
3056                 memset(&p->sched_info, 0, sizeof(p->sched_info));
3057 #endif
3058 #if defined(CONFIG_SMP)
3059         p->on_cpu = 0;
3060 #endif
3061 #ifdef CONFIG_PREEMPT_COUNT
3062         /* Want to start with kernel preemption disabled. */
3063         task_thread_info(p)->preempt_count = 1;
3064 #endif
3065 #ifdef CONFIG_SMP
3066         plist_node_init(&p->pushable_tasks, MAX_PRIO);
3067 #endif
3068
3069         put_cpu();
3070 }
3071
3072 /*
3073  * wake_up_new_task - wake up a newly created task for the first time.
3074  *
3075  * This function will do some initial scheduler statistics housekeeping
3076  * that must be done for every newly created context, then puts the task
3077  * on the runqueue and wakes it.
3078  */
3079 void wake_up_new_task(struct task_struct *p)
3080 {
3081         unsigned long flags;
3082         struct rq *rq;
3083
3084         raw_spin_lock_irqsave(&p->pi_lock, flags);
3085 #ifdef CONFIG_SMP
3086         /*
3087          * Fork balancing, do it here and not earlier because:
3088          *  - cpus_allowed can change in the fork path
3089          *  - any previously selected cpu might disappear through hotplug
3090          */
3091         set_task_cpu(p, select_task_rq(p, SD_BALANCE_FORK, 0));
3092 #endif
3093
3094         rq = __task_rq_lock(p);
3095         activate_task(rq, p, 0);
3096         p->on_rq = 1;
3097         trace_sched_wakeup_new(p, true);
3098         check_preempt_curr(rq, p, WF_FORK);
3099 #ifdef CONFIG_SMP
3100         if (p->sched_class->task_woken)
3101                 p->sched_class->task_woken(rq, p);
3102 #endif
3103         task_rq_unlock(rq, p, &flags);
3104 }
3105
3106 #ifdef CONFIG_PREEMPT_NOTIFIERS
3107
3108 /**
3109  * preempt_notifier_register - tell me when current is being preempted & rescheduled
3110  * @notifier: notifier struct to register
3111  */
3112 void preempt_notifier_register(struct preempt_notifier *notifier)
3113 {
3114         hlist_add_head(&notifier->link, &current->preempt_notifiers);
3115 }
3116 EXPORT_SYMBOL_GPL(preempt_notifier_register);
3117
3118 /**
3119  * preempt_notifier_unregister - no longer interested in preemption notifications
3120  * @notifier: notifier struct to unregister
3121  *
3122  * This is safe to call from within a preemption notifier.
3123  */
3124 void preempt_notifier_unregister(struct preempt_notifier *notifier)
3125 {
3126         hlist_del(&notifier->link);
3127 }
3128 EXPORT_SYMBOL_GPL(preempt_notifier_unregister);
3129
3130 static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
3131 {
3132         struct preempt_notifier *notifier;
3133         struct hlist_node *node;
3134
3135         hlist_for_each_entry(notifier, node, &curr->preempt_notifiers, link)
3136                 notifier->ops->sched_in(notifier, raw_smp_processor_id());
3137 }
3138
3139 static void
3140 fire_sched_out_preempt_notifiers(struct task_struct *curr,
3141                                  struct task_struct *next)
3142 {
3143         struct preempt_notifier *notifier;
3144         struct hlist_node *node;
3145
3146         hlist_for_each_entry(notifier, node, &curr->preempt_notifiers, link)
3147                 notifier->ops->sched_out(notifier, next);
3148 }
3149
3150 #else /* !CONFIG_PREEMPT_NOTIFIERS */
3151
3152 static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
3153 {
3154 }
3155
3156 static void
3157 fire_sched_out_preempt_notifiers(struct task_struct *curr,
3158                                  struct task_struct *next)
3159 {
3160 }
3161
3162 #endif /* CONFIG_PREEMPT_NOTIFIERS */
3163
3164 /**
3165  * prepare_task_switch - prepare to switch tasks
3166  * @rq: the runqueue preparing to switch
3167  * @prev: the current task that is being switched out
3168  * @next: the task we are going to switch to.
3169  *
3170  * This is called with the rq lock held and interrupts off. It must
3171  * be paired with a subsequent finish_task_switch after the context
3172  * switch.
3173  *
3174  * prepare_task_switch sets up locking and calls architecture specific
3175  * hooks.
3176  */
3177 static inline void
3178 prepare_task_switch(struct rq *rq, struct task_struct *prev,
3179                     struct task_struct *next)
3180 {
3181         sched_info_switch(prev, next);
3182         perf_event_task_sched_out(prev, next);
3183         fire_sched_out_preempt_notifiers(prev, next);
3184         prepare_lock_switch(rq, next);
3185         prepare_arch_switch(next);
3186         trace_sched_switch(prev, next);
3187 }
3188
3189 /**
3190  * finish_task_switch - clean up after a task-switch
3191  * @rq: runqueue associated with task-switch
3192  * @prev: the thread we just switched away from.
3193  *
3194  * finish_task_switch must be called after the context switch, paired
3195  * with a prepare_task_switch call before the context switch.
3196  * finish_task_switch will reconcile locking set up by prepare_task_switch,
3197  * and do any other architecture-specific cleanup actions.
3198  *
3199  * Note that we may have delayed dropping an mm in context_switch(). If
3200  * so, we finish that here outside of the runqueue lock. (Doing it
3201  * with the lock held can cause deadlocks; see schedule() for
3202  * details.)
3203  */
3204 static void finish_task_switch(struct rq *rq, struct task_struct *prev)
3205         __releases(rq->lock)
3206 {
3207         struct mm_struct *mm = rq->prev_mm;
3208         long prev_state;
3209
3210         rq->prev_mm = NULL;
3211
3212         /*
3213          * A task struct has one reference for the use as "current".
3214          * If a task dies, then it sets TASK_DEAD in tsk->state and calls
3215          * schedule one last time. The schedule call will never return, and
3216          * the scheduled task must drop that reference.
3217          *
3218          * We must observe prev->state before clearing prev->on_cpu (in
3219          * finish_lock_switch), otherwise a concurrent wakeup can get prev
3220          * running on another CPU and we could rave with its RUNNING -> DEAD
3221          * transition, resulting in a double drop.
3222          */
3223         prev_state = prev->state;
3224         finish_arch_switch(prev);
3225 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
3226         local_irq_disable();
3227 #endif /* __ARCH_WANT_INTERRUPTS_ON_CTXSW */
3228         perf_event_task_sched_in(prev, current);
3229 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
3230         local_irq_enable();
3231 #endif /* __ARCH_WANT_INTERRUPTS_ON_CTXSW */
3232         finish_lock_switch(rq, prev);
3233
3234         fire_sched_in_preempt_notifiers(current);
3235         if (mm)
3236                 mmdrop(mm);
3237         if (unlikely(prev_state == TASK_DEAD)) {
3238                 /*
3239                  * Remove function-return probe instances associated with this
3240                  * task and put them back on the free list.
3241                  */
3242                 kprobe_flush_task(prev);
3243                 put_task_struct(prev);
3244         }
3245 }
3246
3247 #ifdef CONFIG_SMP
3248
3249 /* assumes rq->lock is held */
3250 static inline void pre_schedule(struct rq *rq, struct task_struct *prev)
3251 {
3252         if (prev->sched_class->pre_schedule)
3253                 prev->sched_class->pre_schedule(rq, prev);
3254 }
3255
3256 /* rq->lock is NOT held, but preemption is disabled */
3257 static inline void post_schedule(struct rq *rq)
3258 {
3259         if (rq->post_schedule) {
3260                 unsigned long flags;
3261
3262                 raw_spin_lock_irqsave(&rq->lock, flags);
3263                 if (rq->curr->sched_class->post_schedule)
3264                         rq->curr->sched_class->post_schedule(rq);
3265                 raw_spin_unlock_irqrestore(&rq->lock, flags);
3266
3267                 rq->post_schedule = 0;
3268         }
3269 }
3270
3271 #else
3272
3273 static inline void pre_schedule(struct rq *rq, struct task_struct *p)
3274 {
3275 }
3276
3277 static inline void post_schedule(struct rq *rq)
3278 {
3279 }
3280
3281 #endif
3282
3283 /**
3284  * schedule_tail - first thing a freshly forked thread must call.
3285  * @prev: the thread we just switched away from.
3286  */
3287 asmlinkage void schedule_tail(struct task_struct *prev)
3288         __releases(rq->lock)
3289 {
3290         struct rq *rq = this_rq();
3291
3292         finish_task_switch(rq, prev);
3293
3294         /*
3295          * FIXME: do we need to worry about rq being invalidated by the
3296          * task_switch?
3297          */
3298         post_schedule(rq);
3299
3300 #ifdef __ARCH_WANT_UNLOCKED_CTXSW
3301         /* In this case, finish_task_switch does not reenable preemption */
3302         preempt_enable();
3303 #endif
3304         if (current->set_child_tid)
3305                 put_user(task_pid_vnr(current), current->set_child_tid);
3306 }
3307
3308 /*
3309  * context_switch - switch to the new MM and the new
3310  * thread's register state.
3311  */
3312 static inline void
3313 context_switch(struct rq *rq, struct task_struct *prev,
3314                struct task_struct *next)
3315 {
3316         struct mm_struct *mm, *oldmm;
3317
3318         prepare_task_switch(rq, prev, next);
3319
3320         mm = next->mm;
3321         oldmm = prev->active_mm;
3322         /*
3323          * For paravirt, this is coupled with an exit in switch_to to
3324          * combine the page table reload and the switch backend into
3325          * one hypercall.
3326          */
3327         arch_start_context_switch(prev);
3328
3329         if (!mm) {
3330                 next->active_mm = oldmm;
3331                 atomic_inc(&oldmm->mm_count);
3332                 enter_lazy_tlb(oldmm, next);
3333         } else
3334                 switch_mm_irqs_off(oldmm, mm, next);
3335
3336         if (!prev->mm) {
3337                 prev->active_mm = NULL;
3338                 rq->prev_mm = oldmm;
3339         }
3340         /*
3341          * Since the runqueue lock will be released by the next
3342          * task (which is an invalid locking op but in the case
3343          * of the scheduler it's an obvious special-case), so we
3344          * do an early lockdep release here:
3345          */
3346 #ifndef __ARCH_WANT_UNLOCKED_CTXSW
3347         spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
3348 #endif
3349
3350         /* Here we just switch the register state and the stack. */
3351         switch_to(prev, next, prev);
3352
3353         barrier();
3354         /*
3355          * this_rq must be evaluated again because prev may have moved
3356          * CPUs since it called schedule(), thus the 'rq' on its stack
3357          * frame will be invalid.
3358          */
3359         finish_task_switch(this_rq(), prev);
3360 }
3361
3362 /*
3363  * nr_running, nr_uninterruptible and nr_context_switches:
3364  *
3365  * externally visible scheduler statistics: current number of runnable
3366  * threads, current number of uninterruptible-sleeping threads, total
3367  * number of context switches performed since bootup.
3368  */
3369 unsigned long nr_running(void)
3370 {
3371         unsigned long i, sum = 0;
3372
3373         for_each_online_cpu(i)
3374                 sum += cpu_rq(i)->nr_running;
3375
3376         return sum;
3377 }
3378
3379 unsigned long nr_uninterruptible(void)
3380 {
3381         unsigned long i, sum = 0;
3382
3383         for_each_possible_cpu(i)
3384                 sum += cpu_rq(i)->nr_uninterruptible;
3385
3386         /*
3387          * Since we read the counters lockless, it might be slightly
3388          * inaccurate. Do not allow it to go below zero though:
3389          */
3390         if (unlikely((long)sum < 0))
3391                 sum = 0;
3392
3393         return sum;
3394 }
3395
3396 unsigned long long nr_context_switches(void)
3397 {
3398         int i;
3399         unsigned long long sum = 0;
3400
3401         for_each_possible_cpu(i)
3402                 sum += cpu_rq(i)->nr_switches;
3403
3404         return sum;
3405 }
3406
3407 unsigned long nr_iowait(void)
3408 {
3409         unsigned long i, sum = 0;
3410
3411         for_each_possible_cpu(i)
3412                 sum += atomic_read(&cpu_rq(i)->nr_iowait);
3413
3414         return sum;
3415 }
3416
3417 unsigned long nr_iowait_cpu(int cpu)
3418 {
3419         struct rq *this = cpu_rq(cpu);
3420         return atomic_read(&this->nr_iowait);
3421 }
3422
3423 unsigned long this_cpu_load(void)
3424 {
3425         struct rq *this = this_rq();
3426         return this->cpu_load[0];
3427 }
3428
3429
3430 /*
3431  * Global load-average calculations
3432  *
3433  * We take a distributed and async approach to calculating the global load-avg
3434  * in order to minimize overhead.
3435  *
3436  * The global load average is an exponentially decaying average of nr_running +
3437  * nr_uninterruptible.
3438  *
3439  * Once every LOAD_FREQ:
3440  *
3441  *   nr_active = 0;
3442  *   for_each_possible_cpu(cpu)
3443  *      nr_active += cpu_of(cpu)->nr_running + cpu_of(cpu)->nr_uninterruptible;
3444  *
3445  *   avenrun[n] = avenrun[0] * exp_n + nr_active * (1 - exp_n)
3446  *
3447  * Due to a number of reasons the above turns in the mess below:
3448  *
3449  *  - for_each_possible_cpu() is prohibitively expensive on machines with
3450  *    serious number of cpus, therefore we need to take a distributed approach
3451  *    to calculating nr_active.
3452  *
3453  *        \Sum_i x_i(t) = \Sum_i x_i(t) - x_i(t_0) | x_i(t_0) := 0
3454  *                      = \Sum_i { \Sum_j=1 x_i(t_j) - x_i(t_j-1) }
3455  *
3456  *    So assuming nr_active := 0 when we start out -- true per definition, we
3457  *    can simply take per-cpu deltas and fold those into a global accumulate
3458  *    to obtain the same result. See calc_load_fold_active().
3459  *
3460  *    Furthermore, in order to avoid synchronizing all per-cpu delta folding
3461  *    across the machine, we assume 10 ticks is sufficient time for every
3462  *    cpu to have completed this task.
3463  *
3464  *    This places an upper-bound on the IRQ-off latency of the machine. Then
3465  *    again, being late doesn't loose the delta, just wrecks the sample.
3466  *
3467  *  - cpu_rq()->nr_uninterruptible isn't accurately tracked per-cpu because
3468  *    this would add another cross-cpu cacheline miss and atomic operation
3469  *    to the wakeup path. Instead we increment on whatever cpu the task ran
3470  *    when it went into uninterruptible state and decrement on whatever cpu
3471  *    did the wakeup. This means that only the sum of nr_uninterruptible over
3472  *    all cpus yields the correct result.
3473  *
3474  *  This covers the NO_HZ=n code, for extra head-aches, see the comment below.
3475  */
3476
3477 /* Variables and functions for calc_load */
3478 static atomic_long_t calc_load_tasks;
3479 static unsigned long calc_load_update;
3480 unsigned long avenrun[3];
3481 EXPORT_SYMBOL(avenrun); /* should be removed */
3482
3483 /**
3484  * get_avenrun - get the load average array
3485  * @loads:      pointer to dest load array
3486  * @offset:     offset to add
3487  * @shift:      shift count to shift the result left
3488  *
3489  * These values are estimates at best, so no need for locking.
3490  */
3491 void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
3492 {
3493         loads[0] = (avenrun[0] + offset) << shift;
3494         loads[1] = (avenrun[1] + offset) << shift;
3495         loads[2] = (avenrun[2] + offset) << shift;
3496 }
3497
3498 static long calc_load_fold_active(struct rq *this_rq)
3499 {
3500         long nr_active, delta = 0;
3501
3502         nr_active = this_rq->nr_running;
3503         nr_active += (long) this_rq->nr_uninterruptible;
3504
3505         if (nr_active != this_rq->calc_load_active) {
3506                 delta = nr_active - this_rq->calc_load_active;
3507                 this_rq->calc_load_active = nr_active;
3508         }
3509
3510         return delta;
3511 }
3512
3513 /*
3514  * a1 = a0 * e + a * (1 - e)
3515  */
3516 static unsigned long
3517 calc_load(unsigned long load, unsigned long exp, unsigned long active)
3518 {
3519         unsigned long newload;
3520
3521         newload = load * exp + active * (FIXED_1 - exp);
3522         if (active >= load)
3523                 newload += FIXED_1-1;
3524
3525         return newload / FIXED_1;
3526 }
3527
3528 #ifdef CONFIG_NO_HZ
3529 /*
3530  * Handle NO_HZ for the global load-average.
3531  *
3532  * Since the above described distributed algorithm to compute the global
3533  * load-average relies on per-cpu sampling from the tick, it is affected by
3534  * NO_HZ.
3535  *
3536  * The basic idea is to fold the nr_active delta into a global idle-delta upon
3537  * entering NO_HZ state such that we can include this as an 'extra' cpu delta
3538  * when we read the global state.
3539  *
3540  * Obviously reality has to ruin such a delightfully simple scheme:
3541  *
3542  *  - When we go NO_HZ idle during the window, we can negate our sample
3543  *    contribution, causing under-accounting.
3544  *
3545  *    We avoid this by keeping two idle-delta counters and flipping them
3546  *    when the window starts, thus separating old and new NO_HZ load.
3547  *
3548  *    The only trick is the slight shift in index flip for read vs write.
3549  *
3550  *        0s            5s            10s           15s
3551  *          +10           +10           +10           +10
3552  *        |-|-----------|-|-----------|-|-----------|-|
3553  *    r:0 0 1           1 0           0 1           1 0
3554  *    w:0 1 1           0 0           1 1           0 0
3555  *
3556  *    This ensures we'll fold the old idle contribution in this window while
3557  *    accumlating the new one.
3558  *
3559  *  - When we wake up from NO_HZ idle during the window, we push up our
3560  *    contribution, since we effectively move our sample point to a known
3561  *    busy state.
3562  *
3563  *    This is solved by pushing the window forward, and thus skipping the
3564  *    sample, for this cpu (effectively using the idle-delta for this cpu which
3565  *    was in effect at the time the window opened). This also solves the issue
3566  *    of having to deal with a cpu having been in NOHZ idle for multiple
3567  *    LOAD_FREQ intervals.
3568  *
3569  * When making the ILB scale, we should try to pull this in as well.
3570  */
3571 static atomic_long_t calc_load_idle[2];
3572 static int calc_load_idx;
3573
3574 static inline int calc_load_write_idx(void)
3575 {
3576         int idx = calc_load_idx;
3577
3578         /*
3579          * See calc_global_nohz(), if we observe the new index, we also
3580          * need to observe the new update time.
3581          */
3582         smp_rmb();
3583
3584         /*
3585          * If the folding window started, make sure we start writing in the
3586          * next idle-delta.
3587          */
3588         if (!time_before(jiffies, calc_load_update))
3589                 idx++;
3590
3591         return idx & 1;
3592 }
3593
3594 static inline int calc_load_read_idx(void)
3595 {
3596         return calc_load_idx & 1;
3597 }
3598
3599 void calc_load_enter_idle(void)
3600 {
3601         struct rq *this_rq = this_rq();
3602         long delta;
3603
3604         /*
3605          * We're going into NOHZ mode, if there's any pending delta, fold it
3606          * into the pending idle delta.
3607          */
3608         delta = calc_load_fold_active(this_rq);
3609         if (delta) {
3610                 int idx = calc_load_write_idx();
3611                 atomic_long_add(delta, &calc_load_idle[idx]);
3612         }
3613 }
3614
3615 void calc_load_exit_idle(void)
3616 {
3617         struct rq *this_rq = this_rq();
3618
3619         /*
3620          * If we're still before the pending sample window, we're done.
3621          */
3622         this_rq->calc_load_update = calc_load_update;
3623         if (time_before(jiffies, this_rq->calc_load_update))
3624                 return;
3625
3626         /*
3627          * We woke inside or after the sample window, this means we're already
3628          * accounted through the nohz accounting, so skip the entire deal and
3629          * sync up for the next window.
3630          */
3631         if (time_before(jiffies, this_rq->calc_load_update + 10))
3632                 this_rq->calc_load_update += LOAD_FREQ;
3633 }
3634
3635 static long calc_load_fold_idle(void)
3636 {
3637         int idx = calc_load_read_idx();
3638         long delta = 0;
3639
3640         if (atomic_long_read(&calc_load_idle[idx]))
3641                 delta = atomic_long_xchg(&calc_load_idle[idx], 0);
3642
3643         return delta;
3644 }
3645
3646 /**
3647  * fixed_power_int - compute: x^n, in O(log n) time
3648  *
3649  * @x:         base of the power
3650  * @frac_bits: fractional bits of @x
3651  * @n:         power to raise @x to.
3652  *
3653  * By exploiting the relation between the definition of the natural power
3654  * function: x^n := x*x*...*x (x multiplied by itself for n times), and
3655  * the binary encoding of numbers used by computers: n := \Sum n_i * 2^i,
3656  * (where: n_i \elem {0, 1}, the binary vector representing n),
3657  * we find: x^n := x^(\Sum n_i * 2^i) := \Prod x^(n_i * 2^i), which is
3658  * of course trivially computable in O(log_2 n), the length of our binary
3659  * vector.
3660  */
3661 static unsigned long
3662 fixed_power_int(unsigned long x, unsigned int frac_bits, unsigned int n)
3663 {
3664         unsigned long result = 1UL << frac_bits;
3665
3666         if (n) for (;;) {
3667                 if (n & 1) {
3668                         result *= x;
3669                         result += 1UL << (frac_bits - 1);
3670                         result >>= frac_bits;
3671                 }
3672                 n >>= 1;
3673                 if (!n)
3674                         break;
3675                 x *= x;
3676                 x += 1UL << (frac_bits - 1);
3677                 x >>= frac_bits;
3678         }
3679
3680         return result;
3681 }
3682
3683 /*
3684  * a1 = a0 * e + a * (1 - e)
3685  *
3686  * a2 = a1 * e + a * (1 - e)
3687  *    = (a0 * e + a * (1 - e)) * e + a * (1 - e)
3688  *    = a0 * e^2 + a * (1 - e) * (1 + e)
3689  *
3690  * a3 = a2 * e + a * (1 - e)
3691  *    = (a0 * e^2 + a * (1 - e) * (1 + e)) * e + a * (1 - e)
3692  *    = a0 * e^3 + a * (1 - e) * (1 + e + e^2)
3693  *
3694  *  ...
3695  *
3696  * an = a0 * e^n + a * (1 - e) * (1 + e + ... + e^n-1) [1]
3697  *    = a0 * e^n + a * (1 - e) * (1 - e^n)/(1 - e)
3698  *    = a0 * e^n + a * (1 - e^n)
3699  *
3700  * [1] application of the geometric series:
3701  *
3702  *              n         1 - x^(n+1)
3703  *     S_n := \Sum x^i = -------------
3704  *             i=0          1 - x
3705  */
3706 static unsigned long
3707 calc_load_n(unsigned long load, unsigned long exp,
3708             unsigned long active, unsigned int n)
3709 {
3710
3711         return calc_load(load, fixed_power_int(exp, FSHIFT, n), active);
3712 }
3713
3714 /*
3715  * NO_HZ can leave us missing all per-cpu ticks calling
3716  * calc_load_account_active(), but since an idle CPU folds its delta into
3717  * calc_load_tasks_idle per calc_load_account_idle(), all we need to do is fold
3718  * in the pending idle delta if our idle period crossed a load cycle boundary.
3719  *
3720  * Once we've updated the global active value, we need to apply the exponential
3721  * weights adjusted to the number of cycles missed.
3722  */
3723 static void calc_global_nohz(void)
3724 {
3725         long delta, active, n;
3726
3727         if (!time_before(jiffies, calc_load_update + 10)) {
3728                 /*
3729                  * Catch-up, fold however many we are behind still
3730                  */
3731                 delta = jiffies - calc_load_update - 10;
3732                 n = 1 + (delta / LOAD_FREQ);
3733
3734                 active = atomic_long_read(&calc_load_tasks);
3735                 active = active > 0 ? active * FIXED_1 : 0;
3736
3737                 avenrun[0] = calc_load_n(avenrun[0], EXP_1, active, n);
3738                 avenrun[1] = calc_load_n(avenrun[1], EXP_5, active, n);
3739                 avenrun[2] = calc_load_n(avenrun[2], EXP_15, active, n);
3740
3741                 calc_load_update += n * LOAD_FREQ;
3742         }
3743
3744         /*
3745          * Flip the idle index...
3746          *
3747          * Make sure we first write the new time then flip the index, so that
3748          * calc_load_write_idx() will see the new time when it reads the new
3749          * index, this avoids a double flip messing things up.
3750          */
3751         smp_wmb();
3752         calc_load_idx++;
3753 }
3754 #else /* !CONFIG_NO_HZ */
3755
3756 static inline long calc_load_fold_idle(void) { return 0; }
3757 static inline void calc_global_nohz(void) { }
3758
3759 #endif /* CONFIG_NO_HZ */
3760
3761 /*
3762  * calc_load - update the avenrun load estimates 10 ticks after the
3763  * CPUs have updated calc_load_tasks.
3764  */
3765 void calc_global_load(unsigned long ticks)
3766 {
3767         long active, delta;
3768
3769         if (time_before(jiffies, calc_load_update + 10))
3770                 return;
3771
3772         /*
3773          * Fold the 'old' idle-delta to include all NO_HZ cpus.
3774          */
3775         delta = calc_load_fold_idle();
3776         if (delta)
3777                 atomic_long_add(delta, &calc_load_tasks);
3778
3779         active = atomic_long_read(&calc_load_tasks);
3780         active = active > 0 ? active * FIXED_1 : 0;
3781
3782         avenrun[0] = calc_load(avenrun[0], EXP_1, active);
3783         avenrun[1] = calc_load(avenrun[1], EXP_5, active);
3784         avenrun[2] = calc_load(avenrun[2], EXP_15, active);
3785
3786         calc_load_update += LOAD_FREQ;
3787
3788         /*
3789          * In case we idled for multiple LOAD_FREQ intervals, catch up in bulk.
3790          */
3791         calc_global_nohz();
3792 }
3793
3794 /*
3795  * Called from update_cpu_load() to periodically update this CPU's
3796  * active count.
3797  */
3798 static void calc_load_account_active(struct rq *this_rq)
3799 {
3800         long delta;
3801
3802         if (time_before(jiffies, this_rq->calc_load_update))
3803                 return;
3804
3805         delta  = calc_load_fold_active(this_rq);
3806         if (delta)
3807                 atomic_long_add(delta, &calc_load_tasks);
3808
3809         this_rq->calc_load_update += LOAD_FREQ;
3810 }
3811
3812 /*
3813  * End of global load-average stuff
3814  */
3815
3816 /*
3817  * The exact cpuload at various idx values, calculated at every tick would be
3818  * load = (2^idx - 1) / 2^idx * load + 1 / 2^idx * cur_load
3819  *
3820  * If a cpu misses updates for n-1 ticks (as it was idle) and update gets called
3821  * on nth tick when cpu may be busy, then we have:
3822  * load = ((2^idx - 1) / 2^idx)^(n-1) * load
3823  * load = (2^idx - 1) / 2^idx) * load + 1 / 2^idx * cur_load
3824  *
3825  * decay_load_missed() below does efficient calculation of
3826  * load = ((2^idx - 1) / 2^idx)^(n-1) * load
3827  * avoiding 0..n-1 loop doing load = ((2^idx - 1) / 2^idx) * load
3828  *
3829  * The calculation is approximated on a 128 point scale.
3830  * degrade_zero_ticks is the number of ticks after which load at any
3831  * particular idx is approximated to be zero.
3832  * degrade_factor is a precomputed table, a row for each load idx.
3833  * Each column corresponds to degradation factor for a power of two ticks,
3834  * based on 128 point scale.
3835  * Example:
3836  * row 2, col 3 (=12) says that the degradation at load idx 2 after
3837  * 8 ticks is 12/128 (which is an approximation of exact factor 3^8/4^8).
3838  *
3839  * With this power of 2 load factors, we can degrade the load n times
3840  * by looking at 1 bits in n and doing as many mult/shift instead of
3841  * n mult/shifts needed by the exact degradation.
3842  */
3843 #define DEGRADE_SHIFT           7
3844 static const unsigned char
3845                 degrade_zero_ticks[CPU_LOAD_IDX_MAX] = {0, 8, 32, 64, 128};
3846 static const unsigned char
3847                 degrade_factor[CPU_LOAD_IDX_MAX][DEGRADE_SHIFT + 1] = {
3848                                         {0, 0, 0, 0, 0, 0, 0, 0},
3849                                         {64, 32, 8, 0, 0, 0, 0, 0},
3850                                         {96, 72, 40, 12, 1, 0, 0},
3851                                         {112, 98, 75, 43, 15, 1, 0},
3852                                         {120, 112, 98, 76, 45, 16, 2} };
3853
3854 /*
3855  * Update cpu_load for any missed ticks, due to tickless idle. The backlog
3856  * would be when CPU is idle and so we just decay the old load without
3857  * adding any new load.
3858  */
3859 static unsigned long
3860 decay_load_missed(unsigned long load, unsigned long missed_updates, int idx)
3861 {
3862         int j = 0;
3863
3864         if (!missed_updates)
3865                 return load;
3866
3867         if (missed_updates >= degrade_zero_ticks[idx])
3868                 return 0;
3869
3870         if (idx == 1)
3871                 return load >> missed_updates;
3872
3873         while (missed_updates) {
3874                 if (missed_updates % 2)
3875                         load = (load * degrade_factor[idx][j]) >> DEGRADE_SHIFT;
3876
3877                 missed_updates >>= 1;
3878                 j++;
3879         }
3880         return load;
3881 }
3882
3883 /*
3884  * Update rq->cpu_load[] statistics. This function is usually called every
3885  * scheduler tick (TICK_NSEC). With tickless idle this will not be called
3886  * every tick. We fix it up based on jiffies.
3887  */
3888 static void __update_cpu_load(struct rq *this_rq, unsigned long this_load,
3889                               unsigned long pending_updates)
3890 {
3891         int i, scale;
3892
3893         this_rq->nr_load_updates++;
3894
3895         /* Update our load: */
3896         this_rq->cpu_load[0] = this_load; /* Fasttrack for idx 0 */
3897         for (i = 1, scale = 2; i < CPU_LOAD_IDX_MAX; i++, scale += scale) {
3898                 unsigned long old_load, new_load;
3899
3900                 /* scale is effectively 1 << i now, and >> i divides by scale */
3901
3902                 old_load = this_rq->cpu_load[i];
3903                 old_load = decay_load_missed(old_load, pending_updates - 1, i);
3904                 new_load = this_load;
3905                 /*
3906                  * Round up the averaging division if load is increasing. This
3907                  * prevents us from getting stuck on 9 if the load is 10, for
3908                  * example.
3909                  */
3910                 if (new_load > old_load)
3911                         new_load += scale - 1;
3912
3913                 this_rq->cpu_load[i] = (old_load * (scale - 1) + new_load) >> i;
3914         }
3915
3916         sched_avg_update(this_rq);
3917 }
3918
3919 #ifdef CONFIG_NO_HZ
3920 /*
3921  * There is no sane way to deal with nohz on smp when using jiffies because the
3922  * cpu doing the jiffies update might drift wrt the cpu doing the jiffy reading
3923  * causing off-by-one errors in observed deltas; {0,2} instead of {1,1}.
3924  *
3925  * Therefore we cannot use the delta approach from the regular tick since that
3926  * would seriously skew the load calculation. However we'll make do for those
3927  * updates happening while idle (nohz_idle_balance) or coming out of idle
3928  * (tick_nohz_idle_exit).
3929  *
3930  * This means we might still be one tick off for nohz periods.
3931  */
3932
3933 /*
3934  * Called from nohz_idle_balance() to update the load ratings before doing the
3935  * idle balance.
3936  */
3937 static void update_idle_cpu_load(struct rq *this_rq)
3938 {
3939         unsigned long curr_jiffies = ACCESS_ONCE(jiffies);
3940         unsigned long load = this_rq->load.weight;
3941         unsigned long pending_updates;
3942
3943         /*
3944          * bail if there's load or we're actually up-to-date.
3945          */
3946         if (load || curr_jiffies == this_rq->last_load_update_tick)
3947                 return;
3948
3949         pending_updates = curr_jiffies - this_rq->last_load_update_tick;
3950         this_rq->last_load_update_tick = curr_jiffies;
3951
3952         __update_cpu_load(this_rq, load, pending_updates);
3953 }
3954
3955 /*
3956  * Called from tick_nohz_idle_exit() -- try and fix up the ticks we missed.
3957  */
3958 void update_cpu_load_nohz(void)
3959 {
3960         struct rq *this_rq = this_rq();
3961         unsigned long curr_jiffies = ACCESS_ONCE(jiffies);
3962         unsigned long pending_updates;
3963
3964         if (curr_jiffies == this_rq->last_load_update_tick)
3965                 return;
3966
3967         raw_spin_lock(&this_rq->lock);
3968         pending_updates = curr_jiffies - this_rq->last_load_update_tick;
3969         if (pending_updates) {
3970                 this_rq->last_load_update_tick = curr_jiffies;
3971                 /*
3972                  * We were idle, this means load 0, the current load might be
3973                  * !0 due to remote wakeups and the sort.
3974                  */
3975                 __update_cpu_load(this_rq, 0, pending_updates);
3976         }
3977         raw_spin_unlock(&this_rq->lock);
3978 }
3979 #endif /* CONFIG_NO_HZ */
3980
3981 /*
3982  * Called from scheduler_tick()
3983  */
3984 static void update_cpu_load_active(struct rq *this_rq)
3985 {
3986         /*
3987          * See the mess around update_idle_cpu_load() / update_cpu_load_nohz().
3988          */
3989         this_rq->last_load_update_tick = jiffies;
3990         __update_cpu_load(this_rq, this_rq->load.weight, 1);
3991
3992         calc_load_account_active(this_rq);
3993 }
3994
3995 #ifdef CONFIG_SMP
3996
3997 /*
3998  * sched_exec - execve() is a valuable balancing opportunity, because at
3999  * this point the task has the smallest effective memory and cache footprint.
4000  */
4001 void sched_exec(void)
4002 {
4003         struct task_struct *p = current;
4004         unsigned long flags;
4005         int dest_cpu;
4006
4007         raw_spin_lock_irqsave(&p->pi_lock, flags);
4008         dest_cpu = p->sched_class->select_task_rq(p, SD_BALANCE_EXEC, 0);
4009         if (dest_cpu == smp_processor_id())
4010                 goto unlock;
4011
4012         if (likely(cpu_active(dest_cpu))) {
4013                 struct migration_arg arg = { p, dest_cpu };
4014
4015                 raw_spin_unlock_irqrestore(&p->pi_lock, flags);
4016                 stop_one_cpu(task_cpu(p), migration_cpu_stop, &arg);
4017                 return;
4018         }
4019 unlock:
4020         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
4021 }
4022
4023 #endif
4024
4025 DEFINE_PER_CPU(struct kernel_stat, kstat);
4026
4027 EXPORT_PER_CPU_SYMBOL(kstat);
4028
4029 /*
4030  * Return any ns on the sched_clock that have not yet been accounted in
4031  * @p in case that task is currently running.
4032  *
4033  * Called with task_rq_lock() held on @rq.
4034  */
4035 static u64 do_task_delta_exec(struct task_struct *p, struct rq *rq)
4036 {
4037         u64 ns = 0;
4038
4039         if (task_current(rq, p)) {
4040                 update_rq_clock(rq);
4041                 ns = rq->clock_task - p->se.exec_start;
4042                 if ((s64)ns < 0)
4043                         ns = 0;
4044         }
4045
4046         return ns;
4047 }
4048
4049 unsigned long long task_delta_exec(struct task_struct *p)
4050 {
4051         unsigned long flags;
4052         struct rq *rq;
4053         u64 ns = 0;
4054
4055         rq = task_rq_lock(p, &flags);
4056         ns = do_task_delta_exec(p, rq);
4057         task_rq_unlock(rq, p, &flags);
4058
4059         return ns;
4060 }
4061
4062 /*
4063  * Return accounted runtime for the task.
4064  * In case the task is currently running, return the runtime plus current's
4065  * pending runtime that have not been accounted yet.
4066  */
4067 unsigned long long task_sched_runtime(struct task_struct *p)
4068 {
4069         unsigned long flags;
4070         struct rq *rq;
4071         u64 ns = 0;
4072
4073         rq = task_rq_lock(p, &flags);
4074         ns = p->se.sum_exec_runtime + do_task_delta_exec(p, rq);
4075         task_rq_unlock(rq, p, &flags);
4076
4077         return ns;
4078 }
4079
4080 /*
4081  * Account user cpu time to a process.
4082  * @p: the process that the cpu time gets accounted to
4083  * @cputime: the cpu time spent in user space since the last update
4084  * @cputime_scaled: cputime scaled by cpu frequency
4085  */
4086 void account_user_time(struct task_struct *p, cputime_t cputime,
4087                        cputime_t cputime_scaled)
4088 {
4089         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
4090         cputime64_t tmp;
4091
4092         /* Add user time to process. */
4093         p->utime = cputime_add(p->utime, cputime);
4094         p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
4095         account_group_user_time(p, cputime);
4096
4097         /* Add user time to cpustat. */
4098         tmp = cputime_to_cputime64(cputime);
4099         if (TASK_NICE(p) > 0)
4100                 cpustat->nice = cputime64_add(cpustat->nice, tmp);
4101         else
4102                 cpustat->user = cputime64_add(cpustat->user, tmp);
4103
4104         cpuacct_update_stats(p, CPUACCT_STAT_USER, cputime);
4105         /* Account for user time used */
4106         acct_update_integrals(p);
4107 }
4108
4109 /*
4110  * Account guest cpu time to a process.
4111  * @p: the process that the cpu time gets accounted to
4112  * @cputime: the cpu time spent in virtual machine since the last update
4113  * @cputime_scaled: cputime scaled by cpu frequency
4114  */
4115 static void account_guest_time(struct task_struct *p, cputime_t cputime,
4116                                cputime_t cputime_scaled)
4117 {
4118         cputime64_t tmp;
4119         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
4120
4121         tmp = cputime_to_cputime64(cputime);
4122
4123         /* Add guest time to process. */
4124         p->utime = cputime_add(p->utime, cputime);
4125         p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
4126         account_group_user_time(p, cputime);
4127         p->gtime = cputime_add(p->gtime, cputime);
4128
4129         /* Add guest time to cpustat. */
4130         if (TASK_NICE(p) > 0) {
4131                 cpustat->nice = cputime64_add(cpustat->nice, tmp);
4132                 cpustat->guest_nice = cputime64_add(cpustat->guest_nice, tmp);
4133         } else {
4134                 cpustat->user = cputime64_add(cpustat->user, tmp);
4135                 cpustat->guest = cputime64_add(cpustat->guest, tmp);
4136         }
4137 }
4138
4139 /*
4140  * Account system cpu time to a process and desired cpustat field
4141  * @p: the process that the cpu time gets accounted to
4142  * @cputime: the cpu time spent in kernel space since the last update
4143  * @cputime_scaled: cputime scaled by cpu frequency
4144  * @target_cputime64: pointer to cpustat field that has to be updated
4145  */
4146 static inline
4147 void __account_system_time(struct task_struct *p, cputime_t cputime,
4148                         cputime_t cputime_scaled, cputime64_t *target_cputime64)
4149 {
4150         cputime64_t tmp = cputime_to_cputime64(cputime);
4151
4152         /* Add system time to process. */
4153         p->stime = cputime_add(p->stime, cputime);
4154         p->stimescaled = cputime_add(p->stimescaled, cputime_scaled);
4155         account_group_system_time(p, cputime);
4156
4157         /* Add system time to cpustat. */
4158         *target_cputime64 = cputime64_add(*target_cputime64, tmp);
4159         cpuacct_update_stats(p, CPUACCT_STAT_SYSTEM, cputime);
4160
4161         /* Account for system time used */
4162         acct_update_integrals(p);
4163 }
4164
4165 /*
4166  * Account system cpu time to a process.
4167  * @p: the process that the cpu time gets accounted to
4168  * @hardirq_offset: the offset to subtract from hardirq_count()
4169  * @cputime: the cpu time spent in kernel space since the last update
4170  * @cputime_scaled: cputime scaled by cpu frequency
4171  */
4172 void account_system_time(struct task_struct *p, int hardirq_offset,
4173                          cputime_t cputime, cputime_t cputime_scaled)
4174 {
4175         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
4176         cputime64_t *target_cputime64;
4177
4178         if ((p->flags & PF_VCPU) && (irq_count() - hardirq_offset == 0)) {
4179                 account_guest_time(p, cputime, cputime_scaled);
4180                 return;
4181         }
4182
4183         if (hardirq_count() - hardirq_offset)
4184                 target_cputime64 = &cpustat->irq;
4185         else if (in_serving_softirq())
4186                 target_cputime64 = &cpustat->softirq;
4187         else
4188                 target_cputime64 = &cpustat->system;
4189
4190         __account_system_time(p, cputime, cputime_scaled, target_cputime64);
4191 }
4192
4193 /*
4194  * Account for involuntary wait time.
4195  * @cputime: the cpu time spent in involuntary wait
4196  */
4197 void account_steal_time(cputime_t cputime)
4198 {
4199         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
4200         cputime64_t cputime64 = cputime_to_cputime64(cputime);
4201
4202         cpustat->steal = cputime64_add(cpustat->steal, cputime64);
4203 }
4204
4205 /*
4206  * Account for idle time.
4207  * @cputime: the cpu time spent in idle wait
4208  */
4209 void account_idle_time(cputime_t cputime)
4210 {
4211         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
4212         cputime64_t cputime64 = cputime_to_cputime64(cputime);
4213         struct rq *rq = this_rq();
4214
4215         if (atomic_read(&rq->nr_iowait) > 0)
4216                 cpustat->iowait = cputime64_add(cpustat->iowait, cputime64);
4217         else
4218                 cpustat->idle = cputime64_add(cpustat->idle, cputime64);
4219 }
4220
4221 static __always_inline bool steal_account_process_tick(void)
4222 {
4223 #ifdef CONFIG_PARAVIRT
4224         if (static_branch(&paravirt_steal_enabled)) {
4225                 u64 steal, st = 0;
4226
4227                 steal = paravirt_steal_clock(smp_processor_id());
4228                 steal -= this_rq()->prev_steal_time;
4229
4230                 st = steal_ticks(steal);
4231                 this_rq()->prev_steal_time += st * TICK_NSEC;
4232
4233                 account_steal_time(st);
4234                 return st;
4235         }
4236 #endif
4237         return false;
4238 }
4239
4240 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
4241
4242 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
4243 /*
4244  * Account a tick to a process and cpustat
4245  * @p: the process that the cpu time gets accounted to
4246  * @user_tick: is the tick from userspace
4247  * @rq: the pointer to rq
4248  *
4249  * Tick demultiplexing follows the order
4250  * - pending hardirq update
4251  * - pending softirq update
4252  * - user_time
4253  * - idle_time
4254  * - system time
4255  *   - check for guest_time
4256  *   - else account as system_time
4257  *
4258  * Check for hardirq is done both for system and user time as there is
4259  * no timer going off while we are on hardirq and hence we may never get an
4260  * opportunity to update it solely in system time.
4261  * p->stime and friends are only updated on system time and not on irq
4262  * softirq as those do not count in task exec_runtime any more.
4263  */
4264 static void irqtime_account_process_tick(struct task_struct *p, int user_tick,
4265                                                 struct rq *rq)
4266 {
4267         cputime_t one_jiffy_scaled = cputime_to_scaled(cputime_one_jiffy);
4268         cputime64_t tmp = cputime_to_cputime64(cputime_one_jiffy);
4269         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
4270
4271         if (steal_account_process_tick())
4272                 return;
4273
4274         if (irqtime_account_hi_update()) {
4275                 cpustat->irq = cputime64_add(cpustat->irq, tmp);
4276         } else if (irqtime_account_si_update()) {
4277                 cpustat->softirq = cputime64_add(cpustat->softirq, tmp);
4278         } else if (this_cpu_ksoftirqd() == p) {
4279                 /*
4280                  * ksoftirqd time do not get accounted in cpu_softirq_time.
4281                  * So, we have to handle it separately here.
4282                  * Also, p->stime needs to be updated for ksoftirqd.
4283                  */
4284                 __account_system_time(p, cputime_one_jiffy, one_jiffy_scaled,
4285                                         &cpustat->softirq);
4286         } else if (user_tick) {
4287                 account_user_time(p, cputime_one_jiffy, one_jiffy_scaled);
4288         } else if (p == rq->idle) {
4289                 account_idle_time(cputime_one_jiffy);
4290         } else if (p->flags & PF_VCPU) { /* System time or guest time */
4291                 account_guest_time(p, cputime_one_jiffy, one_jiffy_scaled);
4292         } else {
4293                 __account_system_time(p, cputime_one_jiffy, one_jiffy_scaled,
4294                                         &cpustat->system);
4295         }
4296 }
4297
4298 static void irqtime_account_idle_ticks(int ticks)
4299 {
4300         int i;
4301         struct rq *rq = this_rq();
4302
4303         for (i = 0; i < ticks; i++)
4304                 irqtime_account_process_tick(current, 0, rq);
4305 }
4306 #else /* CONFIG_IRQ_TIME_ACCOUNTING */
4307 static void irqtime_account_idle_ticks(int ticks) {}
4308 static void irqtime_account_process_tick(struct task_struct *p, int user_tick,
4309                                                 struct rq *rq) {}
4310 #endif /* CONFIG_IRQ_TIME_ACCOUNTING */
4311
4312 /*
4313  * Account a single tick of cpu time.
4314  * @p: the process that the cpu time gets accounted to
4315  * @user_tick: indicates if the tick is a user or a system tick
4316  */
4317 void account_process_tick(struct task_struct *p, int user_tick)
4318 {
4319         cputime_t one_jiffy_scaled = cputime_to_scaled(cputime_one_jiffy);
4320         struct rq *rq = this_rq();
4321
4322         if (sched_clock_irqtime) {
4323                 irqtime_account_process_tick(p, user_tick, rq);
4324                 return;
4325         }
4326
4327         if (steal_account_process_tick())
4328                 return;
4329
4330         if (user_tick)
4331                 account_user_time(p, cputime_one_jiffy, one_jiffy_scaled);
4332         else if ((p != rq->idle) || (irq_count() != HARDIRQ_OFFSET))
4333                 account_system_time(p, HARDIRQ_OFFSET, cputime_one_jiffy,
4334                                     one_jiffy_scaled);
4335         else
4336                 account_idle_time(cputime_one_jiffy);
4337 }
4338
4339 /*
4340  * Account multiple ticks of steal time.
4341  * @p: the process from which the cpu time has been stolen
4342  * @ticks: number of stolen ticks
4343  */
4344 void account_steal_ticks(unsigned long ticks)
4345 {
4346         account_steal_time(jiffies_to_cputime(ticks));
4347 }
4348
4349 /*
4350  * Account multiple ticks of idle time.
4351  * @ticks: number of stolen ticks
4352  */
4353 void account_idle_ticks(unsigned long ticks)
4354 {
4355
4356         if (sched_clock_irqtime) {
4357                 irqtime_account_idle_ticks(ticks);
4358                 return;
4359         }
4360
4361         account_idle_time(jiffies_to_cputime(ticks));
4362 }
4363
4364 #endif
4365
4366 /*
4367  * Use precise platform statistics if available:
4368  */
4369 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
4370 void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
4371 {
4372         *ut = p->utime;
4373         *st = p->stime;
4374 }
4375
4376 void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
4377 {
4378         struct task_cputime cputime;
4379
4380         thread_group_cputime(p, &cputime);
4381
4382         *ut = cputime.utime;
4383         *st = cputime.stime;
4384 }
4385 #else
4386
4387 #ifndef nsecs_to_cputime
4388 # define nsecs_to_cputime(__nsecs)      nsecs_to_jiffies(__nsecs)
4389 #endif
4390
4391 static cputime_t scale_utime(cputime_t utime, cputime_t rtime, cputime_t total)
4392 {
4393         u64 temp = (__force u64) rtime;
4394
4395         temp *= (__force u64) utime;
4396
4397         if (sizeof(cputime_t) == 4)
4398                 temp = div_u64(temp, (__force u32) total);
4399         else
4400                 temp = div64_u64(temp, (__force u64) total);
4401
4402         return (__force cputime_t) temp;
4403 }
4404
4405 void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
4406 {
4407         cputime_t rtime, utime = p->utime, total = cputime_add(utime, p->stime);
4408
4409         /*
4410          * Use CFS's precise accounting:
4411          */
4412         rtime = nsecs_to_cputime(p->se.sum_exec_runtime);
4413
4414         if (total)
4415                 utime = scale_utime(utime, rtime, total);
4416         else
4417                 utime = rtime;
4418
4419         /*
4420          * Compare with previous values, to keep monotonicity:
4421          */
4422         p->prev_utime = max(p->prev_utime, utime);
4423         p->prev_stime = max(p->prev_stime, cputime_sub(rtime, p->prev_utime));
4424
4425         *ut = p->prev_utime;
4426         *st = p->prev_stime;
4427 }
4428
4429 /*
4430  * Must be called with siglock held.
4431  */
4432 void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
4433 {
4434         struct signal_struct *sig = p->signal;
4435         struct task_cputime cputime;
4436         cputime_t rtime, utime, total;
4437
4438         thread_group_cputime(p, &cputime);
4439
4440         total = cputime_add(cputime.utime, cputime.stime);
4441         rtime = nsecs_to_cputime(cputime.sum_exec_runtime);
4442
4443         if (total)
4444                 utime = scale_utime(cputime.utime, rtime, total);
4445         else
4446                 utime = rtime;
4447
4448         sig->prev_utime = max(sig->prev_utime, utime);
4449         sig->prev_stime = max(sig->prev_stime,
4450                               cputime_sub(rtime, sig->prev_utime));
4451
4452         *ut = sig->prev_utime;
4453         *st = sig->prev_stime;
4454 }
4455 #endif
4456
4457 /*
4458  * This function gets called by the timer code, with HZ frequency.
4459  * We call it with interrupts disabled.
4460  */
4461 void scheduler_tick(void)
4462 {
4463         int cpu = smp_processor_id();
4464         struct rq *rq = cpu_rq(cpu);
4465         struct task_struct *curr = rq->curr;
4466
4467         sched_clock_tick();
4468
4469         raw_spin_lock(&rq->lock);
4470         update_rq_clock(rq);
4471         update_cpu_load_active(rq);
4472         curr->sched_class->task_tick(rq, curr, 0);
4473         raw_spin_unlock(&rq->lock);
4474
4475         perf_event_task_tick();
4476
4477 #ifdef CONFIG_SMP
4478         rq->idle_balance = idle_cpu(cpu);
4479         trigger_load_balance(rq, cpu);
4480 #endif
4481 }
4482
4483 notrace unsigned long get_parent_ip(unsigned long addr)
4484 {
4485         if (in_lock_functions(addr)) {
4486                 addr = CALLER_ADDR2;
4487                 if (in_lock_functions(addr))
4488                         addr = CALLER_ADDR3;
4489         }
4490         return addr;
4491 }
4492
4493 #if defined(CONFIG_PREEMPT) && (defined(CONFIG_DEBUG_PREEMPT) || \
4494                                 defined(CONFIG_PREEMPT_TRACER))
4495
4496 void __kprobes add_preempt_count(int val)
4497 {
4498 #ifdef CONFIG_DEBUG_PREEMPT
4499         /*
4500          * Underflow?
4501          */
4502         if (DEBUG_LOCKS_WARN_ON((preempt_count() < 0)))
4503                 return;
4504 #endif
4505         preempt_count() += val;
4506 #ifdef CONFIG_DEBUG_PREEMPT
4507         /*
4508          * Spinlock count overflowing soon?
4509          */
4510         DEBUG_LOCKS_WARN_ON((preempt_count() & PREEMPT_MASK) >=
4511                                 PREEMPT_MASK - 10);
4512 #endif
4513         if (preempt_count() == val)
4514                 trace_preempt_off(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
4515 }
4516 EXPORT_SYMBOL(add_preempt_count);
4517
4518 void __kprobes sub_preempt_count(int val)
4519 {
4520 #ifdef CONFIG_DEBUG_PREEMPT
4521         /*
4522          * Underflow?
4523          */
4524         if (DEBUG_LOCKS_WARN_ON(val > preempt_count()))
4525                 return;
4526         /*
4527          * Is the spinlock portion underflowing?
4528          */
4529         if (DEBUG_LOCKS_WARN_ON((val < PREEMPT_MASK) &&
4530                         !(preempt_count() & PREEMPT_MASK)))
4531                 return;
4532 #endif
4533
4534         if (preempt_count() == val)
4535                 trace_preempt_on(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
4536         preempt_count() -= val;
4537 }
4538 EXPORT_SYMBOL(sub_preempt_count);
4539
4540 #endif
4541
4542 /*
4543  * Print scheduling while atomic bug:
4544  */
4545 static noinline void __schedule_bug(struct task_struct *prev)
4546 {
4547         struct pt_regs *regs = get_irq_regs();
4548
4549         printk(KERN_ERR "BUG: scheduling while atomic: %s/%d/0x%08x\n",
4550                 prev->comm, prev->pid, preempt_count());
4551
4552         debug_show_held_locks(prev);
4553         print_modules();
4554         if (irqs_disabled())
4555                 print_irqtrace_events(prev);
4556
4557         if (regs)
4558                 show_regs(regs);
4559         else
4560                 dump_stack();
4561 }
4562
4563 /*
4564  * Various schedule()-time debugging checks and statistics:
4565  */
4566 static inline void schedule_debug(struct task_struct *prev)
4567 {
4568         /*
4569          * Test if we are atomic. Since do_exit() needs to call into
4570          * schedule() atomically, we ignore that path for now.
4571          * Otherwise, whine if we are scheduling when we should not be.
4572          */
4573         if (unlikely(in_atomic_preempt_off() && !prev->exit_state))
4574                 __schedule_bug(prev);
4575         rcu_sleep_check();
4576
4577         profile_hit(SCHED_PROFILING, __builtin_return_address(0));
4578
4579         schedstat_inc(this_rq(), sched_count);
4580 }
4581
4582 static void put_prev_task(struct rq *rq, struct task_struct *prev)
4583 {
4584         if (prev->on_rq || rq->skip_clock_update < 0)
4585                 update_rq_clock(rq);
4586         prev->sched_class->put_prev_task(rq, prev);
4587 }
4588
4589 /*
4590  * Pick up the highest-prio task:
4591  */
4592 static inline struct task_struct *
4593 pick_next_task(struct rq *rq)
4594 {
4595         const struct sched_class *class;
4596         struct task_struct *p;
4597
4598         /*
4599          * Optimization: we know that if all tasks are in
4600          * the fair class we can call that function directly:
4601          */
4602         if (likely(rq->nr_running == rq->cfs.h_nr_running)) {
4603                 p = fair_sched_class.pick_next_task(rq);
4604                 if (likely(p))
4605                         return p;
4606         }
4607
4608         for_each_class(class) {
4609                 p = class->pick_next_task(rq);
4610                 if (p)
4611                         return p;
4612         }
4613
4614         BUG(); /* the idle class will always have a runnable task */
4615 }
4616
4617 /*
4618  * __schedule() is the main scheduler function.
4619  */
4620 static void __sched __schedule(void)
4621 {
4622         struct task_struct *prev, *next;
4623         unsigned long *switch_count;
4624         struct rq *rq;
4625         int cpu;
4626
4627 need_resched:
4628         preempt_disable();
4629         cpu = smp_processor_id();
4630         rq = cpu_rq(cpu);
4631         rcu_note_context_switch(cpu);
4632         prev = rq->curr;
4633
4634         schedule_debug(prev);
4635
4636         if (sched_feat(HRTICK))
4637                 hrtick_clear(rq);
4638
4639         raw_spin_lock_irq(&rq->lock);
4640
4641         switch_count = &prev->nivcsw;
4642         if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
4643                 if (unlikely(signal_pending_state(prev->state, prev))) {
4644                         prev->state = TASK_RUNNING;
4645                 } else {
4646                         deactivate_task(rq, prev, DEQUEUE_SLEEP);
4647                         prev->on_rq = 0;
4648
4649                         /*
4650                          * If a worker went to sleep, notify and ask workqueue
4651                          * whether it wants to wake up a task to maintain
4652                          * concurrency.
4653                          */
4654                         if (prev->flags & PF_WQ_WORKER) {
4655                                 struct task_struct *to_wakeup;
4656
4657                                 to_wakeup = wq_worker_sleeping(prev, cpu);
4658                                 if (to_wakeup)
4659                                         try_to_wake_up_local(to_wakeup);
4660                         }
4661                 }
4662                 switch_count = &prev->nvcsw;
4663         }
4664
4665         pre_schedule(rq, prev);
4666
4667         if (unlikely(!rq->nr_running))
4668                 idle_balance(cpu, rq);
4669
4670         put_prev_task(rq, prev);
4671         next = pick_next_task(rq);
4672         clear_tsk_need_resched(prev);
4673         rq->skip_clock_update = 0;
4674
4675         if (likely(prev != next)) {
4676                 rq->nr_switches++;
4677                 rq->curr = next;
4678                 ++*switch_count;
4679
4680                 context_switch(rq, prev, next); /* unlocks the rq */
4681                 /*
4682                  * The context switch have flipped the stack from under us
4683                  * and restored the local variables which were saved when
4684                  * this task called schedule() in the past. prev == current
4685                  * is still correct, but it can be moved to another cpu/rq.
4686                  */
4687                 cpu = smp_processor_id();
4688                 rq = cpu_rq(cpu);
4689         } else
4690                 raw_spin_unlock_irq(&rq->lock);
4691
4692         post_schedule(rq);
4693
4694         preempt_enable_no_resched();
4695         if (need_resched())
4696                 goto need_resched;
4697 }
4698
4699 static inline void sched_submit_work(struct task_struct *tsk)
4700 {
4701         if (!tsk->state)
4702                 return;
4703         /*
4704          * If we are going to sleep and we have plugged IO queued,
4705          * make sure to submit it to avoid deadlocks.
4706          */
4707         if (blk_needs_flush_plug(tsk))
4708                 blk_schedule_flush_plug(tsk);
4709 }
4710
4711 asmlinkage void __sched schedule(void)
4712 {
4713         struct task_struct *tsk = current;
4714
4715         sched_submit_work(tsk);
4716         __schedule();
4717 }
4718 EXPORT_SYMBOL(schedule);
4719
4720 #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
4721
4722 static inline bool owner_running(struct mutex *lock, struct task_struct *owner)
4723 {
4724         if (lock->owner != owner)
4725                 return false;
4726
4727         /*
4728          * Ensure we emit the owner->on_cpu, dereference _after_ checking
4729          * lock->owner still matches owner, if that fails, owner might
4730          * point to free()d memory, if it still matches, the rcu_read_lock()
4731          * ensures the memory stays valid.
4732          */
4733         barrier();
4734
4735         return owner->on_cpu;
4736 }
4737
4738 /*
4739  * Look out! "owner" is an entirely speculative pointer
4740  * access and not reliable.
4741  */
4742 int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner)
4743 {
4744         if (!sched_feat(OWNER_SPIN))
4745                 return 0;
4746
4747         rcu_read_lock();
4748         while (owner_running(lock, owner)) {
4749                 if (need_resched())
4750                         break;
4751
4752                 arch_mutex_cpu_relax();
4753         }
4754         rcu_read_unlock();
4755
4756         /*
4757          * We break out the loop above on need_resched() and when the
4758          * owner changed, which is a sign for heavy contention. Return
4759          * success only when lock->owner is NULL.
4760          */
4761         return lock->owner == NULL;
4762 }
4763 #endif
4764
4765 #ifdef CONFIG_PREEMPT
4766 /*
4767  * this is the entry point to schedule() from in-kernel preemption
4768  * off of preempt_enable. Kernel preemptions off return from interrupt
4769  * occur there and call schedule directly.
4770  */
4771 asmlinkage void __sched notrace preempt_schedule(void)
4772 {
4773         struct thread_info *ti = current_thread_info();
4774
4775         /*
4776          * If there is a non-zero preempt_count or interrupts are disabled,
4777          * we do not want to preempt the current task. Just return..
4778          */
4779         if (likely(ti->preempt_count || irqs_disabled()))
4780                 return;
4781
4782         do {
4783                 add_preempt_count_notrace(PREEMPT_ACTIVE);
4784                 __schedule();
4785                 sub_preempt_count_notrace(PREEMPT_ACTIVE);
4786
4787                 /*
4788                  * Check again in case we missed a preemption opportunity
4789                  * between schedule and now.
4790                  */
4791                 barrier();
4792         } while (need_resched());
4793 }
4794 EXPORT_SYMBOL(preempt_schedule);
4795
4796 /*
4797  * this is the entry point to schedule() from kernel preemption
4798  * off of irq context.
4799  * Note, that this is called and return with irqs disabled. This will
4800  * protect us against recursive calling from irq.
4801  */
4802 asmlinkage void __sched preempt_schedule_irq(void)
4803 {
4804         struct thread_info *ti = current_thread_info();
4805
4806         /* Catch callers which need to be fixed */
4807         BUG_ON(ti->preempt_count || !irqs_disabled());
4808
4809         do {
4810                 add_preempt_count(PREEMPT_ACTIVE);
4811                 local_irq_enable();
4812                 __schedule();
4813                 local_irq_disable();
4814                 sub_preempt_count(PREEMPT_ACTIVE);
4815
4816                 /*
4817                  * Check again in case we missed a preemption opportunity
4818                  * between schedule and now.
4819                  */
4820                 barrier();
4821         } while (need_resched());
4822 }
4823
4824 #endif /* CONFIG_PREEMPT */
4825
4826 int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
4827                           void *key)
4828 {
4829         return try_to_wake_up(curr->private, mode, wake_flags);
4830 }
4831 EXPORT_SYMBOL(default_wake_function);
4832
4833 /*
4834  * The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just
4835  * wake everything up. If it's an exclusive wakeup (nr_exclusive == small +ve
4836  * number) then we wake all the non-exclusive tasks and one exclusive task.
4837  *
4838  * There are circumstances in which we can try to wake a task which has already
4839  * started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
4840  * zero in this (rare) case, and we handle it by continuing to scan the queue.
4841  */
4842 static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
4843                         int nr_exclusive, int wake_flags, void *key)
4844 {
4845         wait_queue_t *curr, *next;
4846
4847         list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
4848                 unsigned flags = curr->flags;
4849
4850                 if (curr->func(curr, mode, wake_flags, key) &&
4851                                 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
4852                         break;
4853         }
4854 }
4855
4856 /**
4857  * __wake_up - wake up threads blocked on a waitqueue.
4858  * @q: the waitqueue
4859  * @mode: which threads
4860  * @nr_exclusive: how many wake-one or wake-many threads to wake up
4861  * @key: is directly passed to the wakeup function
4862  *
4863  * It may be assumed that this function implies a write memory barrier before
4864  * changing the task state if and only if any tasks are woken up.
4865  */
4866 void __wake_up(wait_queue_head_t *q, unsigned int mode,
4867                         int nr_exclusive, void *key)
4868 {
4869         unsigned long flags;
4870
4871         spin_lock_irqsave(&q->lock, flags);
4872         __wake_up_common(q, mode, nr_exclusive, 0, key);
4873         spin_unlock_irqrestore(&q->lock, flags);
4874 }
4875 EXPORT_SYMBOL(__wake_up);
4876
4877 /*
4878  * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
4879  */
4880 void __wake_up_locked(wait_queue_head_t *q, unsigned int mode)
4881 {
4882         __wake_up_common(q, mode, 1, 0, NULL);
4883 }
4884 EXPORT_SYMBOL_GPL(__wake_up_locked);
4885
4886 void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
4887 {
4888         __wake_up_common(q, mode, 1, 0, key);
4889 }
4890 EXPORT_SYMBOL_GPL(__wake_up_locked_key);
4891
4892 /**
4893  * __wake_up_sync_key - wake up threads blocked on a waitqueue.
4894  * @q: the waitqueue
4895  * @mode: which threads
4896  * @nr_exclusive: how many wake-one or wake-many threads to wake up
4897  * @key: opaque value to be passed to wakeup targets
4898  *
4899  * The sync wakeup differs that the waker knows that it will schedule
4900  * away soon, so while the target thread will be woken up, it will not
4901  * be migrated to another CPU - ie. the two threads are 'synchronized'
4902  * with each other. This can prevent needless bouncing between CPUs.
4903  *
4904  * On UP it can prevent extra preemption.
4905  *
4906  * It may be assumed that this function implies a write memory barrier before
4907  * changing the task state if and only if any tasks are woken up.
4908  */
4909 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
4910                         int nr_exclusive, void *key)
4911 {
4912         unsigned long flags;
4913         int wake_flags = WF_SYNC;
4914
4915         if (unlikely(!q))
4916                 return;
4917
4918         if (unlikely(!nr_exclusive))
4919                 wake_flags = 0;
4920
4921         spin_lock_irqsave(&q->lock, flags);
4922         __wake_up_common(q, mode, nr_exclusive, wake_flags, key);
4923         spin_unlock_irqrestore(&q->lock, flags);
4924 }
4925 EXPORT_SYMBOL_GPL(__wake_up_sync_key);
4926
4927 /*
4928  * __wake_up_sync - see __wake_up_sync_key()
4929  */
4930 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
4931 {
4932         __wake_up_sync_key(q, mode, nr_exclusive, NULL);
4933 }
4934 EXPORT_SYMBOL_GPL(__wake_up_sync);      /* For internal use only */
4935
4936 /**
4937  * complete: - signals a single thread waiting on this completion
4938  * @x:  holds the state of this particular completion
4939  *
4940  * This will wake up a single thread waiting on this completion. Threads will be
4941  * awakened in the same order in which they were queued.
4942  *
4943  * See also complete_all(), wait_for_completion() and related routines.
4944  *
4945  * It may be assumed that this function implies a write memory barrier before
4946  * changing the task state if and only if any tasks are woken up.
4947  */
4948 void complete(struct completion *x)
4949 {
4950         unsigned long flags;
4951
4952         spin_lock_irqsave(&x->wait.lock, flags);
4953         x->done++;
4954         __wake_up_common(&x->wait, TASK_NORMAL, 1, 0, NULL);
4955         spin_unlock_irqrestore(&x->wait.lock, flags);
4956 }
4957 EXPORT_SYMBOL(complete);
4958
4959 /**
4960  * complete_all: - signals all threads waiting on this completion
4961  * @x:  holds the state of this particular completion
4962  *
4963  * This will wake up all threads waiting on this particular completion event.
4964  *
4965  * It may be assumed that this function implies a write memory barrier before
4966  * changing the task state if and only if any tasks are woken up.
4967  */
4968 void complete_all(struct completion *x)
4969 {
4970         unsigned long flags;
4971
4972         spin_lock_irqsave(&x->wait.lock, flags);
4973         x->done += UINT_MAX/2;
4974         __wake_up_common(&x->wait, TASK_NORMAL, 0, 0, NULL);
4975         spin_unlock_irqrestore(&x->wait.lock, flags);
4976 }
4977 EXPORT_SYMBOL(complete_all);
4978
4979 static inline long __sched
4980 do_wait_for_common(struct completion *x, long timeout, int state)
4981 {
4982         if (!x->done) {
4983                 DECLARE_WAITQUEUE(wait, current);
4984
4985                 __add_wait_queue_tail_exclusive(&x->wait, &wait);
4986                 do {
4987                         if (signal_pending_state(state, current)) {
4988                                 timeout = -ERESTARTSYS;
4989                                 break;
4990                         }
4991                         __set_current_state(state);
4992                         spin_unlock_irq(&x->wait.lock);
4993                         timeout = schedule_timeout(timeout);
4994                         spin_lock_irq(&x->wait.lock);
4995                 } while (!x->done && timeout);
4996                 __remove_wait_queue(&x->wait, &wait);
4997                 if (!x->done)
4998                         return timeout;
4999         }
5000         x->done--;
5001         return timeout ?: 1;
5002 }
5003
5004 static long __sched
5005 wait_for_common(struct completion *x, long timeout, int state)
5006 {
5007         might_sleep();
5008
5009         spin_lock_irq(&x->wait.lock);
5010         timeout = do_wait_for_common(x, timeout, state);
5011         spin_unlock_irq(&x->wait.lock);
5012         return timeout;
5013 }
5014
5015 /**
5016  * wait_for_completion: - waits for completion of a task
5017  * @x:  holds the state of this particular completion
5018  *
5019  * This waits to be signaled for completion of a specific task. It is NOT
5020  * interruptible and there is no timeout.
5021  *
5022  * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
5023  * and interrupt capability. Also see complete().
5024  */
5025 void __sched wait_for_completion(struct completion *x)
5026 {
5027         wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
5028 }
5029 EXPORT_SYMBOL(wait_for_completion);
5030
5031 /**
5032  * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
5033  * @x:  holds the state of this particular completion
5034  * @timeout:  timeout value in jiffies
5035  *
5036  * This waits for either a completion of a specific task to be signaled or for a
5037  * specified timeout to expire. The timeout is in jiffies. It is not
5038  * interruptible.
5039  *
5040  * The return value is 0 if timed out, and positive (at least 1, or number of
5041  * jiffies left till timeout) if completed.
5042  */
5043 unsigned long __sched
5044 wait_for_completion_timeout(struct completion *x, unsigned long timeout)
5045 {
5046         return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
5047 }
5048 EXPORT_SYMBOL(wait_for_completion_timeout);
5049
5050 /**
5051  * wait_for_completion_interruptible: - waits for completion of a task (w/intr)
5052  * @x:  holds the state of this particular completion
5053  *
5054  * This waits for completion of a specific task to be signaled. It is
5055  * interruptible.
5056  *
5057  * The return value is -ERESTARTSYS if interrupted, 0 if completed.
5058  */
5059 int __sched wait_for_completion_interruptible(struct completion *x)
5060 {
5061         long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
5062         if (t == -ERESTARTSYS)
5063                 return t;
5064         return 0;
5065 }
5066 EXPORT_SYMBOL(wait_for_completion_interruptible);
5067
5068 /**
5069  * wait_for_completion_interruptible_timeout: - waits for completion (w/(to,intr))
5070  * @x:  holds the state of this particular completion
5071  * @timeout:  timeout value in jiffies
5072  *
5073  * This waits for either a completion of a specific task to be signaled or for a
5074  * specified timeout to expire. It is interruptible. The timeout is in jiffies.
5075  *
5076  * The return value is -ERESTARTSYS if interrupted, 0 if timed out,
5077  * positive (at least 1, or number of jiffies left till timeout) if completed.
5078  */
5079 long __sched
5080 wait_for_completion_interruptible_timeout(struct completion *x,
5081                                           unsigned long timeout)
5082 {
5083         return wait_for_common(x, timeout, TASK_INTERRUPTIBLE);
5084 }
5085 EXPORT_SYMBOL(wait_for_completion_interruptible_timeout);
5086
5087 /**
5088  * wait_for_completion_killable: - waits for completion of a task (killable)
5089  * @x:  holds the state of this particular completion
5090  *
5091  * This waits to be signaled for completion of a specific task. It can be
5092  * interrupted by a kill signal.
5093  *
5094  * The return value is -ERESTARTSYS if interrupted, 0 if completed.
5095  */
5096 int __sched wait_for_completion_killable(struct completion *x)
5097 {
5098         long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);
5099         if (t == -ERESTARTSYS)
5100                 return t;
5101         return 0;
5102 }
5103 EXPORT_SYMBOL(wait_for_completion_killable);
5104
5105 /**
5106  * wait_for_completion_killable_timeout: - waits for completion of a task (w/(to,killable))
5107  * @x:  holds the state of this particular completion
5108  * @timeout:  timeout value in jiffies
5109  *
5110  * This waits for either a completion of a specific task to be
5111  * signaled or for a specified timeout to expire. It can be
5112  * interrupted by a kill signal. The timeout is in jiffies.
5113  *
5114  * The return value is -ERESTARTSYS if interrupted, 0 if timed out,
5115  * positive (at least 1, or number of jiffies left till timeout) if completed.
5116  */
5117 long __sched
5118 wait_for_completion_killable_timeout(struct completion *x,
5119                                      unsigned long timeout)
5120 {
5121         return wait_for_common(x, timeout, TASK_KILLABLE);
5122 }
5123 EXPORT_SYMBOL(wait_for_completion_killable_timeout);
5124
5125 /**
5126  *      try_wait_for_completion - try to decrement a completion without blocking
5127  *      @x:     completion structure
5128  *
5129  *      Returns: 0 if a decrement cannot be done without blocking
5130  *               1 if a decrement succeeded.
5131  *
5132  *      If a completion is being used as a counting completion,
5133  *      attempt to decrement the counter without blocking. This
5134  *      enables us to avoid waiting if the resource the completion
5135  *      is protecting is not available.
5136  */
5137 bool try_wait_for_completion(struct completion *x)
5138 {
5139         unsigned long flags;
5140         int ret = 1;
5141
5142         spin_lock_irqsave(&x->wait.lock, flags);
5143         if (!x->done)
5144                 ret = 0;
5145         else
5146                 x->done--;
5147         spin_unlock_irqrestore(&x->wait.lock, flags);
5148         return ret;
5149 }
5150 EXPORT_SYMBOL(try_wait_for_completion);
5151
5152 /**
5153  *      completion_done - Test to see if a completion has any waiters
5154  *      @x:     completion structure
5155  *
5156  *      Returns: 0 if there are waiters (wait_for_completion() in progress)
5157  *               1 if there are no waiters.
5158  *
5159  */
5160 bool completion_done(struct completion *x)
5161 {
5162         unsigned long flags;
5163         int ret = 1;
5164
5165         spin_lock_irqsave(&x->wait.lock, flags);
5166         if (!x->done)
5167                 ret = 0;
5168         spin_unlock_irqrestore(&x->wait.lock, flags);
5169         return ret;
5170 }
5171 EXPORT_SYMBOL(completion_done);
5172
5173 static long __sched
5174 sleep_on_common(wait_queue_head_t *q, int state, long timeout)
5175 {
5176         unsigned long flags;
5177         wait_queue_t wait;
5178
5179         init_waitqueue_entry(&wait, current);
5180
5181         __set_current_state(state);
5182
5183         spin_lock_irqsave(&q->lock, flags);
5184         __add_wait_queue(q, &wait);
5185         spin_unlock(&q->lock);
5186         timeout = schedule_timeout(timeout);
5187         spin_lock_irq(&q->lock);
5188         __remove_wait_queue(q, &wait);
5189         spin_unlock_irqrestore(&q->lock, flags);
5190
5191         return timeout;
5192 }
5193
5194 void __sched interruptible_sleep_on(wait_queue_head_t *q)
5195 {
5196         sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
5197 }
5198 EXPORT_SYMBOL(interruptible_sleep_on);
5199
5200 long __sched
5201 interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
5202 {
5203         return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
5204 }
5205 EXPORT_SYMBOL(interruptible_sleep_on_timeout);
5206
5207 void __sched sleep_on(wait_queue_head_t *q)
5208 {
5209         sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
5210 }
5211 EXPORT_SYMBOL(sleep_on);
5212
5213 long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
5214 {
5215         return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
5216 }
5217 EXPORT_SYMBOL(sleep_on_timeout);
5218
5219 #ifdef CONFIG_RT_MUTEXES
5220
5221 /*
5222  * rt_mutex_setprio - set the current priority of a task
5223  * @p: task
5224  * @prio: prio value (kernel-internal form)
5225  *
5226  * This function changes the 'effective' priority of a task. It does
5227  * not touch ->normal_prio like __setscheduler().
5228  *
5229  * Used by the rt_mutex code to implement priority inheritance logic.
5230  */
5231 void rt_mutex_setprio(struct task_struct *p, int prio)
5232 {
5233         int oldprio, on_rq, running;
5234         struct rq *rq;
5235         const struct sched_class *prev_class;
5236
5237         BUG_ON(prio < 0 || prio > MAX_PRIO);
5238
5239         rq = __task_rq_lock(p);
5240
5241         trace_sched_pi_setprio(p, prio);
5242         oldprio = p->prio;
5243         prev_class = p->sched_class;
5244         on_rq = p->on_rq;
5245         running = task_current(rq, p);
5246         if (on_rq)
5247                 dequeue_task(rq, p, 0);
5248         if (running)
5249                 p->sched_class->put_prev_task(rq, p);
5250
5251         if (rt_prio(prio))
5252                 p->sched_class = &rt_sched_class;
5253         else {
5254                 if (rt_prio(oldprio))
5255                         p->rt.timeout = 0;
5256                 p->sched_class = &fair_sched_class;
5257         }
5258
5259         p->prio = prio;
5260
5261         if (running)
5262                 p->sched_class->set_curr_task(rq);
5263         if (on_rq)
5264                 enqueue_task(rq, p, oldprio < prio ? ENQUEUE_HEAD : 0);
5265
5266         check_class_changed(rq, p, prev_class, oldprio);
5267         __task_rq_unlock(rq);
5268 }
5269
5270 #endif
5271
5272 void set_user_nice(struct task_struct *p, long nice)
5273 {
5274         int old_prio, delta, on_rq;
5275         unsigned long flags;
5276         struct rq *rq;
5277
5278         if (TASK_NICE(p) == nice || nice < -20 || nice > 19)
5279                 return;
5280         /*
5281          * We have to be careful, if called from sys_setpriority(),
5282          * the task might be in the middle of scheduling on another CPU.
5283          */
5284         rq = task_rq_lock(p, &flags);
5285         /*
5286          * The RT priorities are set via sched_setscheduler(), but we still
5287          * allow the 'normal' nice value to be set - but as expected
5288          * it wont have any effect on scheduling until the task is
5289          * SCHED_FIFO/SCHED_RR:
5290          */
5291         if (task_has_rt_policy(p)) {
5292                 p->static_prio = NICE_TO_PRIO(nice);
5293                 goto out_unlock;
5294         }
5295         on_rq = p->on_rq;
5296         if (on_rq)
5297                 dequeue_task(rq, p, 0);
5298
5299         p->static_prio = NICE_TO_PRIO(nice);
5300         set_load_weight(p);
5301         old_prio = p->prio;
5302         p->prio = effective_prio(p);
5303         delta = p->prio - old_prio;
5304
5305         if (on_rq) {
5306                 enqueue_task(rq, p, 0);
5307                 /*
5308                  * If the task increased its priority or is running and
5309                  * lowered its priority, then reschedule its CPU:
5310                  */
5311                 if (delta < 0 || (delta > 0 && task_running(rq, p)))
5312                         resched_task(rq->curr);
5313         }
5314 out_unlock:
5315         task_rq_unlock(rq, p, &flags);
5316 }
5317 EXPORT_SYMBOL(set_user_nice);
5318
5319 /*
5320  * can_nice - check if a task can reduce its nice value
5321  * @p: task
5322  * @nice: nice value
5323  */
5324 int can_nice(const struct task_struct *p, const int nice)
5325 {
5326         /* convert nice value [19,-20] to rlimit style value [1,40] */
5327         int nice_rlim = 20 - nice;
5328
5329         return (nice_rlim <= task_rlimit(p, RLIMIT_NICE) ||
5330                 capable(CAP_SYS_NICE));
5331 }
5332 EXPORT_SYMBOL_GPL(can_nice);
5333
5334 #ifdef __ARCH_WANT_SYS_NICE
5335
5336 /*
5337  * sys_nice - change the priority of the current process.
5338  * @increment: priority increment
5339  *
5340  * sys_setpriority is a more generic, but much slower function that
5341  * does similar things.
5342  */
5343 SYSCALL_DEFINE1(nice, int, increment)
5344 {
5345         long nice, retval;
5346
5347         /*
5348          * Setpriority might change our priority at the same moment.
5349          * We don't have to worry. Conceptually one call occurs first
5350          * and we have a single winner.
5351          */
5352         if (increment < -40)
5353                 increment = -40;
5354         if (increment > 40)
5355                 increment = 40;
5356
5357         nice = TASK_NICE(current) + increment;
5358         if (nice < -20)
5359                 nice = -20;
5360         if (nice > 19)
5361                 nice = 19;
5362
5363         if (increment < 0 && !can_nice(current, nice))
5364                 return -EPERM;
5365
5366         retval = security_task_setnice(current, nice);
5367         if (retval)
5368                 return retval;
5369
5370         set_user_nice(current, nice);
5371         return 0;
5372 }
5373
5374 #endif
5375
5376 /**
5377  * task_prio - return the priority value of a given task.
5378  * @p: the task in question.
5379  *
5380  * This is the priority value as seen by users in /proc.
5381  * RT tasks are offset by -200. Normal tasks are centered
5382  * around 0, value goes from -16 to +15.
5383  */
5384 int task_prio(const struct task_struct *p)
5385 {
5386         return p->prio - MAX_RT_PRIO;
5387 }
5388
5389 /**
5390  * task_nice - return the nice value of a given task.
5391  * @p: the task in question.
5392  */
5393 int task_nice(const struct task_struct *p)
5394 {
5395         return TASK_NICE(p);
5396 }
5397 EXPORT_SYMBOL(task_nice);
5398
5399 /**
5400  * idle_cpu - is a given cpu idle currently?
5401  * @cpu: the processor in question.
5402  */
5403 int idle_cpu(int cpu)
5404 {
5405         struct rq *rq = cpu_rq(cpu);
5406
5407         if (rq->curr != rq->idle)
5408                 return 0;
5409
5410         if (rq->nr_running)
5411                 return 0;
5412
5413 #ifdef CONFIG_SMP
5414         if (!llist_empty(&rq->wake_list))
5415                 return 0;
5416 #endif
5417
5418         return 1;
5419 }
5420
5421 /**
5422  * idle_task - return the idle task for a given cpu.
5423  * @cpu: the processor in question.
5424  */
5425 struct task_struct *idle_task(int cpu)
5426 {
5427         return cpu_rq(cpu)->idle;
5428 }
5429
5430 /**
5431  * find_process_by_pid - find a process with a matching PID value.
5432  * @pid: the pid in question.
5433  */
5434 static struct task_struct *find_process_by_pid(pid_t pid)
5435 {
5436         return pid ? find_task_by_vpid(pid) : current;
5437 }
5438
5439 /* Actually do priority change: must hold rq lock. */
5440 static void
5441 __setscheduler(struct rq *rq, struct task_struct *p, int policy, int prio)
5442 {
5443         p->policy = policy;
5444         p->rt_priority = prio;
5445         p->normal_prio = normal_prio(p);
5446         /* we are holding p->pi_lock already */
5447         p->prio = rt_mutex_getprio(p);
5448         if (rt_prio(p->prio))
5449                 p->sched_class = &rt_sched_class;
5450         else
5451                 p->sched_class = &fair_sched_class;
5452         set_load_weight(p);
5453 }
5454
5455 /*
5456  * check the target process has a UID that matches the current process's
5457  */
5458 static bool check_same_owner(struct task_struct *p)
5459 {
5460         const struct cred *cred = current_cred(), *pcred;
5461         bool match;
5462
5463         rcu_read_lock();
5464         pcred = __task_cred(p);
5465         if (cred->user->user_ns == pcred->user->user_ns)
5466                 match = (cred->euid == pcred->euid ||
5467                          cred->euid == pcred->uid);
5468         else
5469                 match = false;
5470         rcu_read_unlock();
5471         return match;
5472 }
5473
5474 static int __sched_setscheduler(struct task_struct *p, int policy,
5475                                 const struct sched_param *param, bool user)
5476 {
5477         int retval, oldprio, oldpolicy = -1, on_rq, running;
5478         unsigned long flags;
5479         const struct sched_class *prev_class;
5480         struct rq *rq;
5481         int reset_on_fork;
5482
5483         /* may grab non-irq protected spin_locks */
5484         BUG_ON(in_interrupt());
5485 recheck:
5486         /* double check policy once rq lock held */
5487         if (policy < 0) {
5488                 reset_on_fork = p->sched_reset_on_fork;
5489                 policy = oldpolicy = p->policy;
5490         } else {
5491                 reset_on_fork = !!(policy & SCHED_RESET_ON_FORK);
5492                 policy &= ~SCHED_RESET_ON_FORK;
5493
5494                 if (policy != SCHED_FIFO && policy != SCHED_RR &&
5495                                 policy != SCHED_NORMAL && policy != SCHED_BATCH &&
5496                                 policy != SCHED_IDLE)
5497                         return -EINVAL;
5498         }
5499
5500         /*
5501          * Valid priorities for SCHED_FIFO and SCHED_RR are
5502          * 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL,
5503          * SCHED_BATCH and SCHED_IDLE is 0.
5504          */
5505         if (param->sched_priority < 0 ||
5506             (p->mm && param->sched_priority > MAX_USER_RT_PRIO-1) ||
5507             (!p->mm && param->sched_priority > MAX_RT_PRIO-1))
5508                 return -EINVAL;
5509         if (rt_policy(policy) != (param->sched_priority != 0))
5510                 return -EINVAL;
5511
5512         /*
5513          * Allow unprivileged RT tasks to decrease priority:
5514          */
5515         if (user && !capable(CAP_SYS_NICE)) {
5516                 if (rt_policy(policy)) {
5517                         unsigned long rlim_rtprio =
5518                                         task_rlimit(p, RLIMIT_RTPRIO);
5519
5520                         /* can't set/change the rt policy */
5521                         if (policy != p->policy && !rlim_rtprio)
5522                                 return -EPERM;
5523
5524                         /* can't increase priority */
5525                         if (param->sched_priority > p->rt_priority &&
5526                             param->sched_priority > rlim_rtprio)
5527                                 return -EPERM;
5528                 }
5529
5530                 /*
5531                  * Treat SCHED_IDLE as nice 20. Only allow a switch to
5532                  * SCHED_NORMAL if the RLIMIT_NICE would normally permit it.
5533                  */
5534                 if (p->policy == SCHED_IDLE && policy != SCHED_IDLE) {
5535                         if (!can_nice(p, TASK_NICE(p)))
5536                                 return -EPERM;
5537                 }
5538
5539                 /* can't change other user's priorities */
5540                 if (!check_same_owner(p))
5541                         return -EPERM;
5542
5543                 /* Normal users shall not reset the sched_reset_on_fork flag */
5544                 if (p->sched_reset_on_fork && !reset_on_fork)
5545                         return -EPERM;
5546         }
5547
5548         if (user) {
5549                 retval = security_task_setscheduler(p);
5550                 if (retval)
5551                         return retval;
5552         }
5553
5554         /*
5555          * make sure no PI-waiters arrive (or leave) while we are
5556          * changing the priority of the task:
5557          *
5558          * To be able to change p->policy safely, the appropriate
5559          * runqueue lock must be held.
5560          */
5561         rq = task_rq_lock(p, &flags);
5562
5563         /*
5564          * Changing the policy of the stop threads its a very bad idea
5565          */
5566         if (p == rq->stop) {
5567                 task_rq_unlock(rq, p, &flags);
5568                 return -EINVAL;
5569         }
5570
5571         /*
5572          * If not changing anything there's no need to proceed further:
5573          */
5574         if (unlikely(policy == p->policy && (!rt_policy(policy) ||
5575                         param->sched_priority == p->rt_priority))) {
5576
5577                 __task_rq_unlock(rq);
5578                 raw_spin_unlock_irqrestore(&p->pi_lock, flags);
5579                 return 0;
5580         }
5581
5582 #ifdef CONFIG_RT_GROUP_SCHED
5583         if (user) {
5584                 /*
5585                  * Do not allow realtime tasks into groups that have no runtime
5586                  * assigned.
5587                  */
5588                 if (rt_bandwidth_enabled() && rt_policy(policy) &&
5589                                 task_group(p)->rt_bandwidth.rt_runtime == 0 &&
5590                                 !task_group_is_autogroup(task_group(p))) {
5591                         task_rq_unlock(rq, p, &flags);
5592                         return -EPERM;
5593                 }
5594         }
5595 #endif
5596
5597         /* recheck policy now with rq lock held */
5598         if (unlikely(oldpolicy != -1 && oldpolicy != p->policy)) {
5599                 policy = oldpolicy = -1;
5600                 task_rq_unlock(rq, p, &flags);
5601                 goto recheck;
5602         }
5603         on_rq = p->on_rq;
5604         running = task_current(rq, p);
5605         if (on_rq)
5606                 deactivate_task(rq, p, 0);
5607         if (running)
5608                 p->sched_class->put_prev_task(rq, p);
5609
5610         p->sched_reset_on_fork = reset_on_fork;
5611
5612         oldprio = p->prio;
5613         prev_class = p->sched_class;
5614         __setscheduler(rq, p, policy, param->sched_priority);
5615
5616         if (running)
5617                 p->sched_class->set_curr_task(rq);
5618         if (on_rq)
5619                 activate_task(rq, p, 0);
5620
5621         check_class_changed(rq, p, prev_class, oldprio);
5622         task_rq_unlock(rq, p, &flags);
5623
5624         rt_mutex_adjust_pi(p);
5625
5626         return 0;
5627 }
5628
5629 /**
5630  * sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
5631  * @p: the task in question.
5632  * @policy: new policy.
5633  * @param: structure containing the new RT priority.
5634  *
5635  * NOTE that the task may be already dead.
5636  */
5637 int sched_setscheduler(struct task_struct *p, int policy,
5638                        const struct sched_param *param)
5639 {
5640         return __sched_setscheduler(p, policy, param, true);
5641 }
5642 EXPORT_SYMBOL_GPL(sched_setscheduler);
5643
5644 /**
5645  * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace.
5646  * @p: the task in question.
5647  * @policy: new policy.
5648  * @param: structure containing the new RT priority.
5649  *
5650  * Just like sched_setscheduler, only don't bother checking if the
5651  * current context has permission.  For example, this is needed in
5652  * stop_machine(): we create temporary high priority worker threads,
5653  * but our caller might not have that capability.
5654  */
5655 int sched_setscheduler_nocheck(struct task_struct *p, int policy,
5656                                const struct sched_param *param)
5657 {
5658         return __sched_setscheduler(p, policy, param, false);
5659 }
5660
5661 static int
5662 do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
5663 {
5664         struct sched_param lparam;
5665         struct task_struct *p;
5666         int retval;
5667
5668         if (!param || pid < 0)
5669                 return -EINVAL;
5670         if (copy_from_user(&lparam, param, sizeof(struct sched_param)))
5671                 return -EFAULT;
5672
5673         rcu_read_lock();
5674         retval = -ESRCH;
5675         p = find_process_by_pid(pid);
5676         if (p != NULL)
5677                 retval = sched_setscheduler(p, policy, &lparam);
5678         rcu_read_unlock();
5679
5680         return retval;
5681 }
5682
5683 /**
5684  * sys_sched_setscheduler - set/change the scheduler policy and RT priority
5685  * @pid: the pid in question.
5686  * @policy: new policy.
5687  * @param: structure containing the new RT priority.
5688  */
5689 SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy,
5690                 struct sched_param __user *, param)
5691 {
5692         /* negative values for policy are not valid */
5693         if (policy < 0)
5694                 return -EINVAL;
5695
5696         return do_sched_setscheduler(pid, policy, param);
5697 }
5698
5699 /**
5700  * sys_sched_setparam - set/change the RT priority of a thread
5701  * @pid: the pid in question.
5702  * @param: structure containing the new RT priority.
5703  */
5704 SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
5705 {
5706         return do_sched_setscheduler(pid, -1, param);
5707 }
5708
5709 /**
5710  * sys_sched_getscheduler - get the policy (scheduling class) of a thread
5711  * @pid: the pid in question.
5712  */
5713 SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
5714 {
5715         struct task_struct *p;
5716         int retval;
5717
5718         if (pid < 0)
5719                 return -EINVAL;
5720
5721         retval = -ESRCH;
5722         rcu_read_lock();
5723         p = find_process_by_pid(pid);
5724         if (p) {
5725                 retval = security_task_getscheduler(p);
5726                 if (!retval)
5727                         retval = p->policy
5728                                 | (p->sched_reset_on_fork ? SCHED_RESET_ON_FORK : 0);
5729         }
5730         rcu_read_unlock();
5731         return retval;
5732 }
5733
5734 /**
5735  * sys_sched_getparam - get the RT priority of a thread
5736  * @pid: the pid in question.
5737  * @param: structure containing the RT priority.
5738  */
5739 SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
5740 {
5741         struct sched_param lp;
5742         struct task_struct *p;
5743         int retval;
5744
5745         if (!param || pid < 0)
5746                 return -EINVAL;
5747
5748         rcu_read_lock();
5749         p = find_process_by_pid(pid);
5750         retval = -ESRCH;
5751         if (!p)
5752                 goto out_unlock;
5753
5754         retval = security_task_getscheduler(p);
5755         if (retval)
5756                 goto out_unlock;
5757
5758         lp.sched_priority = p->rt_priority;
5759         rcu_read_unlock();
5760
5761         /*
5762          * This one might sleep, we cannot do it with a spinlock held ...
5763          */
5764         retval = copy_to_user(param, &lp, sizeof(*param)) ? -EFAULT : 0;
5765
5766         return retval;
5767
5768 out_unlock:
5769         rcu_read_unlock();
5770         return retval;
5771 }
5772
5773 long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)
5774 {
5775         cpumask_var_t cpus_allowed, new_mask;
5776         struct task_struct *p;
5777         int retval;
5778
5779         get_online_cpus();
5780         rcu_read_lock();
5781
5782         p = find_process_by_pid(pid);
5783         if (!p) {
5784                 rcu_read_unlock();
5785                 put_online_cpus();
5786                 return -ESRCH;
5787         }
5788
5789         /* Prevent p going away */
5790         get_task_struct(p);
5791         rcu_read_unlock();
5792
5793         if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL)) {
5794                 retval = -ENOMEM;
5795                 goto out_put_task;
5796         }
5797         if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) {
5798                 retval = -ENOMEM;
5799                 goto out_free_cpus_allowed;
5800         }
5801         retval = -EPERM;
5802         if (!check_same_owner(p) && !task_ns_capable(p, CAP_SYS_NICE))
5803                 goto out_unlock;
5804
5805         retval = security_task_setscheduler(p);
5806         if (retval)
5807                 goto out_unlock;
5808
5809         cpuset_cpus_allowed(p, cpus_allowed);
5810         cpumask_and(new_mask, in_mask, cpus_allowed);
5811 again:
5812         retval = set_cpus_allowed_ptr(p, new_mask);
5813
5814         if (!retval) {
5815                 cpuset_cpus_allowed(p, cpus_allowed);
5816                 if (!cpumask_subset(new_mask, cpus_allowed)) {
5817                         /*
5818                          * We must have raced with a concurrent cpuset
5819                          * update. Just reset the cpus_allowed to the
5820                          * cpuset's cpus_allowed
5821                          */
5822                         cpumask_copy(new_mask, cpus_allowed);
5823                         goto again;
5824                 }
5825         }
5826 out_unlock:
5827         free_cpumask_var(new_mask);
5828 out_free_cpus_allowed:
5829         free_cpumask_var(cpus_allowed);
5830 out_put_task:
5831         put_task_struct(p);
5832         put_online_cpus();
5833         return retval;
5834 }
5835
5836 static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
5837                              struct cpumask *new_mask)
5838 {
5839         if (len < cpumask_size())
5840                 cpumask_clear(new_mask);
5841         else if (len > cpumask_size())
5842                 len = cpumask_size();
5843
5844         return copy_from_user(new_mask, user_mask_ptr, len) ? -EFAULT : 0;
5845 }
5846
5847 /**
5848  * sys_sched_setaffinity - set the cpu affinity of a process
5849  * @pid: pid of the process
5850  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
5851  * @user_mask_ptr: user-space pointer to the new cpu mask
5852  */
5853 SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
5854                 unsigned long __user *, user_mask_ptr)
5855 {
5856         cpumask_var_t new_mask;
5857         int retval;
5858
5859         if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
5860                 return -ENOMEM;
5861
5862         retval = get_user_cpu_mask(user_mask_ptr, len, new_mask);
5863         if (retval == 0)
5864                 retval = sched_setaffinity(pid, new_mask);
5865         free_cpumask_var(new_mask);
5866         return retval;
5867 }
5868
5869 long sched_getaffinity(pid_t pid, struct cpumask *mask)
5870 {
5871         struct task_struct *p;
5872         unsigned long flags;
5873         int retval;
5874
5875         get_online_cpus();
5876         rcu_read_lock();
5877
5878         retval = -ESRCH;
5879         p = find_process_by_pid(pid);
5880         if (!p)
5881                 goto out_unlock;
5882
5883         retval = security_task_getscheduler(p);
5884         if (retval)
5885                 goto out_unlock;
5886
5887         raw_spin_lock_irqsave(&p->pi_lock, flags);
5888         cpumask_and(mask, &p->cpus_allowed, cpu_online_mask);
5889         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
5890
5891 out_unlock:
5892         rcu_read_unlock();
5893         put_online_cpus();
5894
5895         return retval;
5896 }
5897
5898 /**
5899  * sys_sched_getaffinity - get the cpu affinity of a process
5900  * @pid: pid of the process
5901  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
5902  * @user_mask_ptr: user-space pointer to hold the current cpu mask
5903  */
5904 SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len,
5905                 unsigned long __user *, user_mask_ptr)
5906 {
5907         int ret;
5908         cpumask_var_t mask;
5909
5910         if ((len * BITS_PER_BYTE) < nr_cpu_ids)
5911                 return -EINVAL;
5912         if (len & (sizeof(unsigned long)-1))
5913                 return -EINVAL;
5914
5915         if (!alloc_cpumask_var(&mask, GFP_KERNEL))
5916                 return -ENOMEM;
5917
5918         ret = sched_getaffinity(pid, mask);
5919         if (ret == 0) {
5920                 size_t retlen = min_t(size_t, len, cpumask_size());
5921
5922                 if (copy_to_user(user_mask_ptr, mask, retlen))
5923                         ret = -EFAULT;
5924                 else
5925                         ret = retlen;
5926         }
5927         free_cpumask_var(mask);
5928
5929         return ret;
5930 }
5931
5932 /**
5933  * sys_sched_yield - yield the current processor to other threads.
5934  *
5935  * This function yields the current CPU to other tasks. If there are no
5936  * other threads running on this CPU then this function will return.
5937  */
5938 SYSCALL_DEFINE0(sched_yield)
5939 {
5940         struct rq *rq = this_rq_lock();
5941
5942         schedstat_inc(rq, yld_count);
5943         current->sched_class->yield_task(rq);
5944
5945         /*
5946          * Since we are going to call schedule() anyway, there's
5947          * no need to preempt or enable interrupts:
5948          */
5949         __release(rq->lock);
5950         spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
5951         do_raw_spin_unlock(&rq->lock);
5952         preempt_enable_no_resched();
5953
5954         schedule();
5955
5956         return 0;
5957 }
5958
5959 static inline int should_resched(void)
5960 {
5961         return need_resched() && !(preempt_count() & PREEMPT_ACTIVE);
5962 }
5963
5964 static void __cond_resched(void)
5965 {
5966         add_preempt_count(PREEMPT_ACTIVE);
5967         __schedule();
5968         sub_preempt_count(PREEMPT_ACTIVE);
5969 }
5970
5971 int __sched _cond_resched(void)
5972 {
5973         if (should_resched()) {
5974                 __cond_resched();
5975                 return 1;
5976         }
5977         return 0;
5978 }
5979 EXPORT_SYMBOL(_cond_resched);
5980
5981 /*
5982  * __cond_resched_lock() - if a reschedule is pending, drop the given lock,
5983  * call schedule, and on return reacquire the lock.
5984  *
5985  * This works OK both with and without CONFIG_PREEMPT. We do strange low-level
5986  * operations here to prevent schedule() from being called twice (once via
5987  * spin_unlock(), once by hand).
5988  */
5989 int __cond_resched_lock(spinlock_t *lock)
5990 {
5991         int resched = should_resched();
5992         int ret = 0;
5993
5994         lockdep_assert_held(lock);
5995
5996         if (spin_needbreak(lock) || resched) {
5997                 spin_unlock(lock);
5998                 if (resched)
5999                         __cond_resched();
6000                 else
6001                         cpu_relax();
6002                 ret = 1;
6003                 spin_lock(lock);
6004         }
6005         return ret;
6006 }
6007 EXPORT_SYMBOL(__cond_resched_lock);
6008
6009 int __sched __cond_resched_softirq(void)
6010 {
6011         BUG_ON(!in_softirq());
6012
6013         if (should_resched()) {
6014                 local_bh_enable();
6015                 __cond_resched();
6016                 local_bh_disable();
6017                 return 1;
6018         }
6019         return 0;
6020 }
6021 EXPORT_SYMBOL(__cond_resched_softirq);
6022
6023 /**
6024  * yield - yield the current processor to other threads.
6025  *
6026  * This is a shortcut for kernel-space yielding - it marks the
6027  * thread runnable and calls sys_sched_yield().
6028  */
6029 void __sched yield(void)
6030 {
6031         set_current_state(TASK_RUNNING);
6032         sys_sched_yield();
6033 }
6034 EXPORT_SYMBOL(yield);
6035
6036 /**
6037  * yield_to - yield the current processor to another thread in
6038  * your thread group, or accelerate that thread toward the
6039  * processor it's on.
6040  * @p: target task
6041  * @preempt: whether task preemption is allowed or not
6042  *
6043  * It's the caller's job to ensure that the target task struct
6044  * can't go away on us before we can do any checks.
6045  *
6046  * Returns true if we indeed boosted the target task.
6047  */
6048 bool __sched yield_to(struct task_struct *p, bool preempt)
6049 {
6050         struct task_struct *curr = current;
6051         struct rq *rq, *p_rq;
6052         unsigned long flags;
6053         bool yielded = 0;
6054
6055         local_irq_save(flags);
6056         rq = this_rq();
6057
6058 again:
6059         p_rq = task_rq(p);
6060         double_rq_lock(rq, p_rq);
6061         while (task_rq(p) != p_rq) {
6062                 double_rq_unlock(rq, p_rq);
6063                 goto again;
6064         }
6065
6066         if (!curr->sched_class->yield_to_task)
6067                 goto out;
6068
6069         if (curr->sched_class != p->sched_class)
6070                 goto out;
6071
6072         if (task_running(p_rq, p) || p->state)
6073                 goto out;
6074
6075         yielded = curr->sched_class->yield_to_task(rq, p, preempt);
6076         if (yielded) {
6077                 schedstat_inc(rq, yld_count);
6078                 /*
6079                  * Make p's CPU reschedule; pick_next_entity takes care of
6080                  * fairness.
6081                  */
6082                 if (preempt && rq != p_rq)
6083                         resched_task(p_rq->curr);
6084         }
6085
6086 out:
6087         double_rq_unlock(rq, p_rq);
6088         local_irq_restore(flags);
6089
6090         if (yielded)
6091                 schedule();
6092
6093         return yielded;
6094 }
6095 EXPORT_SYMBOL_GPL(yield_to);
6096
6097 /*
6098  * This task is about to go to sleep on IO. Increment rq->nr_iowait so
6099  * that process accounting knows that this is a task in IO wait state.
6100  */
6101 void __sched io_schedule(void)
6102 {
6103         struct rq *rq = raw_rq();
6104
6105         delayacct_blkio_start();
6106         atomic_inc(&rq->nr_iowait);
6107         blk_flush_plug(current);
6108         current->in_iowait = 1;
6109         schedule();
6110         current->in_iowait = 0;
6111         atomic_dec(&rq->nr_iowait);
6112         delayacct_blkio_end();
6113 }
6114 EXPORT_SYMBOL(io_schedule);
6115
6116 long __sched io_schedule_timeout(long timeout)
6117 {
6118         struct rq *rq = raw_rq();
6119         long ret;
6120
6121         delayacct_blkio_start();
6122         atomic_inc(&rq->nr_iowait);
6123         blk_flush_plug(current);
6124         current->in_iowait = 1;
6125         ret = schedule_timeout(timeout);
6126         current->in_iowait = 0;
6127         atomic_dec(&rq->nr_iowait);
6128         delayacct_blkio_end();
6129         return ret;
6130 }
6131
6132 /**
6133  * sys_sched_get_priority_max - return maximum RT priority.
6134  * @policy: scheduling class.
6135  *
6136  * this syscall returns the maximum rt_priority that can be used
6137  * by a given scheduling class.
6138  */
6139 SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
6140 {
6141         int ret = -EINVAL;
6142
6143         switch (policy) {
6144         case SCHED_FIFO:
6145         case SCHED_RR:
6146                 ret = MAX_USER_RT_PRIO-1;
6147                 break;
6148         case SCHED_NORMAL:
6149         case SCHED_BATCH:
6150         case SCHED_IDLE:
6151                 ret = 0;
6152                 break;
6153         }
6154         return ret;
6155 }
6156
6157 /**
6158  * sys_sched_get_priority_min - return minimum RT priority.
6159  * @policy: scheduling class.
6160  *
6161  * this syscall returns the minimum rt_priority that can be used
6162  * by a given scheduling class.
6163  */
6164 SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
6165 {
6166         int ret = -EINVAL;
6167
6168         switch (policy) {
6169         case SCHED_FIFO:
6170         case SCHED_RR:
6171                 ret = 1;
6172                 break;
6173         case SCHED_NORMAL:
6174         case SCHED_BATCH:
6175         case SCHED_IDLE:
6176                 ret = 0;
6177         }
6178         return ret;
6179 }
6180
6181 /**
6182  * sys_sched_rr_get_interval - return the default timeslice of a process.
6183  * @pid: pid of the process.
6184  * @interval: userspace pointer to the timeslice value.
6185  *
6186  * this syscall writes the default timeslice value of a given process
6187  * into the user-space timespec buffer. A value of '0' means infinity.
6188  */
6189 SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
6190                 struct timespec __user *, interval)
6191 {
6192         struct task_struct *p;
6193         unsigned int time_slice;
6194         unsigned long flags;
6195         struct rq *rq;
6196         int retval;
6197         struct timespec t;
6198
6199         if (pid < 0)
6200                 return -EINVAL;
6201
6202         retval = -ESRCH;
6203         rcu_read_lock();
6204         p = find_process_by_pid(pid);
6205         if (!p)
6206                 goto out_unlock;
6207
6208         retval = security_task_getscheduler(p);
6209         if (retval)
6210                 goto out_unlock;
6211
6212         rq = task_rq_lock(p, &flags);
6213         time_slice = p->sched_class->get_rr_interval(rq, p);
6214         task_rq_unlock(rq, p, &flags);
6215
6216         rcu_read_unlock();
6217         jiffies_to_timespec(time_slice, &t);
6218         retval = copy_to_user(interval, &t, sizeof(t)) ? -EFAULT : 0;
6219         return retval;
6220
6221 out_unlock:
6222         rcu_read_unlock();
6223         return retval;
6224 }
6225
6226 static const char stat_nam[] = TASK_STATE_TO_CHAR_STR;
6227
6228 void sched_show_task(struct task_struct *p)
6229 {
6230         unsigned long free = 0;
6231         unsigned state;
6232
6233         state = p->state ? __ffs(p->state) + 1 : 0;
6234         printk(KERN_INFO "%-15.15s %c", p->comm,
6235                 state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
6236 #if BITS_PER_LONG == 32
6237         if (state == TASK_RUNNING)
6238                 printk(KERN_CONT " running  ");
6239         else
6240                 printk(KERN_CONT " %08lx ", thread_saved_pc(p));
6241 #else
6242         if (state == TASK_RUNNING)
6243                 printk(KERN_CONT "  running task    ");
6244         else
6245                 printk(KERN_CONT " %016lx ", thread_saved_pc(p));
6246 #endif
6247 #ifdef CONFIG_DEBUG_STACK_USAGE
6248         free = stack_not_used(p);
6249 #endif
6250         printk(KERN_CONT "%5lu %5d %6d 0x%08lx\n", free,
6251                 task_pid_nr(p), task_pid_nr(p->real_parent),
6252                 (unsigned long)task_thread_info(p)->flags);
6253
6254         show_stack(p, NULL);
6255 }
6256
6257 void show_state_filter(unsigned long state_filter)
6258 {
6259         struct task_struct *g, *p;
6260
6261 #if BITS_PER_LONG == 32
6262         printk(KERN_INFO
6263                 "  task                PC stack   pid father\n");
6264 #else
6265         printk(KERN_INFO
6266                 "  task                        PC stack   pid father\n");
6267 #endif
6268         rcu_read_lock();
6269         do_each_thread(g, p) {
6270                 /*
6271                  * reset the NMI-timeout, listing all files on a slow
6272                  * console might take a lot of time:
6273                  * Also, reset softlockup watchdogs on all CPUs, because
6274                  * another CPU might be blocked waiting for us to process
6275                  * an IPI.
6276                  */
6277                 touch_nmi_watchdog();
6278                 touch_all_softlockup_watchdogs();
6279                 if (!state_filter || (p->state & state_filter))
6280                         sched_show_task(p);
6281         } while_each_thread(g, p);
6282
6283 #ifdef CONFIG_SCHED_DEBUG
6284         sysrq_sched_debug_show();
6285 #endif
6286         rcu_read_unlock();
6287         /*
6288          * Only show locks if all tasks are dumped:
6289          */
6290         if (!state_filter)
6291                 debug_show_all_locks();
6292 }
6293
6294 void __cpuinit init_idle_bootup_task(struct task_struct *idle)
6295 {
6296         idle->sched_class = &idle_sched_class;
6297 }
6298
6299 /**
6300  * init_idle - set up an idle thread for a given CPU
6301  * @idle: task in question
6302  * @cpu: cpu the idle task belongs to
6303  *
6304  * NOTE: this function does not set the idle thread's NEED_RESCHED
6305  * flag, to make booting more robust.
6306  */
6307 void __cpuinit init_idle(struct task_struct *idle, int cpu)
6308 {
6309         struct rq *rq = cpu_rq(cpu);
6310         unsigned long flags;
6311
6312         raw_spin_lock_irqsave(&rq->lock, flags);
6313
6314         __sched_fork(idle);
6315         idle->state = TASK_RUNNING;
6316         idle->se.exec_start = sched_clock();
6317
6318         do_set_cpus_allowed(idle, cpumask_of(cpu));
6319         /*
6320          * We're having a chicken and egg problem, even though we are
6321          * holding rq->lock, the cpu isn't yet set to this cpu so the
6322          * lockdep check in task_group() will fail.
6323          *
6324          * Similar case to sched_fork(). / Alternatively we could
6325          * use task_rq_lock() here and obtain the other rq->lock.
6326          *
6327          * Silence PROVE_RCU
6328          */
6329         rcu_read_lock();
6330         __set_task_cpu(idle, cpu);
6331         rcu_read_unlock();
6332
6333         rq->curr = rq->idle = idle;
6334 #if defined(CONFIG_SMP)
6335         idle->on_cpu = 1;
6336 #endif
6337         raw_spin_unlock_irqrestore(&rq->lock, flags);
6338
6339         /* Set the preempt count _outside_ the spinlocks! */
6340         task_thread_info(idle)->preempt_count = 0;
6341
6342         /*
6343          * The idle tasks have their own, simple scheduling class:
6344          */
6345         idle->sched_class = &idle_sched_class;
6346         ftrace_graph_init_idle_task(idle, cpu);
6347 #if defined(CONFIG_SMP)
6348         sprintf(idle->comm, "%s/%d", INIT_TASK_COMM, cpu);
6349 #endif
6350 }
6351
6352 /*
6353  * Increase the granularity value when there are more CPUs,
6354  * because with more CPUs the 'effective latency' as visible
6355  * to users decreases. But the relationship is not linear,
6356  * so pick a second-best guess by going with the log2 of the
6357  * number of CPUs.
6358  *
6359  * This idea comes from the SD scheduler of Con Kolivas:
6360  */
6361 static int get_update_sysctl_factor(void)
6362 {
6363         unsigned int cpus = min_t(int, num_online_cpus(), 8);
6364         unsigned int factor;
6365
6366         switch (sysctl_sched_tunable_scaling) {
6367         case SCHED_TUNABLESCALING_NONE:
6368                 factor = 1;
6369                 break;
6370         case SCHED_TUNABLESCALING_LINEAR:
6371                 factor = cpus;
6372                 break;
6373         case SCHED_TUNABLESCALING_LOG:
6374         default:
6375                 factor = 1 + ilog2(cpus);
6376                 break;
6377         }
6378
6379         return factor;
6380 }
6381
6382 static void update_sysctl(void)
6383 {
6384         unsigned int factor = get_update_sysctl_factor();
6385
6386 #define SET_SYSCTL(name) \
6387         (sysctl_##name = (factor) * normalized_sysctl_##name)
6388         SET_SYSCTL(sched_min_granularity);
6389         SET_SYSCTL(sched_latency);
6390         SET_SYSCTL(sched_wakeup_granularity);
6391 #undef SET_SYSCTL
6392 }
6393
6394 static inline void sched_init_granularity(void)
6395 {
6396         update_sysctl();
6397 }
6398
6399 #ifdef CONFIG_SMP
6400 void do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask)
6401 {
6402         if (p->sched_class && p->sched_class->set_cpus_allowed)
6403                 p->sched_class->set_cpus_allowed(p, new_mask);
6404
6405         cpumask_copy(&p->cpus_allowed, new_mask);
6406         p->rt.nr_cpus_allowed = cpumask_weight(new_mask);
6407 }
6408
6409 /*
6410  * This is how migration works:
6411  *
6412  * 1) we invoke migration_cpu_stop() on the target CPU using
6413  *    stop_one_cpu().
6414  * 2) stopper starts to run (implicitly forcing the migrated thread
6415  *    off the CPU)
6416  * 3) it checks whether the migrated task is still in the wrong runqueue.
6417  * 4) if it's in the wrong runqueue then the migration thread removes
6418  *    it and puts it into the right queue.
6419  * 5) stopper completes and stop_one_cpu() returns and the migration
6420  *    is done.
6421  */
6422
6423 /*
6424  * Change a given task's CPU affinity. Migrate the thread to a
6425  * proper CPU and schedule it away if the CPU it's executing on
6426  * is removed from the allowed bitmask.
6427  *
6428  * NOTE: the caller must have a valid reference to the task, the
6429  * task must not exit() & deallocate itself prematurely. The
6430  * call is not atomic; no spinlocks may be held.
6431  */
6432 int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
6433 {
6434         unsigned long flags;
6435         struct rq *rq;
6436         unsigned int dest_cpu;
6437         int ret = 0;
6438
6439         rq = task_rq_lock(p, &flags);
6440
6441         if (cpumask_equal(&p->cpus_allowed, new_mask))
6442                 goto out;
6443
6444         if (!cpumask_intersects(new_mask, cpu_active_mask)) {
6445                 ret = -EINVAL;
6446                 goto out;
6447         }
6448
6449         if (unlikely((p->flags & PF_THREAD_BOUND) && p != current)) {
6450                 ret = -EINVAL;
6451                 goto out;
6452         }
6453
6454         do_set_cpus_allowed(p, new_mask);
6455
6456         /* Can the task run on the task's current CPU? If so, we're done */
6457         if (cpumask_test_cpu(task_cpu(p), new_mask))
6458                 goto out;
6459
6460         dest_cpu = cpumask_any_and(cpu_active_mask, new_mask);
6461         if (p->on_rq) {
6462                 struct migration_arg arg = { p, dest_cpu };
6463                 /* Need help from migration thread: drop lock and wait. */
6464                 task_rq_unlock(rq, p, &flags);
6465                 stop_one_cpu(cpu_of(rq), migration_cpu_stop, &arg);
6466                 tlb_migrate_finish(p->mm);
6467                 return 0;
6468         }
6469 out:
6470         task_rq_unlock(rq, p, &flags);
6471
6472         return ret;
6473 }
6474 EXPORT_SYMBOL_GPL(set_cpus_allowed_ptr);
6475
6476 /*
6477  * Move (not current) task off this cpu, onto dest cpu. We're doing
6478  * this because either it can't run here any more (set_cpus_allowed()
6479  * away from this CPU, or CPU going down), or because we're
6480  * attempting to rebalance this task on exec (sched_exec).
6481  *
6482  * So we race with normal scheduler movements, but that's OK, as long
6483  * as the task is no longer on this CPU.
6484  *
6485  * Returns non-zero if task was successfully migrated.
6486  */
6487 static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
6488 {
6489         struct rq *rq_dest, *rq_src;
6490         int ret = 0;
6491
6492         if (unlikely(!cpu_active(dest_cpu)))
6493                 return ret;
6494
6495         rq_src = cpu_rq(src_cpu);
6496         rq_dest = cpu_rq(dest_cpu);
6497
6498         raw_spin_lock(&p->pi_lock);
6499         double_rq_lock(rq_src, rq_dest);
6500         /* Already moved. */
6501         if (task_cpu(p) != src_cpu)
6502                 goto done;
6503         /* Affinity changed (again). */
6504         if (!cpumask_test_cpu(dest_cpu, tsk_cpus_allowed(p)))
6505                 goto fail;
6506
6507         /*
6508          * If we're not on a rq, the next wake-up will ensure we're
6509          * placed properly.
6510          */
6511         if (p->on_rq) {
6512                 deactivate_task(rq_src, p, 0);
6513                 set_task_cpu(p, dest_cpu);
6514                 activate_task(rq_dest, p, 0);
6515                 check_preempt_curr(rq_dest, p, 0);
6516         }
6517 done:
6518         ret = 1;
6519 fail:
6520         double_rq_unlock(rq_src, rq_dest);
6521         raw_spin_unlock(&p->pi_lock);
6522         return ret;
6523 }
6524
6525 /*
6526  * migration_cpu_stop - this will be executed by a highprio stopper thread
6527  * and performs thread migration by bumping thread off CPU then
6528  * 'pushing' onto another runqueue.
6529  */
6530 static int migration_cpu_stop(void *data)
6531 {
6532         struct migration_arg *arg = data;
6533
6534         /*
6535          * The original target cpu might have gone down and we might
6536          * be on another cpu but it doesn't matter.
6537          */
6538         local_irq_disable();
6539         __migrate_task(arg->task, raw_smp_processor_id(), arg->dest_cpu);
6540         local_irq_enable();
6541         return 0;
6542 }
6543
6544 #ifdef CONFIG_HOTPLUG_CPU
6545
6546 /*
6547  * Ensures that the idle task is using init_mm right before its cpu goes
6548  * offline.
6549  */
6550 void idle_task_exit(void)
6551 {
6552         struct mm_struct *mm = current->active_mm;
6553
6554         BUG_ON(cpu_online(smp_processor_id()));
6555
6556         if (mm != &init_mm)
6557                 switch_mm(mm, &init_mm, current);
6558         mmdrop(mm);
6559 }
6560
6561 /*
6562  * While a dead CPU has no uninterruptible tasks queued at this point,
6563  * it might still have a nonzero ->nr_uninterruptible counter, because
6564  * for performance reasons the counter is not stricly tracking tasks to
6565  * their home CPUs. So we just add the counter to another CPU's counter,
6566  * to keep the global sum constant after CPU-down:
6567  */
6568 static void migrate_nr_uninterruptible(struct rq *rq_src)
6569 {
6570         struct rq *rq_dest = cpu_rq(cpumask_any(cpu_active_mask));
6571
6572         rq_dest->nr_uninterruptible += rq_src->nr_uninterruptible;
6573         rq_src->nr_uninterruptible = 0;
6574 }
6575
6576 /*
6577  * remove the tasks which were accounted by rq from calc_load_tasks.
6578  */
6579 static void calc_global_load_remove(struct rq *rq)
6580 {
6581         atomic_long_sub(rq->calc_load_active, &calc_load_tasks);
6582         rq->calc_load_active = 0;
6583 }
6584
6585 #ifdef CONFIG_CFS_BANDWIDTH
6586 static void unthrottle_offline_cfs_rqs(struct rq *rq)
6587 {
6588         struct cfs_rq *cfs_rq;
6589
6590         for_each_leaf_cfs_rq(rq, cfs_rq) {
6591                 struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
6592
6593                 if (!cfs_rq->runtime_enabled)
6594                         continue;
6595
6596                 /*
6597                  * clock_task is not advancing so we just need to make sure
6598                  * there's some valid quota amount
6599                  */
6600                 cfs_rq->runtime_remaining = cfs_b->quota;
6601                 if (cfs_rq_throttled(cfs_rq))
6602                         unthrottle_cfs_rq(cfs_rq);
6603         }
6604 }
6605 #endif
6606
6607 /*
6608  * Migrate all tasks from the rq, sleeping tasks will be migrated by
6609  * try_to_wake_up()->select_task_rq().
6610  *
6611  * Called with rq->lock held even though we'er in stop_machine() and
6612  * there's no concurrency possible, we hold the required locks anyway
6613  * because of lock validation efforts.
6614  */
6615 static void migrate_tasks(unsigned int dead_cpu)
6616 {
6617         struct rq *rq = cpu_rq(dead_cpu);
6618         struct task_struct *next, *stop = rq->stop;
6619         int dest_cpu;
6620
6621         /*
6622          * Fudge the rq selection such that the below task selection loop
6623          * doesn't get stuck on the currently eligible stop task.
6624          *
6625          * We're currently inside stop_machine() and the rq is either stuck
6626          * in the stop_machine_cpu_stop() loop, or we're executing this code,
6627          * either way we should never end up calling schedule() until we're
6628          * done here.
6629          */
6630         rq->stop = NULL;
6631
6632         for ( ; ; ) {
6633                 /*
6634                  * There's this thread running, bail when that's the only
6635                  * remaining thread.
6636                  */
6637                 if (rq->nr_running == 1)
6638                         break;
6639
6640                 next = pick_next_task(rq);
6641                 BUG_ON(!next);
6642                 next->sched_class->put_prev_task(rq, next);
6643
6644                 /* Find suitable destination for @next, with force if needed. */
6645                 dest_cpu = select_fallback_rq(dead_cpu, next);
6646                 raw_spin_unlock(&rq->lock);
6647
6648                 __migrate_task(next, dead_cpu, dest_cpu);
6649
6650                 raw_spin_lock(&rq->lock);
6651         }
6652
6653         rq->stop = stop;
6654 }
6655
6656 #endif /* CONFIG_HOTPLUG_CPU */
6657
6658 #if !defined(CONFIG_HOTPLUG_CPU) || !defined(CONFIG_CFS_BANDWIDTH)
6659 static void unthrottle_offline_cfs_rqs(struct rq *rq) {}
6660 #endif
6661
6662 #if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_SYSCTL)
6663
6664 static struct ctl_table sd_ctl_dir[] = {
6665         {
6666                 .procname       = "sched_domain",
6667                 .mode           = 0555,
6668         },
6669         {}
6670 };
6671
6672 static struct ctl_table sd_ctl_root[] = {
6673         {
6674                 .procname       = "kernel",
6675                 .mode           = 0555,
6676                 .child          = sd_ctl_dir,
6677         },
6678         {}
6679 };
6680
6681 static struct ctl_table *sd_alloc_ctl_entry(int n)
6682 {
6683         struct ctl_table *entry =
6684                 kcalloc(n, sizeof(struct ctl_table), GFP_KERNEL);
6685
6686         return entry;
6687 }
6688
6689 static void sd_free_ctl_entry(struct ctl_table **tablep)
6690 {
6691         struct ctl_table *entry;
6692
6693         /*
6694          * In the intermediate directories, both the child directory and
6695          * procname are dynamically allocated and could fail but the mode
6696          * will always be set. In the lowest directory the names are
6697          * static strings and all have proc handlers.
6698          */
6699         for (entry = *tablep; entry->mode; entry++) {
6700                 if (entry->child)
6701                         sd_free_ctl_entry(&entry->child);
6702                 if (entry->proc_handler == NULL)
6703                         kfree(entry->procname);
6704         }
6705
6706         kfree(*tablep);
6707         *tablep = NULL;
6708 }
6709
6710 static int min_load_idx = 0;
6711 static int max_load_idx = CPU_LOAD_IDX_MAX-1;
6712
6713 static void
6714 set_table_entry(struct ctl_table *entry,
6715                 const char *procname, void *data, int maxlen,
6716                 mode_t mode, proc_handler *proc_handler,
6717                 bool load_idx)
6718 {
6719         entry->procname = procname;
6720         entry->data = data;
6721         entry->maxlen = maxlen;
6722         entry->mode = mode;
6723         entry->proc_handler = proc_handler;
6724
6725         if (load_idx) {
6726                 entry->extra1 = &min_load_idx;
6727                 entry->extra2 = &max_load_idx;
6728         }
6729 }
6730
6731 static struct ctl_table *
6732 sd_alloc_ctl_domain_table(struct sched_domain *sd)
6733 {
6734         struct ctl_table *table = sd_alloc_ctl_entry(13);
6735
6736         if (table == NULL)
6737                 return NULL;
6738
6739         set_table_entry(&table[0], "min_interval", &sd->min_interval,
6740                 sizeof(long), 0644, proc_doulongvec_minmax, false);
6741         set_table_entry(&table[1], "max_interval", &sd->max_interval,
6742                 sizeof(long), 0644, proc_doulongvec_minmax, false);
6743         set_table_entry(&table[2], "busy_idx", &sd->busy_idx,
6744                 sizeof(int), 0644, proc_dointvec_minmax, true);
6745         set_table_entry(&table[3], "idle_idx", &sd->idle_idx,
6746                 sizeof(int), 0644, proc_dointvec_minmax, true);
6747         set_table_entry(&table[4], "newidle_idx", &sd->newidle_idx,
6748                 sizeof(int), 0644, proc_dointvec_minmax, true);
6749         set_table_entry(&table[5], "wake_idx", &sd->wake_idx,
6750                 sizeof(int), 0644, proc_dointvec_minmax, true);
6751         set_table_entry(&table[6], "forkexec_idx", &sd->forkexec_idx,
6752                 sizeof(int), 0644, proc_dointvec_minmax, true);
6753         set_table_entry(&table[7], "busy_factor", &sd->busy_factor,
6754                 sizeof(int), 0644, proc_dointvec_minmax, false);
6755         set_table_entry(&table[8], "imbalance_pct", &sd->imbalance_pct,
6756                 sizeof(int), 0644, proc_dointvec_minmax, false);
6757         set_table_entry(&table[9], "cache_nice_tries",
6758                 &sd->cache_nice_tries,
6759                 sizeof(int), 0644, proc_dointvec_minmax, false);
6760         set_table_entry(&table[10], "flags", &sd->flags,
6761                 sizeof(int), 0644, proc_dointvec_minmax, false);
6762         set_table_entry(&table[11], "name", sd->name,
6763                 CORENAME_MAX_SIZE, 0444, proc_dostring, false);
6764         /* &table[12] is terminator */
6765
6766         return table;
6767 }
6768
6769 static ctl_table *sd_alloc_ctl_cpu_table(int cpu)
6770 {
6771         struct ctl_table *entry, *table;
6772         struct sched_domain *sd;
6773         int domain_num = 0, i;
6774         char buf[32];
6775
6776         for_each_domain(cpu, sd)
6777                 domain_num++;
6778         entry = table = sd_alloc_ctl_entry(domain_num + 1);
6779         if (table == NULL)
6780                 return NULL;
6781
6782         i = 0;
6783         for_each_domain(cpu, sd) {
6784                 snprintf(buf, 32, "domain%d", i);
6785                 entry->procname = kstrdup(buf, GFP_KERNEL);
6786                 entry->mode = 0555;
6787                 entry->child = sd_alloc_ctl_domain_table(sd);
6788                 entry++;
6789                 i++;
6790         }
6791         return table;
6792 }
6793
6794 static struct ctl_table_header *sd_sysctl_header;
6795 static void register_sched_domain_sysctl(void)
6796 {
6797         int i, cpu_num = num_possible_cpus();
6798         struct ctl_table *entry = sd_alloc_ctl_entry(cpu_num + 1);
6799         char buf[32];
6800
6801         WARN_ON(sd_ctl_dir[0].child);
6802         sd_ctl_dir[0].child = entry;
6803
6804         if (entry == NULL)
6805                 return;
6806
6807         for_each_possible_cpu(i) {
6808                 snprintf(buf, 32, "cpu%d", i);
6809                 entry->procname = kstrdup(buf, GFP_KERNEL);
6810                 entry->mode = 0555;
6811                 entry->child = sd_alloc_ctl_cpu_table(i);
6812                 entry++;
6813         }
6814
6815         WARN_ON(sd_sysctl_header);
6816         sd_sysctl_header = register_sysctl_table(sd_ctl_root);
6817 }
6818
6819 /* may be called multiple times per register */
6820 static void unregister_sched_domain_sysctl(void)
6821 {
6822         if (sd_sysctl_header)
6823                 unregister_sysctl_table(sd_sysctl_header);
6824         sd_sysctl_header = NULL;
6825         if (sd_ctl_dir[0].child)
6826                 sd_free_ctl_entry(&sd_ctl_dir[0].child);
6827 }
6828 #else
6829 static void register_sched_domain_sysctl(void)
6830 {
6831 }
6832 static void unregister_sched_domain_sysctl(void)
6833 {
6834 }
6835 #endif
6836
6837 static void set_rq_online(struct rq *rq)
6838 {
6839         if (!rq->online) {
6840                 const struct sched_class *class;
6841
6842                 cpumask_set_cpu(rq->cpu, rq->rd->online);
6843                 rq->online = 1;
6844
6845                 for_each_class(class) {
6846                         if (class->rq_online)
6847                                 class->rq_online(rq);
6848                 }
6849         }
6850 }
6851
6852 static void set_rq_offline(struct rq *rq)
6853 {
6854         if (rq->online) {
6855                 const struct sched_class *class;
6856
6857                 for_each_class(class) {
6858                         if (class->rq_offline)
6859                                 class->rq_offline(rq);
6860                 }
6861
6862                 cpumask_clear_cpu(rq->cpu, rq->rd->online);
6863                 rq->online = 0;
6864         }
6865 }
6866
6867 /*
6868  * migration_call - callback that gets triggered when a CPU is added.
6869  * Here we can start up the necessary migration thread for the new CPU.
6870  */
6871 static int __cpuinit
6872 migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
6873 {
6874         int cpu = (long)hcpu;
6875         unsigned long flags;
6876         struct rq *rq = cpu_rq(cpu);
6877
6878         switch (action & ~CPU_TASKS_FROZEN) {
6879
6880         case CPU_UP_PREPARE:
6881                 rq->calc_load_update = calc_load_update;
6882                 break;
6883
6884         case CPU_ONLINE:
6885                 /* Update our root-domain */
6886                 raw_spin_lock_irqsave(&rq->lock, flags);
6887                 if (rq->rd) {
6888                         BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
6889
6890                         set_rq_online(rq);
6891                 }
6892                 raw_spin_unlock_irqrestore(&rq->lock, flags);
6893                 break;
6894
6895 #ifdef CONFIG_HOTPLUG_CPU
6896         case CPU_DYING:
6897                 sched_ttwu_pending();
6898                 /* Update our root-domain */
6899                 raw_spin_lock_irqsave(&rq->lock, flags);
6900                 if (rq->rd) {
6901                         BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
6902                         set_rq_offline(rq);
6903                 }
6904                 migrate_tasks(cpu);
6905                 BUG_ON(rq->nr_running != 1); /* the migration thread */
6906                 raw_spin_unlock_irqrestore(&rq->lock, flags);
6907
6908                 migrate_nr_uninterruptible(rq);
6909                 calc_global_load_remove(rq);
6910                 break;
6911 #endif
6912         }
6913
6914         update_max_interval();
6915
6916         return NOTIFY_OK;
6917 }
6918
6919 /*
6920  * Register at high priority so that task migration (migrate_all_tasks)
6921  * happens before everything else.  This has to be lower priority than
6922  * the notifier in the perf_event subsystem, though.
6923  */
6924 static struct notifier_block __cpuinitdata migration_notifier = {
6925         .notifier_call = migration_call,
6926         .priority = CPU_PRI_MIGRATION,
6927 };
6928
6929 static int __cpuinit sched_cpu_active(struct notifier_block *nfb,
6930                                       unsigned long action, void *hcpu)
6931 {
6932         switch (action & ~CPU_TASKS_FROZEN) {
6933         case CPU_ONLINE:
6934         case CPU_DOWN_FAILED:
6935                 set_cpu_active((long)hcpu, true);
6936                 return NOTIFY_OK;
6937         default:
6938                 return NOTIFY_DONE;
6939         }
6940 }
6941
6942 static int __cpuinit sched_cpu_inactive(struct notifier_block *nfb,
6943                                         unsigned long action, void *hcpu)
6944 {
6945         switch (action & ~CPU_TASKS_FROZEN) {
6946         case CPU_DOWN_PREPARE:
6947                 set_cpu_active((long)hcpu, false);
6948                 return NOTIFY_OK;
6949         default:
6950                 return NOTIFY_DONE;
6951         }
6952 }
6953
6954 static int __init migration_init(void)
6955 {
6956         void *cpu = (void *)(long)smp_processor_id();
6957         int err;
6958
6959         /* Initialize migration for the boot CPU */
6960         err = migration_call(&migration_notifier, CPU_UP_PREPARE, cpu);
6961         BUG_ON(err == NOTIFY_BAD);
6962         migration_call(&migration_notifier, CPU_ONLINE, cpu);
6963         register_cpu_notifier(&migration_notifier);
6964
6965         /* Register cpu active notifiers */
6966         cpu_notifier(sched_cpu_active, CPU_PRI_SCHED_ACTIVE);
6967         cpu_notifier(sched_cpu_inactive, CPU_PRI_SCHED_INACTIVE);
6968
6969         return 0;
6970 }
6971 early_initcall(migration_init);
6972 #endif
6973
6974 #ifdef CONFIG_SMP
6975
6976 static cpumask_var_t sched_domains_tmpmask; /* sched_domains_mutex */
6977
6978 #ifdef CONFIG_SCHED_DEBUG
6979
6980 static __read_mostly int sched_domain_debug_enabled;
6981
6982 static int __init sched_domain_debug_setup(char *str)
6983 {
6984         sched_domain_debug_enabled = 1;
6985
6986         return 0;
6987 }
6988 early_param("sched_debug", sched_domain_debug_setup);
6989
6990 static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
6991                                   struct cpumask *groupmask)
6992 {
6993         struct sched_group *group = sd->groups;
6994         char str[256];
6995
6996         cpulist_scnprintf(str, sizeof(str), sched_domain_span(sd));
6997         cpumask_clear(groupmask);
6998
6999         printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
7000
7001         if (!(sd->flags & SD_LOAD_BALANCE)) {
7002                 printk("does not load-balance\n");
7003                 if (sd->parent)
7004                         printk(KERN_ERR "ERROR: !SD_LOAD_BALANCE domain"
7005                                         " has parent");
7006                 return -1;
7007         }
7008
7009         printk(KERN_CONT "span %s level %s\n", str, sd->name);
7010
7011         if (!cpumask_test_cpu(cpu, sched_domain_span(sd))) {
7012                 printk(KERN_ERR "ERROR: domain->span does not contain "
7013                                 "CPU%d\n", cpu);
7014         }
7015         if (!cpumask_test_cpu(cpu, sched_group_cpus(group))) {
7016                 printk(KERN_ERR "ERROR: domain->groups does not contain"
7017                                 " CPU%d\n", cpu);
7018         }
7019
7020         printk(KERN_DEBUG "%*s groups:", level + 1, "");
7021         do {
7022                 if (!group) {
7023                         printk("\n");
7024                         printk(KERN_ERR "ERROR: group is NULL\n");
7025                         break;
7026                 }
7027
7028                 if (!group->sgp->power) {
7029                         printk(KERN_CONT "\n");
7030                         printk(KERN_ERR "ERROR: domain->cpu_power not "
7031                                         "set\n");
7032                         break;
7033                 }
7034
7035                 if (!cpumask_weight(sched_group_cpus(group))) {
7036                         printk(KERN_CONT "\n");
7037                         printk(KERN_ERR "ERROR: empty group\n");
7038                         break;
7039                 }
7040
7041                 if (cpumask_intersects(groupmask, sched_group_cpus(group))) {
7042                         printk(KERN_CONT "\n");
7043                         printk(KERN_ERR "ERROR: repeated CPUs\n");
7044                         break;
7045                 }
7046
7047                 cpumask_or(groupmask, groupmask, sched_group_cpus(group));
7048
7049                 cpulist_scnprintf(str, sizeof(str), sched_group_cpus(group));
7050
7051                 printk(KERN_CONT " %s", str);
7052                 if (group->sgp->power != SCHED_POWER_SCALE) {
7053                         printk(KERN_CONT " (cpu_power = %d)",
7054                                 group->sgp->power);
7055                 }
7056
7057                 group = group->next;
7058         } while (group != sd->groups);
7059         printk(KERN_CONT "\n");
7060
7061         if (!cpumask_equal(sched_domain_span(sd), groupmask))
7062                 printk(KERN_ERR "ERROR: groups don't span domain->span\n");
7063
7064         if (sd->parent &&
7065             !cpumask_subset(groupmask, sched_domain_span(sd->parent)))
7066                 printk(KERN_ERR "ERROR: parent span is not a superset "
7067                         "of domain->span\n");
7068         return 0;
7069 }
7070
7071 static void sched_domain_debug(struct sched_domain *sd, int cpu)
7072 {
7073         int level = 0;
7074
7075         if (!sched_domain_debug_enabled)
7076                 return;
7077
7078         if (!sd) {
7079                 printk(KERN_DEBUG "CPU%d attaching NULL sched-domain.\n", cpu);
7080                 return;
7081         }
7082
7083         printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
7084
7085         for (;;) {
7086                 if (sched_domain_debug_one(sd, cpu, level, sched_domains_tmpmask))
7087                         break;
7088                 level++;
7089                 sd = sd->parent;
7090                 if (!sd)
7091                         break;
7092         }
7093 }
7094 #else /* !CONFIG_SCHED_DEBUG */
7095 # define sched_domain_debug(sd, cpu) do { } while (0)
7096 #endif /* CONFIG_SCHED_DEBUG */
7097
7098 static int sd_degenerate(struct sched_domain *sd)
7099 {
7100         if (cpumask_weight(sched_domain_span(sd)) == 1)
7101                 return 1;
7102
7103         /* Following flags need at least 2 groups */
7104         if (sd->flags & (SD_LOAD_BALANCE |
7105                          SD_BALANCE_NEWIDLE |
7106                          SD_BALANCE_FORK |
7107                          SD_BALANCE_EXEC |
7108                          SD_SHARE_CPUPOWER |
7109                          SD_SHARE_PKG_RESOURCES)) {
7110                 if (sd->groups != sd->groups->next)
7111                         return 0;
7112         }
7113
7114         /* Following flags don't use groups */
7115         if (sd->flags & (SD_WAKE_AFFINE))
7116                 return 0;
7117
7118         return 1;
7119 }
7120
7121 static int
7122 sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
7123 {
7124         unsigned long cflags = sd->flags, pflags = parent->flags;
7125
7126         if (sd_degenerate(parent))
7127                 return 1;
7128
7129         if (!cpumask_equal(sched_domain_span(sd), sched_domain_span(parent)))
7130                 return 0;
7131
7132         /* Flags needing groups don't count if only 1 group in parent */
7133         if (parent->groups == parent->groups->next) {
7134                 pflags &= ~(SD_LOAD_BALANCE |
7135                                 SD_BALANCE_NEWIDLE |
7136                                 SD_BALANCE_FORK |
7137                                 SD_BALANCE_EXEC |
7138                                 SD_SHARE_CPUPOWER |
7139                                 SD_SHARE_PKG_RESOURCES);
7140                 if (nr_node_ids == 1)
7141                         pflags &= ~SD_SERIALIZE;
7142         }
7143         if (~cflags & pflags)
7144                 return 0;
7145
7146         return 1;
7147 }
7148
7149 static void free_rootdomain(struct rcu_head *rcu)
7150 {
7151         struct root_domain *rd = container_of(rcu, struct root_domain, rcu);
7152
7153         cpupri_cleanup(&rd->cpupri);
7154         free_cpumask_var(rd->rto_mask);
7155         free_cpumask_var(rd->online);
7156         free_cpumask_var(rd->span);
7157         kfree(rd);
7158 }
7159
7160 static void rq_attach_root(struct rq *rq, struct root_domain *rd)
7161 {
7162         struct root_domain *old_rd = NULL;
7163         unsigned long flags;
7164
7165         raw_spin_lock_irqsave(&rq->lock, flags);
7166
7167         if (rq->rd) {
7168                 old_rd = rq->rd;
7169
7170                 if (cpumask_test_cpu(rq->cpu, old_rd->online))
7171                         set_rq_offline(rq);
7172
7173                 cpumask_clear_cpu(rq->cpu, old_rd->span);
7174
7175                 /*
7176                  * If we dont want to free the old_rt yet then
7177                  * set old_rd to NULL to skip the freeing later
7178                  * in this function:
7179                  */
7180                 if (!atomic_dec_and_test(&old_rd->refcount))
7181                         old_rd = NULL;
7182         }
7183
7184         atomic_inc(&rd->refcount);
7185         rq->rd = rd;
7186
7187         cpumask_set_cpu(rq->cpu, rd->span);
7188         if (cpumask_test_cpu(rq->cpu, cpu_active_mask))
7189                 set_rq_online(rq);
7190
7191         raw_spin_unlock_irqrestore(&rq->lock, flags);
7192
7193         if (old_rd)
7194                 call_rcu_sched(&old_rd->rcu, free_rootdomain);
7195 }
7196
7197 static int init_rootdomain(struct root_domain *rd)
7198 {
7199         memset(rd, 0, sizeof(*rd));
7200
7201         if (!zalloc_cpumask_var(&rd->span, GFP_KERNEL))
7202                 goto out;
7203         if (!zalloc_cpumask_var(&rd->online, GFP_KERNEL))
7204                 goto free_span;
7205         if (!zalloc_cpumask_var(&rd->rto_mask, GFP_KERNEL))
7206                 goto free_online;
7207
7208         if (cpupri_init(&rd->cpupri) != 0)
7209                 goto free_rto_mask;
7210         return 0;
7211
7212 free_rto_mask:
7213         free_cpumask_var(rd->rto_mask);
7214 free_online:
7215         free_cpumask_var(rd->online);
7216 free_span:
7217         free_cpumask_var(rd->span);
7218 out:
7219         return -ENOMEM;
7220 }
7221
7222 static void init_defrootdomain(void)
7223 {
7224         init_rootdomain(&def_root_domain);
7225
7226         atomic_set(&def_root_domain.refcount, 1);
7227 }
7228
7229 static struct root_domain *alloc_rootdomain(void)
7230 {
7231         struct root_domain *rd;
7232
7233         rd = kmalloc(sizeof(*rd), GFP_KERNEL);
7234         if (!rd)
7235                 return NULL;
7236
7237         if (init_rootdomain(rd) != 0) {
7238                 kfree(rd);
7239                 return NULL;
7240         }
7241
7242         return rd;
7243 }
7244
7245 static void free_sched_groups(struct sched_group *sg, int free_sgp)
7246 {
7247         struct sched_group *tmp, *first;
7248
7249         if (!sg)
7250                 return;
7251
7252         first = sg;
7253         do {
7254                 tmp = sg->next;
7255
7256                 if (free_sgp && atomic_dec_and_test(&sg->sgp->ref))
7257                         kfree(sg->sgp);
7258
7259                 kfree(sg);
7260                 sg = tmp;
7261         } while (sg != first);
7262 }
7263
7264 static void free_sched_domain(struct rcu_head *rcu)
7265 {
7266         struct sched_domain *sd = container_of(rcu, struct sched_domain, rcu);
7267
7268         /*
7269          * If its an overlapping domain it has private groups, iterate and
7270          * nuke them all.
7271          */
7272         if (sd->flags & SD_OVERLAP) {
7273                 free_sched_groups(sd->groups, 1);
7274         } else if (atomic_dec_and_test(&sd->groups->ref)) {
7275                 kfree(sd->groups->sgp);
7276                 kfree(sd->groups);
7277         }
7278         kfree(sd);
7279 }
7280
7281 static void destroy_sched_domain(struct sched_domain *sd, int cpu)
7282 {
7283         call_rcu(&sd->rcu, free_sched_domain);
7284 }
7285
7286 static void destroy_sched_domains(struct sched_domain *sd, int cpu)
7287 {
7288         for (; sd; sd = sd->parent)
7289                 destroy_sched_domain(sd, cpu);
7290 }
7291
7292 /*
7293  * Attach the domain 'sd' to 'cpu' as its base domain. Callers must
7294  * hold the hotplug lock.
7295  */
7296 static void
7297 cpu_attach_domain(struct sched_domain *sd, struct root_domain *rd, int cpu)
7298 {
7299         struct rq *rq = cpu_rq(cpu);
7300         struct sched_domain *tmp;
7301
7302         /* Remove the sched domains which do not contribute to scheduling. */
7303         for (tmp = sd; tmp; ) {
7304                 struct sched_domain *parent = tmp->parent;
7305                 if (!parent)
7306                         break;
7307
7308                 if (sd_parent_degenerate(tmp, parent)) {
7309                         tmp->parent = parent->parent;
7310                         if (parent->parent)
7311                                 parent->parent->child = tmp;
7312                         destroy_sched_domain(parent, cpu);
7313                 } else
7314                         tmp = tmp->parent;
7315         }
7316
7317         if (sd && sd_degenerate(sd)) {
7318                 tmp = sd;
7319                 sd = sd->parent;
7320                 destroy_sched_domain(tmp, cpu);
7321                 if (sd)
7322                         sd->child = NULL;
7323         }
7324
7325         sched_domain_debug(sd, cpu);
7326
7327         rq_attach_root(rq, rd);
7328         tmp = rq->sd;
7329         rcu_assign_pointer(rq->sd, sd);
7330         destroy_sched_domains(tmp, cpu);
7331 }
7332
7333 /* cpus with isolated domains */
7334 static cpumask_var_t cpu_isolated_map;
7335
7336 /* Setup the mask of cpus configured for isolated domains */
7337 static int __init isolated_cpu_setup(char *str)
7338 {
7339         alloc_bootmem_cpumask_var(&cpu_isolated_map);
7340         cpulist_parse(str, cpu_isolated_map);
7341         return 1;
7342 }
7343
7344 __setup("isolcpus=", isolated_cpu_setup);
7345
7346 #ifdef CONFIG_NUMA
7347
7348 /**
7349  * find_next_best_node - find the next node to include in a sched_domain
7350  * @node: node whose sched_domain we're building
7351  * @used_nodes: nodes already in the sched_domain
7352  *
7353  * Find the next node to include in a given scheduling domain. Simply
7354  * finds the closest node not already in the @used_nodes map.
7355  *
7356  * Should use nodemask_t.
7357  */
7358 static int find_next_best_node(int node, nodemask_t *used_nodes)
7359 {
7360         int i, n, val, min_val, best_node = -1;
7361
7362         min_val = INT_MAX;
7363
7364         for (i = 0; i < nr_node_ids; i++) {
7365                 /* Start at @node */
7366                 n = (node + i) % nr_node_ids;
7367
7368                 if (!nr_cpus_node(n))
7369                         continue;
7370
7371                 /* Skip already used nodes */
7372                 if (node_isset(n, *used_nodes))
7373                         continue;
7374
7375                 /* Simple min distance search */
7376                 val = node_distance(node, n);
7377
7378                 if (val < min_val) {
7379                         min_val = val;
7380                         best_node = n;
7381                 }
7382         }
7383
7384         if (best_node != -1)
7385                 node_set(best_node, *used_nodes);
7386         return best_node;
7387 }
7388
7389 /**
7390  * sched_domain_node_span - get a cpumask for a node's sched_domain
7391  * @node: node whose cpumask we're constructing
7392  * @span: resulting cpumask
7393  *
7394  * Given a node, construct a good cpumask for its sched_domain to span. It
7395  * should be one that prevents unnecessary balancing, but also spreads tasks
7396  * out optimally.
7397  */
7398 static void sched_domain_node_span(int node, struct cpumask *span)
7399 {
7400         nodemask_t used_nodes;
7401         int i;
7402
7403         cpumask_clear(span);
7404         nodes_clear(used_nodes);
7405
7406         cpumask_or(span, span, cpumask_of_node(node));
7407         node_set(node, used_nodes);
7408
7409         for (i = 1; i < SD_NODES_PER_DOMAIN; i++) {
7410                 int next_node = find_next_best_node(node, &used_nodes);
7411                 if (next_node < 0)
7412                         break;
7413                 cpumask_or(span, span, cpumask_of_node(next_node));
7414         }
7415 }
7416
7417 static const struct cpumask *cpu_node_mask(int cpu)
7418 {
7419         lockdep_assert_held(&sched_domains_mutex);
7420
7421         sched_domain_node_span(cpu_to_node(cpu), sched_domains_tmpmask);
7422
7423         return sched_domains_tmpmask;
7424 }
7425
7426 static const struct cpumask *cpu_allnodes_mask(int cpu)
7427 {
7428         return cpu_possible_mask;
7429 }
7430 #endif /* CONFIG_NUMA */
7431
7432 static const struct cpumask *cpu_cpu_mask(int cpu)
7433 {
7434         return cpumask_of_node(cpu_to_node(cpu));
7435 }
7436
7437 int sched_smt_power_savings = 0, sched_mc_power_savings = 0;
7438
7439 struct sd_data {
7440         struct sched_domain **__percpu sd;
7441         struct sched_group **__percpu sg;
7442         struct sched_group_power **__percpu sgp;
7443 };
7444
7445 struct s_data {
7446         struct sched_domain ** __percpu sd;
7447         struct root_domain      *rd;
7448 };
7449
7450 enum s_alloc {
7451         sa_rootdomain,
7452         sa_sd,
7453         sa_sd_storage,
7454         sa_none,
7455 };
7456
7457 struct sched_domain_topology_level;
7458
7459 typedef struct sched_domain *(*sched_domain_init_f)(struct sched_domain_topology_level *tl, int cpu);
7460 typedef const struct cpumask *(*sched_domain_mask_f)(int cpu);
7461
7462 #define SDTL_OVERLAP    0x01
7463
7464 struct sched_domain_topology_level {
7465         sched_domain_init_f init;
7466         sched_domain_mask_f mask;
7467         int                 flags;
7468         struct sd_data      data;
7469 };
7470
7471 static int
7472 build_overlap_sched_groups(struct sched_domain *sd, int cpu)
7473 {
7474         struct sched_group *first = NULL, *last = NULL, *groups = NULL, *sg;
7475         const struct cpumask *span = sched_domain_span(sd);
7476         struct cpumask *covered = sched_domains_tmpmask;
7477         struct sd_data *sdd = sd->private;
7478         struct sched_domain *child;
7479         int i;
7480
7481         cpumask_clear(covered);
7482
7483         for_each_cpu_wrap(i, span, cpu) {
7484                 struct cpumask *sg_span;
7485
7486                 if (cpumask_test_cpu(i, covered))
7487                         continue;
7488
7489                 sg = kzalloc_node(sizeof(struct sched_group) + cpumask_size(),
7490                                 GFP_KERNEL, cpu_to_node(i));
7491
7492                 if (!sg)
7493                         goto fail;
7494
7495                 sg_span = sched_group_cpus(sg);
7496
7497                 child = *per_cpu_ptr(sdd->sd, i);
7498                 if (child->child) {
7499                         child = child->child;
7500                         cpumask_copy(sg_span, sched_domain_span(child));
7501                 } else
7502                         cpumask_set_cpu(i, sg_span);
7503
7504                 cpumask_or(covered, covered, sg_span);
7505
7506                 sg->sgp = *per_cpu_ptr(sdd->sgp, cpumask_first(sg_span));
7507                 atomic_inc(&sg->sgp->ref);
7508
7509                 if (cpumask_test_cpu(cpu, sg_span))
7510                         groups = sg;
7511
7512                 if (!first)
7513                         first = sg;
7514                 if (last)
7515                         last->next = sg;
7516                 last = sg;
7517                 last->next = first;
7518         }
7519         sd->groups = groups;
7520
7521         return 0;
7522
7523 fail:
7524         free_sched_groups(first, 0);
7525
7526         return -ENOMEM;
7527 }
7528
7529 static int get_group(int cpu, struct sd_data *sdd, struct sched_group **sg)
7530 {
7531         struct sched_domain *sd = *per_cpu_ptr(sdd->sd, cpu);
7532         struct sched_domain *child = sd->child;
7533
7534         if (child)
7535                 cpu = cpumask_first(sched_domain_span(child));
7536
7537         if (sg) {
7538                 *sg = *per_cpu_ptr(sdd->sg, cpu);
7539                 (*sg)->sgp = *per_cpu_ptr(sdd->sgp, cpu);
7540                 atomic_set(&(*sg)->sgp->ref, 1); /* for claim_allocations */
7541         }
7542
7543         return cpu;
7544 }
7545
7546 /*
7547  * build_sched_groups will build a circular linked list of the groups
7548  * covered by the given span, and will set each group's ->cpumask correctly,
7549  * and ->cpu_power to 0.
7550  *
7551  * Assumes the sched_domain tree is fully constructed
7552  */
7553 static int
7554 build_sched_groups(struct sched_domain *sd, int cpu)
7555 {
7556         struct sched_group *first = NULL, *last = NULL;
7557         struct sd_data *sdd = sd->private;
7558         const struct cpumask *span = sched_domain_span(sd);
7559         struct cpumask *covered;
7560         int i;
7561
7562         get_group(cpu, sdd, &sd->groups);
7563         atomic_inc(&sd->groups->ref);
7564
7565         if (cpu != cpumask_first(sched_domain_span(sd)))
7566                 return 0;
7567
7568         lockdep_assert_held(&sched_domains_mutex);
7569         covered = sched_domains_tmpmask;
7570
7571         cpumask_clear(covered);
7572
7573         for_each_cpu(i, span) {
7574                 struct sched_group *sg;
7575                 int group = get_group(i, sdd, &sg);
7576                 int j;
7577
7578                 if (cpumask_test_cpu(i, covered))
7579                         continue;
7580
7581                 cpumask_clear(sched_group_cpus(sg));
7582                 sg->sgp->power = 0;
7583
7584                 for_each_cpu(j, span) {
7585                         if (get_group(j, sdd, NULL) != group)
7586                                 continue;
7587
7588                         cpumask_set_cpu(j, covered);
7589                         cpumask_set_cpu(j, sched_group_cpus(sg));
7590                 }
7591
7592                 if (!first)
7593                         first = sg;
7594                 if (last)
7595                         last->next = sg;
7596                 last = sg;
7597         }
7598         last->next = first;
7599
7600         return 0;
7601 }
7602
7603 /*
7604  * Initialize sched groups cpu_power.
7605  *
7606  * cpu_power indicates the capacity of sched group, which is used while
7607  * distributing the load between different sched groups in a sched domain.
7608  * Typically cpu_power for all the groups in a sched domain will be same unless
7609  * there are asymmetries in the topology. If there are asymmetries, group
7610  * having more cpu_power will pickup more load compared to the group having
7611  * less cpu_power.
7612  */
7613 static void init_sched_groups_power(int cpu, struct sched_domain *sd)
7614 {
7615         struct sched_group *sg = sd->groups;
7616
7617         WARN_ON(!sd || !sg);
7618
7619         do {
7620                 sg->group_weight = cpumask_weight(sched_group_cpus(sg));
7621                 sg = sg->next;
7622         } while (sg != sd->groups);
7623
7624         if (cpu != group_first_cpu(sg))
7625                 return;
7626
7627         update_group_power(sd, cpu);
7628 }
7629
7630 /*
7631  * Initializers for schedule domains
7632  * Non-inlined to reduce accumulated stack pressure in build_sched_domains()
7633  */
7634
7635 #ifdef CONFIG_SCHED_DEBUG
7636 # define SD_INIT_NAME(sd, type)         sd->name = #type
7637 #else
7638 # define SD_INIT_NAME(sd, type)         do { } while (0)
7639 #endif
7640
7641 #define SD_INIT_FUNC(type)                                              \
7642 static noinline struct sched_domain *                                   \
7643 sd_init_##type(struct sched_domain_topology_level *tl, int cpu)         \
7644 {                                                                       \
7645         struct sched_domain *sd = *per_cpu_ptr(tl->data.sd, cpu);       \
7646         *sd = SD_##type##_INIT;                                         \
7647         SD_INIT_NAME(sd, type);                                         \
7648         sd->private = &tl->data;                                        \
7649         return sd;                                                      \
7650 }
7651
7652 SD_INIT_FUNC(CPU)
7653 #ifdef CONFIG_NUMA
7654  SD_INIT_FUNC(ALLNODES)
7655  SD_INIT_FUNC(NODE)
7656 #endif
7657 #ifdef CONFIG_SCHED_SMT
7658  SD_INIT_FUNC(SIBLING)
7659 #endif
7660 #ifdef CONFIG_SCHED_MC
7661  SD_INIT_FUNC(MC)
7662 #endif
7663 #ifdef CONFIG_SCHED_BOOK
7664  SD_INIT_FUNC(BOOK)
7665 #endif
7666
7667 static int default_relax_domain_level = -1;
7668 int sched_domain_level_max;
7669
7670 static int __init setup_relax_domain_level(char *str)
7671 {
7672         if (kstrtoint(str, 0, &default_relax_domain_level))
7673                 pr_warn("Unable to set relax_domain_level\n");
7674
7675         return 1;
7676 }
7677 __setup("relax_domain_level=", setup_relax_domain_level);
7678
7679 static void set_domain_attribute(struct sched_domain *sd,
7680                                  struct sched_domain_attr *attr)
7681 {
7682         int request;
7683
7684         if (!attr || attr->relax_domain_level < 0) {
7685                 if (default_relax_domain_level < 0)
7686                         return;
7687                 else
7688                         request = default_relax_domain_level;
7689         } else
7690                 request = attr->relax_domain_level;
7691         if (request < sd->level) {
7692                 /* turn off idle balance on this domain */
7693                 sd->flags &= ~(SD_BALANCE_WAKE|SD_BALANCE_NEWIDLE);
7694         } else {
7695                 /* turn on idle balance on this domain */
7696                 sd->flags |= (SD_BALANCE_WAKE|SD_BALANCE_NEWIDLE);
7697         }
7698 }
7699
7700 static void __sdt_free(const struct cpumask *cpu_map);
7701 static int __sdt_alloc(const struct cpumask *cpu_map);
7702
7703 static void __free_domain_allocs(struct s_data *d, enum s_alloc what,
7704                                  const struct cpumask *cpu_map)
7705 {
7706         switch (what) {
7707         case sa_rootdomain:
7708                 if (!atomic_read(&d->rd->refcount))
7709                         free_rootdomain(&d->rd->rcu); /* fall through */
7710         case sa_sd:
7711                 free_percpu(d->sd); /* fall through */
7712         case sa_sd_storage:
7713                 __sdt_free(cpu_map); /* fall through */
7714         case sa_none:
7715                 break;
7716         }
7717 }
7718
7719 static enum s_alloc __visit_domain_allocation_hell(struct s_data *d,
7720                                                    const struct cpumask *cpu_map)
7721 {
7722         memset(d, 0, sizeof(*d));
7723
7724         if (__sdt_alloc(cpu_map))
7725                 return sa_sd_storage;
7726         d->sd = alloc_percpu(struct sched_domain *);
7727         if (!d->sd)
7728                 return sa_sd_storage;
7729         d->rd = alloc_rootdomain();
7730         if (!d->rd)
7731                 return sa_sd;
7732         return sa_rootdomain;
7733 }
7734
7735 /*
7736  * NULL the sd_data elements we've used to build the sched_domain and
7737  * sched_group structure so that the subsequent __free_domain_allocs()
7738  * will not free the data we're using.
7739  */
7740 static void claim_allocations(int cpu, struct sched_domain *sd)
7741 {
7742         struct sd_data *sdd = sd->private;
7743
7744         WARN_ON_ONCE(*per_cpu_ptr(sdd->sd, cpu) != sd);
7745         *per_cpu_ptr(sdd->sd, cpu) = NULL;
7746
7747         if (atomic_read(&(*per_cpu_ptr(sdd->sg, cpu))->ref))
7748                 *per_cpu_ptr(sdd->sg, cpu) = NULL;
7749
7750         if (atomic_read(&(*per_cpu_ptr(sdd->sgp, cpu))->ref))
7751                 *per_cpu_ptr(sdd->sgp, cpu) = NULL;
7752 }
7753
7754 #ifdef CONFIG_SCHED_SMT
7755 static const struct cpumask *cpu_smt_mask(int cpu)
7756 {
7757         return topology_thread_cpumask(cpu);
7758 }
7759 #endif
7760
7761 /*
7762  * Topology list, bottom-up.
7763  */
7764 static struct sched_domain_topology_level default_topology[] = {
7765 #ifdef CONFIG_SCHED_SMT
7766         { sd_init_SIBLING, cpu_smt_mask, },
7767 #endif
7768 #ifdef CONFIG_SCHED_MC
7769         { sd_init_MC, cpu_coregroup_mask, },
7770 #endif
7771 #ifdef CONFIG_SCHED_BOOK
7772         { sd_init_BOOK, cpu_book_mask, },
7773 #endif
7774         { sd_init_CPU, cpu_cpu_mask, },
7775 #ifdef CONFIG_NUMA
7776         { sd_init_NODE, cpu_node_mask, SDTL_OVERLAP, },
7777         { sd_init_ALLNODES, cpu_allnodes_mask, },
7778 #endif
7779         { NULL, },
7780 };
7781
7782 static struct sched_domain_topology_level *sched_domain_topology = default_topology;
7783
7784 static int __sdt_alloc(const struct cpumask *cpu_map)
7785 {
7786         struct sched_domain_topology_level *tl;
7787         int j;
7788
7789         for (tl = sched_domain_topology; tl->init; tl++) {
7790                 struct sd_data *sdd = &tl->data;
7791
7792                 sdd->sd = alloc_percpu(struct sched_domain *);
7793                 if (!sdd->sd)
7794                         return -ENOMEM;
7795
7796                 sdd->sg = alloc_percpu(struct sched_group *);
7797                 if (!sdd->sg)
7798                         return -ENOMEM;
7799
7800                 sdd->sgp = alloc_percpu(struct sched_group_power *);
7801                 if (!sdd->sgp)
7802                         return -ENOMEM;
7803
7804                 for_each_cpu(j, cpu_map) {
7805                         struct sched_domain *sd;
7806                         struct sched_group *sg;
7807                         struct sched_group_power *sgp;
7808
7809                         sd = kzalloc_node(sizeof(struct sched_domain) + cpumask_size(),
7810                                         GFP_KERNEL, cpu_to_node(j));
7811                         if (!sd)
7812                                 return -ENOMEM;
7813
7814                         *per_cpu_ptr(sdd->sd, j) = sd;
7815
7816                         sg = kzalloc_node(sizeof(struct sched_group) + cpumask_size(),
7817                                         GFP_KERNEL, cpu_to_node(j));
7818                         if (!sg)
7819                                 return -ENOMEM;
7820
7821                         *per_cpu_ptr(sdd->sg, j) = sg;
7822
7823                         sgp = kzalloc_node(sizeof(struct sched_group_power),
7824                                         GFP_KERNEL, cpu_to_node(j));
7825                         if (!sgp)
7826                                 return -ENOMEM;
7827
7828                         *per_cpu_ptr(sdd->sgp, j) = sgp;
7829                 }
7830         }
7831
7832         return 0;
7833 }
7834
7835 static void __sdt_free(const struct cpumask *cpu_map)
7836 {
7837         struct sched_domain_topology_level *tl;
7838         int j;
7839
7840         for (tl = sched_domain_topology; tl->init; tl++) {
7841                 struct sd_data *sdd = &tl->data;
7842
7843                 for_each_cpu(j, cpu_map) {
7844                         struct sched_domain *sd;
7845
7846                         if (sdd->sd) {
7847                                 sd = *per_cpu_ptr(sdd->sd, j);
7848                                 if (sd && (sd->flags & SD_OVERLAP))
7849                                         free_sched_groups(sd->groups, 0);
7850                                 kfree(*per_cpu_ptr(sdd->sd, j));
7851                         }
7852
7853                         if (sdd->sg)
7854                                 kfree(*per_cpu_ptr(sdd->sg, j));
7855                         if (sdd->sgp)
7856                                 kfree(*per_cpu_ptr(sdd->sgp, j));
7857                 }
7858                 free_percpu(sdd->sd);
7859                 sdd->sd = NULL;
7860                 free_percpu(sdd->sg);
7861                 sdd->sg = NULL;
7862                 free_percpu(sdd->sgp);
7863                 sdd->sgp = NULL;
7864         }
7865 }
7866
7867 struct sched_domain *build_sched_domain(struct sched_domain_topology_level *tl,
7868                 struct s_data *d, const struct cpumask *cpu_map,
7869                 struct sched_domain_attr *attr, struct sched_domain *child,
7870                 int cpu)
7871 {
7872         struct sched_domain *sd = tl->init(tl, cpu);
7873         if (!sd)
7874                 return child;
7875
7876         cpumask_and(sched_domain_span(sd), cpu_map, tl->mask(cpu));
7877         if (child) {
7878                 sd->level = child->level + 1;
7879                 sched_domain_level_max = max(sched_domain_level_max, sd->level);
7880                 child->parent = sd;
7881         }
7882         sd->child = child;
7883         set_domain_attribute(sd, attr);
7884
7885         return sd;
7886 }
7887
7888 /*
7889  * Build sched domains for a given set of cpus and attach the sched domains
7890  * to the individual cpus
7891  */
7892 static int build_sched_domains(const struct cpumask *cpu_map,
7893                                struct sched_domain_attr *attr)
7894 {
7895         enum s_alloc alloc_state = sa_none;
7896         struct sched_domain *sd;
7897         struct s_data d;
7898         int i, ret = -ENOMEM;
7899
7900         alloc_state = __visit_domain_allocation_hell(&d, cpu_map);
7901         if (alloc_state != sa_rootdomain)
7902                 goto error;
7903
7904         /* Set up domains for cpus specified by the cpu_map. */
7905         for_each_cpu(i, cpu_map) {
7906                 struct sched_domain_topology_level *tl;
7907
7908                 sd = NULL;
7909                 for (tl = sched_domain_topology; tl->init; tl++) {
7910                         sd = build_sched_domain(tl, &d, cpu_map, attr, sd, i);
7911                         if (tl->flags & SDTL_OVERLAP || sched_feat(FORCE_SD_OVERLAP))
7912                                 sd->flags |= SD_OVERLAP;
7913                         if (cpumask_equal(cpu_map, sched_domain_span(sd)))
7914                                 break;
7915                 }
7916
7917                 while (sd->child)
7918                         sd = sd->child;
7919
7920                 *per_cpu_ptr(d.sd, i) = sd;
7921         }
7922
7923         /* Build the groups for the domains */
7924         for_each_cpu(i, cpu_map) {
7925                 for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
7926                         sd->span_weight = cpumask_weight(sched_domain_span(sd));
7927                         if (sd->flags & SD_OVERLAP) {
7928                                 if (build_overlap_sched_groups(sd, i))
7929                                         goto error;
7930                         } else {
7931                                 if (build_sched_groups(sd, i))
7932                                         goto error;
7933                         }
7934                 }
7935         }
7936
7937         /* Calculate CPU power for physical packages and nodes */
7938         for (i = nr_cpumask_bits-1; i >= 0; i--) {
7939                 if (!cpumask_test_cpu(i, cpu_map))
7940                         continue;
7941
7942                 for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
7943                         claim_allocations(i, sd);
7944                         init_sched_groups_power(i, sd);
7945                 }
7946         }
7947
7948         /* Attach the domains */
7949         rcu_read_lock();
7950         for_each_cpu(i, cpu_map) {
7951                 sd = *per_cpu_ptr(d.sd, i);
7952                 cpu_attach_domain(sd, d.rd, i);
7953         }
7954         rcu_read_unlock();
7955
7956         ret = 0;
7957 error:
7958         __free_domain_allocs(&d, alloc_state, cpu_map);
7959         return ret;
7960 }
7961
7962 static cpumask_var_t *doms_cur; /* current sched domains */
7963 static int ndoms_cur;           /* number of sched domains in 'doms_cur' */
7964 static struct sched_domain_attr *dattr_cur;
7965                                 /* attribues of custom domains in 'doms_cur' */
7966
7967 /*
7968  * Special case: If a kmalloc of a doms_cur partition (array of
7969  * cpumask) fails, then fallback to a single sched domain,
7970  * as determined by the single cpumask fallback_doms.
7971  */
7972 static cpumask_var_t fallback_doms;
7973
7974 /*
7975  * arch_update_cpu_topology lets virtualized architectures update the
7976  * cpu core maps. It is supposed to return 1 if the topology changed
7977  * or 0 if it stayed the same.
7978  */
7979 int __attribute__((weak)) arch_update_cpu_topology(void)
7980 {
7981         return 0;
7982 }
7983
7984 cpumask_var_t *alloc_sched_domains(unsigned int ndoms)
7985 {
7986         int i;
7987         cpumask_var_t *doms;
7988
7989         doms = kmalloc(sizeof(*doms) * ndoms, GFP_KERNEL);
7990         if (!doms)
7991                 return NULL;
7992         for (i = 0; i < ndoms; i++) {
7993                 if (!alloc_cpumask_var(&doms[i], GFP_KERNEL)) {
7994                         free_sched_domains(doms, i);
7995                         return NULL;
7996                 }
7997         }
7998         return doms;
7999 }
8000
8001 void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms)
8002 {
8003         unsigned int i;
8004         for (i = 0; i < ndoms; i++)
8005                 free_cpumask_var(doms[i]);
8006         kfree(doms);
8007 }
8008
8009 /*
8010  * Set up scheduler domains and groups. Callers must hold the hotplug lock.
8011  * For now this just excludes isolated cpus, but could be used to
8012  * exclude other special cases in the future.
8013  */
8014 static int init_sched_domains(const struct cpumask *cpu_map)
8015 {
8016         int err;
8017
8018         arch_update_cpu_topology();
8019         ndoms_cur = 1;
8020         doms_cur = alloc_sched_domains(ndoms_cur);
8021         if (!doms_cur)
8022                 doms_cur = &fallback_doms;
8023         cpumask_andnot(doms_cur[0], cpu_map, cpu_isolated_map);
8024         dattr_cur = NULL;
8025         err = build_sched_domains(doms_cur[0], NULL);
8026         register_sched_domain_sysctl();
8027
8028         return err;
8029 }
8030
8031 /*
8032  * Detach sched domains from a group of cpus specified in cpu_map
8033  * These cpus will now be attached to the NULL domain
8034  */
8035 static void detach_destroy_domains(const struct cpumask *cpu_map)
8036 {
8037         int i;
8038
8039         rcu_read_lock();
8040         for_each_cpu(i, cpu_map)
8041                 cpu_attach_domain(NULL, &def_root_domain, i);
8042         rcu_read_unlock();
8043 }
8044
8045 /* handle null as "default" */
8046 static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
8047                         struct sched_domain_attr *new, int idx_new)
8048 {
8049         struct sched_domain_attr tmp;
8050
8051         /* fast path */
8052         if (!new && !cur)
8053                 return 1;
8054
8055         tmp = SD_ATTR_INIT;
8056         return !memcmp(cur ? (cur + idx_cur) : &tmp,
8057                         new ? (new + idx_new) : &tmp,
8058                         sizeof(struct sched_domain_attr));
8059 }
8060
8061 /*
8062  * Partition sched domains as specified by the 'ndoms_new'
8063  * cpumasks in the array doms_new[] of cpumasks. This compares
8064  * doms_new[] to the current sched domain partitioning, doms_cur[].
8065  * It destroys each deleted domain and builds each new domain.
8066  *
8067  * 'doms_new' is an array of cpumask_var_t's of length 'ndoms_new'.
8068  * The masks don't intersect (don't overlap.) We should setup one
8069  * sched domain for each mask. CPUs not in any of the cpumasks will
8070  * not be load balanced. If the same cpumask appears both in the
8071  * current 'doms_cur' domains and in the new 'doms_new', we can leave
8072  * it as it is.
8073  *
8074  * The passed in 'doms_new' should be allocated using
8075  * alloc_sched_domains.  This routine takes ownership of it and will
8076  * free_sched_domains it when done with it. If the caller failed the
8077  * alloc call, then it can pass in doms_new == NULL && ndoms_new == 1,
8078  * and partition_sched_domains() will fallback to the single partition
8079  * 'fallback_doms', it also forces the domains to be rebuilt.
8080  *
8081  * If doms_new == NULL it will be replaced with cpu_online_mask.
8082  * ndoms_new == 0 is a special case for destroying existing domains,
8083  * and it will not create the default domain.
8084  *
8085  * Call with hotplug lock held
8086  */
8087 void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
8088                              struct sched_domain_attr *dattr_new)
8089 {
8090         int i, j, n;
8091         int new_topology;
8092
8093         mutex_lock(&sched_domains_mutex);
8094
8095         /* always unregister in case we don't destroy any domains */
8096         unregister_sched_domain_sysctl();
8097
8098         /* Let architecture update cpu core mappings. */
8099         new_topology = arch_update_cpu_topology();
8100
8101         n = doms_new ? ndoms_new : 0;
8102
8103         /* Destroy deleted domains */
8104         for (i = 0; i < ndoms_cur; i++) {
8105                 for (j = 0; j < n && !new_topology; j++) {
8106                         if (cpumask_equal(doms_cur[i], doms_new[j])
8107                             && dattrs_equal(dattr_cur, i, dattr_new, j))
8108                                 goto match1;
8109                 }
8110                 /* no match - a current sched domain not in new doms_new[] */
8111                 detach_destroy_domains(doms_cur[i]);
8112 match1:
8113                 ;
8114         }
8115
8116         if (doms_new == NULL) {
8117                 ndoms_cur = 0;
8118                 doms_new = &fallback_doms;
8119                 cpumask_andnot(doms_new[0], cpu_active_mask, cpu_isolated_map);
8120                 WARN_ON_ONCE(dattr_new);
8121         }
8122
8123         /* Build new domains */
8124         for (i = 0; i < ndoms_new; i++) {
8125                 for (j = 0; j < ndoms_cur && !new_topology; j++) {
8126                         if (cpumask_equal(doms_new[i], doms_cur[j])
8127                             && dattrs_equal(dattr_new, i, dattr_cur, j))
8128                                 goto match2;
8129                 }
8130                 /* no match - add a new doms_new */
8131                 build_sched_domains(doms_new[i], dattr_new ? dattr_new + i : NULL);
8132 match2:
8133                 ;
8134         }
8135
8136         /* Remember the new sched domains */
8137         if (doms_cur != &fallback_doms)
8138                 free_sched_domains(doms_cur, ndoms_cur);
8139         kfree(dattr_cur);       /* kfree(NULL) is safe */
8140         doms_cur = doms_new;
8141         dattr_cur = dattr_new;
8142         ndoms_cur = ndoms_new;
8143
8144         register_sched_domain_sysctl();
8145
8146         mutex_unlock(&sched_domains_mutex);
8147 }
8148
8149 #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
8150 static void reinit_sched_domains(void)
8151 {
8152         get_online_cpus();
8153
8154         /* Destroy domains first to force the rebuild */
8155         partition_sched_domains(0, NULL, NULL);
8156
8157         rebuild_sched_domains();
8158         put_online_cpus();
8159 }
8160
8161 static ssize_t sched_power_savings_store(const char *buf, size_t count, int smt)
8162 {
8163         unsigned int level = 0;
8164
8165         if (sscanf(buf, "%u", &level) != 1)
8166                 return -EINVAL;
8167
8168         /*
8169          * level is always be positive so don't check for
8170          * level < POWERSAVINGS_BALANCE_NONE which is 0
8171          * What happens on 0 or 1 byte write,
8172          * need to check for count as well?
8173          */
8174
8175         if (level >= MAX_POWERSAVINGS_BALANCE_LEVELS)
8176                 return -EINVAL;
8177
8178         if (smt)
8179                 sched_smt_power_savings = level;
8180         else
8181                 sched_mc_power_savings = level;
8182
8183         reinit_sched_domains();
8184
8185         return count;
8186 }
8187
8188 #ifdef CONFIG_SCHED_MC
8189 static ssize_t sched_mc_power_savings_show(struct sysdev_class *class,
8190                                            struct sysdev_class_attribute *attr,
8191                                            char *page)
8192 {
8193         return sprintf(page, "%u\n", sched_mc_power_savings);
8194 }
8195 static ssize_t sched_mc_power_savings_store(struct sysdev_class *class,
8196                                             struct sysdev_class_attribute *attr,
8197                                             const char *buf, size_t count)
8198 {
8199         return sched_power_savings_store(buf, count, 0);
8200 }
8201 static SYSDEV_CLASS_ATTR(sched_mc_power_savings, 0644,
8202                          sched_mc_power_savings_show,
8203                          sched_mc_power_savings_store);
8204 #endif
8205
8206 #ifdef CONFIG_SCHED_SMT
8207 static ssize_t sched_smt_power_savings_show(struct sysdev_class *dev,
8208                                             struct sysdev_class_attribute *attr,
8209                                             char *page)
8210 {
8211         return sprintf(page, "%u\n", sched_smt_power_savings);
8212 }
8213 static ssize_t sched_smt_power_savings_store(struct sysdev_class *dev,
8214                                              struct sysdev_class_attribute *attr,
8215                                              const char *buf, size_t count)
8216 {
8217         return sched_power_savings_store(buf, count, 1);
8218 }
8219 static SYSDEV_CLASS_ATTR(sched_smt_power_savings, 0644,
8220                    sched_smt_power_savings_show,
8221                    sched_smt_power_savings_store);
8222 #endif
8223
8224 int __init sched_create_sysfs_power_savings_entries(struct sysdev_class *cls)
8225 {
8226         int err = 0;
8227
8228 #ifdef CONFIG_SCHED_SMT
8229         if (smt_capable())
8230                 err = sysfs_create_file(&cls->kset.kobj,
8231                                         &attr_sched_smt_power_savings.attr);
8232 #endif
8233 #ifdef CONFIG_SCHED_MC
8234         if (!err && mc_capable())
8235                 err = sysfs_create_file(&cls->kset.kobj,
8236                                         &attr_sched_mc_power_savings.attr);
8237 #endif
8238         return err;
8239 }
8240 #endif /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */
8241
8242 static int num_cpus_frozen;     /* used to mark begin/end of suspend/resume */
8243
8244 /*
8245  * Update cpusets according to cpu_active mask.  If cpusets are
8246  * disabled, cpuset_update_active_cpus() becomes a simple wrapper
8247  * around partition_sched_domains().
8248  *
8249  * If we come here as part of a suspend/resume, don't touch cpusets because we
8250  * want to restore it back to its original state upon resume anyway.
8251  */
8252 static int cpuset_cpu_active(struct notifier_block *nfb, unsigned long action,
8253                              void *hcpu)
8254 {
8255         switch (action) {
8256         case CPU_ONLINE_FROZEN:
8257         case CPU_DOWN_FAILED_FROZEN:
8258
8259                 /*
8260                  * num_cpus_frozen tracks how many CPUs are involved in suspend
8261                  * resume sequence. As long as this is not the last online
8262                  * operation in the resume sequence, just build a single sched
8263                  * domain, ignoring cpusets.
8264                  */
8265                 num_cpus_frozen--;
8266                 if (likely(num_cpus_frozen)) {
8267                         partition_sched_domains(1, NULL, NULL);
8268                         break;
8269                 }
8270
8271                 /*
8272                  * This is the last CPU online operation. So fall through and
8273                  * restore the original sched domains by considering the
8274                  * cpuset configurations.
8275                  */
8276
8277         case CPU_ONLINE:
8278         case CPU_DOWN_FAILED:
8279                 cpuset_update_active_cpus();
8280                 break;
8281         default:
8282                 return NOTIFY_DONE;
8283         }
8284         return NOTIFY_OK;
8285 }
8286
8287 static int cpuset_cpu_inactive(struct notifier_block *nfb, unsigned long action,
8288                                void *hcpu)
8289 {
8290         switch (action) {
8291         case CPU_DOWN_PREPARE:
8292                 cpuset_update_active_cpus();
8293                 break;
8294         case CPU_DOWN_PREPARE_FROZEN:
8295                 num_cpus_frozen++;
8296                 partition_sched_domains(1, NULL, NULL);
8297                 break;
8298         default:
8299                 return NOTIFY_DONE;
8300         }
8301         return NOTIFY_OK;
8302 }
8303
8304 static int update_runtime(struct notifier_block *nfb,
8305                                 unsigned long action, void *hcpu)
8306 {
8307         int cpu = (int)(long)hcpu;
8308
8309         switch (action) {
8310         case CPU_DOWN_PREPARE:
8311         case CPU_DOWN_PREPARE_FROZEN:
8312                 disable_runtime(cpu_rq(cpu));
8313                 return NOTIFY_OK;
8314
8315         case CPU_DOWN_FAILED:
8316         case CPU_DOWN_FAILED_FROZEN:
8317         case CPU_ONLINE:
8318         case CPU_ONLINE_FROZEN:
8319                 enable_runtime(cpu_rq(cpu));
8320                 return NOTIFY_OK;
8321
8322         default:
8323                 return NOTIFY_DONE;
8324         }
8325 }
8326
8327 void __init sched_init_smp(void)
8328 {
8329         cpumask_var_t non_isolated_cpus;
8330
8331         alloc_cpumask_var(&non_isolated_cpus, GFP_KERNEL);
8332         alloc_cpumask_var(&fallback_doms, GFP_KERNEL);
8333
8334         get_online_cpus();
8335         mutex_lock(&sched_domains_mutex);
8336         init_sched_domains(cpu_active_mask);
8337         cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
8338         if (cpumask_empty(non_isolated_cpus))
8339                 cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
8340         mutex_unlock(&sched_domains_mutex);
8341         put_online_cpus();
8342
8343         hotcpu_notifier(cpuset_cpu_active, CPU_PRI_CPUSET_ACTIVE);
8344         hotcpu_notifier(cpuset_cpu_inactive, CPU_PRI_CPUSET_INACTIVE);
8345
8346         /* RT runtime code needs to handle some hotplug events */
8347         hotcpu_notifier(update_runtime, 0);
8348
8349         init_hrtick();
8350
8351         /* Move init over to a non-isolated CPU */
8352         if (set_cpus_allowed_ptr(current, non_isolated_cpus) < 0)
8353                 BUG();
8354         sched_init_granularity();
8355         free_cpumask_var(non_isolated_cpus);
8356
8357         init_sched_rt_class();
8358 }
8359 #else
8360 void __init sched_init_smp(void)
8361 {
8362         sched_init_granularity();
8363 }
8364 #endif /* CONFIG_SMP */
8365
8366 const_debug unsigned int sysctl_timer_migration = 1;
8367
8368 int in_sched_functions(unsigned long addr)
8369 {
8370         return in_lock_functions(addr) ||
8371                 (addr >= (unsigned long)__sched_text_start
8372                 && addr < (unsigned long)__sched_text_end);
8373 }
8374
8375 static void init_cfs_rq(struct cfs_rq *cfs_rq)
8376 {
8377         cfs_rq->tasks_timeline = RB_ROOT;
8378         INIT_LIST_HEAD(&cfs_rq->tasks);
8379         cfs_rq->min_vruntime = (u64)(-(1LL << 20));
8380 #ifndef CONFIG_64BIT
8381         cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;
8382 #endif
8383 }
8384
8385 static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
8386 {
8387         struct rt_prio_array *array;
8388         int i;
8389
8390         array = &rt_rq->active;
8391         for (i = 0; i < MAX_RT_PRIO; i++) {
8392                 INIT_LIST_HEAD(array->queue + i);
8393                 __clear_bit(i, array->bitmap);
8394         }
8395         /* delimiter for bitsearch: */
8396         __set_bit(MAX_RT_PRIO, array->bitmap);
8397
8398 #if defined CONFIG_SMP
8399         rt_rq->highest_prio.curr = MAX_RT_PRIO;
8400         rt_rq->highest_prio.next = MAX_RT_PRIO;
8401         rt_rq->rt_nr_migratory = 0;
8402         rt_rq->overloaded = 0;
8403         plist_head_init(&rt_rq->pushable_tasks);
8404 #endif
8405
8406         rt_rq->rt_time = 0;
8407         rt_rq->rt_throttled = 0;
8408         rt_rq->rt_runtime = 0;
8409         raw_spin_lock_init(&rt_rq->rt_runtime_lock);
8410 }
8411
8412 #ifdef CONFIG_FAIR_GROUP_SCHED
8413 static void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
8414                                 struct sched_entity *se, int cpu,
8415                                 struct sched_entity *parent)
8416 {
8417         struct rq *rq = cpu_rq(cpu);
8418
8419         cfs_rq->tg = tg;
8420         cfs_rq->rq = rq;
8421 #ifdef CONFIG_SMP
8422         /* allow initial update_cfs_load() to truncate */
8423         cfs_rq->load_stamp = 1;
8424 #endif
8425         init_cfs_rq_runtime(cfs_rq);
8426
8427         tg->cfs_rq[cpu] = cfs_rq;
8428         tg->se[cpu] = se;
8429
8430         /* se could be NULL for root_task_group */
8431         if (!se)
8432                 return;
8433
8434         if (!parent)
8435                 se->cfs_rq = &rq->cfs;
8436         else
8437                 se->cfs_rq = parent->my_q;
8438
8439         se->my_q = cfs_rq;
8440         update_load_set(&se->load, 0);
8441         se->parent = parent;
8442 }
8443 #endif
8444
8445 #ifdef CONFIG_RT_GROUP_SCHED
8446 static void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
8447                 struct sched_rt_entity *rt_se, int cpu,
8448                 struct sched_rt_entity *parent)
8449 {
8450         struct rq *rq = cpu_rq(cpu);
8451
8452         rt_rq->highest_prio.curr = MAX_RT_PRIO;
8453         rt_rq->rt_nr_boosted = 0;
8454         rt_rq->rq = rq;
8455         rt_rq->tg = tg;
8456
8457         tg->rt_rq[cpu] = rt_rq;
8458         tg->rt_se[cpu] = rt_se;
8459
8460         if (!rt_se)
8461                 return;
8462
8463         if (!parent)
8464                 rt_se->rt_rq = &rq->rt;
8465         else
8466                 rt_se->rt_rq = parent->my_q;
8467
8468         rt_se->my_q = rt_rq;
8469         rt_se->parent = parent;
8470         INIT_LIST_HEAD(&rt_se->run_list);
8471 }
8472 #endif
8473
8474 void __init sched_init(void)
8475 {
8476         int i, j;
8477         unsigned long alloc_size = 0, ptr;
8478
8479 #ifdef CONFIG_FAIR_GROUP_SCHED
8480         alloc_size += 2 * nr_cpu_ids * sizeof(void **);
8481 #endif
8482 #ifdef CONFIG_RT_GROUP_SCHED
8483         alloc_size += 2 * nr_cpu_ids * sizeof(void **);
8484 #endif
8485 #ifdef CONFIG_CPUMASK_OFFSTACK
8486         alloc_size += num_possible_cpus() * cpumask_size();
8487 #endif
8488         if (alloc_size) {
8489                 ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);
8490
8491 #ifdef CONFIG_FAIR_GROUP_SCHED
8492                 root_task_group.se = (struct sched_entity **)ptr;
8493                 ptr += nr_cpu_ids * sizeof(void **);
8494
8495                 root_task_group.cfs_rq = (struct cfs_rq **)ptr;
8496                 ptr += nr_cpu_ids * sizeof(void **);
8497
8498 #endif /* CONFIG_FAIR_GROUP_SCHED */
8499 #ifdef CONFIG_RT_GROUP_SCHED
8500                 root_task_group.rt_se = (struct sched_rt_entity **)ptr;
8501                 ptr += nr_cpu_ids * sizeof(void **);
8502
8503                 root_task_group.rt_rq = (struct rt_rq **)ptr;
8504                 ptr += nr_cpu_ids * sizeof(void **);
8505
8506 #endif /* CONFIG_RT_GROUP_SCHED */
8507 #ifdef CONFIG_CPUMASK_OFFSTACK
8508                 for_each_possible_cpu(i) {
8509                         per_cpu(load_balance_tmpmask, i) = (void *)ptr;
8510                         ptr += cpumask_size();
8511                 }
8512 #endif /* CONFIG_CPUMASK_OFFSTACK */
8513         }
8514
8515 #ifdef CONFIG_SMP
8516         init_defrootdomain();
8517 #endif
8518
8519         init_rt_bandwidth(&def_rt_bandwidth,
8520                         global_rt_period(), global_rt_runtime());
8521
8522 #ifdef CONFIG_RT_GROUP_SCHED
8523         init_rt_bandwidth(&root_task_group.rt_bandwidth,
8524                         global_rt_period(), global_rt_runtime());
8525 #endif /* CONFIG_RT_GROUP_SCHED */
8526
8527 #ifdef CONFIG_CGROUP_SCHED
8528         list_add(&root_task_group.list, &task_groups);
8529         INIT_LIST_HEAD(&root_task_group.children);
8530         INIT_LIST_HEAD(&root_task_group.siblings);
8531         autogroup_init(&init_task);
8532 #endif /* CONFIG_CGROUP_SCHED */
8533
8534         for_each_possible_cpu(i) {
8535                 struct rq *rq;
8536
8537                 rq = cpu_rq(i);
8538                 raw_spin_lock_init(&rq->lock);
8539                 rq->nr_running = 0;
8540                 rq->calc_load_active = 0;
8541                 rq->calc_load_update = jiffies + LOAD_FREQ;
8542                 init_cfs_rq(&rq->cfs);
8543                 init_rt_rq(&rq->rt, rq);
8544 #ifdef CONFIG_FAIR_GROUP_SCHED
8545                 root_task_group.shares = root_task_group_load;
8546                 INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
8547                 /*
8548                  * How much cpu bandwidth does root_task_group get?
8549                  *
8550                  * In case of task-groups formed thr' the cgroup filesystem, it
8551                  * gets 100% of the cpu resources in the system. This overall
8552                  * system cpu resource is divided among the tasks of
8553                  * root_task_group and its child task-groups in a fair manner,
8554                  * based on each entity's (task or task-group's) weight
8555                  * (se->load.weight).
8556                  *
8557                  * In other words, if root_task_group has 10 tasks of weight
8558                  * 1024) and two child groups A0 and A1 (of weight 1024 each),
8559                  * then A0's share of the cpu resource is:
8560                  *
8561                  *      A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%
8562                  *
8563                  * We achieve this by letting root_task_group's tasks sit
8564                  * directly in rq->cfs (i.e root_task_group->se[] = NULL).
8565                  */
8566                 init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
8567                 init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);
8568 #endif /* CONFIG_FAIR_GROUP_SCHED */
8569
8570                 rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
8571 #ifdef CONFIG_RT_GROUP_SCHED
8572                 INIT_LIST_HEAD(&rq->leaf_rt_rq_list);
8573                 init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL);
8574 #endif
8575
8576                 for (j = 0; j < CPU_LOAD_IDX_MAX; j++)
8577                         rq->cpu_load[j] = 0;
8578
8579                 rq->last_load_update_tick = jiffies;
8580
8581 #ifdef CONFIG_SMP
8582                 rq->sd = NULL;
8583                 rq->rd = NULL;
8584                 rq->cpu_power = SCHED_POWER_SCALE;
8585                 rq->post_schedule = 0;
8586                 rq->active_balance = 0;
8587                 rq->next_balance = jiffies;
8588                 rq->push_cpu = 0;
8589                 rq->cpu = i;
8590                 rq->online = 0;
8591                 rq->idle_stamp = 0;
8592                 rq->avg_idle = 2*sysctl_sched_migration_cost;
8593                 rq_attach_root(rq, &def_root_domain);
8594 #ifdef CONFIG_NO_HZ
8595                 rq->nohz_balance_kick = 0;
8596 #endif
8597 #endif
8598                 init_rq_hrtick(rq);
8599                 atomic_set(&rq->nr_iowait, 0);
8600         }
8601
8602         set_load_weight(&init_task);
8603
8604 #ifdef CONFIG_PREEMPT_NOTIFIERS
8605         INIT_HLIST_HEAD(&init_task.preempt_notifiers);
8606 #endif
8607
8608 #ifdef CONFIG_SMP
8609         open_softirq(SCHED_SOFTIRQ, run_rebalance_domains);
8610 #endif
8611
8612 #ifdef CONFIG_RT_MUTEXES
8613         plist_head_init(&init_task.pi_waiters);
8614 #endif
8615
8616         /*
8617          * The boot idle thread does lazy MMU switching as well:
8618          */
8619         atomic_inc(&init_mm.mm_count);
8620         enter_lazy_tlb(&init_mm, current);
8621
8622         /*
8623          * Make us the idle thread. Technically, schedule() should not be
8624          * called from this thread, however somewhere below it might be,
8625          * but because we are the idle thread, we just pick up running again
8626          * when this runqueue becomes "idle".
8627          */
8628         init_idle(current, smp_processor_id());
8629
8630         calc_load_update = jiffies + LOAD_FREQ;
8631
8632         /*
8633          * During early bootup we pretend to be a normal task:
8634          */
8635         current->sched_class = &fair_sched_class;
8636
8637 #ifdef CONFIG_SMP
8638         zalloc_cpumask_var(&sched_domains_tmpmask, GFP_NOWAIT);
8639 #ifdef CONFIG_NO_HZ
8640         zalloc_cpumask_var(&nohz.idle_cpus_mask, GFP_NOWAIT);
8641         alloc_cpumask_var(&nohz.grp_idle_mask, GFP_NOWAIT);
8642         atomic_set(&nohz.load_balancer, nr_cpu_ids);
8643         atomic_set(&nohz.first_pick_cpu, nr_cpu_ids);
8644         atomic_set(&nohz.second_pick_cpu, nr_cpu_ids);
8645 #endif
8646         /* May be allocated at isolcpus cmdline parse time */
8647         if (cpu_isolated_map == NULL)
8648                 zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
8649 #endif /* SMP */
8650
8651         scheduler_running = 1;
8652 }
8653
8654 #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
8655 static inline int preempt_count_equals(int preempt_offset)
8656 {
8657         int nested = (preempt_count() & ~PREEMPT_ACTIVE) + rcu_preempt_depth();
8658
8659         return (nested == preempt_offset);
8660 }
8661
8662 void __might_sleep(const char *file, int line, int preempt_offset)
8663 {
8664         static unsigned long prev_jiffy;        /* ratelimiting */
8665
8666         rcu_sleep_check(); /* WARN_ON_ONCE() by default, no rate limit reqd. */
8667         if ((preempt_count_equals(preempt_offset) && !irqs_disabled()) ||
8668             system_state != SYSTEM_RUNNING || oops_in_progress)
8669                 return;
8670         if (time_before(jiffies, prev_jiffy + HZ) && prev_jiffy)
8671                 return;
8672         prev_jiffy = jiffies;
8673
8674         printk(KERN_ERR
8675                 "BUG: sleeping function called from invalid context at %s:%d\n",
8676                         file, line);
8677         printk(KERN_ERR
8678                 "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
8679                         in_atomic(), irqs_disabled(),
8680                         current->pid, current->comm);
8681
8682         debug_show_held_locks(current);
8683         if (irqs_disabled())
8684                 print_irqtrace_events(current);
8685         dump_stack();
8686 }
8687 EXPORT_SYMBOL(__might_sleep);
8688 #endif
8689
8690 #ifdef CONFIG_MAGIC_SYSRQ
8691 static void normalize_task(struct rq *rq, struct task_struct *p)
8692 {
8693         const struct sched_class *prev_class = p->sched_class;
8694         int old_prio = p->prio;
8695         int on_rq;
8696
8697         on_rq = p->on_rq;
8698         if (on_rq)
8699                 deactivate_task(rq, p, 0);
8700         __setscheduler(rq, p, SCHED_NORMAL, 0);
8701         if (on_rq) {
8702                 activate_task(rq, p, 0);
8703                 resched_task(rq->curr);
8704         }
8705
8706         check_class_changed(rq, p, prev_class, old_prio);
8707 }
8708
8709 void normalize_rt_tasks(void)
8710 {
8711         struct task_struct *g, *p;
8712         unsigned long flags;
8713         struct rq *rq;
8714
8715         read_lock_irqsave(&tasklist_lock, flags);
8716         do_each_thread(g, p) {
8717                 /*
8718                  * Only normalize user tasks:
8719                  */
8720                 if (!p->mm)
8721                         continue;
8722
8723                 p->se.exec_start                = 0;
8724 #ifdef CONFIG_SCHEDSTATS
8725                 p->se.statistics.wait_start     = 0;
8726                 p->se.statistics.sleep_start    = 0;
8727                 p->se.statistics.block_start    = 0;
8728 #endif
8729
8730                 if (!rt_task(p)) {
8731                         /*
8732                          * Renice negative nice level userspace
8733                          * tasks back to 0:
8734                          */
8735                         if (TASK_NICE(p) < 0 && p->mm)
8736                                 set_user_nice(p, 0);
8737                         continue;
8738                 }
8739
8740                 raw_spin_lock(&p->pi_lock);
8741                 rq = __task_rq_lock(p);
8742
8743                 normalize_task(rq, p);
8744
8745                 __task_rq_unlock(rq);
8746                 raw_spin_unlock(&p->pi_lock);
8747         } while_each_thread(g, p);
8748
8749         read_unlock_irqrestore(&tasklist_lock, flags);
8750 }
8751
8752 #endif /* CONFIG_MAGIC_SYSRQ */
8753
8754 #if defined(CONFIG_IA64) || defined(CONFIG_KGDB_KDB)
8755 /*
8756  * These functions are only useful for the IA64 MCA handling, or kdb.
8757  *
8758  * They can only be called when the whole system has been
8759  * stopped - every CPU needs to be quiescent, and no scheduling
8760  * activity can take place. Using them for anything else would
8761  * be a serious bug, and as a result, they aren't even visible
8762  * under any other configuration.
8763  */
8764
8765 /**
8766  * curr_task - return the current task for a given cpu.
8767  * @cpu: the processor in question.
8768  *
8769  * ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
8770  */
8771 struct task_struct *curr_task(int cpu)
8772 {
8773         return cpu_curr(cpu);
8774 }
8775
8776 #endif /* defined(CONFIG_IA64) || defined(CONFIG_KGDB_KDB) */
8777
8778 #ifdef CONFIG_IA64
8779 /**
8780  * set_curr_task - set the current task for a given cpu.
8781  * @cpu: the processor in question.
8782  * @p: the task pointer to set.
8783  *
8784  * Description: This function must only be used when non-maskable interrupts
8785  * are serviced on a separate stack. It allows the architecture to switch the
8786  * notion of the current task on a cpu in a non-blocking manner. This function
8787  * must be called with all CPU's synchronized, and interrupts disabled, the
8788  * and caller must save the original value of the current task (see
8789  * curr_task() above) and restore that value before reenabling interrupts and
8790  * re-starting the system.
8791  *
8792  * ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
8793  */
8794 void set_curr_task(int cpu, struct task_struct *p)
8795 {
8796         cpu_curr(cpu) = p;
8797 }
8798
8799 #endif
8800
8801 #ifdef CONFIG_FAIR_GROUP_SCHED
8802 static void free_fair_sched_group(struct task_group *tg)
8803 {
8804         int i;
8805
8806         destroy_cfs_bandwidth(tg_cfs_bandwidth(tg));
8807
8808         for_each_possible_cpu(i) {
8809                 if (tg->cfs_rq)
8810                         kfree(tg->cfs_rq[i]);
8811                 if (tg->se)
8812                         kfree(tg->se[i]);
8813         }
8814
8815         kfree(tg->cfs_rq);
8816         kfree(tg->se);
8817 }
8818
8819 static
8820 int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
8821 {
8822         struct cfs_rq *cfs_rq;
8823         struct sched_entity *se;
8824         int i;
8825
8826         tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL);
8827         if (!tg->cfs_rq)
8828                 goto err;
8829         tg->se = kzalloc(sizeof(se) * nr_cpu_ids, GFP_KERNEL);
8830         if (!tg->se)
8831                 goto err;
8832
8833         tg->shares = NICE_0_LOAD;
8834
8835         init_cfs_bandwidth(tg_cfs_bandwidth(tg));
8836
8837         for_each_possible_cpu(i) {
8838                 cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
8839                                       GFP_KERNEL, cpu_to_node(i));
8840                 if (!cfs_rq)
8841                         goto err;
8842
8843                 se = kzalloc_node(sizeof(struct sched_entity),
8844                                   GFP_KERNEL, cpu_to_node(i));
8845                 if (!se)
8846                         goto err_free_rq;
8847
8848                 init_cfs_rq(cfs_rq);
8849                 init_tg_cfs_entry(tg, cfs_rq, se, i, parent->se[i]);
8850         }
8851
8852         return 1;
8853
8854 err_free_rq:
8855         kfree(cfs_rq);
8856 err:
8857         return 0;
8858 }
8859
8860 static inline void unregister_fair_sched_group(struct task_group *tg, int cpu)
8861 {
8862         struct rq *rq = cpu_rq(cpu);
8863         unsigned long flags;
8864
8865         /*
8866         * Only empty task groups can be destroyed; so we can speculatively
8867         * check on_list without danger of it being re-added.
8868         */
8869         if (!tg->cfs_rq[cpu]->on_list)
8870                 return;
8871
8872         raw_spin_lock_irqsave(&rq->lock, flags);
8873         list_del_leaf_cfs_rq(tg->cfs_rq[cpu]);
8874         raw_spin_unlock_irqrestore(&rq->lock, flags);
8875 }
8876 #else /* !CONFIG_FAIR_GROUP_SCHED */
8877 static inline void free_fair_sched_group(struct task_group *tg)
8878 {
8879 }
8880
8881 static inline
8882 int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
8883 {
8884         return 1;
8885 }
8886
8887 static inline void unregister_fair_sched_group(struct task_group *tg, int cpu)
8888 {
8889 }
8890 #endif /* CONFIG_FAIR_GROUP_SCHED */
8891
8892 #ifdef CONFIG_RT_GROUP_SCHED
8893 static void free_rt_sched_group(struct task_group *tg)
8894 {
8895         int i;
8896
8897         if (tg->rt_se)
8898                 destroy_rt_bandwidth(&tg->rt_bandwidth);
8899
8900         for_each_possible_cpu(i) {
8901                 if (tg->rt_rq)
8902                         kfree(tg->rt_rq[i]);
8903                 if (tg->rt_se)
8904                         kfree(tg->rt_se[i]);
8905         }
8906
8907         kfree(tg->rt_rq);
8908         kfree(tg->rt_se);
8909 }
8910
8911 static
8912 int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
8913 {
8914         struct rt_rq *rt_rq;
8915         struct sched_rt_entity *rt_se;
8916         int i;
8917
8918         tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL);
8919         if (!tg->rt_rq)
8920                 goto err;
8921         tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);
8922         if (!tg->rt_se)
8923                 goto err;
8924
8925         init_rt_bandwidth(&tg->rt_bandwidth,
8926                         ktime_to_ns(def_rt_bandwidth.rt_period), 0);
8927
8928         for_each_possible_cpu(i) {
8929                 rt_rq = kzalloc_node(sizeof(struct rt_rq),
8930                                      GFP_KERNEL, cpu_to_node(i));
8931                 if (!rt_rq)
8932                         goto err;
8933
8934                 rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
8935                                      GFP_KERNEL, cpu_to_node(i));
8936                 if (!rt_se)
8937                         goto err_free_rq;
8938
8939                 init_rt_rq(rt_rq, cpu_rq(i));
8940                 rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;
8941                 init_tg_rt_entry(tg, rt_rq, rt_se, i, parent->rt_se[i]);
8942         }
8943
8944         return 1;
8945
8946 err_free_rq:
8947         kfree(rt_rq);
8948 err:
8949         return 0;
8950 }
8951 #else /* !CONFIG_RT_GROUP_SCHED */
8952 static inline void free_rt_sched_group(struct task_group *tg)
8953 {
8954 }
8955
8956 static inline
8957 int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
8958 {
8959         return 1;
8960 }
8961 #endif /* CONFIG_RT_GROUP_SCHED */
8962
8963 #ifdef CONFIG_CGROUP_SCHED
8964 static void free_sched_group(struct task_group *tg)
8965 {
8966         free_fair_sched_group(tg);
8967         free_rt_sched_group(tg);
8968         autogroup_free(tg);
8969         kfree(tg);
8970 }
8971
8972 /* allocate runqueue etc for a new task group */
8973 struct task_group *sched_create_group(struct task_group *parent)
8974 {
8975         struct task_group *tg;
8976         unsigned long flags;
8977
8978         tg = kzalloc(sizeof(*tg), GFP_KERNEL);
8979         if (!tg)
8980                 return ERR_PTR(-ENOMEM);
8981
8982         if (!alloc_fair_sched_group(tg, parent))
8983                 goto err;
8984
8985         if (!alloc_rt_sched_group(tg, parent))
8986                 goto err;
8987
8988         spin_lock_irqsave(&task_group_lock, flags);
8989         list_add_rcu(&tg->list, &task_groups);
8990
8991         WARN_ON(!parent); /* root should already exist */
8992
8993         tg->parent = parent;
8994         INIT_LIST_HEAD(&tg->children);
8995         list_add_rcu(&tg->siblings, &parent->children);
8996         spin_unlock_irqrestore(&task_group_lock, flags);
8997
8998         return tg;
8999
9000 err:
9001         free_sched_group(tg);
9002         return ERR_PTR(-ENOMEM);
9003 }
9004
9005 /* rcu callback to free various structures associated with a task group */
9006 static void free_sched_group_rcu(struct rcu_head *rhp)
9007 {
9008         /* now it should be safe to free those cfs_rqs */
9009         free_sched_group(container_of(rhp, struct task_group, rcu));
9010 }
9011
9012 /* Destroy runqueue etc associated with a task group */
9013 void sched_destroy_group(struct task_group *tg)
9014 {
9015         unsigned long flags;
9016         int i;
9017
9018         /* end participation in shares distribution */
9019         for_each_possible_cpu(i)
9020                 unregister_fair_sched_group(tg, i);
9021
9022         spin_lock_irqsave(&task_group_lock, flags);
9023         list_del_rcu(&tg->list);
9024         list_del_rcu(&tg->siblings);
9025         spin_unlock_irqrestore(&task_group_lock, flags);
9026
9027         /* wait for possible concurrent references to cfs_rqs complete */
9028         call_rcu(&tg->rcu, free_sched_group_rcu);
9029 }
9030
9031 /* change task's runqueue when it moves between groups.
9032  *      The caller of this function should have put the task in its new group
9033  *      by now. This function just updates tsk->se.cfs_rq and tsk->se.parent to
9034  *      reflect its new group.
9035  */
9036 void sched_move_task(struct task_struct *tsk)
9037 {
9038         struct task_group *tg;
9039         int on_rq, running;
9040         unsigned long flags;
9041         struct rq *rq;
9042
9043         rq = task_rq_lock(tsk, &flags);
9044
9045         running = task_current(rq, tsk);
9046         on_rq = tsk->on_rq;
9047
9048         if (on_rq)
9049                 dequeue_task(rq, tsk, 0);
9050         if (unlikely(running))
9051                 tsk->sched_class->put_prev_task(rq, tsk);
9052
9053         tg = container_of(task_subsys_state_check(tsk, cpu_cgroup_subsys_id,
9054                                 lockdep_is_held(&tsk->sighand->siglock)),
9055                           struct task_group, css);
9056         tg = autogroup_task_group(tsk, tg);
9057         tsk->sched_task_group = tg;
9058
9059 #ifdef CONFIG_FAIR_GROUP_SCHED
9060         if (tsk->sched_class->task_move_group)
9061                 tsk->sched_class->task_move_group(tsk, on_rq);
9062         else
9063 #endif
9064                 set_task_rq(tsk, task_cpu(tsk));
9065
9066         if (unlikely(running))
9067                 tsk->sched_class->set_curr_task(rq);
9068         if (on_rq)
9069                 enqueue_task(rq, tsk, 0);
9070
9071         task_rq_unlock(rq, tsk, &flags);
9072 }
9073 #endif /* CONFIG_CGROUP_SCHED */
9074
9075 #ifdef CONFIG_FAIR_GROUP_SCHED
9076 static DEFINE_MUTEX(shares_mutex);
9077
9078 int sched_group_set_shares(struct task_group *tg, unsigned long shares)
9079 {
9080         int i;
9081         unsigned long flags;
9082
9083         /*
9084          * We can't change the weight of the root cgroup.
9085          */
9086         if (!tg->se[0])
9087                 return -EINVAL;
9088
9089         shares = clamp(shares, scale_load(MIN_SHARES), scale_load(MAX_SHARES));
9090
9091         mutex_lock(&shares_mutex);
9092         if (tg->shares == shares)
9093                 goto done;
9094
9095         tg->shares = shares;
9096         for_each_possible_cpu(i) {
9097                 struct rq *rq = cpu_rq(i);
9098                 struct sched_entity *se;
9099
9100                 se = tg->se[i];
9101                 /* Propagate contribution to hierarchy */
9102                 raw_spin_lock_irqsave(&rq->lock, flags);
9103                 for_each_sched_entity(se)
9104                         update_cfs_shares(group_cfs_rq(se));
9105                 raw_spin_unlock_irqrestore(&rq->lock, flags);
9106         }
9107
9108 done:
9109         mutex_unlock(&shares_mutex);
9110         return 0;
9111 }
9112
9113 unsigned long sched_group_shares(struct task_group *tg)
9114 {
9115         return tg->shares;
9116 }
9117 #endif
9118
9119 #if defined(CONFIG_RT_GROUP_SCHED) || defined(CONFIG_CFS_BANDWIDTH)
9120 static unsigned long to_ratio(u64 period, u64 runtime)
9121 {
9122         if (runtime == RUNTIME_INF)
9123                 return 1ULL << 20;
9124
9125         return div64_u64(runtime << 20, period);
9126 }
9127 #endif
9128
9129 #ifdef CONFIG_RT_GROUP_SCHED
9130 /*
9131  * Ensure that the real time constraints are schedulable.
9132  */
9133 static DEFINE_MUTEX(rt_constraints_mutex);
9134
9135 /* Must be called with tasklist_lock held */
9136 static inline int tg_has_rt_tasks(struct task_group *tg)
9137 {
9138         struct task_struct *g, *p;
9139
9140         /*
9141          * Autogroups do not have RT tasks; see autogroup_create().
9142          */
9143         if (task_group_is_autogroup(tg))
9144                 return 0;
9145
9146         do_each_thread(g, p) {
9147                 if (rt_task(p) && rt_rq_of_se(&p->rt)->tg == tg)
9148                         return 1;
9149         } while_each_thread(g, p);
9150
9151         return 0;
9152 }
9153
9154 struct rt_schedulable_data {
9155         struct task_group *tg;
9156         u64 rt_period;
9157         u64 rt_runtime;
9158 };
9159
9160 static int tg_rt_schedulable(struct task_group *tg, void *data)
9161 {
9162         struct rt_schedulable_data *d = data;
9163         struct task_group *child;
9164         unsigned long total, sum = 0;
9165         u64 period, runtime;
9166
9167         period = ktime_to_ns(tg->rt_bandwidth.rt_period);
9168         runtime = tg->rt_bandwidth.rt_runtime;
9169
9170         if (tg == d->tg) {
9171                 period = d->rt_period;
9172                 runtime = d->rt_runtime;
9173         }
9174
9175         /*
9176          * Cannot have more runtime than the period.
9177          */
9178         if (runtime > period && runtime != RUNTIME_INF)
9179                 return -EINVAL;
9180
9181         /*
9182          * Ensure we don't starve existing RT tasks.
9183          */
9184         if (rt_bandwidth_enabled() && !runtime && tg_has_rt_tasks(tg))
9185                 return -EBUSY;
9186
9187         total = to_ratio(period, runtime);
9188
9189         /*
9190          * Nobody can have more than the global setting allows.
9191          */
9192         if (total > to_ratio(global_rt_period(), global_rt_runtime()))
9193                 return -EINVAL;
9194
9195         /*
9196          * The sum of our children's runtime should not exceed our own.
9197          */
9198         list_for_each_entry_rcu(child, &tg->children, siblings) {
9199                 period = ktime_to_ns(child->rt_bandwidth.rt_period);
9200                 runtime = child->rt_bandwidth.rt_runtime;
9201
9202                 if (child == d->tg) {
9203                         period = d->rt_period;
9204                         runtime = d->rt_runtime;
9205                 }
9206
9207                 sum += to_ratio(period, runtime);
9208         }
9209
9210         if (sum > total)
9211                 return -EINVAL;
9212
9213         return 0;
9214 }
9215
9216 static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)
9217 {
9218         int ret;
9219
9220         struct rt_schedulable_data data = {
9221                 .tg = tg,
9222                 .rt_period = period,
9223                 .rt_runtime = runtime,
9224         };
9225
9226         rcu_read_lock();
9227         ret = walk_tg_tree(tg_rt_schedulable, tg_nop, &data);
9228         rcu_read_unlock();
9229
9230         return ret;
9231 }
9232
9233 static int tg_set_rt_bandwidth(struct task_group *tg,
9234                 u64 rt_period, u64 rt_runtime)
9235 {
9236         int i, err = 0;
9237
9238         mutex_lock(&rt_constraints_mutex);
9239         read_lock(&tasklist_lock);
9240         err = __rt_schedulable(tg, rt_period, rt_runtime);
9241         if (err)
9242                 goto unlock;
9243
9244         raw_spin_lock_irq(&tg->rt_bandwidth.rt_runtime_lock);
9245         tg->rt_bandwidth.rt_period = ns_to_ktime(rt_period);
9246         tg->rt_bandwidth.rt_runtime = rt_runtime;
9247
9248         for_each_possible_cpu(i) {
9249                 struct rt_rq *rt_rq = tg->rt_rq[i];
9250
9251                 raw_spin_lock(&rt_rq->rt_runtime_lock);
9252                 rt_rq->rt_runtime = rt_runtime;
9253                 raw_spin_unlock(&rt_rq->rt_runtime_lock);
9254         }
9255         raw_spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
9256 unlock:
9257         read_unlock(&tasklist_lock);
9258         mutex_unlock(&rt_constraints_mutex);
9259
9260         return err;
9261 }
9262
9263 int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
9264 {
9265         u64 rt_runtime, rt_period;
9266
9267         rt_period = ktime_to_ns(tg->rt_bandwidth.rt_period);
9268         rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC;
9269         if (rt_runtime_us < 0)
9270                 rt_runtime = RUNTIME_INF;
9271
9272         return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
9273 }
9274
9275 long sched_group_rt_runtime(struct task_group *tg)
9276 {
9277         u64 rt_runtime_us;
9278
9279         if (tg->rt_bandwidth.rt_runtime == RUNTIME_INF)
9280                 return -1;
9281
9282         rt_runtime_us = tg->rt_bandwidth.rt_runtime;
9283         do_div(rt_runtime_us, NSEC_PER_USEC);
9284         return rt_runtime_us;
9285 }
9286
9287 int sched_group_set_rt_period(struct task_group *tg, long rt_period_us)
9288 {
9289         u64 rt_runtime, rt_period;
9290
9291         rt_period = (u64)rt_period_us * NSEC_PER_USEC;
9292         rt_runtime = tg->rt_bandwidth.rt_runtime;
9293
9294         if (rt_period == 0)
9295                 return -EINVAL;
9296
9297         return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
9298 }
9299
9300 long sched_group_rt_period(struct task_group *tg)
9301 {
9302         u64 rt_period_us;
9303
9304         rt_period_us = ktime_to_ns(tg->rt_bandwidth.rt_period);
9305         do_div(rt_period_us, NSEC_PER_USEC);
9306         return rt_period_us;
9307 }
9308
9309 static int sched_rt_global_constraints(void)
9310 {
9311         u64 runtime, period;
9312         int ret = 0;
9313
9314         if (sysctl_sched_rt_period <= 0)
9315                 return -EINVAL;
9316
9317         runtime = global_rt_runtime();
9318         period = global_rt_period();
9319
9320         /*
9321          * Sanity check on the sysctl variables.
9322          */
9323         if (runtime > period && runtime != RUNTIME_INF)
9324                 return -EINVAL;
9325
9326         mutex_lock(&rt_constraints_mutex);
9327         read_lock(&tasklist_lock);
9328         ret = __rt_schedulable(NULL, 0, 0);
9329         read_unlock(&tasklist_lock);
9330         mutex_unlock(&rt_constraints_mutex);
9331
9332         return ret;
9333 }
9334
9335 int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk)
9336 {
9337         /* Don't accept realtime tasks when there is no way for them to run */
9338         if (rt_task(tsk) && tg->rt_bandwidth.rt_runtime == 0)
9339                 return 0;
9340
9341         return 1;
9342 }
9343
9344 #else /* !CONFIG_RT_GROUP_SCHED */
9345 static int sched_rt_global_constraints(void)
9346 {
9347         unsigned long flags;
9348         int i;
9349
9350         if (sysctl_sched_rt_period <= 0)
9351                 return -EINVAL;
9352
9353         /*
9354          * There's always some RT tasks in the root group
9355          * -- migration, kstopmachine etc..
9356          */
9357         if (sysctl_sched_rt_runtime == 0)
9358                 return -EBUSY;
9359
9360         raw_spin_lock_irqsave(&def_rt_bandwidth.rt_runtime_lock, flags);
9361         for_each_possible_cpu(i) {
9362                 struct rt_rq *rt_rq = &cpu_rq(i)->rt;
9363
9364                 raw_spin_lock(&rt_rq->rt_runtime_lock);
9365                 rt_rq->rt_runtime = global_rt_runtime();
9366                 raw_spin_unlock(&rt_rq->rt_runtime_lock);
9367         }
9368         raw_spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
9369
9370         return 0;
9371 }
9372 #endif /* CONFIG_RT_GROUP_SCHED */
9373
9374 int sched_rt_handler(struct ctl_table *table, int write,
9375                 void __user *buffer, size_t *lenp,
9376                 loff_t *ppos)
9377 {
9378         int ret;
9379         int old_period, old_runtime;
9380         static DEFINE_MUTEX(mutex);
9381
9382         mutex_lock(&mutex);
9383         old_period = sysctl_sched_rt_period;
9384         old_runtime = sysctl_sched_rt_runtime;
9385
9386         ret = proc_dointvec(table, write, buffer, lenp, ppos);
9387
9388         if (!ret && write) {
9389                 ret = sched_rt_global_constraints();
9390                 if (ret) {
9391                         sysctl_sched_rt_period = old_period;
9392                         sysctl_sched_rt_runtime = old_runtime;
9393                 } else {
9394                         def_rt_bandwidth.rt_runtime = global_rt_runtime();
9395                         def_rt_bandwidth.rt_period =
9396                                 ns_to_ktime(global_rt_period());
9397                 }
9398         }
9399         mutex_unlock(&mutex);
9400
9401         return ret;
9402 }
9403
9404 #ifdef CONFIG_CGROUP_SCHED
9405
9406 /* return corresponding task_group object of a cgroup */
9407 static inline struct task_group *cgroup_tg(struct cgroup *cgrp)
9408 {
9409         return container_of(cgroup_subsys_state(cgrp, cpu_cgroup_subsys_id),
9410                             struct task_group, css);
9411 }
9412
9413 static struct cgroup_subsys_state *
9414 cpu_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp)
9415 {
9416         struct task_group *tg, *parent;
9417
9418         if (!cgrp->parent) {
9419                 /* This is early initialization for the top cgroup */
9420                 return &root_task_group.css;
9421         }
9422
9423         parent = cgroup_tg(cgrp->parent);
9424         tg = sched_create_group(parent);
9425         if (IS_ERR(tg))
9426                 return ERR_PTR(-ENOMEM);
9427
9428         return &tg->css;
9429 }
9430
9431 static void
9432 cpu_cgroup_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
9433 {
9434         struct task_group *tg = cgroup_tg(cgrp);
9435
9436         sched_destroy_group(tg);
9437 }
9438
9439 static int
9440 cpu_cgroup_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
9441 {
9442 #ifdef CONFIG_RT_GROUP_SCHED
9443         if (!sched_rt_can_attach(cgroup_tg(cgrp), tsk))
9444                 return -EINVAL;
9445 #else
9446         /* We don't support RT-tasks being in separate groups */
9447         if (tsk->sched_class != &fair_sched_class)
9448                 return -EINVAL;
9449 #endif
9450         return 0;
9451 }
9452
9453 static void
9454 cpu_cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
9455 {
9456         sched_move_task(tsk);
9457 }
9458
9459 static void
9460 cpu_cgroup_exit(struct cgroup_subsys *ss, struct cgroup *cgrp,
9461                 struct cgroup *old_cgrp, struct task_struct *task)
9462 {
9463         /*
9464          * cgroup_exit() is called in the copy_process() failure path.
9465          * Ignore this case since the task hasn't ran yet, this avoids
9466          * trying to poke a half freed task state from generic code.
9467          */
9468         if (!(task->flags & PF_EXITING))
9469                 return;
9470
9471         sched_move_task(task);
9472 }
9473
9474 #ifdef CONFIG_FAIR_GROUP_SCHED
9475 static int cpu_shares_write_u64(struct cgroup *cgrp, struct cftype *cftype,
9476                                 u64 shareval)
9477 {
9478         return sched_group_set_shares(cgroup_tg(cgrp), scale_load(shareval));
9479 }
9480
9481 static u64 cpu_shares_read_u64(struct cgroup *cgrp, struct cftype *cft)
9482 {
9483         struct task_group *tg = cgroup_tg(cgrp);
9484
9485         return (u64) scale_load_down(tg->shares);
9486 }
9487
9488 #ifdef CONFIG_CFS_BANDWIDTH
9489 static DEFINE_MUTEX(cfs_constraints_mutex);
9490
9491 const u64 max_cfs_quota_period = 1 * NSEC_PER_SEC; /* 1s */
9492 const u64 min_cfs_quota_period = 1 * NSEC_PER_MSEC; /* 1ms */
9493
9494 static int __cfs_schedulable(struct task_group *tg, u64 period, u64 runtime);
9495
9496 static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)
9497 {
9498         int i, ret = 0, runtime_enabled;
9499         struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(tg);
9500
9501         if (tg == &root_task_group)
9502                 return -EINVAL;
9503
9504         /*
9505          * Ensure we have at some amount of bandwidth every period.  This is
9506          * to prevent reaching a state of large arrears when throttled via
9507          * entity_tick() resulting in prolonged exit starvation.
9508          */
9509         if (quota < min_cfs_quota_period || period < min_cfs_quota_period)
9510                 return -EINVAL;
9511
9512         /*
9513          * Likewise, bound things on the otherside by preventing insane quota
9514          * periods.  This also allows us to normalize in computing quota
9515          * feasibility.
9516          */
9517         if (period > max_cfs_quota_period)
9518                 return -EINVAL;
9519
9520         mutex_lock(&cfs_constraints_mutex);
9521         ret = __cfs_schedulable(tg, period, quota);
9522         if (ret)
9523                 goto out_unlock;
9524
9525         runtime_enabled = quota != RUNTIME_INF;
9526         raw_spin_lock_irq(&cfs_b->lock);
9527         cfs_b->period = ns_to_ktime(period);
9528         cfs_b->quota = quota;
9529
9530         __refill_cfs_bandwidth_runtime(cfs_b);
9531         /* restart the period timer (if active) to handle new period expiry */
9532         if (runtime_enabled && cfs_b->timer_active) {
9533                 /* force a reprogram */
9534                 cfs_b->timer_active = 0;
9535                 __start_cfs_bandwidth(cfs_b);
9536         }
9537         raw_spin_unlock_irq(&cfs_b->lock);
9538
9539         for_each_possible_cpu(i) {
9540                 struct cfs_rq *cfs_rq = tg->cfs_rq[i];
9541                 struct rq *rq = rq_of(cfs_rq);
9542
9543                 raw_spin_lock_irq(&rq->lock);
9544                 cfs_rq->runtime_enabled = runtime_enabled;
9545                 cfs_rq->runtime_remaining = 0;
9546
9547                 if (cfs_rq_throttled(cfs_rq))
9548                         unthrottle_cfs_rq(cfs_rq);
9549                 raw_spin_unlock_irq(&rq->lock);
9550         }
9551 out_unlock:
9552         mutex_unlock(&cfs_constraints_mutex);
9553
9554         return ret;
9555 }
9556
9557 int tg_set_cfs_quota(struct task_group *tg, long cfs_quota_us)
9558 {
9559         u64 quota, period;
9560
9561         period = ktime_to_ns(tg_cfs_bandwidth(tg)->period);
9562         if (cfs_quota_us < 0)
9563                 quota = RUNTIME_INF;
9564         else
9565                 quota = (u64)cfs_quota_us * NSEC_PER_USEC;
9566
9567         return tg_set_cfs_bandwidth(tg, period, quota);
9568 }
9569
9570 long tg_get_cfs_quota(struct task_group *tg)
9571 {
9572         u64 quota_us;
9573
9574         if (tg_cfs_bandwidth(tg)->quota == RUNTIME_INF)
9575                 return -1;
9576
9577         quota_us = tg_cfs_bandwidth(tg)->quota;
9578         do_div(quota_us, NSEC_PER_USEC);
9579
9580         return quota_us;
9581 }
9582
9583 int tg_set_cfs_period(struct task_group *tg, long cfs_period_us)
9584 {
9585         u64 quota, period;
9586
9587         period = (u64)cfs_period_us * NSEC_PER_USEC;
9588         quota = tg_cfs_bandwidth(tg)->quota;
9589
9590         if (period <= 0)
9591                 return -EINVAL;
9592
9593         return tg_set_cfs_bandwidth(tg, period, quota);
9594 }
9595
9596 long tg_get_cfs_period(struct task_group *tg)
9597 {
9598         u64 cfs_period_us;
9599
9600         cfs_period_us = ktime_to_ns(tg_cfs_bandwidth(tg)->period);
9601         do_div(cfs_period_us, NSEC_PER_USEC);
9602
9603         return cfs_period_us;
9604 }
9605
9606 static s64 cpu_cfs_quota_read_s64(struct cgroup *cgrp, struct cftype *cft)
9607 {
9608         return tg_get_cfs_quota(cgroup_tg(cgrp));
9609 }
9610
9611 static int cpu_cfs_quota_write_s64(struct cgroup *cgrp, struct cftype *cftype,
9612                                 s64 cfs_quota_us)
9613 {
9614         return tg_set_cfs_quota(cgroup_tg(cgrp), cfs_quota_us);
9615 }
9616
9617 static u64 cpu_cfs_period_read_u64(struct cgroup *cgrp, struct cftype *cft)
9618 {
9619         return tg_get_cfs_period(cgroup_tg(cgrp));
9620 }
9621
9622 static int cpu_cfs_period_write_u64(struct cgroup *cgrp, struct cftype *cftype,
9623                                 u64 cfs_period_us)
9624 {
9625         return tg_set_cfs_period(cgroup_tg(cgrp), cfs_period_us);
9626 }
9627
9628 struct cfs_schedulable_data {
9629         struct task_group *tg;
9630         u64 period, quota;
9631 };
9632
9633 /*
9634  * normalize group quota/period to be quota/max_period
9635  * note: units are usecs
9636  */
9637 static u64 normalize_cfs_quota(struct task_group *tg,
9638                                struct cfs_schedulable_data *d)
9639 {
9640         u64 quota, period;
9641
9642         if (tg == d->tg) {
9643                 period = d->period;
9644                 quota = d->quota;
9645         } else {
9646                 period = tg_get_cfs_period(tg);
9647                 quota = tg_get_cfs_quota(tg);
9648         }
9649
9650         /* note: these should typically be equivalent */
9651         if (quota == RUNTIME_INF || quota == -1)
9652                 return RUNTIME_INF;
9653
9654         return to_ratio(period, quota);
9655 }
9656
9657 static int tg_cfs_schedulable_down(struct task_group *tg, void *data)
9658 {
9659         struct cfs_schedulable_data *d = data;
9660         struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(tg);
9661         s64 quota = 0, parent_quota = -1;
9662
9663         if (!tg->parent) {
9664                 quota = RUNTIME_INF;
9665         } else {
9666                 struct cfs_bandwidth *parent_b = tg_cfs_bandwidth(tg->parent);
9667
9668                 quota = normalize_cfs_quota(tg, d);
9669                 parent_quota = parent_b->hierarchal_quota;
9670
9671                 /*
9672                  * ensure max(child_quota) <= parent_quota, inherit when no
9673                  * limit is set
9674                  */
9675                 if (quota == RUNTIME_INF)
9676                         quota = parent_quota;
9677                 else if (parent_quota != RUNTIME_INF && quota > parent_quota)
9678                         return -EINVAL;
9679         }
9680         cfs_b->hierarchal_quota = quota;
9681
9682         return 0;
9683 }
9684
9685 static int __cfs_schedulable(struct task_group *tg, u64 period, u64 quota)
9686 {
9687         int ret;
9688         struct cfs_schedulable_data data = {
9689                 .tg = tg,
9690                 .period = period,
9691                 .quota = quota,
9692         };
9693
9694         if (quota != RUNTIME_INF) {
9695                 do_div(data.period, NSEC_PER_USEC);
9696                 do_div(data.quota, NSEC_PER_USEC);
9697         }
9698
9699         rcu_read_lock();
9700         ret = walk_tg_tree(tg_cfs_schedulable_down, tg_nop, &data);
9701         rcu_read_unlock();
9702
9703         return ret;
9704 }
9705
9706 static int cpu_stats_show(struct cgroup *cgrp, struct cftype *cft,
9707                 struct cgroup_map_cb *cb)
9708 {
9709         struct task_group *tg = cgroup_tg(cgrp);
9710         struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(tg);
9711
9712         cb->fill(cb, "nr_periods", cfs_b->nr_periods);
9713         cb->fill(cb, "nr_throttled", cfs_b->nr_throttled);
9714         cb->fill(cb, "throttled_time", cfs_b->throttled_time);
9715
9716         return 0;
9717 }
9718 #endif /* CONFIG_CFS_BANDWIDTH */
9719 #endif /* CONFIG_FAIR_GROUP_SCHED */
9720
9721 #ifdef CONFIG_RT_GROUP_SCHED
9722 static int cpu_rt_runtime_write(struct cgroup *cgrp, struct cftype *cft,
9723                                 s64 val)
9724 {
9725         return sched_group_set_rt_runtime(cgroup_tg(cgrp), val);
9726 }
9727
9728 static s64 cpu_rt_runtime_read(struct cgroup *cgrp, struct cftype *cft)
9729 {
9730         return sched_group_rt_runtime(cgroup_tg(cgrp));
9731 }
9732
9733 static int cpu_rt_period_write_uint(struct cgroup *cgrp, struct cftype *cftype,
9734                 u64 rt_period_us)
9735 {
9736         return sched_group_set_rt_period(cgroup_tg(cgrp), rt_period_us);
9737 }
9738
9739 static u64 cpu_rt_period_read_uint(struct cgroup *cgrp, struct cftype *cft)
9740 {
9741         return sched_group_rt_period(cgroup_tg(cgrp));
9742 }
9743 #endif /* CONFIG_RT_GROUP_SCHED */
9744
9745 static struct cftype cpu_files[] = {
9746 #ifdef CONFIG_FAIR_GROUP_SCHED
9747         {
9748                 .name = "shares",
9749                 .read_u64 = cpu_shares_read_u64,
9750                 .write_u64 = cpu_shares_write_u64,
9751         },
9752 #endif
9753 #ifdef CONFIG_CFS_BANDWIDTH
9754         {
9755                 .name = "cfs_quota_us",
9756                 .read_s64 = cpu_cfs_quota_read_s64,
9757                 .write_s64 = cpu_cfs_quota_write_s64,
9758         },
9759         {
9760                 .name = "cfs_period_us",
9761                 .read_u64 = cpu_cfs_period_read_u64,
9762                 .write_u64 = cpu_cfs_period_write_u64,
9763         },
9764         {
9765                 .name = "stat",
9766                 .read_map = cpu_stats_show,
9767         },
9768 #endif
9769 #ifdef CONFIG_RT_GROUP_SCHED
9770         {
9771                 .name = "rt_runtime_us",
9772                 .read_s64 = cpu_rt_runtime_read,
9773                 .write_s64 = cpu_rt_runtime_write,
9774         },
9775         {
9776                 .name = "rt_period_us",
9777                 .read_u64 = cpu_rt_period_read_uint,
9778                 .write_u64 = cpu_rt_period_write_uint,
9779         },
9780 #endif
9781 };
9782
9783 static int cpu_cgroup_populate(struct cgroup_subsys *ss, struct cgroup *cont)
9784 {
9785         return cgroup_add_files(cont, ss, cpu_files, ARRAY_SIZE(cpu_files));
9786 }
9787
9788 struct cgroup_subsys cpu_cgroup_subsys = {
9789         .name           = "cpu",
9790         .create         = cpu_cgroup_create,
9791         .destroy        = cpu_cgroup_destroy,
9792         .can_attach_task = cpu_cgroup_can_attach_task,
9793         .attach_task    = cpu_cgroup_attach_task,
9794         .exit           = cpu_cgroup_exit,
9795         .populate       = cpu_cgroup_populate,
9796         .subsys_id      = cpu_cgroup_subsys_id,
9797         .early_init     = 1,
9798 };
9799
9800 #endif  /* CONFIG_CGROUP_SCHED */
9801
9802 #ifdef CONFIG_CGROUP_CPUACCT
9803
9804 /*
9805  * CPU accounting code for task groups.
9806  *
9807  * Based on the work by Paul Menage (menage@google.com) and Balbir Singh
9808  * (balbir@in.ibm.com).
9809  */
9810
9811 /* track cpu usage of a group of tasks and its child groups */
9812 struct cpuacct {
9813         struct cgroup_subsys_state css;
9814         /* cpuusage holds pointer to a u64-type object on every cpu */
9815         u64 __percpu *cpuusage;
9816         struct percpu_counter cpustat[CPUACCT_STAT_NSTATS];
9817         struct cpuacct *parent;
9818 };
9819
9820 struct cgroup_subsys cpuacct_subsys;
9821
9822 /* return cpu accounting group corresponding to this container */
9823 static inline struct cpuacct *cgroup_ca(struct cgroup *cgrp)
9824 {
9825         return container_of(cgroup_subsys_state(cgrp, cpuacct_subsys_id),
9826                             struct cpuacct, css);
9827 }
9828
9829 /* return cpu accounting group to which this task belongs */
9830 static inline struct cpuacct *task_ca(struct task_struct *tsk)
9831 {
9832         return container_of(task_subsys_state(tsk, cpuacct_subsys_id),
9833                             struct cpuacct, css);
9834 }
9835
9836 /* create a new cpu accounting group */
9837 static struct cgroup_subsys_state *cpuacct_create(
9838         struct cgroup_subsys *ss, struct cgroup *cgrp)
9839 {
9840         struct cpuacct *ca = kzalloc(sizeof(*ca), GFP_KERNEL);
9841         int i;
9842
9843         if (!ca)
9844                 goto out;
9845
9846         ca->cpuusage = alloc_percpu(u64);
9847         if (!ca->cpuusage)
9848                 goto out_free_ca;
9849
9850         for (i = 0; i < CPUACCT_STAT_NSTATS; i++)
9851                 if (percpu_counter_init(&ca->cpustat[i], 0))
9852                         goto out_free_counters;
9853
9854         if (cgrp->parent)
9855                 ca->parent = cgroup_ca(cgrp->parent);
9856
9857         return &ca->css;
9858
9859 out_free_counters:
9860         while (--i >= 0)
9861                 percpu_counter_destroy(&ca->cpustat[i]);
9862         free_percpu(ca->cpuusage);
9863 out_free_ca:
9864         kfree(ca);
9865 out:
9866         return ERR_PTR(-ENOMEM);
9867 }
9868
9869 /* destroy an existing cpu accounting group */
9870 static void
9871 cpuacct_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
9872 {
9873         struct cpuacct *ca = cgroup_ca(cgrp);
9874         int i;
9875
9876         for (i = 0; i < CPUACCT_STAT_NSTATS; i++)
9877                 percpu_counter_destroy(&ca->cpustat[i]);
9878         free_percpu(ca->cpuusage);
9879         kfree(ca);
9880 }
9881
9882 static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu)
9883 {
9884         u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
9885         u64 data;
9886
9887 #ifndef CONFIG_64BIT
9888         /*
9889          * Take rq->lock to make 64-bit read safe on 32-bit platforms.
9890          */
9891         raw_spin_lock_irq(&cpu_rq(cpu)->lock);
9892         data = *cpuusage;
9893         raw_spin_unlock_irq(&cpu_rq(cpu)->lock);
9894 #else
9895         data = *cpuusage;
9896 #endif
9897
9898         return data;
9899 }
9900
9901 static void cpuacct_cpuusage_write(struct cpuacct *ca, int cpu, u64 val)
9902 {
9903         u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
9904
9905 #ifndef CONFIG_64BIT
9906         /*
9907          * Take rq->lock to make 64-bit write safe on 32-bit platforms.
9908          */
9909         raw_spin_lock_irq(&cpu_rq(cpu)->lock);
9910         *cpuusage = val;
9911         raw_spin_unlock_irq(&cpu_rq(cpu)->lock);
9912 #else
9913         *cpuusage = val;
9914 #endif
9915 }
9916
9917 /* return total cpu usage (in nanoseconds) of a group */
9918 static u64 cpuusage_read(struct cgroup *cgrp, struct cftype *cft)
9919 {
9920         struct cpuacct *ca = cgroup_ca(cgrp);
9921         u64 totalcpuusage = 0;
9922         int i;
9923
9924         for_each_present_cpu(i)
9925                 totalcpuusage += cpuacct_cpuusage_read(ca, i);
9926
9927         return totalcpuusage;
9928 }
9929
9930 static int cpuusage_write(struct cgroup *cgrp, struct cftype *cftype,
9931                                                                 u64 reset)
9932 {
9933         struct cpuacct *ca = cgroup_ca(cgrp);
9934         int err = 0;
9935         int i;
9936
9937         if (reset) {
9938                 err = -EINVAL;
9939                 goto out;
9940         }
9941
9942         for_each_present_cpu(i)
9943                 cpuacct_cpuusage_write(ca, i, 0);
9944
9945 out:
9946         return err;
9947 }
9948
9949 static int cpuacct_percpu_seq_read(struct cgroup *cgroup, struct cftype *cft,
9950                                    struct seq_file *m)
9951 {
9952         struct cpuacct *ca = cgroup_ca(cgroup);
9953         u64 percpu;
9954         int i;
9955
9956         for_each_present_cpu(i) {
9957                 percpu = cpuacct_cpuusage_read(ca, i);
9958                 seq_printf(m, "%llu ", (unsigned long long) percpu);
9959         }
9960         seq_printf(m, "\n");
9961         return 0;
9962 }
9963
9964 static const char *cpuacct_stat_desc[] = {
9965         [CPUACCT_STAT_USER] = "user",
9966         [CPUACCT_STAT_SYSTEM] = "system",
9967 };
9968
9969 static int cpuacct_stats_show(struct cgroup *cgrp, struct cftype *cft,
9970                 struct cgroup_map_cb *cb)
9971 {
9972         struct cpuacct *ca = cgroup_ca(cgrp);
9973         int i;
9974
9975         for (i = 0; i < CPUACCT_STAT_NSTATS; i++) {
9976                 s64 val = percpu_counter_read(&ca->cpustat[i]);
9977                 val = cputime64_to_clock_t(val);
9978                 cb->fill(cb, cpuacct_stat_desc[i], val);
9979         }
9980         return 0;
9981 }
9982
9983 static struct cftype files[] = {
9984         {
9985                 .name = "usage",
9986                 .read_u64 = cpuusage_read,
9987                 .write_u64 = cpuusage_write,
9988         },
9989         {
9990                 .name = "usage_percpu",
9991                 .read_seq_string = cpuacct_percpu_seq_read,
9992         },
9993         {
9994                 .name = "stat",
9995                 .read_map = cpuacct_stats_show,
9996         },
9997 };
9998
9999 static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
10000 {
10001         return cgroup_add_files(cgrp, ss, files, ARRAY_SIZE(files));
10002 }
10003
10004 /*
10005  * charge this task's execution time to its accounting group.
10006  *
10007  * called with rq->lock held.
10008  */
10009 static void cpuacct_charge(struct task_struct *tsk, u64 cputime)
10010 {
10011         struct cpuacct *ca;
10012         int cpu;
10013
10014         if (unlikely(!cpuacct_subsys.active))
10015                 return;
10016
10017         cpu = task_cpu(tsk);
10018
10019         rcu_read_lock();
10020
10021         ca = task_ca(tsk);
10022
10023         for (; ca; ca = ca->parent) {
10024                 u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
10025                 *cpuusage += cputime;
10026         }
10027
10028         rcu_read_unlock();
10029 }
10030
10031 /*
10032  * When CONFIG_VIRT_CPU_ACCOUNTING is enabled one jiffy can be very large
10033  * in cputime_t units. As a result, cpuacct_update_stats calls
10034  * percpu_counter_add with values large enough to always overflow the
10035  * per cpu batch limit causing bad SMP scalability.
10036  *
10037  * To fix this we scale percpu_counter_batch by cputime_one_jiffy so we
10038  * batch the same amount of time with CONFIG_VIRT_CPU_ACCOUNTING disabled
10039  * and enabled. We cap it at INT_MAX which is the largest allowed batch value.
10040  */
10041 #ifdef CONFIG_SMP
10042 #define CPUACCT_BATCH   \
10043         min_t(long, percpu_counter_batch * cputime_one_jiffy, INT_MAX)
10044 #else
10045 #define CPUACCT_BATCH   0
10046 #endif
10047
10048 /*
10049  * Charge the system/user time to the task's accounting group.
10050  */
10051 static void cpuacct_update_stats(struct task_struct *tsk,
10052                 enum cpuacct_stat_index idx, cputime_t val)
10053 {
10054         struct cpuacct *ca;
10055         int batch = CPUACCT_BATCH;
10056
10057         if (unlikely(!cpuacct_subsys.active))
10058                 return;
10059
10060         rcu_read_lock();
10061         ca = task_ca(tsk);
10062
10063         do {
10064                 __percpu_counter_add(&ca->cpustat[idx], val, batch);
10065                 ca = ca->parent;
10066         } while (ca);
10067         rcu_read_unlock();
10068 }
10069
10070 struct cgroup_subsys cpuacct_subsys = {
10071         .name = "cpuacct",
10072         .create = cpuacct_create,
10073         .destroy = cpuacct_destroy,
10074         .populate = cpuacct_populate,
10075         .subsys_id = cpuacct_subsys_id,
10076 };
10077 #endif  /* CONFIG_CGROUP_CPUACCT */