cgroups: new cancel_attach_task() subsystem callback

To cancel a process attachment on a subsystem, we only call the
cancel_attach() callback once on the leader but we have no way to cancel
the attachment individually for each member of the process group.

This is going to be needed for the max number of tasks susbystem that is
coming.

To prepare for this integration, call a new cancel_attach_task() callback
on each task of the group until we reach the member that failed to attach.

Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Acked-by: Paul Menage <paul@paulmenage.org>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Aditya Kali <adityakali@google.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Tim Hockin <thockin@hockin.org>
Cc: Tejun Heo <htejun@gmail.com>
Acked-by: Kirill A. Shutemov <kirill@shutemov.name>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/Documentation/cgroups/cgroups.txt b/Documentation/cgroups/cgroups.txt
index f5a0e9111d49c25505095d2f287f7bb57924bbca..3fa646f6c6d68a3b05f2fa5f2a62e415d6c671fb 100644 (file)
--- a/Documentation/cgroups/cgroups.txt
+++ b/Documentation/cgroups/cgroups.txt
@@ -623,6 +623,13 @@ 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 cancel_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
+(cgroup_mutex held by caller)
+
+As cancel_attach, but for operations that must be cancelled once per
+task that wanted to be attached. This typically revert the effect of
+can_attach_task().
+
 void pre_attach(struct cgroup *cgrp);
 (cgroup_mutex held by caller)
 

diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 0731c6bf96c7ee4eb869411e2d9a4f1573f5b371..3c54299a73c3483f139ac6f066f4b36f2644d48d 100644 (file)
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -472,6 +472,8 @@ struct cgroup_subsys {
                               struct task_struct *tsk);
        void (*cancel_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
                              struct task_struct *tsk);
+       void (*cancel_attach_task)(struct cgroup *cgrp,
+                                  struct task_struct *tsk);
        void (*pre_attach)(struct cgroup *cgrp);
        void (*attach_task)(struct cgroup *cgrp, struct cgroup *old_cgrp,
                            struct task_struct *tsk);

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index ba8f3ebeb0469a087096401a9f9b1d06afd69da2..23d2bad671498c265fb7d039dc5b25cae1120857 100644 (file)
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -1883,6 +1883,9 @@ out:
                                 * remaining subsystems.
                                 */
                                break;
+
+                       if (ss->cancel_attach_task)
+                               ss->cancel_attach_task(cgrp, tsk);
                        if (ss->cancel_attach)
                                ss->cancel_attach(ss, cgrp, tsk);
                }
@@ -1992,7 +1995,7 @@ int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
 {
        int retval, i, group_size;
        struct cgroup_subsys *ss, *failed_ss = NULL;
-       bool cancel_failed_ss = false;
+       struct task_struct *failed_task = NULL;
        /* guaranteed to be initialized later, but the compiler needs this */
        struct cgroup *oldcgrp = NULL;
        struct css_set *oldcg;
@@ -2081,7 +2084,7 @@ int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
                                                             oldcgrp, tsk);
                                if (retval) {
                                        failed_ss = ss;
-                                       cancel_failed_ss = true;
+                                       failed_task = tsk;
                                        goto out_cancel_attach;
                                }
                        }
@@ -2146,8 +2149,11 @@ int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
                                if (ss->attach_task)
                                        ss->attach_task(cgrp, oldcgrp, tsk);
                        }
+               } else if (retval == -ESRCH) {
+                       if (ss->cancel_attach_task)
+                               ss->cancel_attach_task(cgrp, tsk);
                } else {
-                       BUG_ON(retval != -ESRCH);
+                       BUG_ON(1);
                }
        }
        /* nothing is sensitive to fork() after this point. */
@@ -2179,8 +2185,18 @@ out_cancel_attach:
        /* same deal as in cgroup_attach_task */
        if (retval) {
                for_each_subsys(root, ss) {
+                       if (ss->cancel_attach_task && (ss != failed_ss ||
+                                                      failed_task)) {
+                               for (i = 0; i < group_size; i++) {
+                                       tsk = flex_array_get_ptr(group, i);
+                                       if (tsk == failed_task)
+                                               break;
+                                       ss->cancel_attach_task(cgrp, tsk);
+                               }
+                       }
+
                        if (ss == failed_ss) {
-                               if (cancel_failed_ss && ss->cancel_attach)
+                               if (failed_task && ss->cancel_attach)
                                        ss->cancel_attach(ss, cgrp, leader);
                                break;
                        }