1#include "sched.h"
  2
  3/*
  4 * idle-task scheduling class.
  5 *
  6 * (NOTE: these are not related to SCHED_IDLE tasks which are
  7 *  handled in sched/fair.c)
  8 */
  9
 10#ifdef CONFIG_SMP
 11static int
 12select_task_rq_idle(struct task_struct *p, int cpu, int sd_flag, int flags)
 13{
 14	return task_cpu(p); /* IDLE tasks as never migrated */
 15}
 16#endif /* CONFIG_SMP */
 17
 18/*
 19 * Idle tasks are unconditionally rescheduled:
 20 */
 21static void check_preempt_curr_idle(struct rq *rq, struct task_struct *p, int flags)
 22{
 23	resched_curr(rq);
 24}
 25
 26static struct task_struct *
 27pick_next_task_idle(struct rq *rq, struct task_struct *prev)
 28{
 29	put_prev_task(rq, prev);
 30
 31	schedstat_inc(rq, sched_goidle);
 32	return rq->idle;
 33}
 34
 35/*
 36 * It is not legal to sleep in the idle task - print a warning
 37 * message if some code attempts to do it:
 38 */
 39static void
 40dequeue_task_idle(struct rq *rq, struct task_struct *p, int flags)
 41{
 42	raw_spin_unlock_irq(&rq->lock);
 43	printk(KERN_ERR "bad: scheduling from the idle thread!\n");
 44	dump_stack();
 45	raw_spin_lock_irq(&rq->lock);
 46}
 47
 48static void put_prev_task_idle(struct rq *rq, struct task_struct *prev)
 49{
 50	rq_last_tick_reset(rq);
 51}
 52
 53static void task_tick_idle(struct rq *rq, struct task_struct *curr, int queued)
 54{
 55}
 56
 57static void set_curr_task_idle(struct rq *rq)
 58{
 59}
 60
 61static void switched_to_idle(struct rq *rq, struct task_struct *p)
 62{
 63	BUG();
 64}
 65
 66static void
 67prio_changed_idle(struct rq *rq, struct task_struct *p, int oldprio)
 68{
 69	BUG();
 70}
 71
 72static unsigned int get_rr_interval_idle(struct rq *rq, struct task_struct *task)
 73{
 74	return 0;
 75}
 76
 77static void update_curr_idle(struct rq *rq)
 78{
 79}
 80
 81/*
 82 * Simple, special scheduling class for the per-CPU idle tasks:
 83 */
 84const struct sched_class idle_sched_class = {
 85	/* .next is NULL */
 86	/* no enqueue/yield_task for idle tasks */
 87
 88	/* dequeue is not valid, we print a debug message there: */
 89	.dequeue_task		= dequeue_task_idle,
 90
 91	.check_preempt_curr	= check_preempt_curr_idle,
 92
 93	.pick_next_task		= pick_next_task_idle,
 94	.put_prev_task		= put_prev_task_idle,
 95
 96#ifdef CONFIG_SMP
 97	.select_task_rq		= select_task_rq_idle,
 98	.set_cpus_allowed	= set_cpus_allowed_common,
 99#endif
100
101	.set_curr_task          = set_curr_task_idle,
102	.task_tick		= task_tick_idle,
103
104	.get_rr_interval	= get_rr_interval_idle,
105
106	.prio_changed		= prio_changed_idle,
107	.switched_to		= switched_to_idle,
108	.update_curr		= update_curr_idle,
109};

 1#include "sched.h"
 2
 3/*
 4 * idle-task scheduling class.
 5 *
 6 * (NOTE: these are not related to SCHED_IDLE tasks which are
 7 *  handled in sched/fair.c)
 8 */
 9
10#ifdef CONFIG_SMP
11static int
12select_task_rq_idle(struct task_struct *p, int sd_flag, int flags)
13{
14	return task_cpu(p); /* IDLE tasks as never migrated */
15}
16#endif /* CONFIG_SMP */
 
17/*
18 * Idle tasks are unconditionally rescheduled:
19 */
20static void check_preempt_curr_idle(struct rq *rq, struct task_struct *p, int flags)
21{
22	resched_task(rq->idle);
23}
24
25static struct task_struct *pick_next_task_idle(struct rq *rq)
 
26{
 
 
27	schedstat_inc(rq, sched_goidle);
28	return rq->idle;
29}
30
31/*
32 * It is not legal to sleep in the idle task - print a warning
33 * message if some code attempts to do it:
34 */
35static void
36dequeue_task_idle(struct rq *rq, struct task_struct *p, int flags)
37{
38	raw_spin_unlock_irq(&rq->lock);
39	printk(KERN_ERR "bad: scheduling from the idle thread!\n");
40	dump_stack();
41	raw_spin_lock_irq(&rq->lock);
42}
43
44static void put_prev_task_idle(struct rq *rq, struct task_struct *prev)
45{
 
46}
47
48static void task_tick_idle(struct rq *rq, struct task_struct *curr, int queued)
49{
50}
51
52static void set_curr_task_idle(struct rq *rq)
53{
54}
55
56static void switched_to_idle(struct rq *rq, struct task_struct *p)
57{
58	BUG();
59}
60
61static void
62prio_changed_idle(struct rq *rq, struct task_struct *p, int oldprio)
63{
64	BUG();
65}
66
67static unsigned int get_rr_interval_idle(struct rq *rq, struct task_struct *task)
68{
69	return 0;
70}
71
 
 
 
 
72/*
73 * Simple, special scheduling class for the per-CPU idle tasks:
74 */
75const struct sched_class idle_sched_class = {
76	/* .next is NULL */
77	/* no enqueue/yield_task for idle tasks */
78
79	/* dequeue is not valid, we print a debug message there: */
80	.dequeue_task		= dequeue_task_idle,
81
82	.check_preempt_curr	= check_preempt_curr_idle,
83
84	.pick_next_task		= pick_next_task_idle,
85	.put_prev_task		= put_prev_task_idle,
86
87#ifdef CONFIG_SMP
88	.select_task_rq		= select_task_rq_idle,
 
89#endif
90
91	.set_curr_task          = set_curr_task_idle,
92	.task_tick		= task_tick_idle,
93
94	.get_rr_interval	= get_rr_interval_idle,
95
96	.prio_changed		= prio_changed_idle,
97	.switched_to		= switched_to_idle,
 
98};