sched: Add irq_{enter,exit}() to scheduler_ipi()
[omap4-v4l2-camera:astrowus-omap4-v4l2-camera.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 <asm/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
75 #include <asm/tlb.h>
76 #include <asm/irq_regs.h>
77 #include <asm/mutex.h>
78
79 #include "sched_cpupri.h"
80 #include "workqueue_sched.h"
81 #include "sched_autogroup.h"
82
83 #define CREATE_TRACE_POINTS
84 #include <trace/events/sched.h>
85
86 /*
87  * Convert user-nice values [ -20 ... 0 ... 19 ]
88  * to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
89  * and back.
90  */
91 #define NICE_TO_PRIO(nice)      (MAX_RT_PRIO + (nice) + 20)
92 #define PRIO_TO_NICE(prio)      ((prio) - MAX_RT_PRIO - 20)
93 #define TASK_NICE(p)            PRIO_TO_NICE((p)->static_prio)
94
95 /*
96  * 'User priority' is the nice value converted to something we
97  * can work with better when scaling various scheduler parameters,
98  * it's a [ 0 ... 39 ] range.
99  */
100 #define USER_PRIO(p)            ((p)-MAX_RT_PRIO)
101 #define TASK_USER_PRIO(p)       USER_PRIO((p)->static_prio)
102 #define MAX_USER_PRIO           (USER_PRIO(MAX_PRIO))
103
104 /*
105  * Helpers for converting nanosecond timing to jiffy resolution
106  */
107 #define NS_TO_JIFFIES(TIME)     ((unsigned long)(TIME) / (NSEC_PER_SEC / HZ))
108
109 #define NICE_0_LOAD             SCHED_LOAD_SCALE
110 #define NICE_0_SHIFT            SCHED_LOAD_SHIFT
111
112 /*
113  * These are the 'tuning knobs' of the scheduler:
114  *
115  * default timeslice is 100 msecs (used only for SCHED_RR tasks).
116  * Timeslices get refilled after they expire.
117  */
118 #define DEF_TIMESLICE           (100 * HZ / 1000)
119
120 /*
121  * single value that denotes runtime == period, ie unlimited time.
122  */
123 #define RUNTIME_INF     ((u64)~0ULL)
124
125 static inline int rt_policy(int policy)
126 {
127         if (unlikely(policy == SCHED_FIFO || policy == SCHED_RR))
128                 return 1;
129         return 0;
130 }
131
132 static inline int task_has_rt_policy(struct task_struct *p)
133 {
134         return rt_policy(p->policy);
135 }
136
137 /*
138  * This is the priority-queue data structure of the RT scheduling class:
139  */
140 struct rt_prio_array {
141         DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); /* include 1 bit for delimiter */
142         struct list_head queue[MAX_RT_PRIO];
143 };
144
145 struct rt_bandwidth {
146         /* nests inside the rq lock: */
147         raw_spinlock_t          rt_runtime_lock;
148         ktime_t                 rt_period;
149         u64                     rt_runtime;
150         struct hrtimer          rt_period_timer;
151 };
152
153 static struct rt_bandwidth def_rt_bandwidth;
154
155 static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun);
156
157 static enum hrtimer_restart sched_rt_period_timer(struct hrtimer *timer)
158 {
159         struct rt_bandwidth *rt_b =
160                 container_of(timer, struct rt_bandwidth, rt_period_timer);
161         ktime_t now;
162         int overrun;
163         int idle = 0;
164
165         for (;;) {
166                 now = hrtimer_cb_get_time(timer);
167                 overrun = hrtimer_forward(timer, now, rt_b->rt_period);
168
169                 if (!overrun)
170                         break;
171
172                 idle = do_sched_rt_period_timer(rt_b, overrun);
173         }
174
175         return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
176 }
177
178 static
179 void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime)
180 {
181         rt_b->rt_period = ns_to_ktime(period);
182         rt_b->rt_runtime = runtime;
183
184         raw_spin_lock_init(&rt_b->rt_runtime_lock);
185
186         hrtimer_init(&rt_b->rt_period_timer,
187                         CLOCK_MONOTONIC, HRTIMER_MODE_REL);
188         rt_b->rt_period_timer.function = sched_rt_period_timer;
189 }
190
191 static inline int rt_bandwidth_enabled(void)
192 {
193         return sysctl_sched_rt_runtime >= 0;
194 }
195
196 static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
197 {
198         ktime_t now;
199
200         if (!rt_bandwidth_enabled() || rt_b->rt_runtime == RUNTIME_INF)
201                 return;
202
203         if (hrtimer_active(&rt_b->rt_period_timer))
204                 return;
205
206         raw_spin_lock(&rt_b->rt_runtime_lock);
207         for (;;) {
208                 unsigned long delta;
209                 ktime_t soft, hard;
210
211                 if (hrtimer_active(&rt_b->rt_period_timer))
212                         break;
213
214                 now = hrtimer_cb_get_time(&rt_b->rt_period_timer);
215                 hrtimer_forward(&rt_b->rt_period_timer, now, rt_b->rt_period);
216
217                 soft = hrtimer_get_softexpires(&rt_b->rt_period_timer);
218                 hard = hrtimer_get_expires(&rt_b->rt_period_timer);
219                 delta = ktime_to_ns(ktime_sub(hard, soft));
220                 __hrtimer_start_range_ns(&rt_b->rt_period_timer, soft, delta,
221                                 HRTIMER_MODE_ABS_PINNED, 0);
222         }
223         raw_spin_unlock(&rt_b->rt_runtime_lock);
224 }
225
226 #ifdef CONFIG_RT_GROUP_SCHED
227 static void destroy_rt_bandwidth(struct rt_bandwidth *rt_b)
228 {
229         hrtimer_cancel(&rt_b->rt_period_timer);
230 }
231 #endif
232
233 /*
234  * sched_domains_mutex serializes calls to init_sched_domains,
235  * detach_destroy_domains and partition_sched_domains.
236  */
237 static DEFINE_MUTEX(sched_domains_mutex);
238
239 #ifdef CONFIG_CGROUP_SCHED
240
241 #include <linux/cgroup.h>
242
243 struct cfs_rq;
244
245 static LIST_HEAD(task_groups);
246
247 /* task group related information */
248 struct task_group {
249         struct cgroup_subsys_state css;
250
251 #ifdef CONFIG_FAIR_GROUP_SCHED
252         /* schedulable entities of this group on each cpu */
253         struct sched_entity **se;
254         /* runqueue "owned" by this group on each cpu */
255         struct cfs_rq **cfs_rq;
256         unsigned long shares;
257
258         atomic_t load_weight;
259 #endif
260
261 #ifdef CONFIG_RT_GROUP_SCHED
262         struct sched_rt_entity **rt_se;
263         struct rt_rq **rt_rq;
264
265         struct rt_bandwidth rt_bandwidth;
266 #endif
267
268         struct rcu_head rcu;
269         struct list_head list;
270
271         struct task_group *parent;
272         struct list_head siblings;
273         struct list_head children;
274
275 #ifdef CONFIG_SCHED_AUTOGROUP
276         struct autogroup *autogroup;
277 #endif
278 };
279
280 /* task_group_lock serializes the addition/removal of task groups */
281 static DEFINE_SPINLOCK(task_group_lock);
282
283 #ifdef CONFIG_FAIR_GROUP_SCHED
284
285 # define ROOT_TASK_GROUP_LOAD   NICE_0_LOAD
286
287 /*
288  * A weight of 0 or 1 can cause arithmetics problems.
289  * A weight of a cfs_rq is the sum of weights of which entities
290  * are queued on this cfs_rq, so a weight of a entity should not be
291  * too large, so as the shares value of a task group.
292  * (The default weight is 1024 - so there's no practical
293  *  limitation from this.)
294  */
295 #define MIN_SHARES      (1UL <<  1)
296 #define MAX_SHARES      (1UL << 18)
297
298 static int root_task_group_load = ROOT_TASK_GROUP_LOAD;
299 #endif
300
301 /* Default task group.
302  *      Every task in system belong to this group at bootup.
303  */
304 struct task_group root_task_group;
305
306 #endif  /* CONFIG_CGROUP_SCHED */
307
308 /* CFS-related fields in a runqueue */
309 struct cfs_rq {
310         struct load_weight load;
311         unsigned long nr_running;
312
313         u64 exec_clock;
314         u64 min_vruntime;
315 #ifndef CONFIG_64BIT
316         u64 min_vruntime_copy;
317 #endif
318
319         struct rb_root tasks_timeline;
320         struct rb_node *rb_leftmost;
321
322         struct list_head tasks;
323         struct list_head *balance_iterator;
324
325         /*
326          * 'curr' points to currently running entity on this cfs_rq.
327          * It is set to NULL otherwise (i.e when none are currently running).
328          */
329         struct sched_entity *curr, *next, *last, *skip;
330
331 #ifdef  CONFIG_SCHED_DEBUG
332         unsigned int nr_spread_over;
333 #endif
334
335 #ifdef CONFIG_FAIR_GROUP_SCHED
336         struct rq *rq;  /* cpu runqueue to which this cfs_rq is attached */
337
338         /*
339          * leaf cfs_rqs are those that hold tasks (lowest schedulable entity in
340          * a hierarchy). Non-leaf lrqs hold other higher schedulable entities
341          * (like users, containers etc.)
342          *
343          * leaf_cfs_rq_list ties together list of leaf cfs_rq's in a cpu. This
344          * list is used during load balance.
345          */
346         int on_list;
347         struct list_head leaf_cfs_rq_list;
348         struct task_group *tg;  /* group that "owns" this runqueue */
349
350 #ifdef CONFIG_SMP
351         /*
352          * the part of load.weight contributed by tasks
353          */
354         unsigned long task_weight;
355
356         /*
357          *   h_load = weight * f(tg)
358          *
359          * Where f(tg) is the recursive weight fraction assigned to
360          * this group.
361          */
362         unsigned long h_load;
363
364         /*
365          * Maintaining per-cpu shares distribution for group scheduling
366          *
367          * load_stamp is the last time we updated the load average
368          * load_last is the last time we updated the load average and saw load
369          * load_unacc_exec_time is currently unaccounted execution time
370          */
371         u64 load_avg;
372         u64 load_period;
373         u64 load_stamp, load_last, load_unacc_exec_time;
374
375         unsigned long load_contribution;
376 #endif
377 #endif
378 };
379
380 /* Real-Time classes' related field in a runqueue: */
381 struct rt_rq {
382         struct rt_prio_array active;
383         unsigned long rt_nr_running;
384 #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
385         struct {
386                 int curr; /* highest queued rt task prio */
387 #ifdef CONFIG_SMP
388                 int next; /* next highest */
389 #endif
390         } highest_prio;
391 #endif
392 #ifdef CONFIG_SMP
393         unsigned long rt_nr_migratory;
394         unsigned long rt_nr_total;
395         int overloaded;
396         struct plist_head pushable_tasks;
397 #endif
398         int rt_throttled;
399         u64 rt_time;
400         u64 rt_runtime;
401         /* Nests inside the rq lock: */
402         raw_spinlock_t rt_runtime_lock;
403
404 #ifdef CONFIG_RT_GROUP_SCHED
405         unsigned long rt_nr_boosted;
406
407         struct rq *rq;
408         struct list_head leaf_rt_rq_list;
409         struct task_group *tg;
410 #endif
411 };
412
413 #ifdef CONFIG_SMP
414
415 /*
416  * We add the notion of a root-domain which will be used to define per-domain
417  * variables. Each exclusive cpuset essentially defines an island domain by
418  * fully partitioning the member cpus from any other cpuset. Whenever a new
419  * exclusive cpuset is created, we also create and attach a new root-domain
420  * object.
421  *
422  */
423 struct root_domain {
424         atomic_t refcount;
425         struct rcu_head rcu;
426         cpumask_var_t span;
427         cpumask_var_t online;
428
429         /*
430          * The "RT overload" flag: it gets set if a CPU has more than
431          * one runnable RT task.
432          */
433         cpumask_var_t rto_mask;
434         atomic_t rto_count;
435         struct cpupri cpupri;
436 };
437
438 /*
439  * By default the system creates a single root-domain with all cpus as
440  * members (mimicking the global state we have today).
441  */
442 static struct root_domain def_root_domain;
443
444 #endif /* CONFIG_SMP */
445
446 /*
447  * This is the main, per-CPU runqueue data structure.
448  *
449  * Locking rule: those places that want to lock multiple runqueues
450  * (such as the load balancing or the thread migration code), lock
451  * acquire operations must be ordered by ascending &runqueue.
452  */
453 struct rq {
454         /* runqueue lock: */
455         raw_spinlock_t lock;
456
457         /*
458          * nr_running and cpu_load should be in the same cacheline because
459          * remote CPUs use both these fields when doing load calculation.
460          */
461         unsigned long nr_running;
462         #define CPU_LOAD_IDX_MAX 5
463         unsigned long cpu_load[CPU_LOAD_IDX_MAX];
464         unsigned long last_load_update_tick;
465 #ifdef CONFIG_NO_HZ
466         u64 nohz_stamp;
467         unsigned char nohz_balance_kick;
468 #endif
469         int skip_clock_update;
470
471         /* capture load from *all* tasks on this cpu: */
472         struct load_weight load;
473         unsigned long nr_load_updates;
474         u64 nr_switches;
475
476         struct cfs_rq cfs;
477         struct rt_rq rt;
478
479 #ifdef CONFIG_FAIR_GROUP_SCHED
480         /* list of leaf cfs_rq on this cpu: */
481         struct list_head leaf_cfs_rq_list;
482 #endif
483 #ifdef CONFIG_RT_GROUP_SCHED
484         struct list_head leaf_rt_rq_list;
485 #endif
486
487         /*
488          * This is part of a global counter where only the total sum
489          * over all CPUs matters. A task can increase this counter on
490          * one CPU and if it got migrated afterwards it may decrease
491          * it on another CPU. Always updated under the runqueue lock:
492          */
493         unsigned long nr_uninterruptible;
494
495         struct task_struct *curr, *idle, *stop;
496         unsigned long next_balance;
497         struct mm_struct *prev_mm;
498
499         u64 clock;
500         u64 clock_task;
501
502         atomic_t nr_iowait;
503
504 #ifdef CONFIG_SMP
505         struct root_domain *rd;
506         struct sched_domain *sd;
507
508         unsigned long cpu_power;
509
510         unsigned char idle_at_tick;
511         /* For active balancing */
512         int post_schedule;
513         int active_balance;
514         int push_cpu;
515         struct cpu_stop_work active_balance_work;
516         /* cpu of this runqueue: */
517         int cpu;
518         int online;
519
520         unsigned long avg_load_per_task;
521
522         u64 rt_avg;
523         u64 age_stamp;
524         u64 idle_stamp;
525         u64 avg_idle;
526 #endif
527
528 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
529         u64 prev_irq_time;
530 #endif
531
532         /* calc_load related fields */
533         unsigned long calc_load_update;
534         long calc_load_active;
535
536 #ifdef CONFIG_SCHED_HRTICK
537 #ifdef CONFIG_SMP
538         int hrtick_csd_pending;
539         struct call_single_data hrtick_csd;
540 #endif
541         struct hrtimer hrtick_timer;
542 #endif
543
544 #ifdef CONFIG_SCHEDSTATS
545         /* latency stats */
546         struct sched_info rq_sched_info;
547         unsigned long long rq_cpu_time;
548         /* could above be rq->cfs_rq.exec_clock + rq->rt_rq.rt_runtime ? */
549
550         /* sys_sched_yield() stats */
551         unsigned int yld_count;
552
553         /* schedule() stats */
554         unsigned int sched_switch;
555         unsigned int sched_count;
556         unsigned int sched_goidle;
557
558         /* try_to_wake_up() stats */
559         unsigned int ttwu_count;
560         unsigned int ttwu_local;
561 #endif
562
563 #ifdef CONFIG_SMP
564         struct task_struct *wake_list;
565 #endif
566 };
567
568 static DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
569
570
571 static void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags);
572
573 static inline int cpu_of(struct rq *rq)
574 {
575 #ifdef CONFIG_SMP
576         return rq->cpu;
577 #else
578         return 0;
579 #endif
580 }
581
582 #define rcu_dereference_check_sched_domain(p) \
583         rcu_dereference_check((p), \
584                               rcu_read_lock_held() || \
585                               lockdep_is_held(&sched_domains_mutex))
586
587 /*
588  * The domain tree (rq->sd) is protected by RCU's quiescent state transition.
589  * See detach_destroy_domains: synchronize_sched for details.
590  *
591  * The domain tree of any CPU may only be accessed from within
592  * preempt-disabled sections.
593  */
594 #define for_each_domain(cpu, __sd) \
595         for (__sd = rcu_dereference_check_sched_domain(cpu_rq(cpu)->sd); __sd; __sd = __sd->parent)
596
597 #define cpu_rq(cpu)             (&per_cpu(runqueues, (cpu)))
598 #define this_rq()               (&__get_cpu_var(runqueues))
599 #define task_rq(p)              cpu_rq(task_cpu(p))
600 #define cpu_curr(cpu)           (cpu_rq(cpu)->curr)
601 #define raw_rq()                (&__raw_get_cpu_var(runqueues))
602
603 #ifdef CONFIG_CGROUP_SCHED
604
605 /*
606  * Return the group to which this tasks belongs.
607  *
608  * We use task_subsys_state_check() and extend the RCU verification with
609  * pi->lock and rq->lock because cpu_cgroup_attach() holds those locks for each
610  * task it moves into the cgroup. Therefore by holding either of those locks,
611  * we pin the task to the current cgroup.
612  */
613 static inline struct task_group *task_group(struct task_struct *p)
614 {
615         struct task_group *tg;
616         struct cgroup_subsys_state *css;
617
618         css = task_subsys_state_check(p, cpu_cgroup_subsys_id,
619                         lockdep_is_held(&p->pi_lock) ||
620                         lockdep_is_held(&task_rq(p)->lock));
621         tg = container_of(css, struct task_group, css);
622
623         return autogroup_task_group(p, tg);
624 }
625
626 /* Change a task's cfs_rq and parent entity if it moves across CPUs/groups */
627 static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
628 {
629 #ifdef CONFIG_FAIR_GROUP_SCHED
630         p->se.cfs_rq = task_group(p)->cfs_rq[cpu];
631         p->se.parent = task_group(p)->se[cpu];
632 #endif
633
634 #ifdef CONFIG_RT_GROUP_SCHED
635         p->rt.rt_rq  = task_group(p)->rt_rq[cpu];
636         p->rt.parent = task_group(p)->rt_se[cpu];
637 #endif
638 }
639
640 #else /* CONFIG_CGROUP_SCHED */
641
642 static inline void set_task_rq(struct task_struct *p, unsigned int cpu) { }
643 static inline struct task_group *task_group(struct task_struct *p)
644 {
645         return NULL;
646 }
647
648 #endif /* CONFIG_CGROUP_SCHED */
649
650 static void update_rq_clock_task(struct rq *rq, s64 delta);
651
652 static void update_rq_clock(struct rq *rq)
653 {
654         s64 delta;
655
656         if (rq->skip_clock_update > 0)
657                 return;
658
659         delta = sched_clock_cpu(cpu_of(rq)) - rq->clock;
660         rq->clock += delta;
661         update_rq_clock_task(rq, delta);
662 }
663
664 /*
665  * Tunables that become constants when CONFIG_SCHED_DEBUG is off:
666  */
667 #ifdef CONFIG_SCHED_DEBUG
668 # define const_debug __read_mostly
669 #else
670 # define const_debug static const
671 #endif
672
673 /**
674  * runqueue_is_locked - Returns true if the current cpu runqueue is locked
675  * @cpu: the processor in question.
676  *
677  * This interface allows printk to be called with the runqueue lock
678  * held and know whether or not it is OK to wake up the klogd.
679  */
680 int runqueue_is_locked(int cpu)
681 {
682         return raw_spin_is_locked(&cpu_rq(cpu)->lock);
683 }
684
685 /*
686  * Debugging: various feature bits
687  */
688
689 #define SCHED_FEAT(name, enabled)       \
690         __SCHED_FEAT_##name ,
691
692 enum {
693 #include "sched_features.h"
694 };
695
696 #undef SCHED_FEAT
697
698 #define SCHED_FEAT(name, enabled)       \
699         (1UL << __SCHED_FEAT_##name) * enabled |
700
701 const_debug unsigned int sysctl_sched_features =
702 #include "sched_features.h"
703         0;
704
705 #undef SCHED_FEAT
706
707 #ifdef CONFIG_SCHED_DEBUG
708 #define SCHED_FEAT(name, enabled)       \
709         #name ,
710
711 static __read_mostly char *sched_feat_names[] = {
712 #include "sched_features.h"
713         NULL
714 };
715
716 #undef SCHED_FEAT
717
718 static int sched_feat_show(struct seq_file *m, void *v)
719 {
720         int i;
721
722         for (i = 0; sched_feat_names[i]; i++) {
723                 if (!(sysctl_sched_features & (1UL << i)))
724                         seq_puts(m, "NO_");
725                 seq_printf(m, "%s ", sched_feat_names[i]);
726         }
727         seq_puts(m, "\n");
728
729         return 0;
730 }
731
732 static ssize_t
733 sched_feat_write(struct file *filp, const char __user *ubuf,
734                 size_t cnt, loff_t *ppos)
735 {
736         char buf[64];
737         char *cmp;
738         int neg = 0;
739         int i;
740
741         if (cnt > 63)
742                 cnt = 63;
743
744         if (copy_from_user(&buf, ubuf, cnt))
745                 return -EFAULT;
746
747         buf[cnt] = 0;
748         cmp = strstrip(buf);
749
750         if (strncmp(cmp, "NO_", 3) == 0) {
751                 neg = 1;
752                 cmp += 3;
753         }
754
755         for (i = 0; sched_feat_names[i]; i++) {
756                 if (strcmp(cmp, sched_feat_names[i]) == 0) {
757                         if (neg)
758                                 sysctl_sched_features &= ~(1UL << i);
759                         else
760                                 sysctl_sched_features |= (1UL << i);
761                         break;
762                 }
763         }
764
765         if (!sched_feat_names[i])
766                 return -EINVAL;
767
768         *ppos += cnt;
769
770         return cnt;
771 }
772
773 static int sched_feat_open(struct inode *inode, struct file *filp)
774 {
775         return single_open(filp, sched_feat_show, NULL);
776 }
777
778 static const struct file_operations sched_feat_fops = {
779         .open           = sched_feat_open,
780         .write          = sched_feat_write,
781         .read           = seq_read,
782         .llseek         = seq_lseek,
783         .release        = single_release,
784 };
785
786 static __init int sched_init_debug(void)
787 {
788         debugfs_create_file("sched_features", 0644, NULL, NULL,
789                         &sched_feat_fops);
790
791         return 0;
792 }
793 late_initcall(sched_init_debug);
794
795 #endif
796
797 #define sched_feat(x) (sysctl_sched_features & (1UL << __SCHED_FEAT_##x))
798
799 /*
800  * Number of tasks to iterate in a single balance run.
801  * Limited because this is done with IRQs disabled.
802  */
803 const_debug unsigned int sysctl_sched_nr_migrate = 32;
804
805 /*
806  * period over which we average the RT time consumption, measured
807  * in ms.
808  *
809  * default: 1s
810  */
811 const_debug unsigned int sysctl_sched_time_avg = MSEC_PER_SEC;
812
813 /*
814  * period over which we measure -rt task cpu usage in us.
815  * default: 1s
816  */
817 unsigned int sysctl_sched_rt_period = 1000000;
818
819 static __read_mostly int scheduler_running;
820
821 /*
822  * part of the period that we allow rt tasks to run in us.
823  * default: 0.95s
824  */
825 int sysctl_sched_rt_runtime = 950000;
826
827 static inline u64 global_rt_period(void)
828 {
829         return (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
830 }
831
832 static inline u64 global_rt_runtime(void)
833 {
834         if (sysctl_sched_rt_runtime < 0)
835                 return RUNTIME_INF;
836
837         return (u64)sysctl_sched_rt_runtime * NSEC_PER_USEC;
838 }
839
840 #ifndef prepare_arch_switch
841 # define prepare_arch_switch(next)      do { } while (0)
842 #endif
843 #ifndef finish_arch_switch
844 # define finish_arch_switch(prev)       do { } while (0)
845 #endif
846
847 static inline int task_current(struct rq *rq, struct task_struct *p)
848 {
849         return rq->curr == p;
850 }
851
852 static inline int task_running(struct rq *rq, struct task_struct *p)
853 {
854 #ifdef CONFIG_SMP
855         return p->on_cpu;
856 #else
857         return task_current(rq, p);
858 #endif
859 }
860
861 #ifndef __ARCH_WANT_UNLOCKED_CTXSW
862 static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
863 {
864 #ifdef CONFIG_SMP
865         /*
866          * We can optimise this out completely for !SMP, because the
867          * SMP rebalancing from interrupt is the only thing that cares
868          * here.
869          */
870         next->on_cpu = 1;
871 #endif
872 }
873
874 static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
875 {
876 #ifdef CONFIG_SMP
877         /*
878          * After ->on_cpu is cleared, the task can be moved to a different CPU.
879          * We must ensure this doesn't happen until the switch is completely
880          * finished.
881          */
882         smp_wmb();
883         prev->on_cpu = 0;
884 #endif
885 #ifdef CONFIG_DEBUG_SPINLOCK
886         /* this is a valid case when another task releases the spinlock */
887         rq->lock.owner = current;
888 #endif
889         /*
890          * If we are tracking spinlock dependencies then we have to
891          * fix up the runqueue lock - which gets 'carried over' from
892          * prev into current:
893          */
894         spin_acquire(&rq->lock.dep_map, 0, 0, _THIS_IP_);
895
896         raw_spin_unlock_irq(&rq->lock);
897 }
898
899 #else /* __ARCH_WANT_UNLOCKED_CTXSW */
900 static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
901 {
902 #ifdef CONFIG_SMP
903         /*
904          * We can optimise this out completely for !SMP, because the
905          * SMP rebalancing from interrupt is the only thing that cares
906          * here.
907          */
908         next->on_cpu = 1;
909 #endif
910 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
911         raw_spin_unlock_irq(&rq->lock);
912 #else
913         raw_spin_unlock(&rq->lock);
914 #endif
915 }
916
917 static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
918 {
919 #ifdef CONFIG_SMP
920         /*
921          * After ->on_cpu is cleared, the task can be moved to a different CPU.
922          * We must ensure this doesn't happen until the switch is completely
923          * finished.
924          */
925         smp_wmb();
926         prev->on_cpu = 0;
927 #endif
928 #ifndef __ARCH_WANT_INTERRUPTS_ON_CTXSW
929         local_irq_enable();
930 #endif
931 }
932 #endif /* __ARCH_WANT_UNLOCKED_CTXSW */
933
934 /*
935  * __task_rq_lock - lock the rq @p resides on.
936  */
937 static inline struct rq *__task_rq_lock(struct task_struct *p)
938         __acquires(rq->lock)
939 {
940         struct rq *rq;
941
942         lockdep_assert_held(&p->pi_lock);
943
944         for (;;) {
945                 rq = task_rq(p);
946                 raw_spin_lock(&rq->lock);
947                 if (likely(rq == task_rq(p)))
948                         return rq;
949                 raw_spin_unlock(&rq->lock);
950         }
951 }
952
953 /*
954  * task_rq_lock - lock p->pi_lock and lock the rq @p resides on.
955  */
956 static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
957         __acquires(p->pi_lock)
958         __acquires(rq->lock)
959 {
960         struct rq *rq;
961
962         for (;;) {
963                 raw_spin_lock_irqsave(&p->pi_lock, *flags);
964                 rq = task_rq(p);
965                 raw_spin_lock(&rq->lock);
966                 if (likely(rq == task_rq(p)))
967                         return rq;
968                 raw_spin_unlock(&rq->lock);
969                 raw_spin_unlock_irqrestore(&p->pi_lock, *flags);
970         }
971 }
972
973 static void __task_rq_unlock(struct rq *rq)
974         __releases(rq->lock)
975 {
976         raw_spin_unlock(&rq->lock);
977 }
978
979 static inline void
980 task_rq_unlock(struct rq *rq, struct task_struct *p, unsigned long *flags)
981         __releases(rq->lock)
982         __releases(p->pi_lock)
983 {
984         raw_spin_unlock(&rq->lock);
985         raw_spin_unlock_irqrestore(&p->pi_lock, *flags);
986 }
987
988 /*
989  * this_rq_lock - lock this runqueue and disable interrupts.
990  */
991 static struct rq *this_rq_lock(void)
992         __acquires(rq->lock)
993 {
994         struct rq *rq;
995
996         local_irq_disable();
997         rq = this_rq();
998         raw_spin_lock(&rq->lock);
999
1000         return rq;
1001 }
1002
1003 #ifdef CONFIG_SCHED_HRTICK
1004 /*
1005  * Use HR-timers to deliver accurate preemption points.
1006  *
1007  * Its all a bit involved since we cannot program an hrt while holding the
1008  * rq->lock. So what we do is store a state in in rq->hrtick_* and ask for a
1009  * reschedule event.
1010  *
1011  * When we get rescheduled we reprogram the hrtick_timer outside of the
1012  * rq->lock.
1013  */
1014
1015 /*
1016  * Use hrtick when:
1017  *  - enabled by features
1018  *  - hrtimer is actually high res
1019  */
1020 static inline int hrtick_enabled(struct rq *rq)
1021 {
1022         if (!sched_feat(HRTICK))
1023                 return 0;
1024         if (!cpu_active(cpu_of(rq)))
1025                 return 0;
1026         return hrtimer_is_hres_active(&rq->hrtick_timer);
1027 }
1028
1029 static void hrtick_clear(struct rq *rq)
1030 {
1031         if (hrtimer_active(&rq->hrtick_timer))
1032                 hrtimer_cancel(&rq->hrtick_timer);
1033 }
1034
1035 /*
1036  * High-resolution timer tick.
1037  * Runs from hardirq context with interrupts disabled.
1038  */
1039 static enum hrtimer_restart hrtick(struct hrtimer *timer)
1040 {
1041         struct rq *rq = container_of(timer, struct rq, hrtick_timer);
1042
1043         WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());
1044
1045         raw_spin_lock(&rq->lock);
1046         update_rq_clock(rq);
1047         rq->curr->sched_class->task_tick(rq, rq->curr, 1);
1048         raw_spin_unlock(&rq->lock);
1049
1050         return HRTIMER_NORESTART;
1051 }
1052
1053 #ifdef CONFIG_SMP
1054 /*
1055  * called from hardirq (IPI) context
1056  */
1057 static void __hrtick_start(void *arg)
1058 {
1059         struct rq *rq = arg;
1060
1061         raw_spin_lock(&rq->lock);
1062         hrtimer_restart(&rq->hrtick_timer);
1063         rq->hrtick_csd_pending = 0;
1064         raw_spin_unlock(&rq->lock);
1065 }
1066
1067 /*
1068  * Called to set the hrtick timer state.
1069  *
1070  * called with rq->lock held and irqs disabled
1071  */
1072 static void hrtick_start(struct rq *rq, u64 delay)
1073 {
1074         struct hrtimer *timer = &rq->hrtick_timer;
1075         ktime_t time = ktime_add_ns(timer->base->get_time(), delay);
1076
1077         hrtimer_set_expires(timer, time);
1078
1079         if (rq == this_rq()) {
1080                 hrtimer_restart(timer);
1081         } else if (!rq->hrtick_csd_pending) {
1082                 __smp_call_function_single(cpu_of(rq), &rq->hrtick_csd, 0);
1083                 rq->hrtick_csd_pending = 1;
1084         }
1085 }
1086
1087 static int
1088 hotplug_hrtick(struct notifier_block *nfb, unsigned long action, void *hcpu)
1089 {
1090         int cpu = (int)(long)hcpu;
1091
1092         switch (action) {
1093         case CPU_UP_CANCELED:
1094         case CPU_UP_CANCELED_FROZEN:
1095         case CPU_DOWN_PREPARE:
1096         case CPU_DOWN_PREPARE_FROZEN:
1097         case CPU_DEAD:
1098         case CPU_DEAD_FROZEN:
1099                 hrtick_clear(cpu_rq(cpu));
1100                 return NOTIFY_OK;
1101         }
1102
1103         return NOTIFY_DONE;
1104 }
1105
1106 static __init void init_hrtick(void)
1107 {
1108         hotcpu_notifier(hotplug_hrtick, 0);
1109 }
1110 #else
1111 /*
1112  * Called to set the hrtick timer state.
1113  *
1114  * called with rq->lock held and irqs disabled
1115  */
1116 static void hrtick_start(struct rq *rq, u64 delay)
1117 {
1118         __hrtimer_start_range_ns(&rq->hrtick_timer, ns_to_ktime(delay), 0,
1119                         HRTIMER_MODE_REL_PINNED, 0);
1120 }
1121
1122 static inline void init_hrtick(void)
1123 {
1124 }
1125 #endif /* CONFIG_SMP */
1126
1127 static void init_rq_hrtick(struct rq *rq)
1128 {
1129 #ifdef CONFIG_SMP
1130         rq->hrtick_csd_pending = 0;
1131
1132         rq->hrtick_csd.flags = 0;
1133         rq->hrtick_csd.func = __hrtick_start;
1134         rq->hrtick_csd.info = rq;
1135 #endif
1136
1137         hrtimer_init(&rq->hrtick_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1138         rq->hrtick_timer.function = hrtick;
1139 }
1140 #else   /* CONFIG_SCHED_HRTICK */
1141 static inline void hrtick_clear(struct rq *rq)
1142 {
1143 }
1144
1145 static inline void init_rq_hrtick(struct rq *rq)
1146 {
1147 }
1148
1149 static inline void init_hrtick(void)
1150 {
1151 }
1152 #endif  /* CONFIG_SCHED_HRTICK */
1153
1154 /*
1155  * resched_task - mark a task 'to be rescheduled now'.
1156  *
1157  * On UP this means the setting of the need_resched flag, on SMP it
1158  * might also involve a cross-CPU call to trigger the scheduler on
1159  * the target CPU.
1160  */
1161 #ifdef CONFIG_SMP
1162
1163 #ifndef tsk_is_polling
1164 #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG)
1165 #endif
1166
1167 static void resched_task(struct task_struct *p)
1168 {
1169         int cpu;
1170
1171         assert_raw_spin_locked(&task_rq(p)->lock);
1172
1173         if (test_tsk_need_resched(p))
1174                 return;
1175
1176         set_tsk_need_resched(p);
1177
1178         cpu = task_cpu(p);
1179         if (cpu == smp_processor_id())
1180                 return;
1181
1182         /* NEED_RESCHED must be visible before we test polling */
1183         smp_mb();
1184         if (!tsk_is_polling(p))
1185                 smp_send_reschedule(cpu);
1186 }
1187
1188 static void resched_cpu(int cpu)
1189 {
1190         struct rq *rq = cpu_rq(cpu);
1191         unsigned long flags;
1192
1193         if (!raw_spin_trylock_irqsave(&rq->lock, flags))
1194                 return;
1195         resched_task(cpu_curr(cpu));
1196         raw_spin_unlock_irqrestore(&rq->lock, flags);
1197 }
1198
1199 #ifdef CONFIG_NO_HZ
1200 /*
1201  * In the semi idle case, use the nearest busy cpu for migrating timers
1202  * from an idle cpu.  This is good for power-savings.
1203  *
1204  * We don't do similar optimization for completely idle system, as
1205  * selecting an idle cpu will add more delays to the timers than intended
1206  * (as that cpu's timer base may not be uptodate wrt jiffies etc).
1207  */
1208 int get_nohz_timer_target(void)
1209 {
1210         int cpu = smp_processor_id();
1211         int i;
1212         struct sched_domain *sd;
1213
1214         rcu_read_lock();
1215         for_each_domain(cpu, sd) {
1216                 for_each_cpu(i, sched_domain_span(sd)) {
1217                         if (!idle_cpu(i)) {
1218                                 cpu = i;
1219                                 goto unlock;
1220                         }
1221                 }
1222         }
1223 unlock:
1224         rcu_read_unlock();
1225         return cpu;
1226 }
1227 /*
1228  * When add_timer_on() enqueues a timer into the timer wheel of an
1229  * idle CPU then this timer might expire before the next timer event
1230  * which is scheduled to wake up that CPU. In case of a completely
1231  * idle system the next event might even be infinite time into the
1232  * future. wake_up_idle_cpu() ensures that the CPU is woken up and
1233  * leaves the inner idle loop so the newly added timer is taken into
1234  * account when the CPU goes back to idle and evaluates the timer
1235  * wheel for the next timer event.
1236  */
1237 void wake_up_idle_cpu(int cpu)
1238 {
1239         struct rq *rq = cpu_rq(cpu);
1240
1241         if (cpu == smp_processor_id())
1242                 return;
1243
1244         /*
1245          * This is safe, as this function is called with the timer
1246          * wheel base lock of (cpu) held. When the CPU is on the way
1247          * to idle and has not yet set rq->curr to idle then it will
1248          * be serialized on the timer wheel base lock and take the new
1249          * timer into account automatically.
1250          */
1251         if (rq->curr != rq->idle)
1252                 return;
1253
1254         /*
1255          * We can set TIF_RESCHED on the idle task of the other CPU
1256          * lockless. The worst case is that the other CPU runs the
1257          * idle task through an additional NOOP schedule()
1258          */
1259         set_tsk_need_resched(rq->idle);
1260
1261         /* NEED_RESCHED must be visible before we test polling */
1262         smp_mb();
1263         if (!tsk_is_polling(rq->idle))
1264                 smp_send_reschedule(cpu);
1265 }
1266
1267 #endif /* CONFIG_NO_HZ */
1268
1269 static u64 sched_avg_period(void)
1270 {
1271         return (u64)sysctl_sched_time_avg * NSEC_PER_MSEC / 2;
1272 }
1273
1274 static void sched_avg_update(struct rq *rq)
1275 {
1276         s64 period = sched_avg_period();
1277
1278         while ((s64)(rq->clock - rq->age_stamp) > period) {
1279                 /*
1280                  * Inline assembly required to prevent the compiler
1281                  * optimising this loop into a divmod call.
1282                  * See __iter_div_u64_rem() for another example of this.
1283                  */
1284                 asm("" : "+rm" (rq->age_stamp));
1285                 rq->age_stamp += period;
1286                 rq->rt_avg /= 2;
1287         }
1288 }
1289
1290 static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
1291 {
1292         rq->rt_avg += rt_delta;
1293         sched_avg_update(rq);
1294 }
1295
1296 #else /* !CONFIG_SMP */
1297 static void resched_task(struct task_struct *p)
1298 {
1299         assert_raw_spin_locked(&task_rq(p)->lock);
1300         set_tsk_need_resched(p);
1301 }
1302
1303 static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
1304 {
1305 }
1306
1307 static void sched_avg_update(struct rq *rq)
1308 {
1309 }
1310 #endif /* CONFIG_SMP */
1311
1312 #if BITS_PER_LONG == 32
1313 # define WMULT_CONST    (~0UL)
1314 #else
1315 # define WMULT_CONST    (1UL << 32)
1316 #endif
1317
1318 #define WMULT_SHIFT     32
1319
1320 /*
1321  * Shift right and round:
1322  */
1323 #define SRR(x, y) (((x) + (1UL << ((y) - 1))) >> (y))
1324
1325 /*
1326  * delta *= weight / lw
1327  */
1328 static unsigned long
1329 calc_delta_mine(unsigned long delta_exec, unsigned long weight,
1330                 struct load_weight *lw)
1331 {
1332         u64 tmp;
1333
1334         /*
1335          * weight can be less than 2^SCHED_LOAD_RESOLUTION for task group sched
1336          * entities since MIN_SHARES = 2. Treat weight as 1 if less than
1337          * 2^SCHED_LOAD_RESOLUTION.
1338          */
1339         if (likely(weight > (1UL << SCHED_LOAD_RESOLUTION)))
1340                 tmp = (u64)delta_exec * scale_load_down(weight);
1341         else
1342                 tmp = (u64)delta_exec;
1343
1344         if (!lw->inv_weight) {
1345                 unsigned long w = scale_load_down(lw->weight);
1346
1347                 if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
1348                         lw->inv_weight = 1;
1349                 else if (unlikely(!w))
1350                         lw->inv_weight = WMULT_CONST;
1351                 else
1352                         lw->inv_weight = WMULT_CONST / w;
1353         }
1354
1355         /*
1356          * Check whether we'd overflow the 64-bit multiplication:
1357          */
1358         if (unlikely(tmp > WMULT_CONST))
1359                 tmp = SRR(SRR(tmp, WMULT_SHIFT/2) * lw->inv_weight,
1360                         WMULT_SHIFT/2);
1361         else
1362                 tmp = SRR(tmp * lw->inv_weight, WMULT_SHIFT);
1363
1364         return (unsigned long)min(tmp, (u64)(unsigned long)LONG_MAX);
1365 }
1366
1367 static inline void update_load_add(struct load_weight *lw, unsigned long inc)
1368 {
1369         lw->weight += inc;
1370         lw->inv_weight = 0;
1371 }
1372
1373 static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
1374 {
1375         lw->weight -= dec;
1376         lw->inv_weight = 0;
1377 }
1378
1379 static inline void update_load_set(struct load_weight *lw, unsigned long w)
1380 {
1381         lw->weight = w;
1382         lw->inv_weight = 0;
1383 }
1384
1385 /*
1386  * To aid in avoiding the subversion of "niceness" due to uneven distribution
1387  * of tasks with abnormal "nice" values across CPUs the contribution that
1388  * each task makes to its run queue's load is weighted according to its
1389  * scheduling class and "nice" value. For SCHED_NORMAL tasks this is just a
1390  * scaled version of the new time slice allocation that they receive on time
1391  * slice expiry etc.
1392  */
1393
1394 #define WEIGHT_IDLEPRIO                3
1395 #define WMULT_IDLEPRIO         1431655765
1396
1397 /*
1398  * Nice levels are multiplicative, with a gentle 10% change for every
1399  * nice level changed. I.e. when a CPU-bound task goes from nice 0 to
1400  * nice 1, it will get ~10% less CPU time than another CPU-bound task
1401  * that remained on nice 0.
1402  *
1403  * The "10% effect" is relative and cumulative: from _any_ nice level,
1404  * if you go up 1 level, it's -10% CPU usage, if you go down 1 level
1405  * it's +10% CPU usage. (to achieve that we use a multiplier of 1.25.
1406  * If a task goes up by ~10% and another task goes down by ~10% then
1407  * the relative distance between them is ~25%.)
1408  */
1409 static const int prio_to_weight[40] = {
1410  /* -20 */     88761,     71755,     56483,     46273,     36291,
1411  /* -15 */     29154,     23254,     18705,     14949,     11916,
1412  /* -10 */      9548,      7620,      6100,      4904,      3906,
1413  /*  -5 */      3121,      2501,      1991,      1586,      1277,
1414  /*   0 */      1024,       820,       655,       526,       423,
1415  /*   5 */       335,       272,       215,       172,       137,
1416  /*  10 */       110,        87,        70,        56,        45,
1417  /*  15 */        36,        29,        23,        18,        15,
1418 };
1419
1420 /*
1421  * Inverse (2^32/x) values of the prio_to_weight[] array, precalculated.
1422  *
1423  * In cases where the weight does not change often, we can use the
1424  * precalculated inverse to speed up arithmetics by turning divisions
1425  * into multiplications:
1426  */
1427 static const u32 prio_to_wmult[40] = {
1428  /* -20 */     48388,     59856,     76040,     92818,    118348,
1429  /* -15 */    147320,    184698,    229616,    287308,    360437,
1430  /* -10 */    449829,    563644,    704093,    875809,   1099582,
1431  /*  -5 */   1376151,   1717300,   2157191,   2708050,   3363326,
1432  /*   0 */   4194304,   5237765,   6557202,   8165337,  10153587,
1433  /*   5 */  12820798,  15790321,  19976592,  24970740,  31350126,
1434  /*  10 */  39045157,  49367440,  61356676,  76695844,  95443717,
1435  /*  15 */ 119304647, 148102320, 186737708, 238609294, 286331153,
1436 };
1437
1438 /* Time spent by the tasks of the cpu accounting group executing in ... */
1439 enum cpuacct_stat_index {
1440         CPUACCT_STAT_USER,      /* ... user mode */
1441         CPUACCT_STAT_SYSTEM,    /* ... kernel mode */
1442
1443         CPUACCT_STAT_NSTATS,
1444 };
1445
1446 #ifdef CONFIG_CGROUP_CPUACCT
1447 static void cpuacct_charge(struct task_struct *tsk, u64 cputime);
1448 static void cpuacct_update_stats(struct task_struct *tsk,
1449                 enum cpuacct_stat_index idx, cputime_t val);
1450 #else
1451 static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}
1452 static inline void cpuacct_update_stats(struct task_struct *tsk,
1453                 enum cpuacct_stat_index idx, cputime_t val) {}
1454 #endif
1455
1456 static inline void inc_cpu_load(struct rq *rq, unsigned long load)
1457 {
1458         update_load_add(&rq->load, load);
1459 }
1460
1461 static inline void dec_cpu_load(struct rq *rq, unsigned long load)
1462 {
1463         update_load_sub(&rq->load, load);
1464 }
1465
1466 #if (defined(CONFIG_SMP) && defined(CONFIG_FAIR_GROUP_SCHED)) || defined(CONFIG_RT_GROUP_SCHED)
1467 typedef int (*tg_visitor)(struct task_group *, void *);
1468
1469 /*
1470  * Iterate the full tree, calling @down when first entering a node and @up when
1471  * leaving it for the final time.
1472  */
1473 static int walk_tg_tree(tg_visitor down, tg_visitor up, void *data)
1474 {
1475         struct task_group *parent, *child;
1476         int ret;
1477
1478         rcu_read_lock();
1479         parent = &root_task_group;
1480 down:
1481         ret = (*down)(parent, data);
1482         if (ret)
1483                 goto out_unlock;
1484         list_for_each_entry_rcu(child, &parent->children, siblings) {
1485                 parent = child;
1486                 goto down;
1487
1488 up:
1489                 continue;
1490         }
1491         ret = (*up)(parent, data);
1492         if (ret)
1493                 goto out_unlock;
1494
1495         child = parent;
1496         parent = parent->parent;
1497         if (parent)
1498                 goto up;
1499 out_unlock:
1500         rcu_read_unlock();
1501
1502         return ret;
1503 }
1504
1505 static int tg_nop(struct task_group *tg, void *data)
1506 {
1507         return 0;
1508 }
1509 #endif
1510
1511 #ifdef CONFIG_SMP
1512 /* Used instead of source_load when we know the type == 0 */
1513 static unsigned long weighted_cpuload(const int cpu)
1514 {
1515         return cpu_rq(cpu)->load.weight;
1516 }
1517
1518 /*
1519  * Return a low guess at the load of a migration-source cpu weighted
1520  * according to the scheduling class and "nice" value.
1521  *
1522  * We want to under-estimate the load of migration sources, to
1523  * balance conservatively.
1524  */
1525 static unsigned long source_load(int cpu, int type)
1526 {
1527         struct rq *rq = cpu_rq(cpu);
1528         unsigned long total = weighted_cpuload(cpu);
1529
1530         if (type == 0 || !sched_feat(LB_BIAS))
1531                 return total;
1532
1533         return min(rq->cpu_load[type-1], total);
1534 }
1535
1536 /*
1537  * Return a high guess at the load of a migration-target cpu weighted
1538  * according to the scheduling class and "nice" value.
1539  */
1540 static unsigned long target_load(int cpu, int type)
1541 {
1542         struct rq *rq = cpu_rq(cpu);
1543         unsigned long total = weighted_cpuload(cpu);
1544
1545         if (type == 0 || !sched_feat(LB_BIAS))
1546                 return total;
1547
1548         return max(rq->cpu_load[type-1], total);
1549 }
1550
1551 static unsigned long power_of(int cpu)
1552 {
1553         return cpu_rq(cpu)->cpu_power;
1554 }
1555
1556 static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd);
1557
1558 static unsigned long cpu_avg_load_per_task(int cpu)
1559 {
1560         struct rq *rq = cpu_rq(cpu);
1561         unsigned long nr_running = ACCESS_ONCE(rq->nr_running);
1562
1563         if (nr_running)
1564                 rq->avg_load_per_task = rq->load.weight / nr_running;
1565         else
1566                 rq->avg_load_per_task = 0;
1567
1568         return rq->avg_load_per_task;
1569 }
1570
1571 #ifdef CONFIG_FAIR_GROUP_SCHED
1572
1573 /*
1574  * Compute the cpu's hierarchical load factor for each task group.
1575  * This needs to be done in a top-down fashion because the load of a child
1576  * group is a fraction of its parents load.
1577  */
1578 static int tg_load_down(struct task_group *tg, void *data)
1579 {
1580         unsigned long load;
1581         long cpu = (long)data;
1582
1583         if (!tg->parent) {
1584                 load = cpu_rq(cpu)->load.weight;
1585         } else {
1586                 load = tg->parent->cfs_rq[cpu]->h_load;
1587                 load *= tg->se[cpu]->load.weight;
1588                 load /= tg->parent->cfs_rq[cpu]->load.weight + 1;
1589         }
1590
1591         tg->cfs_rq[cpu]->h_load = load;
1592
1593         return 0;
1594 }
1595
1596 static void update_h_load(long cpu)
1597 {
1598         walk_tg_tree(tg_load_down, tg_nop, (void *)cpu);
1599 }
1600
1601 #endif
1602
1603 #ifdef CONFIG_PREEMPT
1604
1605 static void double_rq_lock(struct rq *rq1, struct rq *rq2);
1606
1607 /*
1608  * fair double_lock_balance: Safely acquires both rq->locks in a fair
1609  * way at the expense of forcing extra atomic operations in all
1610  * invocations.  This assures that the double_lock is acquired using the
1611  * same underlying policy as the spinlock_t on this architecture, which
1612  * reduces latency compared to the unfair variant below.  However, it
1613  * also adds more overhead and therefore may reduce throughput.
1614  */
1615 static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
1616         __releases(this_rq->lock)
1617         __acquires(busiest->lock)
1618         __acquires(this_rq->lock)
1619 {
1620         raw_spin_unlock(&this_rq->lock);
1621         double_rq_lock(this_rq, busiest);
1622
1623         return 1;
1624 }
1625
1626 #else
1627 /*
1628  * Unfair double_lock_balance: Optimizes throughput at the expense of
1629  * latency by eliminating extra atomic operations when the locks are
1630  * already in proper order on entry.  This favors lower cpu-ids and will
1631  * grant the double lock to lower cpus over higher ids under contention,
1632  * regardless of entry order into the function.
1633  */
1634 static int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
1635         __releases(this_rq->lock)
1636         __acquires(busiest->lock)
1637         __acquires(this_rq->lock)
1638 {
1639         int ret = 0;
1640
1641         if (unlikely(!raw_spin_trylock(&busiest->lock))) {
1642                 if (busiest < this_rq) {
1643                         raw_spin_unlock(&this_rq->lock);
1644                         raw_spin_lock(&busiest->lock);
1645                         raw_spin_lock_nested(&this_rq->lock,
1646                                               SINGLE_DEPTH_NESTING);
1647                         ret = 1;
1648                 } else
1649                         raw_spin_lock_nested(&busiest->lock,
1650                                               SINGLE_DEPTH_NESTING);
1651         }
1652         return ret;
1653 }
1654
1655 #endif /* CONFIG_PREEMPT */
1656
1657 /*
1658  * double_lock_balance - lock the busiest runqueue, this_rq is locked already.
1659  */
1660 static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
1661 {
1662         if (unlikely(!irqs_disabled())) {
1663                 /* printk() doesn't work good under rq->lock */
1664                 raw_spin_unlock(&this_rq->lock);
1665                 BUG_ON(1);
1666         }
1667
1668         return _double_lock_balance(this_rq, busiest);
1669 }
1670
1671 static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
1672         __releases(busiest->lock)
1673 {
1674         raw_spin_unlock(&busiest->lock);
1675         lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
1676 }
1677
1678 /*
1679  * double_rq_lock - safely lock two runqueues
1680  *
1681  * Note this does not disable interrupts like task_rq_lock,
1682  * you need to do so manually before calling.
1683  */
1684 static void double_rq_lock(struct rq *rq1, struct rq *rq2)
1685         __acquires(rq1->lock)
1686         __acquires(rq2->lock)
1687 {
1688         BUG_ON(!irqs_disabled());
1689         if (rq1 == rq2) {
1690                 raw_spin_lock(&rq1->lock);
1691                 __acquire(rq2->lock);   /* Fake it out ;) */
1692         } else {
1693                 if (rq1 < rq2) {
1694                         raw_spin_lock(&rq1->lock);
1695                         raw_spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
1696                 } else {
1697                         raw_spin_lock(&rq2->lock);
1698                         raw_spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
1699                 }
1700         }
1701 }
1702
1703 /*
1704  * double_rq_unlock - safely unlock two runqueues
1705  *
1706  * Note this does not restore interrupts like task_rq_unlock,
1707  * you need to do so manually after calling.
1708  */
1709 static void double_rq_unlock(struct rq *rq1, struct rq *rq2)
1710         __releases(rq1->lock)
1711         __releases(rq2->lock)
1712 {
1713         raw_spin_unlock(&rq1->lock);
1714         if (rq1 != rq2)
1715                 raw_spin_unlock(&rq2->lock);
1716         else
1717                 __release(rq2->lock);
1718 }
1719
1720 #else /* CONFIG_SMP */
1721
1722 /*
1723  * double_rq_lock - safely lock two runqueues
1724  *
1725  * Note this does not disable interrupts like task_rq_lock,
1726  * you need to do so manually before calling.
1727  */
1728 static void double_rq_lock(struct rq *rq1, struct rq *rq2)
1729         __acquires(rq1->lock)
1730         __acquires(rq2->lock)
1731 {
1732         BUG_ON(!irqs_disabled());
1733         BUG_ON(rq1 != rq2);
1734         raw_spin_lock(&rq1->lock);
1735         __acquire(rq2->lock);   /* Fake it out ;) */
1736 }
1737
1738 /*
1739  * double_rq_unlock - safely unlock two runqueues
1740  *
1741  * Note this does not restore interrupts like task_rq_unlock,
1742  * you need to do so manually after calling.
1743  */
1744 static void double_rq_unlock(struct rq *rq1, struct rq *rq2)
1745         __releases(rq1->lock)
1746         __releases(rq2->lock)
1747 {
1748         BUG_ON(rq1 != rq2);
1749         raw_spin_unlock(&rq1->lock);
1750         __release(rq2->lock);
1751 }
1752
1753 #endif
1754
1755 static void calc_load_account_idle(struct rq *this_rq);
1756 static void update_sysctl(void);
1757 static int get_update_sysctl_factor(void);
1758 static void update_cpu_load(struct rq *this_rq);
1759
1760 static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
1761 {
1762         set_task_rq(p, cpu);
1763 #ifdef CONFIG_SMP
1764         /*
1765          * After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
1766          * successfuly executed on another CPU. We must ensure that updates of
1767          * per-task data have been completed by this moment.
1768          */
1769         smp_wmb();
1770         task_thread_info(p)->cpu = cpu;
1771 #endif
1772 }
1773
1774 static const struct sched_class rt_sched_class;
1775
1776 #define sched_class_highest (&stop_sched_class)
1777 #define for_each_class(class) \
1778    for (class = sched_class_highest; class; class = class->next)
1779
1780 #include "sched_stats.h"
1781
1782 static void inc_nr_running(struct rq *rq)
1783 {
1784         rq->nr_running++;
1785 }
1786
1787 static void dec_nr_running(struct rq *rq)
1788 {
1789         rq->nr_running--;
1790 }
1791
1792 static void set_load_weight(struct task_struct *p)
1793 {
1794         int prio = p->static_prio - MAX_RT_PRIO;
1795         struct load_weight *load = &p->se.load;
1796
1797         /*
1798          * SCHED_IDLE tasks get minimal weight:
1799          */
1800         if (p->policy == SCHED_IDLE) {
1801                 load->weight = scale_load(WEIGHT_IDLEPRIO);
1802                 load->inv_weight = WMULT_IDLEPRIO;
1803                 return;
1804         }
1805
1806         load->weight = scale_load(prio_to_weight[prio]);
1807         load->inv_weight = prio_to_wmult[prio];
1808 }
1809
1810 static void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
1811 {
1812         update_rq_clock(rq);
1813         sched_info_queued(p);
1814         p->sched_class->enqueue_task(rq, p, flags);
1815 }
1816
1817 static void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
1818 {
1819         update_rq_clock(rq);
1820         sched_info_dequeued(p);
1821         p->sched_class->dequeue_task(rq, p, flags);
1822 }
1823
1824 /*
1825  * activate_task - move a task to the runqueue.
1826  */
1827 static void activate_task(struct rq *rq, struct task_struct *p, int flags)
1828 {
1829         if (task_contributes_to_load(p))
1830                 rq->nr_uninterruptible--;
1831
1832         enqueue_task(rq, p, flags);
1833         inc_nr_running(rq);
1834 }
1835
1836 /*
1837  * deactivate_task - remove a task from the runqueue.
1838  */
1839 static void deactivate_task(struct rq *rq, struct task_struct *p, int flags)
1840 {
1841         if (task_contributes_to_load(p))
1842                 rq->nr_uninterruptible++;
1843
1844         dequeue_task(rq, p, flags);
1845         dec_nr_running(rq);
1846 }
1847
1848 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
1849
1850 /*
1851  * There are no locks covering percpu hardirq/softirq time.
1852  * They are only modified in account_system_vtime, on corresponding CPU
1853  * with interrupts disabled. So, writes are safe.
1854  * They are read and saved off onto struct rq in update_rq_clock().
1855  * This may result in other CPU reading this CPU's irq time and can
1856  * race with irq/account_system_vtime on this CPU. We would either get old
1857  * or new value with a side effect of accounting a slice of irq time to wrong
1858  * task when irq is in progress while we read rq->clock. That is a worthy
1859  * compromise in place of having locks on each irq in account_system_time.
1860  */
1861 static DEFINE_PER_CPU(u64, cpu_hardirq_time);
1862 static DEFINE_PER_CPU(u64, cpu_softirq_time);
1863
1864 static DEFINE_PER_CPU(u64, irq_start_time);
1865 static int sched_clock_irqtime;
1866
1867 void enable_sched_clock_irqtime(void)
1868 {
1869         sched_clock_irqtime = 1;
1870 }
1871
1872 void disable_sched_clock_irqtime(void)
1873 {
1874         sched_clock_irqtime = 0;
1875 }
1876
1877 #ifndef CONFIG_64BIT
1878 static DEFINE_PER_CPU(seqcount_t, irq_time_seq);
1879
1880 static inline void irq_time_write_begin(void)
1881 {
1882         __this_cpu_inc(irq_time_seq.sequence);
1883         smp_wmb();
1884 }
1885
1886 static inline void irq_time_write_end(void)
1887 {
1888         smp_wmb();
1889         __this_cpu_inc(irq_time_seq.sequence);
1890 }
1891
1892 static inline u64 irq_time_read(int cpu)
1893 {
1894         u64 irq_time;
1895         unsigned seq;
1896
1897         do {
1898                 seq = read_seqcount_begin(&per_cpu(irq_time_seq, cpu));
1899                 irq_time = per_cpu(cpu_softirq_time, cpu) +
1900                            per_cpu(cpu_hardirq_time, cpu);
1901         } while (read_seqcount_retry(&per_cpu(irq_time_seq, cpu), seq));
1902
1903         return irq_time;
1904 }
1905 #else /* CONFIG_64BIT */
1906 static inline void irq_time_write_begin(void)
1907 {
1908 }
1909
1910 static inline void irq_time_write_end(void)
1911 {
1912 }
1913
1914 static inline u64 irq_time_read(int cpu)
1915 {
1916         return per_cpu(cpu_softirq_time, cpu) + per_cpu(cpu_hardirq_time, cpu);
1917 }
1918 #endif /* CONFIG_64BIT */
1919
1920 /*
1921  * Called before incrementing preempt_count on {soft,}irq_enter
1922  * and before decrementing preempt_count on {soft,}irq_exit.
1923  */
1924 void account_system_vtime(struct task_struct *curr)
1925 {
1926         unsigned long flags;
1927         s64 delta;
1928         int cpu;
1929
1930         if (!sched_clock_irqtime)
1931                 return;
1932
1933         local_irq_save(flags);
1934
1935         cpu = smp_processor_id();
1936         delta = sched_clock_cpu(cpu) - __this_cpu_read(irq_start_time);
1937         __this_cpu_add(irq_start_time, delta);
1938
1939         irq_time_write_begin();
1940         /*
1941          * We do not account for softirq time from ksoftirqd here.
1942          * We want to continue accounting softirq time to ksoftirqd thread
1943          * in that case, so as not to confuse scheduler with a special task
1944          * that do not consume any time, but still wants to run.
1945          */
1946         if (hardirq_count())
1947                 __this_cpu_add(cpu_hardirq_time, delta);
1948         else if (in_serving_softirq() && curr != this_cpu_ksoftirqd())
1949                 __this_cpu_add(cpu_softirq_time, delta);
1950
1951         irq_time_write_end();
1952         local_irq_restore(flags);
1953 }
1954 EXPORT_SYMBOL_GPL(account_system_vtime);
1955
1956 static void update_rq_clock_task(struct rq *rq, s64 delta)
1957 {
1958         s64 irq_delta;
1959
1960         irq_delta = irq_time_read(cpu_of(rq)) - rq->prev_irq_time;
1961
1962         /*
1963          * Since irq_time is only updated on {soft,}irq_exit, we might run into
1964          * this case when a previous update_rq_clock() happened inside a
1965          * {soft,}irq region.
1966          *
1967          * When this happens, we stop ->clock_task and only update the
1968          * prev_irq_time stamp to account for the part that fit, so that a next
1969          * update will consume the rest. This ensures ->clock_task is
1970          * monotonic.
1971          *
1972          * It does however cause some slight miss-attribution of {soft,}irq
1973          * time, a more accurate solution would be to update the irq_time using
1974          * the current rq->clock timestamp, except that would require using
1975          * atomic ops.
1976          */
1977         if (irq_delta > delta)
1978                 irq_delta = delta;
1979
1980         rq->prev_irq_time += irq_delta;
1981         delta -= irq_delta;
1982         rq->clock_task += delta;
1983
1984         if (irq_delta && sched_feat(NONIRQ_POWER))
1985                 sched_rt_avg_update(rq, irq_delta);
1986 }
1987
1988 static int irqtime_account_hi_update(void)
1989 {
1990         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
1991         unsigned long flags;
1992         u64 latest_ns;
1993         int ret = 0;
1994
1995         local_irq_save(flags);
1996         latest_ns = this_cpu_read(cpu_hardirq_time);
1997         if (cputime64_gt(nsecs_to_cputime64(latest_ns), cpustat->irq))
1998                 ret = 1;
1999         local_irq_restore(flags);
2000         return ret;
2001 }
2002
2003 static int irqtime_account_si_update(void)
2004 {
2005         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
2006         unsigned long flags;
2007         u64 latest_ns;
2008         int ret = 0;
2009
2010         local_irq_save(flags);
2011         latest_ns = this_cpu_read(cpu_softirq_time);
2012         if (cputime64_gt(nsecs_to_cputime64(latest_ns), cpustat->softirq))
2013                 ret = 1;
2014         local_irq_restore(flags);
2015         return ret;
2016 }
2017
2018 #else /* CONFIG_IRQ_TIME_ACCOUNTING */
2019
2020 #define sched_clock_irqtime     (0)
2021
2022 static void update_rq_clock_task(struct rq *rq, s64 delta)
2023 {
2024         rq->clock_task += delta;
2025 }
2026
2027 #endif /* CONFIG_IRQ_TIME_ACCOUNTING */
2028
2029 #include "sched_idletask.c"
2030 #include "sched_fair.c"
2031 #include "sched_rt.c"
2032 #include "sched_autogroup.c"
2033 #include "sched_stoptask.c"
2034 #ifdef CONFIG_SCHED_DEBUG
2035 # include "sched_debug.c"
2036 #endif
2037
2038 void sched_set_stop_task(int cpu, struct task_struct *stop)
2039 {
2040         struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
2041         struct task_struct *old_stop = cpu_rq(cpu)->stop;
2042
2043         if (stop) {
2044                 /*
2045                  * Make it appear like a SCHED_FIFO task, its something
2046                  * userspace knows about and won't get confused about.
2047                  *
2048                  * Also, it will make PI more or less work without too
2049                  * much confusion -- but then, stop work should not
2050                  * rely on PI working anyway.
2051                  */
2052                 sched_setscheduler_nocheck(stop, SCHED_FIFO, &param);
2053
2054                 stop->sched_class = &stop_sched_class;
2055         }
2056
2057         cpu_rq(cpu)->stop = stop;
2058
2059         if (old_stop) {
2060                 /*
2061                  * Reset it back to a normal scheduling class so that
2062                  * it can die in pieces.
2063                  */
2064                 old_stop->sched_class = &rt_sched_class;
2065         }
2066 }
2067
2068 /*
2069  * __normal_prio - return the priority that is based on the static prio
2070  */
2071 static inline int __normal_prio(struct task_struct *p)
2072 {
2073         return p->static_prio;
2074 }
2075
2076 /*
2077  * Calculate the expected normal priority: i.e. priority
2078  * without taking RT-inheritance into account. Might be
2079  * boosted by interactivity modifiers. Changes upon fork,
2080  * setprio syscalls, and whenever the interactivity
2081  * estimator recalculates.
2082  */
2083 static inline int normal_prio(struct task_struct *p)
2084 {
2085         int prio;
2086
2087         if (task_has_rt_policy(p))
2088                 prio = MAX_RT_PRIO-1 - p->rt_priority;
2089         else
2090                 prio = __normal_prio(p);
2091         return prio;
2092 }
2093
2094 /*
2095  * Calculate the current priority, i.e. the priority
2096  * taken into account by the scheduler. This value might
2097  * be boosted by RT tasks, or might be boosted by
2098  * interactivity modifiers. Will be RT if the task got
2099  * RT-boosted. If not then it returns p->normal_prio.
2100  */
2101 static int effective_prio(struct task_struct *p)
2102 {
2103         p->normal_prio = normal_prio(p);
2104         /*
2105          * If we are RT tasks or we were boosted to RT priority,
2106          * keep the priority unchanged. Otherwise, update priority
2107          * to the normal priority:
2108          */
2109         if (!rt_prio(p->prio))
2110                 return p->normal_prio;
2111         return p->prio;
2112 }
2113
2114 /**
2115  * task_curr - is this task currently executing on a CPU?
2116  * @p: the task in question.
2117  */
2118 inline int task_curr(const struct task_struct *p)
2119 {
2120         return cpu_curr(task_cpu(p)) == p;
2121 }
2122
2123 static inline void check_class_changed(struct rq *rq, struct task_struct *p,
2124                                        const struct sched_class *prev_class,
2125                                        int oldprio)
2126 {
2127         if (prev_class != p->sched_class) {
2128                 if (prev_class->switched_from)
2129                         prev_class->switched_from(rq, p);
2130                 p->sched_class->switched_to(rq, p);
2131         } else if (oldprio != p->prio)
2132                 p->sched_class->prio_changed(rq, p, oldprio);
2133 }
2134
2135 static void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags)
2136 {
2137         const struct sched_class *class;
2138
2139         if (p->sched_class == rq->curr->sched_class) {
2140                 rq->curr->sched_class->check_preempt_curr(rq, p, flags);
2141         } else {
2142                 for_each_class(class) {
2143                         if (class == rq->curr->sched_class)
2144                                 break;
2145                         if (class == p->sched_class) {
2146                                 resched_task(rq->curr);
2147                                 break;
2148                         }
2149                 }
2150         }
2151
2152         /*
2153          * A queue event has occurred, and we're going to schedule.  In
2154          * this case, we can save a useless back to back clock update.
2155          */
2156         if (rq->curr->on_rq && test_tsk_need_resched(rq->curr))
2157                 rq->skip_clock_update = 1;
2158 }
2159
2160 #ifdef CONFIG_SMP
2161 /*
2162  * Is this task likely cache-hot:
2163  */
2164 static int
2165 task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
2166 {
2167         s64 delta;
2168
2169         if (p->sched_class != &fair_sched_class)
2170                 return 0;
2171
2172         if (unlikely(p->policy == SCHED_IDLE))
2173                 return 0;
2174
2175         /*
2176          * Buddy candidates are cache hot:
2177          */
2178         if (sched_feat(CACHE_HOT_BUDDY) && this_rq()->nr_running &&
2179                         (&p->se == cfs_rq_of(&p->se)->next ||
2180                          &p->se == cfs_rq_of(&p->se)->last))
2181                 return 1;
2182
2183         if (sysctl_sched_migration_cost == -1)
2184                 return 1;
2185         if (sysctl_sched_migration_cost == 0)
2186                 return 0;
2187
2188         delta = now - p->se.exec_start;
2189
2190         return delta < (s64)sysctl_sched_migration_cost;
2191 }
2192
2193 void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
2194 {
2195 #ifdef CONFIG_SCHED_DEBUG
2196         /*
2197          * We should never call set_task_cpu() on a blocked task,
2198          * ttwu() will sort out the placement.
2199          */
2200         WARN_ON_ONCE(p->state != TASK_RUNNING && p->state != TASK_WAKING &&
2201                         !(task_thread_info(p)->preempt_count & PREEMPT_ACTIVE));
2202
2203 #ifdef CONFIG_LOCKDEP
2204         /*
2205          * The caller should hold either p->pi_lock or rq->lock, when changing
2206          * a task's CPU. ->pi_lock for waking tasks, rq->lock for runnable tasks.
2207          *
2208          * sched_move_task() holds both and thus holding either pins the cgroup,
2209          * see set_task_rq().
2210          *
2211          * Furthermore, all task_rq users should acquire both locks, see
2212          * task_rq_lock().
2213          */
2214         WARN_ON_ONCE(debug_locks && !(lockdep_is_held(&p->pi_lock) ||
2215                                       lockdep_is_held(&task_rq(p)->lock)));
2216 #endif
2217 #endif
2218
2219         trace_sched_migrate_task(p, new_cpu);
2220
2221         if (task_cpu(p) != new_cpu) {
2222                 p->se.nr_migrations++;
2223                 perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, 1, NULL, 0);
2224         }
2225
2226         __set_task_cpu(p, new_cpu);
2227 }
2228
2229 struct migration_arg {
2230         struct task_struct *task;
2231         int dest_cpu;
2232 };
2233
2234 static int migration_cpu_stop(void *data);
2235
2236 /*
2237  * wait_task_inactive - wait for a thread to unschedule.
2238  *
2239  * If @match_state is nonzero, it's the @p->state value just checked and
2240  * not expected to change.  If it changes, i.e. @p might have woken up,
2241  * then return zero.  When we succeed in waiting for @p to be off its CPU,
2242  * we return a positive number (its total switch count).  If a second call
2243  * a short while later returns the same number, the caller can be sure that
2244  * @p has remained unscheduled the whole time.
2245  *
2246  * The caller must ensure that the task *will* unschedule sometime soon,
2247  * else this function might spin for a *long* time. This function can't
2248  * be called with interrupts off, or it may introduce deadlock with
2249  * smp_call_function() if an IPI is sent by the same process we are
2250  * waiting to become inactive.
2251  */
2252 unsigned long wait_task_inactive(struct task_struct *p, long match_state)
2253 {
2254         unsigned long flags;
2255         int running, on_rq;
2256         unsigned long ncsw;
2257         struct rq *rq;
2258
2259         for (;;) {
2260                 /*
2261                  * We do the initial early heuristics without holding
2262                  * any task-queue locks at all. We'll only try to get
2263                  * the runqueue lock when things look like they will
2264                  * work out!
2265                  */
2266                 rq = task_rq(p);
2267
2268                 /*
2269                  * If the task is actively running on another CPU
2270                  * still, just relax and busy-wait without holding
2271                  * any locks.
2272                  *
2273                  * NOTE! Since we don't hold any locks, it's not
2274                  * even sure that "rq" stays as the right runqueue!
2275                  * But we don't care, since "task_running()" will
2276                  * return false if the runqueue has changed and p
2277                  * is actually now running somewhere else!
2278                  */
2279                 while (task_running(rq, p)) {
2280                         if (match_state && unlikely(p->state != match_state))
2281                                 return 0;
2282                         cpu_relax();
2283                 }
2284
2285                 /*
2286                  * Ok, time to look more closely! We need the rq
2287                  * lock now, to be *sure*. If we're wrong, we'll
2288                  * just go back and repeat.
2289                  */
2290                 rq = task_rq_lock(p, &flags);
2291                 trace_sched_wait_task(p);
2292                 running = task_running(rq, p);
2293                 on_rq = p->on_rq;
2294                 ncsw = 0;
2295                 if (!match_state || p->state == match_state)
2296                         ncsw = p->nvcsw | LONG_MIN; /* sets MSB */
2297                 task_rq_unlock(rq, p, &flags);
2298
2299                 /*
2300                  * If it changed from the expected state, bail out now.
2301                  */
2302                 if (unlikely(!ncsw))
2303                         break;
2304
2305                 /*
2306                  * Was it really running after all now that we
2307                  * checked with the proper locks actually held?
2308                  *
2309                  * Oops. Go back and try again..
2310                  */
2311                 if (unlikely(running)) {
2312                         cpu_relax();
2313                         continue;
2314                 }
2315
2316                 /*
2317                  * It's not enough that it's not actively running,
2318                  * it must be off the runqueue _entirely_, and not
2319                  * preempted!
2320                  *
2321                  * So if it was still runnable (but just not actively
2322                  * running right now), it's preempted, and we should
2323                  * yield - it could be a while.
2324                  */
2325                 if (unlikely(on_rq)) {
2326                         ktime_t to = ktime_set(0, NSEC_PER_SEC/HZ);
2327
2328                         set_current_state(TASK_UNINTERRUPTIBLE);
2329                         schedule_hrtimeout(&to, HRTIMER_MODE_REL);
2330                         continue;
2331                 }
2332
2333                 /*
2334                  * Ahh, all good. It wasn't running, and it wasn't
2335                  * runnable, which means that it will never become
2336                  * running in the future either. We're all done!
2337                  */
2338                 break;
2339         }
2340
2341         return ncsw;
2342 }
2343
2344 /***
2345  * kick_process - kick a running thread to enter/exit the kernel
2346  * @p: the to-be-kicked thread
2347  *
2348  * Cause a process which is running on another CPU to enter
2349  * kernel-mode, without any delay. (to get signals handled.)
2350  *
2351  * NOTE: this function doesn't have to take the runqueue lock,
2352  * because all it wants to ensure is that the remote task enters
2353  * the kernel. If the IPI races and the task has been migrated
2354  * to another CPU then no harm is done and the purpose has been
2355  * achieved as well.
2356  */
2357 void kick_process(struct task_struct *p)
2358 {
2359         int cpu;
2360
2361         preempt_disable();
2362         cpu = task_cpu(p);
2363         if ((cpu != smp_processor_id()) && task_curr(p))
2364                 smp_send_reschedule(cpu);
2365         preempt_enable();
2366 }
2367 EXPORT_SYMBOL_GPL(kick_process);
2368 #endif /* CONFIG_SMP */
2369
2370 #ifdef CONFIG_SMP
2371 /*
2372  * ->cpus_allowed is protected by both rq->lock and p->pi_lock
2373  */
2374 static int select_fallback_rq(int cpu, struct task_struct *p)
2375 {
2376         int dest_cpu;
2377         const struct cpumask *nodemask = cpumask_of_node(cpu_to_node(cpu));
2378
2379         /* Look for allowed, online CPU in same node. */
2380         for_each_cpu_and(dest_cpu, nodemask, cpu_active_mask)
2381                 if (cpumask_test_cpu(dest_cpu, &p->cpus_allowed))
2382                         return dest_cpu;
2383
2384         /* Any allowed, online CPU? */
2385         dest_cpu = cpumask_any_and(&p->cpus_allowed, cpu_active_mask);
2386         if (dest_cpu < nr_cpu_ids)
2387                 return dest_cpu;
2388
2389         /* No more Mr. Nice Guy. */
2390         dest_cpu = cpuset_cpus_allowed_fallback(p);
2391         /*
2392          * Don't tell them about moving exiting tasks or
2393          * kernel threads (both mm NULL), since they never
2394          * leave kernel.
2395          */
2396         if (p->mm && printk_ratelimit()) {
2397                 printk(KERN_INFO "process %d (%s) no longer affine to cpu%d\n",
2398                                 task_pid_nr(p), p->comm, cpu);
2399         }
2400
2401         return dest_cpu;
2402 }
2403
2404 /*
2405  * The caller (fork, wakeup) owns p->pi_lock, ->cpus_allowed is stable.
2406  */
2407 static inline
2408 int select_task_rq(struct task_struct *p, int sd_flags, int wake_flags)
2409 {
2410         int cpu = p->sched_class->select_task_rq(p, sd_flags, wake_flags);
2411
2412         /*
2413          * In order not to call set_task_cpu() on a blocking task we need
2414          * to rely on ttwu() to place the task on a valid ->cpus_allowed
2415          * cpu.
2416          *
2417          * Since this is common to all placement strategies, this lives here.
2418          *
2419          * [ this allows ->select_task() to simply return task_cpu(p) and
2420          *   not worry about this generic constraint ]
2421          */
2422         if (unlikely(!cpumask_test_cpu(cpu, &p->cpus_allowed) ||
2423                      !cpu_online(cpu)))
2424                 cpu = select_fallback_rq(task_cpu(p), p);
2425
2426         return cpu;
2427 }
2428
2429 static void update_avg(u64 *avg, u64 sample)
2430 {
2431         s64 diff = sample - *avg;
2432         *avg += diff >> 3;
2433 }
2434 #endif
2435
2436 static void
2437 ttwu_stat(struct task_struct *p, int cpu, int wake_flags)
2438 {
2439 #ifdef CONFIG_SCHEDSTATS
2440         struct rq *rq = this_rq();
2441
2442 #ifdef CONFIG_SMP
2443         int this_cpu = smp_processor_id();
2444
2445         if (cpu == this_cpu) {
2446                 schedstat_inc(rq, ttwu_local);
2447                 schedstat_inc(p, se.statistics.nr_wakeups_local);
2448         } else {
2449                 struct sched_domain *sd;
2450
2451                 schedstat_inc(p, se.statistics.nr_wakeups_remote);
2452                 rcu_read_lock();
2453                 for_each_domain(this_cpu, sd) {
2454                         if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
2455                                 schedstat_inc(sd, ttwu_wake_remote);
2456                                 break;
2457                         }
2458                 }
2459                 rcu_read_unlock();
2460         }
2461
2462         if (wake_flags & WF_MIGRATED)
2463                 schedstat_inc(p, se.statistics.nr_wakeups_migrate);
2464
2465 #endif /* CONFIG_SMP */
2466
2467         schedstat_inc(rq, ttwu_count);
2468         schedstat_inc(p, se.statistics.nr_wakeups);
2469
2470         if (wake_flags & WF_SYNC)
2471                 schedstat_inc(p, se.statistics.nr_wakeups_sync);
2472
2473 #endif /* CONFIG_SCHEDSTATS */
2474 }
2475
2476 static void ttwu_activate(struct rq *rq, struct task_struct *p, int en_flags)
2477 {
2478         activate_task(rq, p, en_flags);
2479         p->on_rq = 1;
2480
2481         /* if a worker is waking up, notify workqueue */
2482         if (p->flags & PF_WQ_WORKER)
2483                 wq_worker_waking_up(p, cpu_of(rq));
2484 }
2485
2486 /*
2487  * Mark the task runnable and perform wakeup-preemption.
2488  */
2489 static void
2490 ttwu_do_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
2491 {
2492         trace_sched_wakeup(p, true);
2493         check_preempt_curr(rq, p, wake_flags);
2494
2495         p->state = TASK_RUNNING;
2496 #ifdef CONFIG_SMP
2497         if (p->sched_class->task_woken)
2498                 p->sched_class->task_woken(rq, p);
2499
2500         if (unlikely(rq->idle_stamp)) {
2501                 u64 delta = rq->clock - rq->idle_stamp;
2502                 u64 max = 2*sysctl_sched_migration_cost;
2503
2504                 if (delta > max)
2505                         rq->avg_idle = max;
2506                 else
2507                         update_avg(&rq->avg_idle, delta);
2508                 rq->idle_stamp = 0;
2509         }
2510 #endif
2511 }
2512
2513 static void
2514 ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags)
2515 {
2516 #ifdef CONFIG_SMP
2517         if (p->sched_contributes_to_load)
2518                 rq->nr_uninterruptible--;
2519 #endif
2520
2521         ttwu_activate(rq, p, ENQUEUE_WAKEUP | ENQUEUE_WAKING);
2522         ttwu_do_wakeup(rq, p, wake_flags);
2523 }
2524
2525 /*
2526  * Called in case the task @p isn't fully descheduled from its runqueue,
2527  * in this case we must do a remote wakeup. Its a 'light' wakeup though,
2528  * since all we need to do is flip p->state to TASK_RUNNING, since
2529  * the task is still ->on_rq.
2530  */
2531 static int ttwu_remote(struct task_struct *p, int wake_flags)
2532 {
2533         struct rq *rq;
2534         int ret = 0;
2535
2536         rq = __task_rq_lock(p);
2537         if (p->on_rq) {
2538                 ttwu_do_wakeup(rq, p, wake_flags);
2539                 ret = 1;
2540         }
2541         __task_rq_unlock(rq);
2542
2543         return ret;
2544 }
2545
2546 #ifdef CONFIG_SMP
2547 static void sched_ttwu_do_pending(struct task_struct *list)
2548 {
2549         struct rq *rq = this_rq();
2550
2551         raw_spin_lock(&rq->lock);
2552
2553         while (list) {
2554                 struct task_struct *p = list;
2555                 list = list->wake_entry;
2556                 ttwu_do_activate(rq, p, 0);
2557         }
2558
2559         raw_spin_unlock(&rq->lock);
2560 }
2561
2562 #ifdef CONFIG_HOTPLUG_CPU
2563
2564 static void sched_ttwu_pending(void)
2565 {
2566         struct rq *rq = this_rq();
2567         struct task_struct *list = xchg(&rq->wake_list, NULL);
2568
2569         if (!list)
2570                 return;
2571
2572         sched_ttwu_do_pending(list);
2573 }
2574
2575 #endif /* CONFIG_HOTPLUG_CPU */
2576
2577 void scheduler_ipi(void)
2578 {
2579         struct rq *rq = this_rq();
2580         struct task_struct *list = xchg(&rq->wake_list, NULL);
2581
2582         if (!list)
2583                 return;
2584
2585         /*
2586          * Not all reschedule IPI handlers call irq_enter/irq_exit, since
2587          * traditionally all their work was done from the interrupt return
2588          * path. Now that we actually do some work, we need to make sure
2589          * we do call them.
2590          *
2591          * Some archs already do call them, luckily irq_enter/exit nest
2592          * properly.
2593          *
2594          * Arguably we should visit all archs and update all handlers,
2595          * however a fair share of IPIs are still resched only so this would
2596          * somewhat pessimize the simple resched case.
2597          */
2598         irq_enter();
2599         sched_ttwu_do_pending(list);
2600         irq_exit();
2601 }
2602
2603 static void ttwu_queue_remote(struct task_struct *p, int cpu)
2604 {
2605         struct rq *rq = cpu_rq(cpu);
2606         struct task_struct *next = rq->wake_list;
2607
2608         for (;;) {
2609                 struct task_struct *old = next;
2610
2611                 p->wake_entry = next;
2612                 next = cmpxchg(&rq->wake_list, old, p);
2613                 if (next == old)
2614                         break;
2615         }
2616
2617         if (!next)
2618                 smp_send_reschedule(cpu);
2619 }