Linux Kernel Cgroups源码浅析

struct task_struct 
{
    // ...
    
    #ifdef CONFIG_CGROUPS
    
    /* Control Group info protected by css_set_lock */
    
    struct css_set __rcu *cgroups;
    
    /* cg_list protected by css_set_lock and tsk->alloc_lock */
    
    struct list_head cg_list; 
    
    #endif
    
    // ...
}

struct css_set {
    /* Reference count */
    atomic_t refcount;
 
    /*
     * List running through all cgroup groups in the same hash
     * slot. Protected by css_set_lock
     */
    struct hlist_node hlist;
 
    /*
     * Lists running through all tasks using this cgroup group.
     * mg_tasks lists tasks which belong to this cset but are in the
     * process of being migrated out or in.  Protected by
     * css_set_rwsem, but, during migration, once tasks are moved to
     * mg_tasks, it can be read safely while holding cgroup_mutex.
     */
    struct list_head tasks;
    struct list_head mg_tasks;
 
    /*
     * List of cgrp_cset_links pointing at cgroups referenced from this
     * css_set.  Protected by css_set_lock.
     */
    struct list_head cgrp_links;
 
    /* the default cgroup associated with this css_set */
    struct cgroup *dfl_cgrp;
 
    /*
     * Set of subsystem states, one for each subsystem. This array is
     * immutable after creation apart from the init_css_set during
     * subsystem registration (at boot time).
     */
    struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
 
    /*
     * List of csets participating in the on-going migration either as
     * source or destination.  Protected by cgroup_mutex.
     */
    struct list_head mg_preload_node;
    struct list_head mg_node;
 
    /*
     * If this cset is acting as the source of migration the following
     * two fields are set.  mg_src_cgrp is the source cgroup of the
     * on-going migration and mg_dst_cset is the destination cset the
     * target tasks on this cset should be migrated to.  Protected by
     * cgroup_mutex.
     */
    struct cgroup *mg_src_cgrp;
    struct css_set *mg_dst_cset;
 
    /*
     * On the default hierarhcy, ->subsys[ssid] may point to a css
     * attached to an ancestor instead of the cgroup this css_set is
     * associated with.  The following node is anchored at
     * ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to
     * iterate through all css's attached to a given cgroup.
     */
    struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
 
    /* all css_task_iters currently walking this cset */
    struct list_head task_iters;
 
    /* dead and being drained, ignore for migration */
    bool dead;
 
    /* For RCU-protected deletion */
    struct rcu_head rcu_head;
};

asmlinkage __visible void __init start_kernel(void)
{
    // ...
    cpuset_init();
    cgroup_init();
    // ...
}

int __init cgroup_init(void)
{
    struct cgroup_subsys *ss;
    unsigned long key;
    int ssid;
 
    BUG_ON(percpu_init_rwsem(&cgroup_threadgroup_rwsem));
    BUG_ON(cgroup_init_cftypes(NULL, cgroup_dfl_base_files));
    BUG_ON(cgroup_init_cftypes(NULL, cgroup_legacy_base_files));
 
    mutex_lock(&cgroup_mutex);
 
    /* Add init_css_set to the hash table */
    key = css_set_hash(init_css_set.subsys);
    hash_add(css_set_table, &init_css_set.hlist, key);
 
    BUG_ON(cgroup_setup_root(&cgrp_dfl_root, 0));
 
    mutex_unlock(&cgroup_mutex);
 
    for_each_subsys(ss, ssid) {
        if (ss->early_init) {
            struct cgroup_subsys_state *css =
                init_css_set.subsys[ss->id];
 
            css->id = cgroup_idr_alloc(&ss->css_idr, css, 1, 2,
                           GFP_KERNEL);
            BUG_ON(css->id < 0);
        } else {
            cgroup_init_subsys(ss, false);
        }
 
        list_add_tail(&init_css_set.e_cset_node[ssid],
                  &cgrp_dfl_root.cgrp.e_csets[ssid]);
 
        /*
         * Setting dfl_root subsys_mask needs to consider the
         * disabled flag and cftype registration needs kmalloc,
         * both of which aren't available during early_init.
         */
        if (cgroup_disable_mask & (1 << ssid)) {
            static_branch_disable(cgroup_subsys_enabled_key[ssid]);
            printk(KERN_INFO "Disabling %s control group subsystem\n",
                   ss->name);
            continue;
        }
 
        cgrp_dfl_root.subsys_mask |= 1 << ss->id;
 
        if (!ss->dfl_cftypes)
            cgrp_dfl_root_inhibit_ss_mask |= 1 << ss->id;
 
        if (ss->dfl_cftypes == ss->legacy_cftypes) {
            WARN_ON(cgroup_add_cftypes(ss, ss->dfl_cftypes));
        } else {
            WARN_ON(cgroup_add_dfl_cftypes(ss, ss->dfl_cftypes));
            WARN_ON(cgroup_add_legacy_cftypes(ss, ss->legacy_cftypes));
        }
 
        if (ss->bind)
            ss->bind(init_css_set.subsys[ssid]);
    }
 
    WARN_ON(sysfs_create_mount_point(fs_kobj, "cgroup"));
    WARN_ON(register_filesystem(&cgroup_fs_type));
    WARN_ON(!proc_create("cgroups", 0, NULL, &proc_cgroupstats_operations));
 
    return 0;
}

