struct task_struct {

      ......

      /* 指向进程内核栈 */

      void *stack;

      ......

  };

 union thread_union {

      struct thread_info thread_info;

      unsigned long stack[THREAD_SIZE/sizeof(long)];    /*内核态的进程堆栈*/

 };

 /*线程描述符(linux4.5 x86架构)*/

 /*typedef unsigned int __u32*/

 struct thread_info {

     struct task_struct  *task;    /* 存储进(线)程的信息 */

     __u32            　　flags;    /* 进程标记 */

     __u32            　　status;    /* 线程状态 */

     __u32            　　cpu;        /* current CPU */

     mm_segment_t        addr_limit;

     unsigned int        sig_on_uaccess_error:;

     unsigned int        uaccess_err:;    /* uaccess failed */

 };

#define task_thread_info(task)  ((struct thread_info *)(task)->stack)

struct task_struct {

    ........

    /* 进程ID，每个进程(线程)的PID都不同 */

    pid_t pid;

    /* 线程组ID，同一个线程组拥有相同的pid，与领头线程(该组中第一个轻量级进程)pid一致，保存在tgid中，线程组领头线程的pid和tgid相同 */

    pid_t tgid;

    /* 用于连接到PID、TGID、PGRP、SESSION哈希表 */

    struct pid_link pids[PIDTYPE_MAX];

    /*PID : 进程的ID(Process Identifier),对应pids[PIDTYPE_PID]

     *TGID : 线程组ID(Thread Group Identifier),对应pids[PIDTYPE_TGID]

     *PGRP : 进程组(Process Group),对应pids[PIDTYPE_PGID]

     *SESSION : 会话(Session),对应pids[PIDTYPE_SID]

    */

    ........

};

volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */

 /*

  * Task state bitmask. NOTE! These bits are also

  * encoded in fs/proc/array.c: get_task_state().

  *

  * We have two separate sets of flags: task->state

  * is about runnability, while task->exit_state are

  * about the task exiting. Confusing, but this way

  * modifying one set can't modify the other one by

  * mistake.

  */

 #define TASK_RUNNING            0

 #define TASK_INTERRUPTIBLE      1

 #define TASK_UNINTERRUPTIBLE    2

 #define __TASK_STOPPED          4

 #define __TASK_TRACED           8

 /* in tsk->exit_state */

 #define EXIT_DEAD               16

 #define EXIT_ZOMBIE             32

 #define EXIT_TRACE              (EXIT_ZOMBIE | EXIT_DEAD)

 /* in tsk->state again */

 #define TASK_DEAD               64

 #define TASK_WAKEKILL           128    /** wake on signals that are deadly **/

 #define TASK_WAKING             256

 #define TASK_PARKED             512

 #define TASK_NOLOAD             1024

 #define TASK_STATE_MAX          2048

  /* Convenience macros for the sake of set_task_state */

 #define TASK_KILLABLE           (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)

 #define TASK_STOPPED            (TASK_WAKEKILL | __TASK_STOPPED)

 #define TASK_TRACED             (TASK_WAKEKILL | __TASK_TRACED)

