/*
 * Scheduling policies
 */
#define SCHED_NORMAL            0
#define SCHED_FIFO              1
#define SCHED_RR                2
#define SCHED_BATCH             3
/* SCHED_ISO: reserved but not implemented yet */
#define SCHED_IDLE              5
#define SCHED_DEADLINE          6

1 #ifdef CONFIG_SMP
2 #define sched_class_highest (&stop_sched_class)
3 #else
4 #define sched_class_highest (&dl_sched_class)
5 #endif
6 #define for_each_class(class) \
7   for (class = sched_class_highest; class; class = class->next)

const struct sched_class stop_sched_class = {
        .next                   = &dl_sched_class, //DEADLINEクラス

const struct sched_class dl_sched_class = {
        .next                   = &rt_sched_class, //RTクラス

const struct sched_class rt_sched_class = {
        .next                   = &fair_sched_class, //FAIRクラス

const struct sched_class fair_sched_class = {
        .next                   = &idle_sched_class, //IDLEクラス

const struct sched_class idle_sched_class = {
        /* .next is NULL */

/*
 * SCHED_DEADLINE tasks has negative priorities, reflecting
 * the fact that any of them has higher prio than RT and
 * NORMAL/BATCH tasks.
 */

#define MAX_DL_PRIO             0
：

:
/*
 * Priority of a process goes from 0..MAX_PRIO-1, valid RT
 * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
 * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
 * values are inverted: lower p->prio value means higher priority.
 *
 * The MAX_USER_RT_PRIO value allows the actual maximum
 * RT priority to be separate from the value exported to
 * user-space.  This allows kernel threads to set their
 * priority to a value higher than any user task. Note:
 * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
 */

#define MAX_USER_RT_PRIO        100
#define MAX_RT_PRIO             MAX_USER_RT_PRIO
:

#define MAX_NICE        19
#define MIN_NICE        -20
#define NICE_WIDTH      (MAX_NICE - MIN_NICE + 1) //NICE_WIDTHは40
：
#define MAX_PRIO                (MAX_RT_PRIO + NICE_WIDTH) //MAX_PRIOは140
：

:
/*
 * Convert user-nice values [ -20 ... 0 ... 19 ]
 * to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
 * and back.
 */
#define NICE_TO_PRIO(nice)  ((nice) + DEFAULT_PRIO) //nice値から優先度への変換。DEFAULT_PRIOは120
#define PRIO_TO_NICE(prio)  ((prio) - DEFAULT_PRIO) //優先度→niceへの変換

static inline struct task_struct *
pick_next_task(struct rq *rq, struct task_struct *prev, struct rq_flags *rf)
{
1        const struct sched_class *class;
2        struct task_struct *p;

        /*
         * Optimization: we know that if all tasks are in the fair class we can
         * call that function directly, but only if the @prev task wasn't of a
         * higher scheduling class, because otherwise those loose the
         * opportunity to pull in more work from other CPUs.
         */
3        if (likely((prev->sched_class == &idle_sched_class ||
4                    prev->sched_class == &fair_sched_class) &&
5                   rq->nr_running == rq->cfs.h_nr_running)) {

6                p = fair_sched_class.pick_next_task(rq, prev, rf);
7                if (unlikely(p == RETRY_TASK))
8                        goto again;

                /* Assumes fair_sched_class->next == idle_sched_class */
9                if (unlikely(!p))
10                        p = idle_sched_class.pick_next_task(rq, prev, rf);

11                return p;
12        }

13 again:
14        for_each_class(class) {
15                p = class->pick_next_task(rq, prev, rf);
16                if (p) {
17                        if (unlikely(p == RETRY_TASK))
18                                goto again;
19                        return p;
20                }
21        }

        /* The idle class should always have a runnable task: */
22        BUG();
23}