Lines Matching refs:cset
616 count += link->cset->nr_tasks;
742 * The following field is re-initialized when this cset gets linked
752 static bool css_set_threaded(struct css_set *cset)
754 return cset->dom_cset != cset;
759 * @cset: target css_set
761 * css_set_populated() should be the same as !!cset->nr_tasks at steady
766 static bool css_set_populated(struct css_set *cset)
770 return !list_empty(&cset->tasks) || !list_empty(&cset->mg_tasks);
824 * @cset: target css_set
825 * @populated: whether @cset is populated or depopulated
827 * @cset is either getting the first task or losing the last. Update the
830 static void css_set_update_populated(struct css_set *cset, bool populated)
836 list_for_each_entry(link, &cset->cgrp_links, cgrp_link)
846 static void css_set_skip_task_iters(struct css_set *cset,
851 list_for_each_entry_safe(it, pos, &cset->task_iters, iters_node)
925 void put_css_set_locked(struct css_set *cset)
933 if (!refcount_dec_and_test(&cset->refcount))
936 WARN_ON_ONCE(!list_empty(&cset->threaded_csets));
940 list_del(&cset->e_cset_node[ssid]);
941 css_put(cset->subsys[ssid]);
943 hash_del(&cset->hlist);
946 list_for_each_entry_safe(link, tmp_link, &cset->cgrp_links, cgrp_link) {
954 if (css_set_threaded(cset)) {
955 list_del(&cset->threaded_csets_node);
956 put_css_set_locked(cset->dom_cset);
959 kfree_rcu(cset, rcu_head);
964 * @cset: candidate css_set being tested
969 * Returns true if "cset" matches "old_cset" except for the hierarchy
972 static bool compare_css_sets(struct css_set *cset,
985 if (memcmp(template, cset->subsys, sizeof(cset->subsys)))
989 /* @cset's domain should match the default cgroup's */
995 if (new_dfl_cgrp->dom_cgrp != cset->dom_cset->dfl_cgrp)
1004 l1 = &cset->cgrp_links;
1013 if (l1 == &cset->cgrp_links) {
1057 struct css_set *cset;
1083 hash_for_each_possible(css_set_table, cset, hlist, key) {
1084 if (!compare_css_sets(cset, old_cset, cgrp, template))
1088 return cset;
1134 * @cset: the css_set to be linked
1137 static void link_css_set(struct list_head *tmp_links, struct css_set *cset,
1145 cset->dfl_cgrp = cgrp;
1148 link->cset = cset;
1156 list_add_tail(&link->cgrp_link, &cset->cgrp_links);
1174 struct css_set *cset;
1186 cset = find_existing_css_set(old_cset, cgrp, template);
1187 if (cset)
1188 get_css_set(cset);
1191 if (cset)
1192 return cset;
1194 cset = kzalloc(sizeof(*cset), GFP_KERNEL);
1195 if (!cset)
1200 kfree(cset);
1204 refcount_set(&cset->refcount, 1);
1205 cset->dom_cset = cset;
1206 INIT_LIST_HEAD(&cset->tasks);
1207 INIT_LIST_HEAD(&cset->mg_tasks);
1208 INIT_LIST_HEAD(&cset->dying_tasks);
1209 INIT_LIST_HEAD(&cset->task_iters);
1210 INIT_LIST_HEAD(&cset->threaded_csets);
1211 INIT_HLIST_NODE(&cset->hlist);
1212 INIT_LIST_HEAD(&cset->cgrp_links);
1213 INIT_LIST_HEAD(&cset->mg_src_preload_node);
1214 INIT_LIST_HEAD(&cset->mg_dst_preload_node);
1215 INIT_LIST_HEAD(&cset->mg_node);
1219 memcpy(cset->subsys, template, sizeof(cset->subsys));
1228 link_css_set(&tmp_links, cset, c);
1235 /* Add @cset to the hash table */
1236 key = css_set_hash(cset->subsys);
1237 hash_add(css_set_table, &cset->hlist, key);
1240 struct cgroup_subsys_state *css = cset->subsys[ssid];
1242 list_add_tail(&cset->e_cset_node[ssid],
1250 * If @cset should be threaded, look up the matching dom_cset and
1251 * link them up. We first fully initialize @cset then look for the
1252 * dom_cset. It's simpler this way and safe as @cset is guaranteed
1255 if (cgroup_is_threaded(cset->dfl_cgrp)) {
1258 dcset = find_css_set(cset, cset->dfl_cgrp->dom_cgrp);
1260 put_css_set(cset);
1265 cset->dom_cset = dcset;
1266 list_add_tail(&cset->threaded_csets_node,
1271 return cset;
1367 * Returned cgroup is without refcount but it's valid as long as cset pins it.
1369 static inline struct cgroup *__cset_cgroup_from_root(struct css_set *cset,
1374 if (cset == &init_css_set) {
1377 res_cgroup = cset->dfl_cgrp;
1382 list_for_each_entry(link, &cset->cgrp_links, cgrp_link) {
1412 struct css_set *cset;
1418 cset = current->nsproxy->cgroup_ns->root_cset;
1419 res = __cset_cgroup_from_root(cset, root);
1438 * - css_set_lock is not needed because we just read cset->dfl_cgrp.
1444 struct css_set *cset;
1447 cset = current->nsproxy->cgroup_ns->root_cset;
1448 return __cset_cgroup_from_root(cset, &cgrp_dfl_root);
1461 static struct cgroup *cset_cgroup_from_root(struct css_set *cset,
1466 return __cset_cgroup_from_root(cset, root);
1829 struct css_set *cset, *cset_pos;
1849 list_for_each_entry_safe(cset, cset_pos, &scgrp->e_csets[ss->id],
1851 list_move_tail(&cset->e_cset_node[ss->id],
1860 list_for_each_entry(it, &cset->task_iters, iters_node)
2090 struct css_set *cset;
2161 hash_for_each(css_set_table, i, cset, hlist) {
2162 link_css_set(&tmp_links, cset, root_cgrp);
2163 if (css_set_populated(cset))
2464 struct css_set *cset;
2475 cset = task_css_set(task);
2476 if (!cset->mg_src_cgrp)
2481 list_move_tail(&task->cg_list, &cset->mg_tasks);
2482 if (list_empty(&cset->mg_node))
2483 list_add_tail(&cset->mg_node,
2485 if (list_empty(&cset->mg_dst_cset->mg_node))
2486 list_add_tail(&cset->mg_dst_cset->mg_node,
2517 struct css_set *cset = tset->cur_cset;
2520 while (CGROUP_HAS_SUBSYS_CONFIG && &cset->mg_node != tset->csets) {
2522 task = list_first_entry(&cset->mg_tasks,
2527 if (&task->cg_list != &cset->mg_tasks) {
2528 tset->cur_cset = cset;
2534 * can be distinguished by looking at whether @cset
2537 if (cset->mg_dst_cset)
2538 *dst_cssp = cset->mg_dst_cset->subsys[tset->ssid];
2540 *dst_cssp = cset->subsys[tset->ssid];
2545 cset = list_next_entry(cset, mg_node);
2566 struct css_set *cset, *tmp_cset;
2589 list_for_each_entry(cset, &tset->src_csets, mg_node) {
2590 list_for_each_entry_safe(task, tmp_task, &cset->mg_tasks, cg_list) {
2592 struct css_set *to_cset = cset->mg_dst_cset;
2643 list_for_each_entry_safe(cset, tmp_cset, &tset->src_csets, mg_node) {
2644 list_splice_tail_init(&cset->mg_tasks, &cset->tasks);
2645 list_del_init(&cset->mg_node);
2701 struct css_set *cset, *tmp_cset;
2707 list_for_each_entry_safe(cset, tmp_cset, &mgctx->preloaded_src_csets,
2709 cset->mg_src_cgrp = NULL;
2710 cset->mg_dst_cgrp = NULL;
2711 cset->mg_dst_cset = NULL;
2712 list_del_init(&cset->mg_src_preload_node);
2713 put_css_set_locked(cset);
2716 list_for_each_entry_safe(cset, tmp_cset, &mgctx->preloaded_dst_csets,
2718 cset->mg_src_cgrp = NULL;
2719 cset->mg_dst_cgrp = NULL;
2720 cset->mg_dst_cset = NULL;
2721 list_del_init(&cset->mg_dst_preload_node);
2722 put_css_set_locked(cset);
2797 /* look up the dst cset for each src cset and link it to src */
2811 * If src cset equals dst, it's noop. Drop the src.
2812 * cgroup_migrate() will skip the cset too. Note that we
3061 cgroup_migrate_add_src(link->cset, dsct, &mgctx);
4793 struct css_set *cset;
4797 /* find the next threaded cset */
4810 /* find the next cset */
4819 cset = container_of(l, struct css_set, e_cset_node[it->ss->id]);
4822 cset = link->cset;
4831 it->cur_dcset = cset;
4832 get_css_set(cset);
4834 it->tcset_head = &cset->threaded_csets;
4835 it->tcset_pos = &cset->threaded_csets;
4838 return cset;
4849 struct css_set *cset;
4854 while ((cset = css_task_iter_next_css_set(it))) {
4855 if (!list_empty(&cset->tasks)) {
4856 it->cur_tasks_head = &cset->tasks;
4858 } else if (!list_empty(&cset->mg_tasks)) {
4859 it->cur_tasks_head = &cset->mg_tasks;
4861 } else if (!list_empty(&cset->dying_tasks)) {
4862 it->cur_tasks_head = &cset->dying_tasks;
4866 if (!cset) {
4882 * Tasks may leave @cset across iteration steps. This is resolved
4891 get_css_set(cset);
4892 it->cur_cset = cset;
4893 list_add(&it->iters_node, &cset->task_iters);
4915 * Advance iterator to find next entry. We go through cset
4917 * the next cset.
4935 /* called from start, proceed to the first cset */
6000 link->cset->dead = true;
6477 struct css_set *cset;
6487 cset = task_css_set(current);
6488 get_css_set(cset);
6492 kargs->cset = cset;
6538 ret = cgroup_attach_permissions(cset->dfl_cgrp, dst_cgrp, sb,
6544 kargs->cset = find_css_set(cset, dst_cgrp);
6545 if (!kargs->cset) {
6550 put_css_set(cset);
6562 put_css_set(cset);
6563 if (kargs->cset)
6564 put_css_set(kargs->cset);
6579 struct css_set *cset = kargs->cset;
6583 if (cset) {
6584 put_css_set(cset);
6585 kargs->cset = NULL;
6618 ret = ss->can_fork(child, kargs->cset);
6630 ss->cancel_fork(child, kargs->cset);
6655 ss->cancel_fork(child, kargs->cset);
6675 struct css_set *cset;
6678 cset = kargs->cset;
6679 kargs->cset = NULL;
6688 cgrp_flags = cset->dfl_cgrp->flags;
6691 cset->nr_tasks++;
6692 css_set_move_task(child, NULL, cset, false);
6694 put_css_set(cset);
6695 cset = NULL;
6737 /* Make the new cset the root_cset of the new cgroup namespace. */
6741 get_css_set(cset);
6742 child->nsproxy->cgroup_ns->root_cset = cset;
6763 struct css_set *cset;
6769 cset = task_css_set(tsk);
6770 css_set_move_task(tsk, cset, NULL, false);
6771 cset->nr_tasks--;
6774 list_add_tail(&tsk->cg_list, &cset->dying_tasks);
6811 struct css_set *cset = task_css_set(task);
6812 put_css_set(cset);
7060 struct css_set *cset;
7062 cset = task_css_set(current);
7063 if (likely(cgroup_tryget(cset->dfl_cgrp))) {
7064 cgroup = cset->dfl_cgrp;