struct cgroup {
    /* self css with NULL ->ss, points back to this cgroup */
    struct cgroup_subsys_state self;
 
    unsigned long flags;        /* "unsigned long" so bitops work */
 
    /*
     * idr allocated in-hierarchy ID.
     *
     * ID 0 is not used, the ID of the root cgroup is always 1, and a
     * new cgroup will be assigned with a smallest available ID.
     *
     * Allocating/Removing ID must be protected by cgroup_mutex.
     */
    int id;
 
    /*
     * Each non-empty css_set associated with this cgroup contributes
     * one to populated_cnt.  All children with non-zero popuplated_cnt
     * of their own contribute one.  The count is zero iff there's no
     * task in this cgroup or its subtree.
     */
    int populated_cnt;
 
    struct kernfs_node *kn;     /* cgroup kernfs entry */
    struct cgroup_file procs_file;  /* handle for "cgroup.procs" */
    struct cgroup_file events_file; /* handle for "cgroup.events" */
 
    /*
     * The bitmask of subsystems enabled on the child cgroups.
     * ->subtree_control is the one configured through
     * "cgroup.subtree_control" while ->child_subsys_mask is the
     * effective one which may have more subsystems enabled.
     * Controller knobs are made available iff it's enabled in
     * ->subtree_control.
     */
    unsigned int subtree_control;
    unsigned int child_subsys_mask;
 
    /* Private pointers for each registered subsystem */
    struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
 
    struct cgroup_root *root;
 
    /*
     * List of cgrp_cset_links pointing at css_sets with tasks in this
     * cgroup.  Protected by css_set_lock.
     */
    struct list_head cset_links;
 
    /*
     * On the default hierarchy, a css_set for a cgroup with some
     * susbsys disabled will point to css's which are associated with
     * the closest ancestor which has the subsys enabled.  The
     * following lists all css_sets which point to this cgroup's css
     * for the given subsystem.
     */
    struct list_head e_csets[CGROUP_SUBSYS_COUNT];
 
    /*
     * list of pidlists, up to two for each namespace (one for procs, one
     * for tasks); created on demand.
     */
    struct list_head pidlists;
    struct mutex pidlist_mutex;
 
    /* used to wait for offlining of csses */
    wait_queue_head_t offline_waitq;
 
    /* used to schedule release agent */
    struct work_struct release_agent_work;
};

linux-4.4.19/include/linux/cgroup-defs.h #98
/*
 * Per-subsystem/per-cgroup state maintained by the system.  This is the
 * fundamental structural building block that controllers deal with.
 *
 * Fields marked with "PI:" are public and immutable and may be accessed
 * directly without synchronization.
 */
struct cgroup_subsys_state {
    /* PI: the cgroup that this css is attached to */
    struct cgroup *cgroup;
 
    /* PI: the cgroup subsystem that this css is attached to */
    struct cgroup_subsys *ss;
 
    /* reference count - access via css_[try]get() and css_put() */
    struct percpu_ref refcnt;
 
    /* PI: the parent css */
    struct cgroup_subsys_state *parent;
 
    /* siblings list anchored at the parent's ->children */
    struct list_head sibling;
    struct list_head children;
 
