Commit af0ba678 authored by Tejun Heo's avatar Tejun Heo
Browse files

cgroup: implement cgroup_subsys->depends_on 



Currently, the blkio subsystem attributes all of writeback IOs to the
root.  One of the issues is that there's no way to tell who originated
a writeback IO from block layer.  Those IOs are usually issued
asynchronously from a task which didn't have anything to do with
actually generating the dirty pages.  The memory subsystem, when
enabled, already keeps track of the ownership of each dirty page and
it's desirable for blkio to piggyback instead of adding its own
per-page tag.

blkio piggybacking on memory is an implementation detail which
preferably should be handled automatically without requiring explicit
userland action.  To achieve that, this patch implements
cgroup_subsys->depends_on which contains the mask of subsystems which
should be enabled together when the subsystem is enabled.

The previous patches already implemented the support for enabled but
invisible subsystems and cgroup_subsys->depends_on can be easily
implemented by updating cgroup_refresh_child_subsys_mask() so that it
calculates cgroup->child_subsys_mask considering
cgroup_subsys->depends_on of the explicitly enabled subsystems.

Documentation/cgroups/unified-hierarchy.txt is updated to explain that
subsystems may not become immediately available after being unused
from userland and that dependency could be a factor in it.  As
subsystems may already keep residual references, this doesn't
significantly change how subsystem rebinding can be used.

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
Acked-by: default avatarLi Zefan <lizefan@huawei.com>
Acked-by: default avatarJohannes Weiner <hannes@cmpxchg.org>
parent b4536f0c

Documentation/cgroups/unified-hierarchy.txt

+20 −3
Original line number Diff line number Diff line
@@ -97,9 +97,26 @@ change soon. 
All controllers which are not bound to other hierarchies are

automatically bound to unified hierarchy and show up at the root of

it.  Controllers which are enabled only in the root of unified

hierarchy can be bound to other hierarchies at any time.  This allows

mixing unified hierarchy with the traditional multiple hierarchies in

a fully backward compatible way.

hierarchy can be bound to other hierarchies.  This allows mixing

unified hierarchy with the traditional multiple hierarchies in a fully

backward compatible way.



A controller can be moved across hierarchies only after the controller

is no longer referenced in its current hierarchy.  Because per-cgroup

controller states are destroyed asynchronously and controllers may

have lingering references, a controller may not show up immediately on

the unified hierarchy after the final umount of the previous

hierarchy.  Similarly, a controller should be fully disabled to be

moved out of the unified hierarchy and it may take some time for the

disabled controller to become available for other hierarchies;

furthermore, due to dependencies among controllers, other controllers

may need to be disabled too.



While useful for development and manual configurations, dynamically

moving controllers between the unified and other hierarchies is

strongly discouraged for production use.  It is recommended to decide

the hierarchies and controller associations before starting using the

controllers.





2-2. cgroup.subtree_control

include/linux/cgroup.h

+9 −0
Original line number Diff line number Diff line
@@ -693,6 +693,15 @@ struct cgroup_subsys { 


	/* base cftypes, automatically registered with subsys itself */

	struct cftype *base_cftypes;



	/*

	 * A subsystem may depend on other subsystems.  When such subsystem

	 * is enabled on a cgroup, the depended-upon subsystems are enabled

	 * together if available.  Subsystems enabled due to dependency are

	 * not visible to userland until explicitly enabled.  The following

	 * specifies the mask of subsystems that this one depends on.

	 */

	unsigned int depends_on;

};



#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;

kernel/cgroup.c

+48 −1
Original line number Diff line number Diff line
@@ -1037,9 +1037,56 @@ static void cgroup_put(struct cgroup *cgrp) 
	css_put(&cgrp->self);

}



/**

 * cgroup_refresh_child_subsys_mask - update child_subsys_mask

 * @cgrp: the target cgroup

 *

 * On the default hierarchy, a subsystem may request other subsystems to be

 * enabled together through its ->depends_on mask.  In such cases, more

 * subsystems than specified in "cgroup.subtree_control" may be enabled.

 *

 * This function determines which subsystems need to be enabled given the

 * current @cgrp->subtree_control and records it in

 * @cgrp->child_subsys_mask.  The resulting mask is always a superset of

 * @cgrp->subtree_control and follows the usual hierarchy rules.

 */

static void cgroup_refresh_child_subsys_mask(struct cgroup *cgrp)

{

	cgrp->child_subsys_mask = cgrp->subtree_control;

	struct cgroup *parent = cgroup_parent(cgrp);

	unsigned int cur_ss_mask = cgrp->subtree_control;

	struct cgroup_subsys *ss;

	int ssid;



	lockdep_assert_held(&cgroup_mutex);



	if (!cgroup_on_dfl(cgrp)) {

		cgrp->child_subsys_mask = cur_ss_mask;

		return;

	}



	while (true) {

		unsigned int new_ss_mask = cur_ss_mask;



		for_each_subsys(ss, ssid)

			if (cur_ss_mask & (1 << ssid))

				new_ss_mask |= ss->depends_on;



		/*

		 * Mask out subsystems which aren't available.  This can

		 * happen only if some depended-upon subsystems were bound

		 * to non-default hierarchies.

		 */

		if (parent)

			new_ss_mask &= parent->child_subsys_mask;

		else

			new_ss_mask &= cgrp->root->subsys_mask;



		if (new_ss_mask == cur_ss_mask)

			break;

		cur_ss_mask = new_ss_mask;

	}



	cgrp->child_subsys_mask = cur_ss_mask;

}



/**

CRA Git | Maintained and supported by SUSTech CRA and CCSE