stop_sched_class -> dl_sched_class -> rt_sched_class -> fair_sched_class -> idle_sched_class

 /*

  * All the scheduling class methods:

  */

 const struct sched_class fair_sched_class = {

     .next            = &idle_sched_class,

     .enqueue_task        = enqueue_task_fair,

     .dequeue_task        = dequeue_task_fair,

     .yield_task        = yield_task_fair,

     .yield_to_task        = yield_to_task_fair,

     .check_preempt_curr    = check_preempt_wakeup,

     .pick_next_task        = pick_next_task_fair,

     .put_prev_task        = put_prev_task_fair,

 #ifdef CONFIG_SMP

     .select_task_rq        = select_task_rq_fair,

     .migrate_task_rq    = migrate_task_rq_fair,

     .rq_online        = rq_online_fair,

     .rq_offline        = rq_offline_fair,

     .task_waking        = task_waking_fair,

     .task_dead        = task_dead_fair,

     .set_cpus_allowed    = set_cpus_allowed_common,

 #endif

     .set_curr_task          = set_curr_task_fair,

     .task_tick        = task_tick_fair,

     .task_fork        = task_fork_fair,

     .prio_changed        = prio_changed_fair,

     .switched_from        = switched_from_fair,

     .switched_to        = switched_to_fair,

     .get_rr_interval    = get_rr_interval_fair,

     .update_curr        = update_curr_fair,

 #ifdef CONFIG_FAIR_GROUP_SCHED

     .task_move_group    = task_move_group_fair,

 #endif

 };

 struct cfs_rq {

     struct load_weight load;/*CFS队列中所有进程的总负载*/

     unsigned int nr_running, h_nr_running;

     u64 exec_clock;/**/

     u64 min_vruntime; /*最小虚拟运行时间*/

 #ifndef CONFIG_64BIT

     u64 min_vruntime_copy;

 #endif

 　　 /*红黑树的根root*/

     struct rb_root tasks_timeline;
　　　/*红黑树最左边的节点，也是下一个调度节点*/

     struct rb_node *rb_leftmost;

 　　

     /*

      * 'curr' points to currently running entity on this cfs_rq.

      * It is set to NULL otherwise (i.e when none are currently running).

      */

     struct sched_entity *curr, *next, *last, *skip;

 #ifdef    CONFIG_SCHED_DEBUG

     unsigned int nr_spread_over;

 #endif

 #ifdef CONFIG_SMP

     /*

      * CFS load tracking

      */

     struct sched_avg avg;

     u64 runnable_load_sum;

     unsigned long runnable_load_avg;

 #ifdef CONFIG_FAIR_GROUP_SCHED

     unsigned long tg_load_avg_contrib;

 #endif

     atomic_long_t removed_load_avg, removed_util_avg;

 #ifndef CONFIG_64BIT

     u64 load_last_update_time_copy;

 #endif

 #ifdef CONFIG_FAIR_GROUP_SCHED

     /*

      *   h_load = weight * f(tg)

      *

      * Where f(tg) is the recursive weight fraction assigned to

      * this group.

      */

     unsigned long h_load;

     u64 last_h_load_update;

     struct sched_entity *h_load_next;

 #endif /* CONFIG_FAIR_GROUP_SCHED */

 #endif /* CONFIG_SMP */

 #ifdef CONFIG_FAIR_GROUP_SCHED

     struct rq *rq;    /* cpu runqueue to which this cfs_rq is attached */

     /*

      * leaf cfs_rqs are those that hold tasks (lowest schedulable entity in

      * a hierarchy). Non-leaf lrqs hold other higher schedulable entities

      * (like users, containers etc.)

      *

      * leaf_cfs_rq_list ties together list of leaf cfs_rq's in a cpu. This

      * list is used during load balance.

      */

     int on_list;

     struct list_head leaf_cfs_rq_list;

     struct task_group *tg;    /* group that "owns" this runqueue */

 #ifdef CONFIG_CFS_BANDWIDTH

     int runtime_enabled;

     u64 runtime_expires;

     s64 runtime_remaining;

     u64 throttled_clock, throttled_clock_task;

     u64 throttled_clock_task_time;

     int throttled, throttle_count;

     struct list_head throttled_list;

 #endif /* CONFIG_CFS_BANDWIDTH */

 #endif /* CONFIG_FAIR_GROUP_SCHED */

 };

 /*nice和权重值的转换表*/

static const int prio_to_weight[] = {

 /* -20 */    ,    ,     ,     ,     ,

 /* -15 */    ,    ,     ,     ,     ,

 /* -10 */     ,     ,      ,      ,      ,

 /*  -5 */     ,     ,      ,      ,      ,

 /*   0 */     ,      ,       ,       ,       ,

 /*   5 */      ,      ,       ,       ,       ,

 /*  10 */      ,       ,        ,        ,        ,

 /*  15 */       ,       ,        ,        ,        ,

};

static void update_min_vruntime(struct cfs_rq *cfs_rq)

{
　　 /*初始化vruntime的值 
　　　*相当于如下的代码 
　　　*if (cfs_rq->curr != NULL) 
　　　*　　vruntime = cfs_rq->curr->vruntime; 
　　　*else 
　　　*　　vruntime = cfs_rq->min_vruntime;
　　　*/

    u64 vruntime = cfs_rq->min_vruntime;

　　if (cfs_rq->curr)

        vruntime = cfs_rq->curr->vruntime;

　　　　/* 检测红黑树是都有最左的节点, 即是否有进程在树上等待调度
　　 　　* cfs_rq->rb_leftmost(struct rb_node *)存储了进程红黑树的最左节点
　　 　　* 这个节点存储了即将要被调度的结点 */

　　if (cfs_rq->rb_leftmost) {
　　　　/* 获取最左结点的调度实体信息se, se中存储了其vruntime　　　　　　
　　　　 * rb_leftmost的vruntime即树中所有节点的vruntiem中最小的那个 */

struct sched_entity *se = rb_entry(cfs_rq->rb_leftmost,

                           struct sched_entity,

                           run_node);

　　　/* 如果就绪队列上没有curr进程 　　　　　
　　　 * 则vruntime设置为树种最左结点的vruntime 　　　　　
　　　 * 否则设置vruntiem值为cfs_rq->curr->vruntime和se->vruntime的最小值 */

        if (!cfs_rq->curr)　　/* 此时vruntime的原值为cfs_rq->min_vruntime*/

            vruntime = se->vruntime;

        else　　　　　　　　　　/* 此时vruntime的原值为cfs_rq->curr->vruntime*/

            vruntime = min_vruntime(vruntime, se->vruntime);

    }

    /* ensure we never gain time by being placed backwards. 
　　 * 为了保证min_vruntime单调不减 
　　 * 只有在vruntime超出的cfs_rq->min_vruntime的时候才更新 */

    cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime);

#ifndef CONFIG_64BIT

    smp_wmb();

    cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;

#endif

}