Commit f780bdb7 authored by Ben Blum's avatar Ben Blum Committed by Linus Torvalds
Browse files

cgroups: add per-thread subsystem callbacks 



Add cgroup subsystem callbacks for per-thread attachment in atomic contexts

Add can_attach_task(), pre_attach(), and attach_task() as new callbacks
for cgroups's subsystem interface.  Unlike can_attach and attach, these
are for per-thread operations, to be called potentially many times when
attaching an entire threadgroup.

Also, the old "bool threadgroup" interface is removed, as replaced by
this.  All subsystems are modified for the new interface - of note is
cpuset, which requires from/to nodemasks for attach to be globally scoped
(though per-cpuset would work too) to persist from its pre_attach to
attach_task and attach.

This is a pre-patch for cgroup-procs-writable.patch.

Signed-off-by: default avatarBen Blum <bblum@andrew.cmu.edu>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Matt Helsley <matthltc@us.ibm.com>
Reviewed-by: default avatarPaul Menage <menage@google.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 4714d1d3

Documentation/cgroups/cgroups.txt

+22 −8
Original line number Original line Diff line number Diff line
@@ -575,7 +575,7 @@ rmdir() will fail with it. From this behavior, pre_destroy() can be 
called multiple times against a cgroup.

called multiple times against a cgroup.





int can_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,

int can_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,

	       struct task_struct *task, bool threadgroup)

	       struct task_struct *task)

(cgroup_mutex held by caller)

(cgroup_mutex held by caller)





Called prior to moving a task into a cgroup; if the subsystem

Called prior to moving a task into a cgroup; if the subsystem
@@ -584,9 +584,14 @@ task is passed, then a successful result indicates that *any* 
unspecified task can be moved into the cgroup. Note that this isn't

unspecified task can be moved into the cgroup. Note that this isn't

called on a fork. If this method returns 0 (success) then this should

called on a fork. If this method returns 0 (success) then this should

remain valid while the caller holds cgroup_mutex and it is ensured that either

remain valid while the caller holds cgroup_mutex and it is ensured that either

attach() or cancel_attach() will be called in future. If threadgroup is

attach() or cancel_attach() will be called in future.

true, then a successful result indicates that all threads in the given



thread's threadgroup can be moved together.

int can_attach_task(struct cgroup *cgrp, struct task_struct *tsk);

(cgroup_mutex held by caller)



As can_attach, but for operations that must be run once per task to be

attached (possibly many when using cgroup_attach_proc). Called after

can_attach.





void cancel_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,

void cancel_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,

	       struct task_struct *task, bool threadgroup)

	       struct task_struct *task, bool threadgroup)
@@ -598,15 +603,24 @@ function, so that the subsystem can implement a rollback. If not, not necessary. 
This will be called only about subsystems whose can_attach() operation have

This will be called only about subsystems whose can_attach() operation have

succeeded.

succeeded.





void pre_attach(struct cgroup *cgrp);

(cgroup_mutex held by caller)



For any non-per-thread attachment work that needs to happen before

attach_task. Needed by cpuset.



void attach(struct cgroup_subsys *ss, struct cgroup *cgrp,

void attach(struct cgroup_subsys *ss, struct cgroup *cgrp,

	    struct cgroup *old_cgrp, struct task_struct *task,

	    struct cgroup *old_cgrp, struct task_struct *task)

	    bool threadgroup)

(cgroup_mutex held by caller)

(cgroup_mutex held by caller)





Called after the task has been attached to the cgroup, to allow any

Called after the task has been attached to the cgroup, to allow any

post-attachment activity that requires memory allocations or blocking.

post-attachment activity that requires memory allocations or blocking.

If threadgroup is true, the subsystem should take care of all threads



in the specified thread's threadgroup. Currently does not support any

void attach_task(struct cgroup *cgrp, struct task_struct *tsk);

(cgroup_mutex held by caller)



As attach, but for operations that must be run once per task to be attached,

like can_attach_task. Called before attach. Currently does not support any

subsystem that might need the old_cgrp for every thread in the group.

subsystem that might need the old_cgrp for every thread in the group.





void fork(struct cgroup_subsy *ss, struct task_struct *task)

void fork(struct cgroup_subsy *ss, struct task_struct *task)

block/blk-cgroup.c

