cgroup: implement cgroup_subsys->implicit_on_dfl

Some controllers, perf_event for now and possibly freezer in the
future, don't really make sense to control explicitly through
"cgroup.subtree_control".  For example, the primary role of perf_event
is identifying the cgroups of tasks; however, because the controller
also keeps a small amount of state per cgroup, it can't be replaced
with simple cgroup membership tests.

This patch implements cgroup_subsys->implicit_on_dfl flag.  When set,
the controller is implicitly enabled on all cgroups on the v2
hierarchy so that utility type controllers such as perf_event can be
enabled and function transparently.

An implicit controller doesn't show up in "cgroup.controllers" or
"cgroup.subtree_control", is exempt from no internal process rule and
can be stolen from the default hierarchy even if there are non-root
csses.

v2: Reimplemented on top of the recent updates to css handling and
    subsystem rebinding.  Rebinding implicit subsystems is now a
    simple matter of exempting it from the busy subsystem check.

Signed-off-by: Tejun Heo <tj@kernel.org>

diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
index 590291d56049cf1408177cb370e748ba15f49d75..34b42f03fcd88c1c4c6137ad44f0795c971e3826 100644 (file)
--- a/include/linux/cgroup-defs.h
+++ b/include/linux/cgroup-defs.h
@@ -450,6 +450,19 @@ struct cgroup_subsys {
 
        bool early_init:1;
 
+       /*
+        * If %true, the controller, on the default hierarchy, doesn't show
+        * up in "cgroup.controllers" or "cgroup.subtree_control", is
+        * implicitly enabled on all cgroups on the default hierarchy, and
+        * bypasses the "no internal process" constraint.  This is for
+        * utility type controllers which is transparent to userland.
+        *
+        * An implicit controller can be stolen from the default hierarchy
+        * anytime and thus must be okay with offline csses from previous
+        * hierarchies coexisting with csses for the current one.
+        */
+       bool implicit_on_dfl:1;
+
        /*
         * If %false, this subsystem is properly hierarchical -
         * configuration, resource accounting and restriction on a parent

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index fbd3e99a4e981d1560ed8e1e66bed3b68933c276..e22df5d81e599f2e94bad9d30bbcdb5058faf460 100644 (file)
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -186,6 +186,9 @@ static u16 cgroup_no_v1_mask;
 /* some controllers are not supported in the default hierarchy */
 static u16 cgrp_dfl_inhibit_ss_mask;
 
+/* some controllers are implicitly enabled on the default hierarchy */
+static unsigned long cgrp_dfl_implicit_ss_mask;
+
 /* The list of hierarchy roots */
 
 static LIST_HEAD(cgroup_roots);
@@ -359,8 +362,8 @@ static u16 cgroup_control(struct cgroup *cgrp)
                return parent->subtree_control;
 
        if (cgroup_on_dfl(cgrp))
-               root_ss_mask &= ~cgrp_dfl_inhibit_ss_mask;
-
+               root_ss_mask &= ~(cgrp_dfl_inhibit_ss_mask |
+                                 cgrp_dfl_implicit_ss_mask);
        return root_ss_mask;
 }
 
@@ -1327,6 +1330,8 @@ static u16 cgroup_calc_subtree_ss_mask(u16 subtree_control, u16 this_ss_mask)
 
        lockdep_assert_held(&cgroup_mutex);
 
+       cur_ss_mask |= cgrp_dfl_implicit_ss_mask;
+
        while (true) {
                u16 new_ss_mask = cur_ss_mask;
 
@@ -1512,8 +1517,13 @@ static int rebind_subsystems(struct cgroup_root *dst_root, u16 ss_mask)
        lockdep_assert_held(&cgroup_mutex);
 
        do_each_subsys_mask(ss, ssid, ss_mask) {
-               /* if @ss has non-root csses attached to it, can't move */
-               if (css_next_child(NULL, cgroup_css(&ss->root->cgrp, ss)))
+               /*
+                * If @ss has non-root csses attached to it, can't move.
+                * If @ss is an implicit controller, it is exempt from this
+                * rule and can be stolen.
+                */
+               if (css_next_child(NULL, cgroup_css(&ss->root->cgrp, ss)) &&
+                   !ss->implicit_on_dfl)
                        return -EBUSY;
 
                /* can't move between two non-dummy roots either */
@@ -3039,6 +3049,18 @@ static void cgroup_restore_control(struct cgroup *cgrp)
        }
 }
 
+static bool css_visible(struct cgroup_subsys_state *css)
+{
+       struct cgroup_subsys *ss = css->ss;
+       struct cgroup *cgrp = css->cgroup;
+
+       if (cgroup_control(cgrp) & (1 << ss->id))
+               return true;
+       if (!(cgroup_ss_mask(cgrp) & (1 << ss->id)))
+               return false;
+       return cgroup_on_dfl(cgrp) && ss->implicit_on_dfl;
+}
+
 /**
  * cgroup_apply_control_enable - enable or show csses according to control
  * @cgrp: root of the target subtree
@@ -3074,7 +3096,7 @@ static int cgroup_apply_control_enable(struct cgroup *cgrp)
                                        return PTR_ERR(css);
                        }
 
-                       if (cgroup_control(dsct) & (1 << ss->id)) {
+                       if (css_visible(css)) {
                                ret = css_populate_dir(css);
                                if (ret)
                                        return ret;
@@ -3117,7 +3139,7 @@ static void cgroup_apply_control_disable(struct cgroup *cgrp)
                        if (css->parent &&
                            !(cgroup_ss_mask(dsct) & (1 << ss->id))) {
                                kill_css(css);
-                       } else if (!(cgroup_control(dsct) & (1 << ss->id))) {
+                       } else if (!css_visible(css)) {
                                css_clear_dir(css);
                                if (ss->css_reset)
                                        ss->css_reset(css);
@@ -5455,7 +5477,9 @@ int __init cgroup_init(void)
 
                cgrp_dfl_root.subsys_mask |= 1 << ss->id;
 
-               if (!ss->dfl_cftypes)
+               if (ss->implicit_on_dfl)
+                       cgrp_dfl_implicit_ss_mask |= 1 << ss->id;
+               else if (!ss->dfl_cftypes)
                        cgrp_dfl_inhibit_ss_mask |= 1 << ss->id;
 
                if (ss->dfl_cftypes == ss->legacy_cftypes) {