cgroup/cpuset: Fix CLONE_INTO_CGROUP problem & other issues
Subsystems (2)
Waiman Long
maintainerv3 cover cgroup/cpuset: Fix CLONE_INTO_CGROUP problem & other issues
v3:
- Update patches 2 & 3 to put task_cs() call under rcu_read_lock().
v2:
- Drop v1 patch 3
- Add a new patch to fix an issue in cpuset_cancel_attach() and another patch to add cpuset_can_fork() and cpuset_cacnel_fork() methods.
The first patch in this series fixes a problem in cpuset_cancel_attach(). Patches 2 and 3 fixes the CLONE_INTO_CGROUP problem in cpuset. The last one is a minor fix.
Waiman Long (4):
cgroup/cpuset: Wake up cpuset_attach_wq tasks in
cpuset_cancel_attach()
cgroup/cpuset: Make cpuset_fork() handle CLONE_INTO_CGROUP properly cgroup/cpuset: Add cpuset_can_fork() and cpuset_cancel_fork() methods cgroup/cpuset: Make cpuset_attach_task() skip subpartitions CPUs for
top_cpuset
kernel/cgroup/cpuset.c | 161 +++++++++++++++++++++++++++++++++-------- 1 file changed, 129 insertions(+), 32 deletions(-)
Signature · 1 line
2.31.1
Waiman Long
maintainerPATCH v3 1/4 cgroup/cpuset: Wake up cpuset_attach_wq tasks in cpuset_cancel_attach()
After a successful cpuset_can_attach() call which increments the attach_in_progress flag, either cpuset_cancel_attach() or cpuset_attach() will be called later. In cpuset_attach(), tasks in cpuset_attach_wq, if present, will be woken up at the end. That is not the case in cpuset_cancel_attach(). So missed wakeup is possible if the attach operation is somehow cancelled. Fix that by doing the wakeup in cpuset_cancel_attach() as well.
--- kernel/cgroup/cpuset.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
kernel/cgroup/cpuset.c +5 -1
@@ -2507,11 +2507,15 @@ static int cpuset_can_attach(struct cgroup_taskset *tset)static void cpuset_cancel_attach (struct cgroup_taskset *tset) {struct cgroup_subsys_state *css; +struct cpuset *cs;cgroup_taskset_first (tset, &css); + cs =css_cs (css);percpu_down_write (&cpuset_rwsem); -css_cs (css)->attach_in_progress--; + cs->attach_in_progress--; +if (!cs->attach_in_progress) +wake_up (&cpuset_attach_wq);percpu_up_write (&cpuset_rwsem); }
Signature · 1 line
2.31.1
Waiman Long
maintainerPATCH v3 2/4 cgroup/cpuset: Make cpuset_fork() handle CLONE_INTO_CGROUP properly
In reply to Waiman LongBy default, the clone(2) syscall spawn a child process into the same cgroup as its parent. With the use of the CLONE_INTO_CGROUP flag introduced by commit ef2c41cf38a7 ("clone3: allow spawning processes into cgroups"), the child will be spawned into a different cgroup which is somewhat similar to writing the child's tid into "cgroup.threads".
The current cpuset_fork() method does not properly handle the CLONE_INTO_CGROUP case where the cpuset of the child may be different from that of its parent. Update the cpuset_fork() method to treat the CLONE_INTO_CGROUP case similar to cpuset_attach().
Since the newly cloned task has not been running yet, its actual memory usage isn't known. So it is not necessary to make change to mm in cpuset_fork().
--- kernel/cgroup/cpuset.c | 62 ++++++++++++++++++++++++++++-------------- 1 file changed, 42 insertions(+), 20 deletions(-)
kernel/cgroup/cpuset.c +42 -20
@@ -2520,16 +2520,33 @@ static void cpuset_cancel_attach(struct cgroup_taskset *tset) }/* -* Protected by cpuset_rwsem. cpus_attach is used only by cpuset_attach() +* Protected by cpuset_rwsem. cpus_attach is used only by cpuset_attach_task() * but we can't allocate it dynamically there. Define it global and * allocate from cpuset_init(). */ static cpumask_var_t cpus_attach; +static nodemask_t cpuset_attach_nodemask_to; + +static void cpuset_attach_task (struct cpuset *cs,struct task_struct *task) +{ +percpu_rwsem_assert_held (&cpuset_rwsem); + +if (cs != &top_cpuset) +guarantee_online_cpus (task, cpus_attach); +else +cpumask_copy (cpus_attach,task_cpu_possible_mask (task)); +/* +* can_attach beforehand should guarantee that this doesn't +* fail. TODO: have a better way to handle failure here +*/ +WARN_ON_ONCE (set_cpus_allowed_ptr (task, cpus_attach)); + +cpuset_change_task_nodemask (task, &cpuset_attach_nodemask_to); +cpuset_update_task_spread_flags (cs, task); +}static void cpuset_attach (struct cgroup_taskset *tset) { -/* static buf protected by cpuset_rwsem */ -static nodemask_t cpuset_attach_nodemask_to;struct task_struct *task;struct task_struct *leader;struct cgroup_subsys_state *css;
@@ -2560,20 +2577,8 @@ static void cpuset_attach(struct cgroup_taskset *tset)guarantee_online_mems (cs, &cpuset_attach_nodemask_to); -cgroup_taskset_for_each (task, css, tset) { -if (cs != &top_cpuset) -guarantee_online_cpus (task, cpus_attach); -else -cpumask_copy (cpus_attach,task_cpu_possible_mask (task)); -/* -* can_attach beforehand should guarantee that this doesn't -* fail. TODO: have a better way to handle failure here -*/ -WARN_ON_ONCE (set_cpus_allowed_ptr (task, cpus_attach)); - -cpuset_change_task_nodemask (task, &cpuset_attach_nodemask_to); -cpuset_update_task_spread_flags (cs, task); - } +cgroup_taskset_for_each (task, css, tset) +cpuset_attach_task (cs, task);/* * Change mm for all threadgroup leaders. This is expensive and may
@@ -3271,11 +3276,28 @@ static void cpuset_bind(struct cgroup_subsys_state *root_css)*/ static void cpuset_fork (struct task_struct *task) { -if (task_css_is_root (task, cpuset_cgrp_id)) +struct cpuset *cs; +bool same_cs; + +rcu_read_lock (); + cs =task_cs (task); + same_cs = (cs ==task_cs (current)); +rcu_read_unlock (); + +if (same_cs) { +if (cs == &top_cpuset) +return ; + +set_cpus_allowed_ptr (task, current->cpus_ptr); + task->mems_allowed = current->mems_allowed;return ; + } -set_cpus_allowed_ptr (task, current->cpus_ptr); - task->mems_allowed = current->mems_allowed; +/* CLONE_INTO_CGROUP */ +percpu_down_write (&cpuset_rwsem); +guarantee_online_mems (cs, &cpuset_attach_nodemask_to); +cpuset_attach_task (cs, task); +percpu_up_write (&cpuset_rwsem); }struct cgroup_subsys cpuset_cgrp_subsys = {
Signature · 1 line
2.31.1
Waiman Long
maintainerPATCH v3 3/4 cgroup/cpuset: Add cpuset_can_fork() and cpuset_cancel_fork() methods
In reply to Waiman LongIn the case of CLONE_INTO_CGROUP, not all cpusets are ready to accept new tasks. It is too late to check that in cpuset_fork(). So we need to add the cpuset_can_fork() and cpuset_cancel_fork() methods to pre-check it before we can allow attachment to a different cpuset.
We also need to set the attach_in_progress flag to alert other code that a new task is going to be added to the cpuset.
--- kernel/cgroup/cpuset.c | 92 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 81 insertions(+), 11 deletions(-)
kernel/cgroup/cpuset.c +81 -11
@@ -2458,6 +2458,20 @@ static int fmeter_getrate(struct fmeter *fmp)static struct cpuset *cpuset_attach_old_cs; +/* +* Check to see if a cpuset can accept a new task +* For v1, cpus_allowed and mems_allowed can't be empty. +* For v2, effective_cpus can't be empty. +* Note that in v1, effective_cpus = cpus_allowed. +*/ +static int cpuset_can_attach_check (struct cpuset *cs) +{ +if (cpumask_empty (cs->effective_cpus) || + (!is_in_v2_mode () &&nodes_empty (cs->mems_allowed))) +return -ENOSPC ; +return 0 ; +} +/* Called by cgroups to determine if a cpuset is usable; cpuset_rwsem held */ static int cpuset_can_attach (struct cgroup_taskset *tset) {
@@ -2472,16 +2486,9 @@ static int cpuset_can_attach(struct cgroup_taskset *tset)percpu_down_write (&cpuset_rwsem); -/* allow moving tasks into an empty cpuset if on default hierarchy */ - ret = -ENOSPC ; -if (!is_in_v2_mode () && - (cpumask_empty (cs->cpus_allowed) ||nodes_empty (cs->mems_allowed))) - goto out_unlock; - -/* -* Task cannot be moved to a cpuset with empty effective cpus. -*/ -if (cpumask_empty (cs->effective_cpus)) +/* Check to see if task is allowed in the cpuset */ + ret =cpuset_can_attach_check (cs); +if (ret) goto out_unlock;cgroup_taskset_for_each (task, css, tset) {
@@ -2498,7 +2505,6 @@ static int cpuset_can_attach(struct cgroup_taskset *tset)* changes which zero cpus/mems_allowed. */ cs->attach_in_progress++; - ret =0 ; out_unlock:percpu_up_write (&cpuset_rwsem);return ret;
@@ -3269,6 +3275,63 @@ static void cpuset_bind(struct cgroup_subsys_state *root_css)percpu_up_write (&cpuset_rwsem); } +/* +* In case the child is cloned into a cpuset different from its parent, +* additional checks are done to see if the move is allowed. +*/ +static int cpuset_can_fork (struct task_struct *task,struct css_set *cset) +{ +struct cpuset *cs =css_cs (cset->subsys[cpuset_cgrp_id]); +bool same_cs; +int ret; + +rcu_read_lock (); + same_cs = (cs ==task_cs (current)); +rcu_read_unlock (); + +if (same_cs) +return 0 ; + +lockdep_assert_held (&cgroup_mutex); +percpu_down_write (&cpuset_rwsem); + +/* Check to see if task is allowed in the cpuset */ + ret =cpuset_can_attach_check (cs); +if (ret) + goto out_unlock; + + ret =task_can_attach (task, cs->effective_cpus); +if (ret) + goto out_unlock; + + ret =security_task_setscheduler (task); +if (ret) + goto out_unlock; + +/* +* Mark attach is in progress. This makes validate_change() fail +* changes which zero cpus/mems_allowed. +*/ + cs->attach_in_progress++; +out_unlock: +percpu_up_write (&cpuset_rwsem); +return ret; +} + +static void cpuset_cancel_fork (struct task_struct *task,struct css_set *cset) +{ +struct cpuset *cs =css_cs (cset->subsys[cpuset_cgrp_id]); + +if (cs ==task_cs (current)) +return ; + +percpu_down_write (&cpuset_rwsem); + cs->attach_in_progress--; +if (!cs->attach_in_progress) +wake_up (&cpuset_attach_wq); +percpu_up_write (&cpuset_rwsem); +} +/* * Make sure the new task conform to the current state of its parent, * which could have been changed by cpuset just after it inherits the
@@ -3297,6 +3360,11 @@ static void cpuset_fork(struct task_struct *task)percpu_down_write (&cpuset_rwsem);guarantee_online_mems (cs, &cpuset_attach_nodemask_to);cpuset_attach_task (cs, task); + + cs->attach_in_progress--; +if (!cs->attach_in_progress) +wake_up (&cpuset_attach_wq); +percpu_up_write (&cpuset_rwsem); }
@@ -3310,6 +3378,8 @@ struct cgroup_subsys cpuset_cgrp_subsys = { .attach = cpuset_attach, .post_attach = cpuset_post_attach, .bind = cpuset_bind, + .can_fork = cpuset_can_fork, + .cancel_fork = cpuset_cancel_fork, .fork = cpuset_fork, .legacy_cftypes = legacy_files, .dfl_cftypes = dfl_files,
Signature · 1 line
2.31.1
Waiman Long
maintainerPATCH v3 4/4 cgroup/cpuset: Make cpuset_attach_task() skip subpartitions CPUs for top_cpuset
In reply to Waiman LongIt is found that attaching a task to the top_cpuset does not currently ignore CPUs allocated to subpartitions in cpuset_attach_task(). So the code is changed to fix that.
--- kernel/cgroup/cpuset.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/cgroup/cpuset.c +2 -1
@@ -2540,7 +2540,8 @@ static void cpuset_attach_task(struct cpuset *cs, struct task_struct *task)if (cs != &top_cpuset)guarantee_online_cpus (task, cpus_attach);else -cpumask_copy (cpus_attach,task_cpu_possible_mask (task)); +cpumask_andnot (cpus_attach,task_cpu_possible_mask (task), + cs->subparts_cpus);/* * can_attach beforehand should guarantee that this doesn't * fail. TODO: have a better way to handle failure here
Signature · 1 line
2.31.1