+6 −12
Original line number Original line Diff line number Diff line
@@ -30,10 +30,8 @@ EXPORT_SYMBOL_GPL(blkio_root_cgroup); 




static struct cgroup_subsys_state *blkiocg_create(struct cgroup_subsys *,

static struct cgroup_subsys_state *blkiocg_create(struct cgroup_subsys *,

						  struct cgroup *);

						  struct cgroup *);

static int blkiocg_can_attach(struct cgroup_subsys *, struct cgroup *,

static int blkiocg_can_attach_task(struct cgroup *, struct task_struct *);

			      struct task_struct *, bool);

static void blkiocg_attach_task(struct cgroup *, struct task_struct *);

static void blkiocg_attach(struct cgroup_subsys *, struct cgroup *,

			   struct cgroup *, struct task_struct *, bool);

static void blkiocg_destroy(struct cgroup_subsys *, struct cgroup *);

static void blkiocg_destroy(struct cgroup_subsys *, struct cgroup *);

static int blkiocg_populate(struct cgroup_subsys *, struct cgroup *);

static int blkiocg_populate(struct cgroup_subsys *, struct cgroup *);
@@ -46,8 +44,8 @@ static int blkiocg_populate(struct cgroup_subsys *, struct cgroup *); 
struct cgroup_subsys blkio_subsys = {

struct cgroup_subsys blkio_subsys = {

	.name = "blkio",

	.name = "blkio",

	.create = blkiocg_create,

	.create = blkiocg_create,

	.can_attach = blkiocg_can_attach,

	.can_attach_task = blkiocg_can_attach_task,

	.attach = blkiocg_attach,

	.attach_task = blkiocg_attach_task,

	.destroy = blkiocg_destroy,

	.destroy = blkiocg_destroy,

	.populate = blkiocg_populate,

	.populate = blkiocg_populate,

#ifdef CONFIG_BLK_CGROUP

#ifdef CONFIG_BLK_CGROUP
@@ -1616,9 +1614,7 @@ done: 
 * of the main cic data structures.  For now we allow a task to change

 * of the main cic data structures.  For now we allow a task to change

 * its cgroup only if it's the only owner of its ioc.

 * its cgroup only if it's the only owner of its ioc.

 */

 */

static int blkiocg_can_attach(struct cgroup_subsys *subsys,

static int blkiocg_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk)

				struct cgroup *cgroup, struct task_struct *tsk,

				bool threadgroup)

{

{

	struct io_context *ioc;

	struct io_context *ioc;

	int ret = 0;

	int ret = 0;
@@ -1633,9 +1629,7 @@ static int blkiocg_can_attach(struct cgroup_subsys *subsys, 
	return ret;

	return ret;

}

}





static void blkiocg_attach(struct cgroup_subsys *subsys, struct cgroup *cgroup,

static void blkiocg_attach_task(struct cgroup *cgrp, struct task_struct *tsk)

				struct cgroup *prev, struct task_struct *tsk,

				bool threadgroup)

{

{

	struct io_context *ioc;

	struct io_context *ioc;

include/linux/cgroup.h

+6 −4
Original line number Original line Diff line number Diff line
@@ -467,12 +467,14 @@ struct cgroup_subsys { 
	int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);

	int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);

	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);

	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);

	int (*can_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,

	int (*can_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,

			  struct task_struct *tsk, bool threadgroup);

			  struct task_struct *tsk);

	int (*can_attach_task)(struct cgroup *cgrp, struct task_struct *tsk);

	void (*cancel_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,

	void (*cancel_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,

			  struct task_struct *tsk, bool threadgroup);

			      struct task_struct *tsk);

	void (*pre_attach)(struct cgroup *cgrp);

	void (*attach_task)(struct cgroup *cgrp, struct task_struct *tsk);

	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,

	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,

			struct cgroup *old_cgrp, struct task_struct *tsk,

		       struct cgroup *old_cgrp, struct task_struct *tsk);

			bool threadgroup);

	void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);

	void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);

	void (*exit)(struct cgroup_subsys *ss, struct cgroup *cgrp,

	void (*exit)(struct cgroup_subsys *ss, struct cgroup *cgrp,

			struct cgroup *old_cgrp, struct task_struct *task);

			struct cgroup *old_cgrp, struct task_struct *task);

kernel/cgroup.c

