/* returns 0 on failure to allocate runtime */
static int assign_cfs_rq_runtime(struct cfs_rq *cfs_rq)
{
        struct task_group *tg = cfs_rq->tg;
        struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(tg);
        u64 amount = 0, min_amount, expires;

        /* note: this is a positive sum as runtime_remaining <= 0 */
        min_amount = sched_cfs_bandwidth_slice() - cfs_rq->runtime_remaining;

        raw_spin_lock(&cfs_b->lock);
        if (cfs_b->quota == RUNTIME_INF)
                amount = min_amount;
        else {
                /*
                 * If the bandwidth pool has become inactive, then at least one
                 * period must have elapsed since the last consumption.
                 * Refresh the global state and ensure bandwidth timer becomes
                 * active.
                 */
                if (!cfs_b->timer_active) {
                        __refill_cfs_bandwidth_runtime(cfs_b); // 重新填满时间
                        __start_cfs_bandwidth(cfs_b);
                }

                if (cfs_b->runtime > 0) {
                        amount = min(cfs_b->runtime, min_amount);
                        cfs_b->runtime -= amount;
                        cfs_b->idle = 0;
                }
        }
        expires = cfs_b->runtime_expires;
        raw_spin_unlock(&cfs_b->lock);

        cfs_rq->runtime_remaining += amount;
        /*
         * we may have advanced our local expiration to account for allowed
         * spread between our sched_clock and the one on which runtime was
         * issued.
         */
        if ((s64)(expires - cfs_rq->runtime_expires) > 0)
                cfs_rq->runtime_expires = expires;

        return cfs_rq->runtime_remaining > 0;
}

const struct sched_class fair_sched_class = {
        .next                   = &idle_sched_class,
         // kernel 面向对象设计,在 core.c 中被调用。
        .enqueue_task           = enqueue_task_fair,

/*
 * The enqueue_task method is called before nr_running is
 * increased. Here we update the fair scheduling stats and
 * then put the task into the rbtree:
 */
static void
enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
{
        struct cfs_rq *cfs_rq;
        struct sched_entity *se = &p->se;
        
        // 因为需要支持组调度，而组调度下面 se 是有层次结构的，所以遍历所有调度实体。
        // 如果没有组调度是没有必要获取层次信息。
        for_each_sched_entity(se) { 
                if (se->on_rq) // 如果 se 已经在就绪队列上
                        break;
                cfs_rq = cfs_rq_of(se); // 获取当前 se 所在的 cfs_rq
                enqueue_entity(cfs_rq, se, flags); // enqueue_entity 完成 se 的真正插入操作

static void
enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
        /*
         * Update the normalized vruntime before updating min_vruntime
         * through callig update_curr().
         */
         // 如果当前 se 不是被唤醒，或者 se 已经是在运行的了，则更新 se 的 vruntime。
        if (!(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_WAKING))
                se->vruntime += cfs_rq->min_vruntime;

        /*
         * Update run-time statistics of the 'current'.
         */
        update_curr(cfs_rq); // 这里通向 local pool 的更新流程, 参考核心函数分析部分。
        enqueue_entity_load_avg(cfs_rq, se, flags & ENQUEUE_WAKEUP);
        account_entity_enqueue(cfs_rq, se); // 记账，更新 cfs->nr_running 和 load 等
        update_cfs_shares(cfs_rq); // 更新 se 的权重
        
        // 如果当前 se 是被唤醒的
        if (flags & ENQUEUE_WAKEUP) {
                place_entity(cfs_rq, se, 0);
                enqueue_sleeper(cfs_rq, se);
        }

        update_stats_enqueue(cfs_rq, se);
        check_spread(cfs_rq, se);
        if (se != cfs_rq->curr)
                __enqueue_entity(cfs_rq, se);
        se->on_rq = 1;

        if (cfs_rq->nr_running == 1) {
                list_add_leaf_cfs_rq(cfs_rq);
                check_enqueue_throttle(cfs_rq); // cfs_rq 限流检查
        }
}

/*
 * When a group wakes up we want to make sure that its quota is not already
 * expired/exceeded, otherwise it may be allowed to steal additional ticks of
 * runtime as update_curr() throttling can not not trigger until it's on-rq.
 */
static void check_enqueue_throttle(struct cfs_rq *cfs_rq)
{
        if (!cfs_bandwidth_used()) // 如果限流没有开
                return;

        /* an active group must be handled by the update_curr()->put() path */
        if (!cfs_rq->runtime_enabled || cfs_rq->curr) // 如果 runtime 没有启用
                return;

        /* ensure the group is not already throttled */
        if (cfs_rq_throttled(cfs_rq)) // 已经限流操作了
                return;

        /* update runtime allocation */
        account_cfs_rq_runtime(cfs_rq, 0); // 再抢救一下试试
        if (cfs_rq->runtime_remaining <= 0)
        // 抢救无效，限流开始。
        // 具体实现：就是 task group 限流的尾插到 cfs_rq 维护的已经限流的列表里面。
                throttle_cfs_rq(cfs_rq); 
}