#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_ZOMBIE        16
#define EXIT_DEAD        32

asmlinkage void __sched schedule(void)
{
    struct task_struct *prev, *next;  //当前进程、下一个进程的结构体
    unsigned long *switch_count;      //进程切换次数
    struct rq *rq;                    //就绪队列
    int cpu;

need_resched:
    preempt_disable();               //关闭内核抢占
    cpu = smp_processor_id();        //找到当前CPU上的就绪队列rq
    rq = cpu_rq(cpu);                
    rcu_note_context_switch(cpu);
    prev = rq->curr;                 //将正在运行的进程保存在prev

    schedule_debug(prev);

    if (sched_feat(HRTICK))
        hrtick_clear(rq);

    raw_spin_lock_irq(&rq->lock);

    switch_count = &prev->nivcsw;   //切换次数记录
    if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) { //当前进程非运行状态，并且非内核抢占
       
        if (unlikely(signal_pending_state(prev->state, prev))) { //若不是非挂起信号，设置进程为就绪状态
            prev->state = TASK_RUNNING;
        } else { //若为非挂起信号，则将其从队列中移出
            /*
             * If a worker is going to sleep, notify and
             * ask workqueue whether it wants to wake up a
             * task to maintain concurrency.  If so, wake
             * up the task.
             */
            if (prev->flags & PF_WQ_WORKER) {
                struct task_struct *to_wakeup;

                to_wakeup = wq_worker_sleeping(prev, cpu);
                if (to_wakeup)
                    try_to_wake_up_local(to_wakeup);
            }
            deactivate_task(rq, prev, DEQUEUE_SLEEP);

            /*
             * If we are going to sleep and we have plugged IO queued, make
             * sure to submit it to avoid deadlocks.
             */
            if (blk_needs_flush_plug(prev)) {
                raw_spin_unlock(&rq->lock);
                blk_schedule_flush_plug(prev);
                raw_spin_lock(&rq->lock);
            }
        }
        switch_count = &prev->nvcsw;
    }

    pre_schedule(rq, prev); //通知调度器，即将发生进程切换

    if (unlikely(!rq->nr_running))
        idle_balance(cpu, rq);

    put_prev_task(rq, prev); //通知调度器，即将用另一个进程替换当前进程
    next = pick_next_task(rq); //挑选可运行的任务
    clear_tsk_need_resched(prev); //清除pre的TIF_NEED_RESCHED标志
    rq->skip_clock_update = 0;

    if (likely(prev != next)) { //如果不是同一个进程
        rq->nr_switches++;      
        rq->curr = next;        //将当前进程切换成挑选的那个进程
        ++*switch_count;        //切换次数更新

        context_switch(rq, prev, next); /* unlocks the rq */ //进程上下文切换
        /*
         * The context switch have flipped the stack from under us
         * and restored the local variables which were saved when
         * this task called schedule() in the past. prev == current
         * is still correct, but it can be moved to another cpu/rq.
         */
        cpu = smp_processor_id();
        rq = cpu_rq(cpu);
    } else
        raw_spin_unlock_irq(&rq->lock);

    post_schedule(rq); //通知调度类，完成进程切换

    preempt_enable_no_resched();
    if (need_resched())  //如果该进程被其他进程设置了TIF_NEED_RESCHED标志，则函数重新执行进行调度
        goto need_resched;
}