    /*
     * PI: Subsys-unique ID.  0 is unused and root is always 1.  The
     * matching css can be looked up using css_from_id().
     */
    int id;
 
    unsigned int flags;
 
    /*
     * Monotonically increasing unique serial number which defines a
     * uniform order among all csses.  It's guaranteed that all
     * ->children lists are in the ascending order of ->serial_nr and
     * used to allow interrupting and resuming iterations.
     */
    u64 serial_nr;
 
    /*
     * Incremented by online self and children.  Used to guarantee that
     * parents are not offlined before their children.
     */
    atomic_t online_cnt;
 
    /* percpu_ref killing and RCU release */
    struct rcu_head rcu_head;
    struct work_struct destroy_work;
}

/*
 * A cgroup_root represents the root of a cgroup hierarchy, and may be
 * associated with a kernfs_root to form an active hierarchy.  This is
 * internal to cgroup core.  Don't access directly from controllers.
 */
struct cgroup_root {
    struct kernfs_root *kf_root;
 
    /* The bitmask of subsystems attached to this hierarchy */
    unsigned int subsys_mask;
 
    /* Unique id for this hierarchy. */
    int hierarchy_id;
 
    /* The root cgroup.  Root is destroyed on its release. */
    struct cgroup cgrp;
 
    /* for cgrp->ancestor_ids[0] */
    int cgrp_ancestor_id_storage;
 
    /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
    atomic_t nr_cgrps;
 
    /* A list running through the active hierarchies */
    struct list_head root_list;
 
    /* Hierarchy-specific flags */
    unsigned int flags;
 
    /* IDs for cgroups in this hierarchy */
    struct idr cgroup_idr;
 
    /* The path to use for release notifications. */
    char release_agent_path[PATH_MAX];
 
    /* The name for this hierarchy - may be empty */
    char name[MAX_CGROUP_ROOT_NAMELEN];
};

/*
 * A cgroup can be associated with multiple css_sets as different tasks may
 * belong to different cgroups on different hierarchies.  In the other
 * direction, a css_set is naturally associated with multiple cgroups.
 * This M:N relationship is represented by the following link structure
 * which exists for each association and allows traversing the associations
 * from both sides.
 */
struct cgrp_cset_link {
    /* the cgroup and css_set this link associates */
    struct cgroup       *cgrp;
    struct css_set      *cset;
 
    /* list of cgrp_cset_links anchored at cgrp->cset_links */
    struct list_head    cset_link;
 
    /* list of cgrp_cset_links anchored at css_set->cgrp_links */
    struct list_head    cgrp_link;
};

/**
 * link_css_set - a helper function to link a css_set to a cgroup
 * @tmp_links: cgrp_cset_link objects allocated by allocate_cgrp_cset_links()
 * @cset: the css_set to be linked
 * @cgrp: the destination cgroup
 */
 
 /* link_css_set函数的功能就是把一个css_set与一个cgroup通过struct */cgrp_cset_link联系起来。
static void link_css_set(struct list_head *tmp_links, struct css_set *cset, struct cgroup *cgrp)
{
    struct cgrp_cset_link *link;
 
    BUG_ON(list_empty(tmp_links));
 
    if (cgroup_on_dfl(cgrp))
        cset->dfl_cgrp = cgrp;
    
    // 从已经分配好的一个cgrp_cset_link链表(表头为tmp_links)中拿一个出来，填上cgroup与css_set的指针
    link = list_first_entry(tmp_links, struct cgrp_cset_link, cset_link);
    link->cset = cset;
    link->cgrp = cgrp;
     
     // 把这个cgrp_cset_link从原来的链表中移出来，加入到cgrp（这个就是那个cgroup）的cset_links链表中
    list_move_tail(&link->cset_link, &cgrp->cset_links);
    
    // 把cgrp_cset_link的cgrp_link加入到cset的cgrp_links链表中
    list_add_tail(&link->cgrp_link, &cset->cgrp_links);
 
    if (cgroup_parent(cgrp))
        cgroup_get(cgrp);
}

/**
 * allocate_cgrp_cset_links - allocate cgrp_cset_links
 * @count: the number of links to allocate
 * @tmp_links: list_head the allocated links are put on
 *
 * Allocate @count cgrp_cset_link structures and chain them on @tmp_links
 * through ->cset_link.  Returns 0 on success or -errno.
 */
