From: Ben Blum <bblum-OM76b2Iv3yLQjUSlxSEPGw@public.gmane.org> To: Ben Blum <bblum-OM76b2Iv3yLQjUSlxSEPGw@public.gmane.org> Cc: containers-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, oleg-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org, Miao Xie <miaox-BthXqXjhjHXQFUHtdCDX3A@public.gmane.org>, David Rientjes <rientjes-hpIqsD4AKlfQT0dZR+AlfA@public.gmane.org>, akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org, menage-hpIqsD4AKlfQT0dZR+AlfA@public.gmane.org, ebiederm-aS9lmoZGLiVWk0Htik3J/w@public.gmane.org Subject: [PATCH v8 2/3] cgroups: add per-thread subsystem callbacks Date: Mon, 7 Feb 2011 20:39:15 -0500 [thread overview] Message-ID: <20110208013915.GE31569@ghc17.ghc.andrew.cmu.edu> (raw) In-Reply-To: <20110208013542.GC31569-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> Add cgroup subsystem callbacks for per-thread attachment From: Ben Blum <bblum-OM76b2Iv3yLQjUSlxSEPGw@public.gmane.org> This patch adds 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: Ben Blum <bblum-OM76b2Iv3yLQjUSlxSEPGw@public.gmane.org> --- Documentation/cgroups/cgroups.txt | 30 ++++++++--- block/blk-cgroup.c | 18 ++---- include/linux/cgroup.h | 10 ++-- kernel/cgroup.c | 17 +++++- kernel/cgroup_freezer.c | 26 ++++----- kernel/cpuset.c | 105 ++++++++++++++++--------------------- kernel/ns_cgroup.c | 23 +++----- kernel/sched.c | 38 +------------ mm/memcontrol.c | 18 ++---- security/device_cgroup.c | 3 - 10 files changed, 122 insertions(+), 166 deletions(-) diff --git a/Documentation/cgroups/cgroups.txt b/Documentation/cgroups/cgroups.txt index 190018b..d3c9a24 100644 --- a/Documentation/cgroups/cgroups.txt +++ b/Documentation/cgroups/cgroups.txt @@ -563,7 +563,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, bool threadgroup) + struct task_struct *task) (cgroup_mutex held by caller) Called prior to moving a task into a cgroup; if the subsystem @@ -572,9 +572,14 @@ 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 and it is ensured that either -attach() or cancel_attach() will be called in future. If threadgroup is -true, then a successful result indicates that all threads in the given -thread's threadgroup can be moved together. +attach() or cancel_attach() will be called in future. + +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, struct task_struct *task, bool threadgroup) @@ -586,15 +591,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 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, - struct cgroup *old_cgrp, struct task_struct *task, - bool threadgroup) + struct cgroup *old_cgrp, struct task_struct *task) (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 + +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. void fork(struct cgroup_subsy *ss, struct task_struct *task) diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c index b1febd0..45b3809 100644 --- a/block/blk-cgroup.c +++ b/block/blk-cgroup.c @@ -30,10 +30,8 @@ EXPORT_SYMBOL_GPL(blkio_root_cgroup); static struct cgroup_subsys_state *blkiocg_create(struct cgroup_subsys *, struct cgroup *); -static int blkiocg_can_attach(struct cgroup_subsys *, struct cgroup *, - struct task_struct *, bool); -static void blkiocg_attach(struct cgroup_subsys *, struct cgroup *, - struct cgroup *, struct task_struct *, bool); +static int blkiocg_can_attach_task(struct cgroup *, struct task_struct *); +static void blkiocg_attach_task(struct cgroup *, struct task_struct *); static void blkiocg_destroy(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 = { .name = "blkio", .create = blkiocg_create, - .can_attach = blkiocg_can_attach, - .attach = blkiocg_attach, + .can_attach_task = blkiocg_can_attach_task, + .attach_task = blkiocg_attach_task, .destroy = blkiocg_destroy, .populate = blkiocg_populate, #ifdef CONFIG_BLK_CGROUP @@ -1475,9 +1473,7 @@ done: * 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. */ -static int blkiocg_can_attach(struct cgroup_subsys *subsys, - struct cgroup *cgroup, struct task_struct *tsk, - bool threadgroup) +static int blkiocg_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk) { struct io_context *ioc; int ret = 0; @@ -1492,9 +1488,7 @@ static int blkiocg_can_attach(struct cgroup_subsys *subsys, return ret; } -static void blkiocg_attach(struct cgroup_subsys *subsys, struct cgroup *cgroup, - struct cgroup *prev, struct task_struct *tsk, - bool threadgroup) +static void blkiocg_attach_task(struct cgroup *cgrp, struct task_struct *tsk) { struct io_context *ioc; diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h index ce104e3..35b69b4 100644 --- a/include/linux/cgroup.h +++ b/include/linux/cgroup.h @@ -467,12 +467,14 @@ struct cgroup_subsys { 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, 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, - 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, - struct cgroup *old_cgrp, struct task_struct *tsk, - bool threadgroup); + struct cgroup *old_cgrp, struct task_struct *tsk); 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, diff --git a/kernel/cgroup.c b/kernel/cgroup.c index 66a416b..616f27a 100644 --- a/kernel/cgroup.c +++ b/kernel/cgroup.c @@ -1750,7 +1750,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, false); + retval = ss->can_attach(ss, cgrp, tsk); if (retval) { /* * Remember on which subsystem the can_attach() @@ -1762,6 +1762,13 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) goto out; } } + if (ss->can_attach_task) { + retval = ss->can_attach_task(cgrp, tsk); + if (retval) { + failed_ss = ss; + goto out; + } + } } task_lock(tsk); @@ -1798,8 +1805,12 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) write_unlock(&css_set_lock); 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) - ss->attach(ss, cgrp, oldcgrp, tsk, false); + ss->attach(ss, cgrp, oldcgrp, tsk); } set_bit(CGRP_RELEASABLE, &oldcgrp->flags); synchronize_rcu(); @@ -1822,7 +1833,7 @@ out: */ break; if (ss->cancel_attach) - ss->cancel_attach(ss, cgrp, tsk, false); + ss->cancel_attach(ss, cgrp, tsk); } } return retval; diff --git a/kernel/cgroup_freezer.c b/kernel/cgroup_freezer.c index e7bebb7..e691818 100644 --- a/kernel/cgroup_freezer.c +++ b/kernel/cgroup_freezer.c @@ -160,7 +160,7 @@ static void freezer_destroy(struct cgroup_subsys *ss, */ static int freezer_can_attach(struct cgroup_subsys *ss, struct cgroup *new_cgroup, - struct task_struct *task, bool threadgroup) + struct task_struct *task) { struct freezer *freezer; @@ -172,26 +172,17 @@ static int freezer_can_attach(struct cgroup_subsys *ss, if (freezer->state != CGROUP_THAWED) return -EBUSY; + return 0; +} + +static int freezer_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk) +{ rcu_read_lock(); - if (__cgroup_freezing_or_frozen(task)) { + if (__cgroup_freezing_or_frozen(tsk)) { rcu_read_unlock(); return -EBUSY; } rcu_read_unlock(); - - if (threadgroup) { - struct task_struct *c; - - rcu_read_lock(); - list_for_each_entry_rcu(c, &task->thread_group, thread_group) { - if (__cgroup_freezing_or_frozen(c)) { - rcu_read_unlock(); - return -EBUSY; - } - } - rcu_read_unlock(); - } - return 0; } @@ -390,6 +381,9 @@ struct cgroup_subsys freezer_subsys = { .populate = freezer_populate, .subsys_id = freezer_subsys_id, .can_attach = freezer_can_attach, + .can_attach_task = freezer_can_attach_task, + .pre_attach = NULL, + .attach_task = NULL, .attach = NULL, .fork = freezer_fork, .exit = NULL, diff --git a/kernel/cpuset.c b/kernel/cpuset.c index 4349935..5f71ca2 100644 --- a/kernel/cpuset.c +++ b/kernel/cpuset.c @@ -1372,14 +1372,10 @@ static int fmeter_getrate(struct fmeter *fmp) return val; } -/* Protected by cgroup_lock */ -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, bool threadgroup) + struct task_struct *tsk) { - int ret; struct cpuset *cs = cgroup_cs(cont); if (cpumask_empty(cs->cpus_allowed) || nodes_empty(cs->mems_allowed)) @@ -1396,29 +1392,42 @@ static int cpuset_can_attach(struct cgroup_subsys *ss, struct cgroup *cont, if (tsk->flags & PF_THREAD_BOUND) return -EINVAL; - ret = security_task_setscheduler(tsk); - 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); - if (ret) { - rcu_read_unlock(); - return ret; - } - } - rcu_read_unlock(); - } return 0; } -static void cpuset_attach_task(struct task_struct *tsk, nodemask_t *to, - struct cpuset *cs) +static int cpuset_can_attach_task(struct cgroup *cgrp, struct task_struct *task) +{ + return security_task_setscheduler(task); +} + +/* + * Protected by cgroup_lock. The nodemasks must be stored globally because + * dynamically allocating them is not allowed in pre_attach, and they must + * persist among pre_attach, attach_task, and attach. + */ +static cpumask_var_t cpus_attach; +static nodemask_t cpuset_attach_nodemask_from; +static nodemask_t cpuset_attach_nodemask_to; + +/* Set-up work for before attaching each task. */ +static void cpuset_pre_attach(struct cgroup *cont) +{ + struct cpuset *cs = cgroup_cs(cont); + + if (cs == &top_cpuset) + cpumask_copy(cpus_attach, cpu_possible_mask); + else + guarantee_online_cpus(cs, cpus_attach); + + guarantee_online_mems(cs, &cpuset_attach_nodemask_to); +} + +/* Per-thread attachment work. */ +static void cpuset_attach_task(struct cgroup *cont, struct task_struct *tsk) { int err; + struct cpuset *cs = cgroup_cs(cont); + /* * can_attach beforehand should guarantee that this doesn't fail. * TODO: have a better way to handle failure here @@ -1426,56 +1435,31 @@ static void cpuset_attach_task(struct task_struct *tsk, nodemask_t *to, err = set_cpus_allowed_ptr(tsk, cpus_attach); WARN_ON_ONCE(err); - cpuset_change_task_nodemask(tsk, to); + cpuset_change_task_nodemask(tsk, &cpuset_attach_nodemask_to); 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) + struct cgroup *oldcont, struct task_struct *tsk) { struct mm_struct *mm; struct cpuset *cs = cgroup_cs(cont); struct cpuset *oldcs = cgroup_cs(oldcont); - NODEMASK_ALLOC(nodemask_t, from, GFP_KERNEL); - NODEMASK_ALLOC(nodemask_t, to, GFP_KERNEL); - - if (from == NULL || to == NULL) - goto alloc_fail; - if (cs == &top_cpuset) { - cpumask_copy(cpus_attach, cpu_possible_mask); - } else { - guarantee_online_cpus(cs, cpus_attach); - } - guarantee_online_mems(cs, to); - - /* 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; + /* + * Change mm, possibly for multiple threads in a threadgroup. This is + * expensive and may sleep. + */ + cpuset_attach_nodemask_from = oldcs->mems_allowed; + cpuset_attach_nodemask_to = cs->mems_allowed; mm = get_task_mm(tsk); if (mm) { - mpol_rebind_mm(mm, to); + mpol_rebind_mm(mm, &cpuset_attach_nodemask_to); if (is_memory_migrate(cs)) - cpuset_migrate_mm(mm, from, to); + cpuset_migrate_mm(mm, &cpuset_attach_nodemask_from, + &cpuset_attach_nodemask_to); mmput(mm); } - -alloc_fail: - NODEMASK_FREE(from); - NODEMASK_FREE(to); } /* The various types of files and directories in a cpuset file system */ @@ -1928,6 +1912,9 @@ struct cgroup_subsys cpuset_subsys = { .create = cpuset_create, .destroy = cpuset_destroy, .can_attach = cpuset_can_attach, + .can_attach_task = cpuset_can_attach_task, + .pre_attach = cpuset_pre_attach, + .attach_task = cpuset_attach_task, .attach = cpuset_attach, .populate = cpuset_populate, .post_clone = cpuset_post_clone, diff --git a/kernel/ns_cgroup.c b/kernel/ns_cgroup.c index 2c98ad9..1fc2b1b 100644 --- a/kernel/ns_cgroup.c +++ b/kernel/ns_cgroup.c @@ -43,7 +43,7 @@ int ns_cgroup_clone(struct task_struct *task, struct pid *pid) * ancestor cgroup thereof) */ static int ns_can_attach(struct cgroup_subsys *ss, struct cgroup *new_cgroup, - struct task_struct *task, bool threadgroup) + struct task_struct *task) { if (current != task) { if (!capable(CAP_SYS_ADMIN)) @@ -53,21 +53,13 @@ static int ns_can_attach(struct cgroup_subsys *ss, struct cgroup *new_cgroup, return -EPERM; } - if (!cgroup_is_descendant(new_cgroup, task)) - return -EPERM; - - if (threadgroup) { - struct task_struct *c; - rcu_read_lock(); - list_for_each_entry_rcu(c, &task->thread_group, thread_group) { - if (!cgroup_is_descendant(new_cgroup, c)) { - rcu_read_unlock(); - return -EPERM; - } - } - rcu_read_unlock(); - } + return 0; +} +static int ns_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk) +{ + if (!cgroup_is_descendant(cgrp, tsk)) + return -EPERM; return 0; } @@ -112,6 +104,7 @@ static void ns_destroy(struct cgroup_subsys *ss, struct cgroup_subsys ns_subsys = { .name = "ns", .can_attach = ns_can_attach, + .can_attach_task = ns_can_attach_task, .create = ns_create, .destroy = ns_destroy, .subsys_id = ns_subsys_id, diff --git a/kernel/sched.c b/kernel/sched.c index 218ef20..d619f1d 100644 --- a/kernel/sched.c +++ b/kernel/sched.c @@ -8655,42 +8655,10 @@ cpu_cgroup_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk) return 0; } -static int -cpu_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgrp, - struct task_struct *tsk, bool threadgroup) -{ - int retval = cpu_cgroup_can_attach_task(cgrp, tsk); - if (retval) - return retval; - if (threadgroup) { - struct task_struct *c; - rcu_read_lock(); - list_for_each_entry_rcu(c, &tsk->thread_group, thread_group) { - retval = cpu_cgroup_can_attach_task(cgrp, c); - if (retval) { - rcu_read_unlock(); - return retval; - } - } - rcu_read_unlock(); - } - return 0; -} - static void -cpu_cgroup_attach(struct cgroup_subsys *ss, struct cgroup *cgrp, - struct cgroup *old_cont, struct task_struct *tsk, - bool threadgroup) +cpu_cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) { sched_move_task(tsk); - if (threadgroup) { - struct task_struct *c; - rcu_read_lock(); - list_for_each_entry_rcu(c, &tsk->thread_group, thread_group) { - sched_move_task(c); - } - rcu_read_unlock(); - } } #ifdef CONFIG_FAIR_GROUP_SCHED @@ -8763,8 +8731,8 @@ struct cgroup_subsys cpu_cgroup_subsys = { .name = "cpu", .create = cpu_cgroup_create, .destroy = cpu_cgroup_destroy, - .can_attach = cpu_cgroup_can_attach, - .attach = cpu_cgroup_attach, + .can_attach_task = cpu_cgroup_can_attach_task, + .attach_task = cpu_cgroup_attach_task, .populate = cpu_cgroup_populate, .subsys_id = cpu_cgroup_subsys_id, .early_init = 1, diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 729beb7..995f0b9 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -4720,8 +4720,7 @@ static void mem_cgroup_clear_mc(void) static int mem_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgroup, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { int ret = 0; struct mem_cgroup *mem = mem_cgroup_from_cont(cgroup); @@ -4775,8 +4774,7 @@ static int mem_cgroup_can_attach(struct cgroup_subsys *ss, static void mem_cgroup_cancel_attach(struct cgroup_subsys *ss, struct cgroup *cgroup, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { mem_cgroup_clear_mc(); } @@ -4880,8 +4878,7 @@ static void mem_cgroup_move_charge(struct mm_struct *mm) static void mem_cgroup_move_task(struct cgroup_subsys *ss, struct cgroup *cont, struct cgroup *old_cont, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { if (!mc.mm) /* no need to move charge */ @@ -4893,22 +4890,19 @@ static void mem_cgroup_move_task(struct cgroup_subsys *ss, #else /* !CONFIG_MMU */ static int mem_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgroup, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { return 0; } static void mem_cgroup_cancel_attach(struct cgroup_subsys *ss, struct cgroup *cgroup, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { } static void mem_cgroup_move_task(struct cgroup_subsys *ss, struct cgroup *cont, struct cgroup *old_cont, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { } #endif diff --git a/security/device_cgroup.c b/security/device_cgroup.c index 8d9c48f..cd1f779 100644 --- a/security/device_cgroup.c +++ b/security/device_cgroup.c @@ -62,8 +62,7 @@ static inline struct dev_cgroup *task_devcgroup(struct task_struct *task) struct cgroup_subsys devices_subsys; static int devcgroup_can_attach(struct cgroup_subsys *ss, - struct cgroup *new_cgroup, struct task_struct *task, - bool threadgroup) + struct cgroup *new_cgroup, struct task_struct *task) { if (current != task && !capable(CAP_SYS_ADMIN)) return -EPERM;
WARNING: multiple messages have this Message-ID (diff)
From: Ben Blum <bblum@andrew.cmu.edu> To: Ben Blum <bblum@andrew.cmu.edu> Cc: linux-kernel@vger.kernel.org, containers@lists.linux-foundation.org, akpm@linux-foundation.org, ebiederm@xmission.com, lizf@cn.fujitsu.com, matthltc@us.ibm.com, menage@google.com, oleg@redhat.com, David Rientjes <rientjes@google.com>, Miao Xie <miaox@cn.fujitsu.com> Subject: [PATCH v8 2/3] cgroups: add per-thread subsystem callbacks Date: Mon, 7 Feb 2011 20:39:15 -0500 [thread overview] Message-ID: <20110208013915.GE31569@ghc17.ghc.andrew.cmu.edu> (raw) In-Reply-To: <20110208013542.GC31569@ghc17.ghc.andrew.cmu.edu> Add cgroup subsystem callbacks for per-thread attachment From: Ben Blum <bblum@andrew.cmu.edu> This patch adds 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: Ben Blum <bblum@andrew.cmu.edu> --- Documentation/cgroups/cgroups.txt | 30 ++++++++--- block/blk-cgroup.c | 18 ++---- include/linux/cgroup.h | 10 ++-- kernel/cgroup.c | 17 +++++- kernel/cgroup_freezer.c | 26 ++++----- kernel/cpuset.c | 105 ++++++++++++++++--------------------- kernel/ns_cgroup.c | 23 +++----- kernel/sched.c | 38 +------------ mm/memcontrol.c | 18 ++---- security/device_cgroup.c | 3 - 10 files changed, 122 insertions(+), 166 deletions(-) diff --git a/Documentation/cgroups/cgroups.txt b/Documentation/cgroups/cgroups.txt index 190018b..d3c9a24 100644 --- a/Documentation/cgroups/cgroups.txt +++ b/Documentation/cgroups/cgroups.txt @@ -563,7 +563,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, bool threadgroup) + struct task_struct *task) (cgroup_mutex held by caller) Called prior to moving a task into a cgroup; if the subsystem @@ -572,9 +572,14 @@ 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 and it is ensured that either -attach() or cancel_attach() will be called in future. If threadgroup is -true, then a successful result indicates that all threads in the given -thread's threadgroup can be moved together. +attach() or cancel_attach() will be called in future. + +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, struct task_struct *task, bool threadgroup) @@ -586,15 +591,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 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, - struct cgroup *old_cgrp, struct task_struct *task, - bool threadgroup) + struct cgroup *old_cgrp, struct task_struct *task) (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 + +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. void fork(struct cgroup_subsy *ss, struct task_struct *task) diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c index b1febd0..45b3809 100644 --- a/block/blk-cgroup.c +++ b/block/blk-cgroup.c @@ -30,10 +30,8 @@ EXPORT_SYMBOL_GPL(blkio_root_cgroup); static struct cgroup_subsys_state *blkiocg_create(struct cgroup_subsys *, struct cgroup *); -static int blkiocg_can_attach(struct cgroup_subsys *, struct cgroup *, - struct task_struct *, bool); -static void blkiocg_attach(struct cgroup_subsys *, struct cgroup *, - struct cgroup *, struct task_struct *, bool); +static int blkiocg_can_attach_task(struct cgroup *, struct task_struct *); +static void blkiocg_attach_task(struct cgroup *, struct task_struct *); static void blkiocg_destroy(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 = { .name = "blkio", .create = blkiocg_create, - .can_attach = blkiocg_can_attach, - .attach = blkiocg_attach, + .can_attach_task = blkiocg_can_attach_task, + .attach_task = blkiocg_attach_task, .destroy = blkiocg_destroy, .populate = blkiocg_populate, #ifdef CONFIG_BLK_CGROUP @@ -1475,9 +1473,7 @@ done: * 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. */ -static int blkiocg_can_attach(struct cgroup_subsys *subsys, - struct cgroup *cgroup, struct task_struct *tsk, - bool threadgroup) +static int blkiocg_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk) { struct io_context *ioc; int ret = 0; @@ -1492,9 +1488,7 @@ static int blkiocg_can_attach(struct cgroup_subsys *subsys, return ret; } -static void blkiocg_attach(struct cgroup_subsys *subsys, struct cgroup *cgroup, - struct cgroup *prev, struct task_struct *tsk, - bool threadgroup) +static void blkiocg_attach_task(struct cgroup *cgrp, struct task_struct *tsk) { struct io_context *ioc; diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h index ce104e3..35b69b4 100644 --- a/include/linux/cgroup.h +++ b/include/linux/cgroup.h @@ -467,12 +467,14 @@ struct cgroup_subsys { 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, 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, - 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, - struct cgroup *old_cgrp, struct task_struct *tsk, - bool threadgroup); + struct cgroup *old_cgrp, struct task_struct *tsk); 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, diff --git a/kernel/cgroup.c b/kernel/cgroup.c index 66a416b..616f27a 100644 --- a/kernel/cgroup.c +++ b/kernel/cgroup.c @@ -1750,7 +1750,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, false); + retval = ss->can_attach(ss, cgrp, tsk); if (retval) { /* * Remember on which subsystem the can_attach() @@ -1762,6 +1762,13 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) goto out; } } + if (ss->can_attach_task) { + retval = ss->can_attach_task(cgrp, tsk); + if (retval) { + failed_ss = ss; + goto out; + } + } } task_lock(tsk); @@ -1798,8 +1805,12 @@ int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) write_unlock(&css_set_lock); 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) - ss->attach(ss, cgrp, oldcgrp, tsk, false); + ss->attach(ss, cgrp, oldcgrp, tsk); } set_bit(CGRP_RELEASABLE, &oldcgrp->flags); synchronize_rcu(); @@ -1822,7 +1833,7 @@ out: */ break; if (ss->cancel_attach) - ss->cancel_attach(ss, cgrp, tsk, false); + ss->cancel_attach(ss, cgrp, tsk); } } return retval; diff --git a/kernel/cgroup_freezer.c b/kernel/cgroup_freezer.c index e7bebb7..e691818 100644 --- a/kernel/cgroup_freezer.c +++ b/kernel/cgroup_freezer.c @@ -160,7 +160,7 @@ static void freezer_destroy(struct cgroup_subsys *ss, */ static int freezer_can_attach(struct cgroup_subsys *ss, struct cgroup *new_cgroup, - struct task_struct *task, bool threadgroup) + struct task_struct *task) { struct freezer *freezer; @@ -172,26 +172,17 @@ static int freezer_can_attach(struct cgroup_subsys *ss, if (freezer->state != CGROUP_THAWED) return -EBUSY; + return 0; +} + +static int freezer_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk) +{ rcu_read_lock(); - if (__cgroup_freezing_or_frozen(task)) { + if (__cgroup_freezing_or_frozen(tsk)) { rcu_read_unlock(); return -EBUSY; } rcu_read_unlock(); - - if (threadgroup) { - struct task_struct *c; - - rcu_read_lock(); - list_for_each_entry_rcu(c, &task->thread_group, thread_group) { - if (__cgroup_freezing_or_frozen(c)) { - rcu_read_unlock(); - return -EBUSY; - } - } - rcu_read_unlock(); - } - return 0; } @@ -390,6 +381,9 @@ struct cgroup_subsys freezer_subsys = { .populate = freezer_populate, .subsys_id = freezer_subsys_id, .can_attach = freezer_can_attach, + .can_attach_task = freezer_can_attach_task, + .pre_attach = NULL, + .attach_task = NULL, .attach = NULL, .fork = freezer_fork, .exit = NULL, diff --git a/kernel/cpuset.c b/kernel/cpuset.c index 4349935..5f71ca2 100644 --- a/kernel/cpuset.c +++ b/kernel/cpuset.c @@ -1372,14 +1372,10 @@ static int fmeter_getrate(struct fmeter *fmp) return val; } -/* Protected by cgroup_lock */ -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, bool threadgroup) + struct task_struct *tsk) { - int ret; struct cpuset *cs = cgroup_cs(cont); if (cpumask_empty(cs->cpus_allowed) || nodes_empty(cs->mems_allowed)) @@ -1396,29 +1392,42 @@ static int cpuset_can_attach(struct cgroup_subsys *ss, struct cgroup *cont, if (tsk->flags & PF_THREAD_BOUND) return -EINVAL; - ret = security_task_setscheduler(tsk); - 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); - if (ret) { - rcu_read_unlock(); - return ret; - } - } - rcu_read_unlock(); - } return 0; } -static void cpuset_attach_task(struct task_struct *tsk, nodemask_t *to, - struct cpuset *cs) +static int cpuset_can_attach_task(struct cgroup *cgrp, struct task_struct *task) +{ + return security_task_setscheduler(task); +} + +/* + * Protected by cgroup_lock. The nodemasks must be stored globally because + * dynamically allocating them is not allowed in pre_attach, and they must + * persist among pre_attach, attach_task, and attach. + */ +static cpumask_var_t cpus_attach; +static nodemask_t cpuset_attach_nodemask_from; +static nodemask_t cpuset_attach_nodemask_to; + +/* Set-up work for before attaching each task. */ +static void cpuset_pre_attach(struct cgroup *cont) +{ + struct cpuset *cs = cgroup_cs(cont); + + if (cs == &top_cpuset) + cpumask_copy(cpus_attach, cpu_possible_mask); + else + guarantee_online_cpus(cs, cpus_attach); + + guarantee_online_mems(cs, &cpuset_attach_nodemask_to); +} + +/* Per-thread attachment work. */ +static void cpuset_attach_task(struct cgroup *cont, struct task_struct *tsk) { int err; + struct cpuset *cs = cgroup_cs(cont); + /* * can_attach beforehand should guarantee that this doesn't fail. * TODO: have a better way to handle failure here @@ -1426,56 +1435,31 @@ static void cpuset_attach_task(struct task_struct *tsk, nodemask_t *to, err = set_cpus_allowed_ptr(tsk, cpus_attach); WARN_ON_ONCE(err); - cpuset_change_task_nodemask(tsk, to); + cpuset_change_task_nodemask(tsk, &cpuset_attach_nodemask_to); 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) + struct cgroup *oldcont, struct task_struct *tsk) { struct mm_struct *mm; struct cpuset *cs = cgroup_cs(cont); struct cpuset *oldcs = cgroup_cs(oldcont); - NODEMASK_ALLOC(nodemask_t, from, GFP_KERNEL); - NODEMASK_ALLOC(nodemask_t, to, GFP_KERNEL); - - if (from == NULL || to == NULL) - goto alloc_fail; - if (cs == &top_cpuset) { - cpumask_copy(cpus_attach, cpu_possible_mask); - } else { - guarantee_online_cpus(cs, cpus_attach); - } - guarantee_online_mems(cs, to); - - /* 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; + /* + * Change mm, possibly for multiple threads in a threadgroup. This is + * expensive and may sleep. + */ + cpuset_attach_nodemask_from = oldcs->mems_allowed; + cpuset_attach_nodemask_to = cs->mems_allowed; mm = get_task_mm(tsk); if (mm) { - mpol_rebind_mm(mm, to); + mpol_rebind_mm(mm, &cpuset_attach_nodemask_to); if (is_memory_migrate(cs)) - cpuset_migrate_mm(mm, from, to); + cpuset_migrate_mm(mm, &cpuset_attach_nodemask_from, + &cpuset_attach_nodemask_to); mmput(mm); } - -alloc_fail: - NODEMASK_FREE(from); - NODEMASK_FREE(to); } /* The various types of files and directories in a cpuset file system */ @@ -1928,6 +1912,9 @@ struct cgroup_subsys cpuset_subsys = { .create = cpuset_create, .destroy = cpuset_destroy, .can_attach = cpuset_can_attach, + .can_attach_task = cpuset_can_attach_task, + .pre_attach = cpuset_pre_attach, + .attach_task = cpuset_attach_task, .attach = cpuset_attach, .populate = cpuset_populate, .post_clone = cpuset_post_clone, diff --git a/kernel/ns_cgroup.c b/kernel/ns_cgroup.c index 2c98ad9..1fc2b1b 100644 --- a/kernel/ns_cgroup.c +++ b/kernel/ns_cgroup.c @@ -43,7 +43,7 @@ int ns_cgroup_clone(struct task_struct *task, struct pid *pid) * ancestor cgroup thereof) */ static int ns_can_attach(struct cgroup_subsys *ss, struct cgroup *new_cgroup, - struct task_struct *task, bool threadgroup) + struct task_struct *task) { if (current != task) { if (!capable(CAP_SYS_ADMIN)) @@ -53,21 +53,13 @@ static int ns_can_attach(struct cgroup_subsys *ss, struct cgroup *new_cgroup, return -EPERM; } - if (!cgroup_is_descendant(new_cgroup, task)) - return -EPERM; - - if (threadgroup) { - struct task_struct *c; - rcu_read_lock(); - list_for_each_entry_rcu(c, &task->thread_group, thread_group) { - if (!cgroup_is_descendant(new_cgroup, c)) { - rcu_read_unlock(); - return -EPERM; - } - } - rcu_read_unlock(); - } + return 0; +} +static int ns_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk) +{ + if (!cgroup_is_descendant(cgrp, tsk)) + return -EPERM; return 0; } @@ -112,6 +104,7 @@ static void ns_destroy(struct cgroup_subsys *ss, struct cgroup_subsys ns_subsys = { .name = "ns", .can_attach = ns_can_attach, + .can_attach_task = ns_can_attach_task, .create = ns_create, .destroy = ns_destroy, .subsys_id = ns_subsys_id, diff --git a/kernel/sched.c b/kernel/sched.c index 218ef20..d619f1d 100644 --- a/kernel/sched.c +++ b/kernel/sched.c @@ -8655,42 +8655,10 @@ cpu_cgroup_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk) return 0; } -static int -cpu_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgrp, - struct task_struct *tsk, bool threadgroup) -{ - int retval = cpu_cgroup_can_attach_task(cgrp, tsk); - if (retval) - return retval; - if (threadgroup) { - struct task_struct *c; - rcu_read_lock(); - list_for_each_entry_rcu(c, &tsk->thread_group, thread_group) { - retval = cpu_cgroup_can_attach_task(cgrp, c); - if (retval) { - rcu_read_unlock(); - return retval; - } - } - rcu_read_unlock(); - } - return 0; -} - static void -cpu_cgroup_attach(struct cgroup_subsys *ss, struct cgroup *cgrp, - struct cgroup *old_cont, struct task_struct *tsk, - bool threadgroup) +cpu_cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk) { sched_move_task(tsk); - if (threadgroup) { - struct task_struct *c; - rcu_read_lock(); - list_for_each_entry_rcu(c, &tsk->thread_group, thread_group) { - sched_move_task(c); - } - rcu_read_unlock(); - } } #ifdef CONFIG_FAIR_GROUP_SCHED @@ -8763,8 +8731,8 @@ struct cgroup_subsys cpu_cgroup_subsys = { .name = "cpu", .create = cpu_cgroup_create, .destroy = cpu_cgroup_destroy, - .can_attach = cpu_cgroup_can_attach, - .attach = cpu_cgroup_attach, + .can_attach_task = cpu_cgroup_can_attach_task, + .attach_task = cpu_cgroup_attach_task, .populate = cpu_cgroup_populate, .subsys_id = cpu_cgroup_subsys_id, .early_init = 1, diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 729beb7..995f0b9 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -4720,8 +4720,7 @@ static void mem_cgroup_clear_mc(void) static int mem_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgroup, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { int ret = 0; struct mem_cgroup *mem = mem_cgroup_from_cont(cgroup); @@ -4775,8 +4774,7 @@ static int mem_cgroup_can_attach(struct cgroup_subsys *ss, static void mem_cgroup_cancel_attach(struct cgroup_subsys *ss, struct cgroup *cgroup, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { mem_cgroup_clear_mc(); } @@ -4880,8 +4878,7 @@ static void mem_cgroup_move_charge(struct mm_struct *mm) static void mem_cgroup_move_task(struct cgroup_subsys *ss, struct cgroup *cont, struct cgroup *old_cont, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { if (!mc.mm) /* no need to move charge */ @@ -4893,22 +4890,19 @@ static void mem_cgroup_move_task(struct cgroup_subsys *ss, #else /* !CONFIG_MMU */ static int mem_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgroup, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { return 0; } static void mem_cgroup_cancel_attach(struct cgroup_subsys *ss, struct cgroup *cgroup, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { } static void mem_cgroup_move_task(struct cgroup_subsys *ss, struct cgroup *cont, struct cgroup *old_cont, - struct task_struct *p, - bool threadgroup) + struct task_struct *p) { } #endif diff --git a/security/device_cgroup.c b/security/device_cgroup.c index 8d9c48f..cd1f779 100644 --- a/security/device_cgroup.c +++ b/security/device_cgroup.c @@ -62,8 +62,7 @@ static inline struct dev_cgroup *task_devcgroup(struct task_struct *task) struct cgroup_subsys devices_subsys; static int devcgroup_can_attach(struct cgroup_subsys *ss, - struct cgroup *new_cgroup, struct task_struct *task, - bool threadgroup) + struct cgroup *new_cgroup, struct task_struct *task) { if (current != task && !capable(CAP_SYS_ADMIN)) return -EPERM;
next prev parent reply other threads:[~2011-02-08 1:39 UTC|newest] Thread overview: 185+ messages / expand[flat|nested] mbox.gz Atom feed top 2010-07-30 23:56 [PATCH v4 0/2] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Ben Blum 2010-07-30 23:59 ` [PATCH v4 2/2] cgroups: make procs file writable Ben Blum 2010-08-04 1:08 ` KAMEZAWA Hiroyuki 2010-08-04 4:28 ` Ben Blum [not found] ` <20100804100811.199d73ba.kamezawa.hiroyu-+CUm20s59erQFUHtdCDX3A@public.gmane.org> 2010-08-04 4:28 ` Ben Blum 2010-08-04 4:30 ` Paul Menage 2010-08-04 4:30 ` Paul Menage [not found] ` <AANLkTikMofFGHSwF2QrdcAsit+hU6ihndhK5cod8duwS-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2010-08-04 4:38 ` Ben Blum 2010-08-04 4:38 ` Ben Blum 2010-08-04 4:46 ` Paul Menage [not found] ` <20100804043849.GC11950-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-04 4:46 ` Paul Menage [not found] ` <20100730235902.GC22644-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-04 1:08 ` KAMEZAWA Hiroyuki [not found] ` <20100730235649.GA22644-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-07-30 23:57 ` [PATCH v4 1/2] cgroups: read-write lock CLONE_THREAD forking per threadgroup Ben Blum 2010-07-30 23:57 ` Ben Blum 2010-08-04 3:44 ` Paul Menage [not found] ` <AANLkTikpNG2Y3S3AyxAbCkMynKu1u5yKPrw=bh+uy=9R-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2010-08-04 4:33 ` Ben Blum 2010-08-04 4:33 ` Ben Blum [not found] ` <20100804043328.GB11950-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-04 4:34 ` Paul Menage 2010-08-04 4:34 ` Paul Menage 2010-08-06 6:02 ` Ben Blum 2010-08-06 7:08 ` KAMEZAWA Hiroyuki [not found] ` <20100806060224.GA1351-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-06 7:08 ` KAMEZAWA Hiroyuki [not found] ` <AANLkTi=dhym3c+XJVjoObROcw=mz2Y+a2R5oMdePK3Ng-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2010-08-06 6:02 ` Ben Blum 2010-08-04 16:34 ` Brian K. White 2010-08-04 16:34 ` Brian K. White [not found] ` <20100730235754.GB22644-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-04 3:44 ` Paul Menage 2010-07-30 23:59 ` [PATCH v4 2/2] cgroups: make procs file writable Ben Blum 2010-08-03 19:58 ` [PATCH v4 0/2] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Andrew Morton 2010-08-11 5:46 ` [PATCH v5 0/3] " Ben Blum 2010-08-11 5:46 ` Ben Blum 2010-08-11 5:47 ` [PATCH v5 1/3] cgroups: read-write lock CLONE_THREAD forking per threadgroup Ben Blum 2010-08-23 23:35 ` Paul Menage [not found] ` <20100811054711.GB8743-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-23 23:35 ` Paul Menage [not found] ` <20100811054604.GA8743-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-11 5:47 ` Ben Blum 2010-08-11 5:48 ` [PATCH v5 2/3] cgroups: add can_attach callback for checking all threads in a group Ben Blum 2010-08-11 5:48 ` Ben Blum 2010-08-23 23:31 ` Paul Menage [not found] ` <20100811054814.GC8743-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-23 23:31 ` Paul Menage 2010-08-11 5:48 ` [PATCH v5 3/3] cgroups: make procs file writable Ben Blum 2010-12-24 8:22 ` [PATCH v6 0/3] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Ben Blum 2010-12-24 8:22 ` Ben Blum [not found] ` <20101224082226.GA13872-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-24 8:23 ` [PATCH v6 1/3] cgroups: read-write lock CLONE_THREAD forking per threadgroup Ben Blum 2010-12-24 8:23 ` Ben Blum 2010-12-24 8:24 ` [PATCH v6 2/3] cgroups: add can_attach callback for checking all threads in a group Ben Blum 2010-12-24 8:24 ` Ben Blum 2010-12-24 8:24 ` [PATCH v6 3/3] cgroups: make procs file writable Ben Blum 2010-12-24 8:24 ` Ben Blum 2011-01-12 23:26 ` Paul E. McKenney [not found] ` <20101224082445.GD13872-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-01-12 23:26 ` Paul E. McKenney 2010-12-26 12:09 ` [PATCH v7 0/3] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Ben Blum 2010-12-26 12:09 ` Ben Blum 2010-12-26 12:09 ` [PATCH v7 1/3] cgroups: read-write lock CLONE_THREAD forking per threadgroup Ben Blum 2011-01-24 8:38 ` Paul Menage 2011-01-24 21:05 ` Andrew Morton 2011-02-04 21:25 ` Ben Blum [not found] ` <20110204212515.GA5916-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-02-04 21:36 ` Andrew Morton 2011-02-04 21:36 ` Andrew Morton [not found] ` <20110204133657.78aeebe3.akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org> 2011-02-04 21:43 ` Ben Blum 2011-02-04 21:43 ` Ben Blum 2011-02-14 5:31 ` Paul Menage [not found] ` <20110124130529.903d9832.akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org> 2011-02-04 21:25 ` Ben Blum 2011-02-14 5:31 ` Paul Menage [not found] ` <20101226120951.GB28529-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-01-24 8:38 ` Paul Menage 2011-01-24 21:05 ` Andrew Morton 2010-12-26 12:11 ` [PATCH v7 2/3] cgroups: add atomic-context per-thread subsystem callbacks Ben Blum [not found] ` <20101226121100.GC28529-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-01-24 8:38 ` Paul Menage 2011-01-24 8:38 ` Paul Menage 2011-01-24 15:32 ` Ben Blum [not found] ` <AANLkTimytfrDnr_5SzBUFQu0SaGdAWDC0p38hiFiHrtU-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2011-01-24 15:32 ` Ben Blum 2010-12-26 12:12 ` [PATCH v7 3/3] cgroups: make procs file writable Ben Blum [not found] ` <20101226120919.GA28529-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-26 12:09 ` [PATCH v7 1/3] cgroups: read-write lock CLONE_THREAD forking per threadgroup Ben Blum 2010-12-26 12:11 ` [PATCH v7 2/3] cgroups: add atomic-context per-thread subsystem callbacks Ben Blum 2010-12-26 12:12 ` [PATCH v7 3/3] cgroups: make procs file writable Ben Blum 2011-02-08 1:35 ` [PATCH v8 0/3] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Ben Blum 2011-02-08 1:35 ` Ben Blum 2011-02-08 1:37 ` [PATCH v8 1/3] cgroups: read-write lock CLONE_THREAD forking per threadgroup Ben Blum 2011-03-03 17:54 ` Paul Menage [not found] ` <20110208013741.GD31569-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-03-03 17:54 ` Paul Menage [not found] ` <20110208013542.GC31569-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-02-08 1:37 ` Ben Blum 2011-02-08 1:39 ` Ben Blum [this message] 2011-02-08 1:39 ` [PATCH v8 2/3] cgroups: add per-thread subsystem callbacks Ben Blum 2011-03-03 17:59 ` Paul Menage [not found] ` <20110208013915.GE31569-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-03-03 17:59 ` Paul Menage 2011-02-08 1:39 ` [PATCH v8 3/3] cgroups: make procs file writable Ben Blum 2011-02-08 1:39 ` Ben Blum 2011-02-16 19:22 ` [PATCH v8 4/3] cgroups: use flex_array in attach_proc Ben Blum [not found] ` <20110216192200.GA11980-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-03-03 17:48 ` Paul Menage 2011-03-03 17:48 ` Paul Menage 2011-03-22 5:15 ` Ben Blum [not found] ` <20110322051553.GB11447-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-03-22 5:19 ` [PATCH v8.5 " Ben Blum 2011-03-22 5:19 ` Ben Blum [not found] ` <AANLkTinKTqBnjLKkv93UxyWoPL-2vyXP=LUvRz8JTC2K-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2011-03-22 5:15 ` [PATCH v8 " Ben Blum 2011-03-03 18:38 ` [PATCH v8 3/3] cgroups: make procs file writable Paul Menage [not found] ` <AANLkTinEnNsu8=PEktXL_EECzGYqsgdf+uogGxe7k4W+-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2011-03-10 6:18 ` Ben Blum 2011-03-10 6:18 ` Ben Blum 2011-03-10 20:01 ` Paul Menage [not found] ` <AANLkTikkmfwk0nV0p=omz2ddrw+ZqWF1Lx3EfO6dTjEQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2011-03-15 21:13 ` Ben Blum 2011-03-15 21:13 ` Ben Blum 2011-03-18 16:54 ` Paul Menage [not found] ` <AANLkTim4z_x_UQE__f5t73Dimja8PTTXTKKgj2phv6FY-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2011-03-22 5:18 ` [PATCH v8.5 " Ben Blum 2011-03-22 5:18 ` Ben Blum [not found] ` <20110322051841.GA12055-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-03-29 23:27 ` Paul Menage 2011-03-29 23:27 ` Paul Menage 2011-03-29 23:39 ` Andrew Morton [not found] ` <BANLkTikMgd5HvMyC1BTGzAtj_=Jk=wZm+A-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2011-03-29 23:39 ` Andrew Morton [not found] ` <20110315211353.GA9992-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-03-18 16:54 ` [PATCH v8 " Paul Menage 2011-03-22 5:08 ` Ben Blum [not found] ` <20110310061831.GA23736-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-03-10 20:01 ` Paul Menage 2011-03-22 5:08 ` Ben Blum [not found] ` <20110208013950.GF31569-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-02-16 19:22 ` [PATCH v8 4/3] cgroups: use flex_array in attach_proc Ben Blum 2011-03-03 18:38 ` [PATCH v8 3/3] cgroups: make procs file writable Paul Menage 2011-02-09 23:10 ` [PATCH v8 0/3] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Andrew Morton 2011-04-06 19:44 ` [PATCH v8.75 0/4] " Ben Blum 2011-02-09 23:10 ` [PATCH v8 0/3] " Andrew Morton 2011-02-10 1:02 ` KAMEZAWA Hiroyuki [not found] ` <20110210100210.adf09c49.kamezawa.hiroyu-+CUm20s59erQFUHtdCDX3A@public.gmane.org> 2011-02-10 1:36 ` Ben Blum 2011-02-14 6:12 ` Paul Menage 2011-02-10 1:36 ` Ben Blum 2011-02-14 6:12 ` Paul Menage 2011-02-14 6:12 ` Paul Menage [not found] ` <20110209151046.89e03dcd.akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org> 2011-02-10 1:02 ` KAMEZAWA Hiroyuki 2011-02-14 6:12 ` Paul Menage 2011-04-06 19:44 ` [PATCH v8.75 0/4] " Ben Blum 2011-04-06 19:45 ` [PATCH v8.75 1/4] cgroups: read-write lock CLONE_THREAD forking per threadgroup Ben Blum [not found] ` <20110406194420.GC10792-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-04-06 19:45 ` Ben Blum 2011-04-06 19:46 ` [PATCH v8.75 2/4] cgroups: add per-thread subsystem callbacks Ben Blum 2011-04-06 19:46 ` [PATCH v8.75 3/4] cgroups: make procs file writable Ben Blum 2011-04-06 19:47 ` [PATCH v8.75 4/4] cgroups: use flex_array in attach_proc Ben Blum 2011-04-12 23:25 ` [PATCH v8.75 0/4] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Andrew Morton 2011-04-06 19:46 ` [PATCH v8.75 2/4] cgroups: add per-thread subsystem callbacks Ben Blum 2011-04-06 19:46 ` [PATCH v8.75 3/4] cgroups: make procs file writable Ben Blum 2011-04-06 19:47 ` [PATCH v8.75 4/4] cgroups: use flex_array in attach_proc Ben Blum 2011-04-12 23:25 ` [PATCH v8.75 0/4] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Andrew Morton 2011-04-12 23:59 ` Ben Blum 2011-04-13 2:07 ` Li Zefan [not found] ` <20110412162516.4120c441.akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org> 2011-04-12 23:59 ` Ben Blum 2011-04-13 2:07 ` Li Zefan 2010-08-11 5:48 ` [PATCH v5 3/3] cgroups: make procs file writable Ben Blum [not found] ` <20100811054851.GD8743-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-08-24 18:08 ` Paul Menage 2010-08-24 18:08 ` Paul Menage [not found] ` <AANLkTimRM8rDe+u7fTy853RK=1mnLJMK57Tci2OLPR7L-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2010-10-08 21:57 ` Paul Menage [not found] ` <AANLkTim7HW0wNyqOPePFXmEMV8hx_fMKNMTAsSwkRzZX-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2010-12-16 6:34 ` Paul Menage [not found] ` <AANLkTin7aK5uEFi0U+iU_9=cbfRTHfDzKsbWupn73fSL-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2010-12-16 8:26 ` Andrew Morton [not found] ` <20101216002603.6741874a.akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org> 2010-12-24 3:33 ` Ben Blum [not found] ` <20101224033352.GA7804-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-24 10:49 ` David Rientjes [not found] ` <alpine.DEB.2.00.1012240245040.775-X6Q0R45D7oAcqpCFd4KODRPsWskHk0ljAL8bYrjMMd8@public.gmane.org> 2010-12-24 11:45 ` Ben Blum [not found] ` <20101224114500.GA18036-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-24 11:53 ` Andrew Morton [not found] ` <20101224035331.b907b410.akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org> 2010-12-24 12:08 ` Ben Blum [not found] ` <20101224120853.GA18518-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-24 21:24 ` Ben Blum [not found] ` <20101224212452.GA27275-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-24 21:34 ` David Rientjes [not found] ` <alpine.DEB.2.00.1012241333010.13509-X6Q0R45D7oAcqpCFd4KODRPsWskHk0ljAL8bYrjMMd8@public.gmane.org> 2010-12-24 23:09 ` Ben Blum [not found] ` <20101224230901.GA30136-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-26 21:48 ` David Rientjes [not found] ` <alpine.DEB.2.00.1012261345340.23173-X6Q0R45D7oAcqpCFd4KODRPsWskHk0ljAL8bYrjMMd8@public.gmane.org> 2010-12-27 0:12 ` Ben Blum [not found] ` <20101227001233.GA10951-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-27 10:31 ` David Rientjes [not found] ` <alpine.DEB.2.00.1012270227010.3960-X6Q0R45D7oAcqpCFd4KODRPsWskHk0ljAL8bYrjMMd8@public.gmane.org> 2010-12-27 10:37 ` Ben Blum [not found] ` <20101227103701.GC20986-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-27 10:53 ` David Rientjes [not found] ` <alpine.DEB.2.00.1012270240400.3960-X6Q0R45D7oAcqpCFd4KODRPsWskHk0ljAL8bYrjMMd8@public.gmane.org> 2010-12-27 11:00 ` Ben Blum [not found] ` <20101227110050.GF20986-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-27 11:03 ` David Rientjes 2010-12-29 1:39 ` Li Zefan [not found] ` <4D1A913C.5080702-BthXqXjhjHXQFUHtdCDX3A@public.gmane.org> 2010-12-30 0:26 ` David Rientjes [not found] ` <alpine.DEB.2.00.1012291624210.6040-X6Q0R45D7oAcqpCFd4KODRPsWskHk0ljAL8bYrjMMd8@public.gmane.org> 2010-12-30 4:02 ` Li Zefan [not found] ` <4D1C0464.5090801-BthXqXjhjHXQFUHtdCDX3A@public.gmane.org> 2010-12-30 4:24 ` David Rientjes [not found] ` <alpine.DEB.2.00.1012292019540.27634-X6Q0R45D7oAcqpCFd4KODRPsWskHk0ljAL8bYrjMMd8@public.gmane.org> 2010-12-30 4:38 ` Li Zefan [not found] ` <4D1C0CC6.4090107-BthXqXjhjHXQFUHtdCDX3A@public.gmane.org> 2010-12-30 5:49 ` David Rientjes [not found] ` <alpine.DEB.2.00.1012292149000.29486-X6Q0R45D7oAcqpCFd4KODRPsWskHk0ljAL8bYrjMMd8@public.gmane.org> 2010-12-30 6:12 ` Li Zefan [not found] ` <4D1C22D2.9090007-BthXqXjhjHXQFUHtdCDX3A@public.gmane.org> 2010-12-30 18:25 ` David Rientjes 2010-12-24 21:32 ` David Rientjes 2010-12-25 2:55 ` Ben Blum [not found] ` <20101225025508.GA649-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-27 0:53 ` Daisuke Nishimura [not found] ` <20101227095353.48d95687.nishimura-YQH0OdQVrdy45+QrQBaojngSJqDPrsil@public.gmane.org> 2010-12-27 1:15 ` KAMEZAWA Hiroyuki 2010-12-27 4:22 ` Ben Blum [not found] ` <20101227042254.GA15417-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-27 7:00 ` KAMEZAWA Hiroyuki [not found] ` <20101227160041.07bff52a.kamezawa.hiroyu-+CUm20s59erQFUHtdCDX3A@public.gmane.org> 2010-12-27 7:21 ` Ben Blum [not found] ` <20101227072123.GA19652-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-27 7:42 ` KAMEZAWA Hiroyuki [not found] ` <20101227164207.b09318be.kamezawa.hiroyu-+CUm20s59erQFUHtdCDX3A@public.gmane.org> 2010-12-27 8:42 ` Ben Blum [not found] ` <20101227084257.GA20986-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2010-12-27 9:18 ` KAMEZAWA Hiroyuki [not found] ` <20101227181801.095e9a23.kamezawa.hiroyu-+CUm20s59erQFUHtdCDX3A@public.gmane.org> 2010-12-27 10:12 ` Ben Blum [not found] ` <20101227101228.GB20986-dJQ2lsn+DImqwBT9kiuFm8WGCVk0P7UB@public.gmane.org> 2011-01-04 0:57 ` KAMEZAWA Hiroyuki 2010-12-28 2:43 ` [RFC][BUGFIX] memcg: fix dead lock between cpuset and memcg (Re: [PATCH v5 3/3] cgroups: make procs file writable) Daisuke Nishimura 2010-12-25 4:24 ` [PATCH v5 3/3] cgroups: make procs file writable Ben Blum 2010-08-03 19:58 ` [PATCH v4 0/2] cgroups: implement moving a threadgroup's threads atomically with cgroup.procs Andrew Morton [not found] ` <20100803125827.0822e6ab.akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org> 2010-08-03 23:45 ` KAMEZAWA Hiroyuki 2010-08-04 2:00 ` Li Zefan 2010-08-04 2:00 ` Li Zefan 2010-08-03 23:45 ` KAMEZAWA Hiroyuki
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20110208013915.GE31569@ghc17.ghc.andrew.cmu.edu \ --to=bblum-om76b2iv3ylqjuslxsepgw@public.gmane.org \ --cc=akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org \ --cc=containers-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org \ --cc=ebiederm-aS9lmoZGLiVWk0Htik3J/w@public.gmane.org \ --cc=linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org \ --cc=menage-hpIqsD4AKlfQT0dZR+AlfA@public.gmane.org \ --cc=miaox-BthXqXjhjHXQFUHtdCDX3A@public.gmane.org \ --cc=oleg-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org \ --cc=rientjes-hpIqsD4AKlfQT0dZR+AlfA@public.gmane.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.