+14 −3
Original line number Original line Diff line number Diff line
@@ -1759,7 +1759,7 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) 




	for_each_subsys(root, ss) {

	for_each_subsys(root, ss) {

		if (ss->can_attach) {

		if (ss->can_attach) {

			retval = ss->can_attach(ss, cgrp, tsk, false);

			retval = ss->can_attach(ss, cgrp, tsk);

			if (retval) {

			if (retval) {

				/*

				/*

				 * Remember on which subsystem the can_attach()

				 * Remember on which subsystem the can_attach()
@@ -1771,6 +1771,13 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) 
				goto out;

				goto out;

			}

			}

		}

		}

		if (ss->can_attach_task) {

			retval = ss->can_attach_task(cgrp, tsk);

			if (retval) {

				failed_ss = ss;

				goto out;

			}

		}

	}

	}





	task_lock(tsk);

	task_lock(tsk);
@@ -1805,8 +1812,12 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) 
	write_unlock(&css_set_lock);

	write_unlock(&css_set_lock);





	for_each_subsys(root, ss) {

	for_each_subsys(root, ss) {

		if (ss->pre_attach)

			ss->pre_attach(cgrp);

		if (ss->attach_task)

			ss->attach_task(cgrp, tsk);

		if (ss->attach)

		if (ss->attach)

			ss->attach(ss, cgrp, oldcgrp, tsk, false);

			ss->attach(ss, cgrp, oldcgrp, tsk);

	}

	}

	set_bit(CGRP_RELEASABLE, &oldcgrp->flags);

	set_bit(CGRP_RELEASABLE, &oldcgrp->flags);

	synchronize_rcu();

	synchronize_rcu();
@@ -1829,7 +1840,7 @@ out: 
				 */

				 */

				break;

				break;

			if (ss->cancel_attach)

			if (ss->cancel_attach)

				ss->cancel_attach(ss, cgrp, tsk, false);

				ss->cancel_attach(ss, cgrp, tsk);

		}

		}

	}

	}

	return retval;

	return retval;

kernel/cgroup_freezer.c

+10 −16
Original line number Original line Diff line number Diff line
@@ -160,7 +160,7 @@ static void freezer_destroy(struct cgroup_subsys *ss, 
 */

 */

static int freezer_can_attach(struct cgroup_subsys *ss,

static int freezer_can_attach(struct cgroup_subsys *ss,

			      struct cgroup *new_cgroup,

			      struct cgroup *new_cgroup,

			      struct task_struct *task, bool threadgroup)

			      struct task_struct *task)

{

{

	struct freezer *freezer;

	struct freezer *freezer;
@@ -172,26 +172,17 @@ static int freezer_can_attach(struct cgroup_subsys *ss, 
	if (freezer->state != CGROUP_THAWED)

	if (freezer->state != CGROUP_THAWED)

		return -EBUSY;

		return -EBUSY;





	rcu_read_lock();

	return 0;

	if (__cgroup_freezing_or_frozen(task)) {

		rcu_read_unlock();

		return -EBUSY;

}

}

	rcu_read_unlock();



	if (threadgroup) {

		struct task_struct *c;





static int freezer_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk)

{

	rcu_read_lock();

	rcu_read_lock();

		list_for_each_entry_rcu(c, &task->thread_group, thread_group) {

	if (__cgroup_freezing_or_frozen(tsk)) {

			if (__cgroup_freezing_or_frozen(c)) {

		rcu_read_unlock();

		rcu_read_unlock();

		return -EBUSY;

		return -EBUSY;

	}

	}

		}

	rcu_read_unlock();

	rcu_read_unlock();

	}



	return 0;

	return 0;

}

}
@@ -390,6 +381,9 @@ struct cgroup_subsys freezer_subsys = { 
	.populate	= freezer_populate,

	.populate	= freezer_populate,

	.subsys_id	= freezer_subsys_id,

	.subsys_id	= freezer_subsys_id,

	.can_attach	= freezer_can_attach,

	.can_attach	= freezer_can_attach,

	.can_attach_task = freezer_can_attach_task,

	.pre_attach	= NULL,

	.attach_task	= NULL,

	.attach		= NULL,

	.attach		= NULL,

	.fork		= freezer_fork,

	.fork		= freezer_fork,

	.exit		= NULL,

	.exit		= NULL,

CRA Git | Maintained and supported by SUSTech CRA and CCSE