struct cgroup_subsys freezer_cgrp_subsys = {
    .css_alloc    = freezer_css_alloc,
    .css_online    = freezer_css_online,
    .css_offline    = freezer_css_offline,
    .css_free    = freezer_css_free,
    .attach        = freezer_attach,
    .fork        = freezer_fork,
    .legacy_cftypes    = files,
};

struct freezer {
    struct cgroup_subsys_state    css;
    unsigned int            state;
};

static struct cftype files[] = {
    {
        .name = "state",  子系统当前的状态
        .flags = CFTYPE_NOT_ON_ROOT,
        .seq_show = freezer_read,
        .write = freezer_write,
    },
    {
        .name = "self_freezing",  自身当前是否处于freezing状态
        .flags = CFTYPE_NOT_ON_ROOT,
        .read_u64 = freezer_self_freezing_read,
    },
    {
        .name = "parent_freezing",  父子系统是否处于freezing状态
        .flags = CFTYPE_NOT_ON_ROOT,
        .read_u64 = freezer_parent_freezing_read,
    },
    { }    /* terminate */
};

enum freezer_state_flags {
    CGROUP_FREEZER_ONLINE    = (1 << 0), /* freezer is fully online */  freezer没有被冻结
    CGROUP_FREEZING_SELF    = (1 << 1), /* this freezer is freezing */  freezer自身正在冻结中
    CGROUP_FREEZING_PARENT    = (1 << 2), /* the parent freezer is freezing */  父freezer正在冻结中
    CGROUP_FROZEN        = (1 << 3), /* this and its descendants frozen */  自身和者子freezer已经被冻结

/* mask for all FREEZING flags */
    CGROUP_FREEZING        = CGROUP_FREEZING_SELF | CGROUP_FREEZING_PARENT,  自身或者父freezer处于冻结过程中
};

static int freezer_read(struct seq_file *m, void *v)
{
    struct cgroup_subsys_state *css = seq_css(m), *pos;

mutex_lock(&freezer_mutex);
    rcu_read_lock();

/* update states bottom-up */
    css_for_each_descendant_post(pos, css) { 倒序遍历当前css的所有子css，最后一个遍历根css。
        if (!css_tryget_online(pos))
            continue;
        rcu_read_unlock();

update_if_frozen(pos);  更新当前css的state，这样确保当前css状态是最新的。然后根css的状态也是最新的。

rcu_read_lock();
        css_put(pos);
    }

rcu_read_unlock();
    mutex_unlock(&freezer_mutex);

seq_puts(m, freezer_state_strs(css_freezer(css)->state));
    seq_putc(m, '\n');
    return 0;
}

static ssize_t freezer_write(struct kernfs_open_file *of,
                 char *buf, size_t nbytes, loff_t off)
{
    bool freeze;

buf = strstrip(buf);

if (strcmp(buf, freezer_state_strs(0)) == 0)  对应THAWED状态
        freeze = false;
    else if (strcmp(buf, freezer_state_strs(CGROUP_FROZEN)) == 0)  对应FROZEN状态
        freeze = true;
    else
        return -EINVAL;

freezer_change_state(css_freezer(of_css(of)), freeze); 切换freezer状态
    return nbytes;
}

static void freezer_change_state(struct freezer *freezer, bool freeze)
{
    struct cgroup_subsys_state *pos;

/*
     * Update all its descendants in pre-order traversal.  Each
     * descendant will try to inherit its parent's FREEZING state as
     * CGROUP_FREEZING_PARENT.
     */
    mutex_lock(&freezer_mutex);
    rcu_read_lock();
    css_for_each_descendant_pre(pos, &freezer->css) {  这里和freezer_read是一个相反的过程，这是从跟css开始，逐级遍历所有css。
        struct freezer *pos_f = css_freezer(pos);
        struct freezer *parent = parent_freezer(pos_f);

if (!css_tryget_online(pos))
            continue;
        rcu_read_unlock();

if (pos_f == freezer)  如果是根css则进入CGROUP_FREEZING_SELF
            freezer_apply_state(pos_f, freeze,
                        CGROUP_FREEZING_SELF);
        else
            freezer_apply_state(pos_f,  其他css，表示是继承CGROUP_FREEZING_PARENT
                        parent->state & CGROUP_FREEZING,
                        CGROUP_FREEZING_PARENT);

rcu_read_lock();
        css_put(pos);
    }
    rcu_read_unlock();
    mutex_unlock(&freezer_mutex);
}

static void freezer_apply_state(struct freezer *freezer, bool freeze,
                unsigned int state)
{
    /* also synchronizes against task migration, see freezer_attach() */
    lockdep_assert_held(&freezer_mutex);

if (!(freezer->state & CGROUP_FREEZER_ONLINE))
        return;

if (freeze) {  需要freeze，调用freeze_cgroup。冻结当前Cgroup下面所有task
        if (!(freezer->state & CGROUP_FREEZING))
            atomic_inc(&system_freezing_cnt);
        freezer->state |= state;
        freeze_cgroup(freezer);
    } else {  不需要freeze
        bool was_freezing = freezer->state & CGROUP_FREEZING;

freezer->state &= ~state;

if (!(freezer->state & CGROUP_FREEZING)) {  并且不是CGROUP_FREEZING状态
            if (was_freezing)
                atomic_dec(&system_freezing_cnt);
            freezer->state &= ~CGROUP_FROZEN;
            unfreeze_cgroup(freezer);  此CGroup下的所有tasks解冻
        }
    }
}

bool freeze_task(struct task_struct *p)
{
    unsigned long flags;

/*
     * This check can race with freezer_do_not_count, but worst case that
     * will result in an extra wakeup being sent to the task.  It does not
     * race with freezer_count(), the barriers in freezer_count() and
     * freezer_should_skip() ensure that either freezer_count() sees
     * freezing == true in try_to_freeze() and freezes, or
     * freezer_should_skip() sees !PF_FREEZE_SKIP and freezes the task
     * normally.
     */
    if (freezer_should_skip(p))  在需要冻结的时候，是否跳过此进程
        return false;

spin_lock_irqsave(&freezer_lock, flags);
    if (!freezing(p) || frozen(p)) {  如果进程不是freezing，或已经被FROZEN，返回false
        spin_unlock_irqrestore(&freezer_lock, flags);
        return false;
    }

if (!(p->flags & PF_KTHREAD))
        fake_signal_wake_up(p);  不是内核线程，发送伪唤醒信号
    else
        wake_up_state(p, TASK_INTERRUPTIBLE);  设置进程唤醒条件为TASK_INTERRUPTIBLE

spin_unlock_irqrestore(&freezer_lock, flags);
    return true;
}

void __thaw_task(struct task_struct *p)
{
    unsigned long flags;

spin_lock_irqsave(&freezer_lock, flags);
    if (frozen(p))  如果已经被FROZEN，则简单的去唤醒
        wake_up_process(p);
    spin_unlock_irqrestore(&freezer_lock, flags);
}