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

cgroups: let ss->can_attach and ss->attach do whole threadgroups at a time 



Alter the ss->can_attach and ss->attach functions to be able to deal with
a whole threadgroup at a time, for use in cgroup_attach_proc.  (This is a
pre-patch to cgroup-procs-writable.patch.)

Currently, new mode of the attach function can only tell the subsystem
about the old cgroup of the threadgroup leader.  No subsystem currently
needs that information for each thread that's being moved, but if one were
to be added (for example, one that counts tasks within a group) this bit
would need to be reworked a bit to tell the subsystem the right
information.

[hidave.darkstar@gmail.com: fix build]
Signed-off-by: default avatarBen Blum <bblum@google.com>
Signed-off-by: default avatarPaul Menage <menage@google.com>
Acked-by: default avatarLi Zefan <lizf@cn.fujitsu.com>
Reviewed-by: default avatarMatt Helsley <matthltc@us.ibm.com>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Dave Young <hidave.darkstar@gmail.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent c378369d

Documentation/cgroups/cgroups.txt

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



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

	       struct task_struct *task)

	       struct task_struct *task, bool threadgroup)

(cgroup_mutex held by caller)



Called prior to moving a task into a cgroup; if the subsystem
@@ -529,14 +529,20 @@ returns an error, this will abort the attach operation. If a NULL 
task is passed, then a successful result indicates that *any*

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

remain valid while the caller holds cgroup_mutex.

remain valid while the caller holds cgroup_mutex. If threadgroup is

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

thread's threadgroup can be moved together.



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)



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

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

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



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

include/linux/cgroup.h

+4 −3
Original line number Diff line number Diff line
@@ -425,10 +425,11 @@ struct cgroup_subsys { 
						  struct cgroup *cgrp);

	int (*pre_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, struct task_struct *tsk);

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

			  struct task_struct *tsk, bool threadgroup);

	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 (*exit)(struct cgroup_subsys *ss, struct task_struct *task);

	int (*populate)(struct cgroup_subsys *ss,

kernel/cgroup.c

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


	for_each_subsys(root, ss) {

		if (ss->can_attach) {

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

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

			if (retval)

				return retval;

		}
@@ -1590,7 +1590,7 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) 


	for_each_subsys(root, ss) {

		if (ss->attach)

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

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

	}

	set_bit(CGRP_RELEASABLE, &oldcgrp->flags);

	synchronize_rcu();

kernel/cgroup_freezer.c

+14 −1
Original line number Diff line number Diff line
@@ -159,7 +159,7 @@ static bool is_task_frozen_enough(struct task_struct *task) 
 */

static int freezer_can_attach(struct cgroup_subsys *ss,

			      struct cgroup *new_cgroup,

			      struct task_struct *task)

			      struct task_struct *task, bool threadgroup)

{

	struct freezer *freezer;
@@ -177,6 +177,19 @@ static int freezer_can_attach(struct cgroup_subsys *ss, 
	if (freezer->state == CGROUP_FROZEN)

		return -EBUSY;



	if (threadgroup) {

		struct task_struct *c;



		rcu_read_lock();

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

			if (is_task_frozen_enough(c)) {

				rcu_read_unlock();

				return -EBUSY;

			}

		}

		rcu_read_unlock();

	}



	return 0;

}

kernel/cpuset.c

+52 −14
Original line number Diff line number Diff line
@@ -1324,9 +1324,10 @@ static int fmeter_getrate(struct fmeter *fmp) 
static cpumask_var_t cpus_attach;



/* Called by cgroups to determine if a cpuset is usable; cgroup_mutex held */

static int cpuset_can_attach(struct cgroup_subsys *ss,

			     struct cgroup *cont, struct task_struct *tsk)

static int cpuset_can_attach(struct cgroup_subsys *ss, struct cgroup *cont,

			     struct task_struct *tsk, bool threadgroup)

{

	int ret;

	struct cpuset *cs = cgroup_cs(cont);



	if (cpumask_empty(cs->cpus_allowed) || nodes_empty(cs->mems_allowed))
@@ -1343,18 +1344,51 @@ static int cpuset_can_attach(struct cgroup_subsys *ss, 
	if (tsk->flags & PF_THREAD_BOUND)

		return -EINVAL;



	return security_task_setscheduler(tsk, 0, NULL);

	ret = security_task_setscheduler(tsk, 0, NULL);

	if (ret)

		return ret;

	if (threadgroup) {

		struct task_struct *c;



		rcu_read_lock();

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

			ret = security_task_setscheduler(c, 0, NULL);

			if (ret) {

				rcu_read_unlock();

				return ret;

			}

		}

		rcu_read_unlock();

	}

	return 0;

}



static void cpuset_attach(struct cgroup_subsys *ss,

			  struct cgroup *cont, struct cgroup *oldcont,

			  struct task_struct *tsk)

static void cpuset_attach_task(struct task_struct *tsk, nodemask_t *to,

			       struct cpuset *cs)

{

	int err;

	/*

	 * can_attach beforehand should guarantee that this doesn't fail.

	 * TODO: have a better way to handle failure here

	 */

	err = set_cpus_allowed_ptr(tsk, cpus_attach);

	WARN_ON_ONCE(err);



	task_lock(tsk);

	cpuset_change_task_nodemask(tsk, to);

	task_unlock(tsk);

	cpuset_update_task_spread_flag(cs, tsk);



}



static void cpuset_attach(struct cgroup_subsys *ss, struct cgroup *cont,

			  struct cgroup *oldcont, struct task_struct *tsk,

			  bool threadgroup)

{

	nodemask_t from, to;

	struct mm_struct *mm;

	struct cpuset *cs = cgroup_cs(cont);

	struct cpuset *oldcs = cgroup_cs(oldcont);

	int err;



	if (cs == &top_cpuset) {

		cpumask_copy(cpus_attach, cpu_possible_mask);
@@ -1363,15 +1397,19 @@ static void cpuset_attach(struct cgroup_subsys *ss, 
		guarantee_online_cpus(cs, cpus_attach);

		guarantee_online_mems(cs, &to);

	}

	err = set_cpus_allowed_ptr(tsk, cpus_attach);

	if (err)

		return;



	task_lock(tsk);

	cpuset_change_task_nodemask(tsk, &to);

	task_unlock(tsk);

	cpuset_update_task_spread_flag(cs, tsk);

	/* do per-task migration stuff possibly for each in the threadgroup */

	cpuset_attach_task(tsk, &to, cs);

	if (threadgroup) {

		struct task_struct *c;

		rcu_read_lock();

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

			cpuset_attach_task(c, &to, cs);

		}

		rcu_read_unlock();

	}



	/* change mm; only needs to be done once even if threadgroup */

	from = oldcs->mems_allowed;

	to = cs->mems_allowed;

	mm = get_task_mm(tsk);

CRA Git | Maintained and supported by SUSTech CRA and CCSE