static int allocate_cgrp_cset_links(int count, struct list_head *tmp_links)
{
    struct cgrp_cset_link *link;
    int i;
 
    INIT_LIST_HEAD(tmp_links);
 
    for (i = 0; i < count; i++) {
        link = kzalloc(sizeof(*link), GFP_KERNEL);
        if (!link) {
            free_cgrp_cset_links(tmp_links);
            return -ENOMEM;
        }
        list_add(&link->cset_link, tmp_links);
    }
    return 0;
}

/*
 * Return the cgroup for "task" from the given hierarchy. Must be
 * called with cgroup_mutex and css_set_lock held.
 */
static struct cgroup *task_cgroup_from_root(struct task_struct *task,
                        struct cgroup_root *root)
{
    /*
     * No need to lock the task - since we hold cgroup_mutex the
     * task can't change groups, so the only thing that can happen
     * is that it exits and its css is set back to init_css_set.
     */
    return cset_cgroup_from_root(task_css_set(task), root);
}

/* look up cgroup associated with given css_set on the specified hierarchy */
static struct cgroup *cset_cgroup_from_root(struct css_set *cset,
                        struct cgroup_root *root)
{
    struct cgroup *res = NULL;
 
    lockdep_assert_held(&cgroup_mutex);
    lockdep_assert_held(&css_set_lock);
 
    if (cset == &init_css_set) {
        res = &root->cgrp;
    } else {
        struct cgrp_cset_link *link;
 
        list_for_each_entry(link, &cset->cgrp_links, cgrp_link) {
            struct cgroup *c = link->cgrp;
 
            if (c->root == root) {
                res = c;
                break;
            }
        }
    }
 
    BUG_ON(!res);
    return res;
}

/* task group related information */
struct task_group {
    struct cgroup_subsys_state css;
 
#ifdef CONFIG_FAIR_GROUP_SCHED
    /* schedulable entities of this group on each cpu */
    struct sched_entity **se;
    /* runqueue "owned" by this group on each cpu */
    struct cfs_rq **cfs_rq;
    unsigned long shares;
 
#ifdef  CONFIG_SMP
    atomic_long_t load_avg;
#endif
#endif
 
#ifdef CONFIG_RT_GROUP_SCHED
    struct sched_rt_entity **rt_se;
    struct rt_rq **rt_rq;
 
    struct rt_bandwidth rt_bandwidth;
#endif
 
    struct rcu_head rcu;
    struct list_head list;
 
    struct task_group *parent;
    struct list_head siblings;
    struct list_head children;
 
#ifdef CONFIG_SCHED_AUTOGROUP
    struct autogroup *autogroup;
#endif
 
    struct cfs_bandwidth cfs_bandwidth;
};

static int cpu_shares_write_u64(struct cgroup_subsys_state *css,
                struct cftype *cftype, u64 shareval)
{
    return sched_group_set_shares(css_tg(css), scale_load(shareval));
}

int sched_group_set_shares(struct task_group *tg, unsigned long shares)
{
    int i;
    unsigned long flags;
 
    /*
     * We can't change the weight of the root cgroup.
     */
    if (!tg->se[0])
        return -EINVAL;
 
    shares = clamp(shares, scale_load(MIN_SHARES), scale_load(MAX_SHARES));
 
    mutex_lock(&shares_mutex);
    if (tg->shares == shares)
        goto done;
 
    tg->shares = shares;
    for_each_possible_cpu(i) {
        struct rq *rq = cpu_rq(i);
        struct sched_entity *se;
 
        se = tg->se[i];
        /* Propagate contribution to hierarchy */
        raw_spin_lock_irqsave(&rq->lock, flags);
 
        /* Possible calls to update_curr() need rq clock */
        update_rq_clock(rq);
        for_each_sched_entity(se)
            update_cfs_shares(group_cfs_rq(se));
        raw_spin_unlock_irqrestore(&rq->lock, flags);
    }
 
done:
    mutex_unlock(&shares_mutex);
    return 0;
}

static inline void update_load_set(struct load_weight *lw, unsigned long w)

{
    lw->weight = w;
    lw->inv_weight = 0;
}