sched: Persistent user requested affinity
v7 cover sched: Persistent user requested affinity
v6:
- Make changes recommended by Peter such as making scratch_mask allocation earlier and using percpu variable to pass information.
v6:
- Drop the cpuset patch and make user_cpus_ptr masking applicable to all callers of set_cpus_allowed_ptr().
- Make user_cpus_ptr and cpus_mask update in a single lock critical section to avoid race problems.
v5:
- Update patch 3 to handle race with concurrent sched_setaffinity() by rechecking a previously cleared user_cpus_ptr afterward.
The user_cpus_ptr field is added by commit b90ca8badbd1 ("sched:
Introduce task_struct::user_cpus_ptr to track requested affinity") which uses it narrowly to allow keeping cpus affinity intact with asymmetric cpu setup.
This patchset extends user_cpus_ptr to store user requested cpus affinity via the sched_setaffinity() API. With that information available, it will enable cpuset and other callers of set_cpus_allowed_ptr() like hotplug to keep cpus afinity as close to what the user wants as possible within the cpu list constraint of the current cpuset. Otherwise some change to the cpuset hierarchy or a hotplug event may reset the cpumask of the tasks in the affected cpusets to the default cpuset value even if those tasks have cpus affinity explicitly set by the users before.
It also means that once sched_setaffinity() is called, user_cpus_ptr will remain allocated until the task exits.
Waiman Long (5):
sched: Add __releases annotations to affine_move_task()
sched: Use user_cpus_ptr for saving user provided cpumask in
sched_setaffinity()
sched: Enforce user requested affinity
sched: Handle set_cpus_allowed_ptr() & sched_setaffinity() race
sched: Fix sched_setaffinity() and fork/clone() race
kernel/sched/core.c | 125 +++++++++++++++++++++++++------------------ kernel/sched/sched.h | 10 ++++ 2 files changed, 83 insertions(+), 52 deletions(-)
Signature · 1 line
2.31.1
PATCH v7 1/5 sched: Add __releases annotations to affine_move_task()
affine_move_task() assumes task_rq_lock() has been called and it does an implicit task_rq_unlock() before returning. Add the appropriate __releases annotations to make this clear.
A typo error in comment is also fixed.
--- kernel/sched/core.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
kernel/sched/core.c +3 -1
@@ -2696,6 +2696,8 @@ void release_user_cpus_ptr(struct task_struct *p)*/ static int affine_move_task (struct rq *rq,struct task_struct *p,struct rq_flags *rf,int dest_cpu,unsigned int flags) + __releases(rq->lock) + __releases(p->pi_lock) {struct set_affinity_pending my_pending = { }, *pending =NULL ;bool stop_pending, complete = false;
@@ -3005,7 +3007,7 @@ static int restrict_cpus_allowed_ptr(struct task_struct *p,/* * Restrict the CPU affinity of task @p so that it is a subset of -* task_cpu_possible_mask() and point @p->user_cpu_ptr to a copy of the +* task_cpu_possible_mask() and point @p->user_cpus_ptr to a copy of the * old affinity mask. If the resulting mask is empty, we warn and walk * up the cpuset hierarchy until we find a suitable mask. */
Signature · 1 line
2.31.1
PATCH v7 2/5 sched: Use user_cpus_ptr for saving user provided cpumask in sched_setaffinity()
In reply to Waiman LongThe user_cpus_ptr field is added by commit b90ca8badbd1 ("sched:
Introduce task_struct::user_cpus_ptr to track requested affinity"). It is currently used only by arm64 arch due to possible asymmetric CPU setup. This patch extends its usage to save user provided cpumask when sched_setaffinity() is called for all arches. With this patch applied, user_cpus_ptr, once allocated after a successful call to sched_setaffinity(), will only be freed when the task exits.
Since user_cpus_ptr is supposed to be used for "requested affinity", there is actually no point to save current cpu affinity in restrict_cpus_allowed_ptr() if sched_setaffinity() has never been called. Modify the logic to set user_cpus_ptr only in sched_setaffinity() and use it in restrict_cpus_allowed_ptr() and relax_compatible_cpus_allowed_ptr() if defined but not changing it.
This will be some changes in behavior for arm64 systems with asymmetric CPUs in some corner cases. For instance, if sched_setaffinity() has never been called and there is a cpuset change before relax_compatible_cpus_allowed_ptr() is called, its subsequent call will follow what the cpuset allows but not what the previous cpu affinity setting allows.
--- kernel/sched/core.c | 82 ++++++++++++++++++++------------------------ kernel/sched/sched.h | 7 ++++ 2 files changed, 44 insertions(+), 45 deletions(-)
kernel/sched/core.c +37 -45
@@ -2850,7 +2850,6 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p,const struct cpumask *cpu_allowed_mask =task_cpu_possible_mask (p);const struct cpumask *cpu_valid_mask = cpu_active_mask;bool kthread = p->flags &PF_KTHREAD ; -struct cpumask *user_mask =NULL ;unsigned int dest_cpu;int ret =0 ;
@@ -2909,14 +2908,7 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p,__do_set_cpus_allowed (p, new_mask, flags); -if (flags &SCA_USER ) - user_mask =clear_user_cpus_ptr (p); - - ret =affine_move_task (rq, p, rf, dest_cpu, flags); - -kfree (user_mask); - -return ret; +return affine_move_task (rq, p, rf, dest_cpu, flags); out:task_rq_unlock (rq, p, rf);
@@ -2951,8 +2943,10 @@ EXPORT_SYMBOL_GPL(set_cpus_allowed_ptr);/* * Change a given task's CPU affinity to the intersection of its current -* affinity mask and @subset_mask, writing the resulting mask to @new_mask -* and pointing @p->user_cpus_ptr to a copy of the old mask. +* affinity mask and @subset_mask, writing the resulting mask to @new_mask. +* If user_cpus_ptr is defined, use it as the basis for restricting CPU +* affinity or use cpu_online_mask instead. +* * If the resulting mask is empty, leave the affinity unchanged and return * -EINVAL. */
@@ -2960,17 +2954,10 @@ static int restrict_cpus_allowed_ptr(struct task_struct *p,struct cpumask *new_mask, const struct cpumask *subset_mask) { - struct cpumask *user_mask = NULL; struct rq_flags rf;struct rq *rq;int err; -if (!p->user_cpus_ptr) { - user_mask =kmalloc (cpumask_size (),GFP_KERNEL ); -if (!user_mask) -return -ENOMEM ; - } - rq =task_rq_lock (p, &rf);/*
@@ -2983,25 +2970,15 @@ static int restrict_cpus_allowed_ptr(struct task_struct *p, goto err_unlock; } -if (!cpumask_and (new_mask, &p->cpus_mask, subset_mask)) { +if (!cpumask_and (new_mask,task_user_cpus (p), subset_mask)) { err = -EINVAL ; goto err_unlock; } -/* -* We're about to butcher the task affinity, so keep track of what -* the user asked for in case we're able to restore it later on. -*/ -if (user_mask) { -cpumask_copy (user_mask, p->cpus_ptr); - p->user_cpus_ptr = user_mask; - } -return __set_cpus_allowed_ptr_locked (p, new_mask,0 , rq, &rf); err_unlock:task_rq_unlock (rq, p, &rf); -kfree (user_mask);return err; }
@@ -3055,30 +3032,21 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask);/* * Restore the affinity of a task @p which was previously restricted by a -* call to force_compatible_cpus_allowed_ptr(). This will clear (and free) -* @p->user_cpus_ptr. +* call to force_compatible_cpus_allowed_ptr(). * * It is the caller's responsibility to serialise this with any calls to * force_compatible_cpus_allowed_ptr(@p). */ void relax_compatible_cpus_allowed_ptr (struct task_struct *p) { -struct cpumask *user_mask = p->user_cpus_ptr; -unsigned long flags; +int ret;/* -* Try to restore the old affinity mask. If this fails, then -* we free the mask explicitly to avoid it being inherited across -* a subsequent fork(). +* Try to restore the old affinity mask with __sched_setaffinity(). +* Cpuset masking will be done there too. */ -if (!user_mask || !__sched_setaffinity (p, user_mask)) -return ; - -raw_spin_lock_irqsave (&p->pi_lock, flags); - user_mask =clear_user_cpus_ptr (p); -raw_spin_unlock_irqrestore (&p->pi_lock, flags); - -kfree (user_mask); + ret =__sched_setaffinity (p,task_user_cpus (p)); +WARN_ON_ONCE (ret); }void set_task_cpu (struct task_struct *p,unsigned int new_cpu)
@@ -8101,7 +8069,7 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask)if (retval) goto out_free_new_mask; again: - retval =__set_cpus_allowed_ptr (p, new_mask,SCA_CHECK |SCA_USER ); + retval =__set_cpus_allowed_ptr (p, new_mask,SCA_CHECK );if (retval) goto out_free_new_mask;
@@ -8124,6 +8092,7 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask)long sched_setaffinity (pid_t pid,const struct cpumask *in_mask) { +struct cpumask *user_mask;struct task_struct *p;int retval;
@@ -8158,7 +8127,30 @@ long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)if (retval) goto out_put_task; + user_mask =kmalloc (cpumask_size (),GFP_KERNEL ); +if (!user_mask) { + retval = -ENOMEM ; + goto out_put_task; + } +cpumask_copy (user_mask, in_mask); + retval =__sched_setaffinity (p, in_mask); + +/* +* Save in_mask into user_cpus_ptr after a successful +* __sched_setaffinity() call. pi_lock is used to synchronize +* changes to user_cpus_ptr. +*/ +if (!retval) { +unsigned long flags; + +/* Use pi_lock to synchronize changes to user_cpus_ptr */ +raw_spin_lock_irqsave (&p->pi_lock, flags); +swap (p->user_cpus_ptr, user_mask); +raw_spin_unlock_irqrestore (&p->pi_lock, flags); + } +kfree (user_mask); + out_put_task:put_task_struct (p);return retval;
kernel/sched/sched.h +7 -0
@@ -1881,6 +1881,13 @@ static inline void dirty_sched_domain_sysctl(int cpu)#endif extern int sched_update_scaling (void ); + +static inline const struct cpumask *task_user_cpus (struct task_struct *p) +{ +if (!p->user_cpus_ptr) +return cpu_possible_mask;/* &init_task.cpus_mask */ +return p->user_cpus_ptr; +}#endif /* CONFIG_SMP */ #include "stats.h"
Signature · 1 line
2.31.1
PATCH v7 3/5 sched: Enforce user requested affinity
In reply to Waiman LongIt was found that the user requested affinity via sched_setaffinity() can be easily overwritten by other kernel subsystems without an easy way to reset it back to what the user requested. For example, any change to the current cpuset hierarchy may reset the cpumask of the tasks in the affected cpusets to the default cpuset value even if those tasks have pre-existing user requested affinity. That is especially easy to trigger under a cgroup v2 environment where writing "+cpuset" to the root cgroup's cgroup.subtree_control file will reset the cpus affinity of all the processes in the system.
That is problematic in a nohz_full environment where the tasks running in the nohz_full CPUs usually have their cpus affinity explicitly set and will behave incorrectly if cpus affinity changes.
Fix this problem by looking at user_cpus_ptr in __set_cpus_allowed_ptr() and use it to restrcit the given cpumask unless there is no overlap. In that case, it will fallback to the given one. The SCA_USER flag is reused to indicate intent to set user_cpus_ptr and so user_cpus_ptr masking should be skipped.
All callers of set_cpus_allowed_ptr() will be affected by this change. A scratch cpumask is added to percpu runqueues structure for doing additional masking when user_cpus_ptr is set.
--- kernel/sched/core.c | 17 ++++++++++++----- kernel/sched/sched.h | 3 +++ 2 files changed, 15 insertions(+), 5 deletions(-)
kernel/sched/core.c +12 -5
@@ -2932,6 +2932,10 @@ static int __set_cpus_allowed_ptr(struct task_struct *p,struct rq *rq; rq =task_rq_lock (p, &rf); +if (p->user_cpus_ptr && !(flags &SCA_USER ) && +cpumask_and (rq->scratch_mask, new_mask, p->user_cpus_ptr)) + new_mask = rq->scratch_mask; +return __set_cpus_allowed_ptr_locked (p, new_mask, flags, rq, &rf); }
@@ -3028,7 +3032,7 @@ void force_compatible_cpus_allowed_ptr(struct task_struct *p) }static int -__sched_setaffinity (struct task_struct *p,const struct cpumask *mask); +__sched_setaffinity (struct task_struct *p,const struct cpumask *mask,int flags);/* * Restore the affinity of a task @p which was previously restricted by a
@@ -3045,7 +3049,7 @@ void relax_compatible_cpus_allowed_ptr(struct task_struct *p)* Try to restore the old affinity mask with __sched_setaffinity(). * Cpuset masking will be done there too. */ - ret =__sched_setaffinity (p,task_user_cpus (p)); + ret =__sched_setaffinity (p,task_user_cpus (p),0 );WARN_ON_ONCE (ret); }
@@ -8049,7 +8053,7 @@ int dl_task_check_affinity(struct task_struct *p, const struct cpumask *mask)#endif static int -__sched_setaffinity (struct task_struct *p,const struct cpumask *mask) +__sched_setaffinity (struct task_struct *p,const struct cpumask *mask,int flags) {int retval;cpumask_var_t cpus_allowed, new_mask;
@@ -8069,7 +8073,7 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask)if (retval) goto out_free_new_mask; again: - retval =__set_cpus_allowed_ptr (p, new_mask,SCA_CHECK ); + retval =__set_cpus_allowed_ptr (p, new_mask,SCA_CHECK | flags);if (retval) goto out_free_new_mask;
@@ -8134,7 +8138,7 @@ long sched_setaffinity(pid_t pid, const struct cpumask *in_mask) }cpumask_copy (user_mask, in_mask); - retval =__sched_setaffinity (p, in_mask); + retval =__sched_setaffinity (p, in_mask,SCA_USER );/* * Save in_mask into user_cpus_ptr after a successful
@@ -9647,6 +9651,9 @@ void __init sched_init(void) cpumask_size(), GFP_KERNEL, cpu_to_node(i));per_cpu (select_rq_mask, i) = (cpumask_var_t )kzalloc_node (cpumask_size (),GFP_KERNEL ,cpu_to_node (i)); +per_cpu (runqueues.scratch_mask, i) = + (cpumask_var_t )kzalloc_node (cpumask_size (), + GFP_KERNEL, cpu_to_node(i)); }#endif /* CONFIG_CPUMASK_OFFSTACK */
kernel/sched/sched.h +3 -0
@@ -1159,6 +1159,9 @@ struct rq {unsigned int core_forceidle_occupation;u64 core_forceidle_start;#endif + +/* Scratch cpumask to be temporarily used under rq_lock */ +cpumask_var_t scratch_mask; };#ifdef CONFIG_FAIR_GROUP_SCHED
Signature · 1 line
2.31.1
PATCH v7 4/5 sched: Handle set_cpus_allowed_ptr() & sched_setaffinity() race
In reply to Waiman LongRacing is possible between set_cpus_allowed_ptr() and sched_setaffinity() or between multiple sched_setaffinity() calls from different CPUs. To resolve these race conditions, we need to update both user_cpus_ptr and cpus_mask in a single lock critical section instead of separated ones. This requires moving the user_cpus_ptr update to set_cpus_allowed_common().
The SCA_USER flag will be used to signify that a user_cpus_ptr update will have to be done. The new user_cpus_ptr will be put into the a percpu variable pending_user_mask at the beginning of the lock crtical section. The pending user mask will then be taken up in set_cpus_allowed_common().
Ideally, user_cpus_ptr should only be updated if the sched_setaffinity() is successful. However, this patch will update user_cpus_ptr when the first call to __set_cpus_allowed_ptr() is successful. However, if there is racing between sched_setaffinity() and cpuset update, the subsequent calls to __set_cpus_allowed_ptr() may fail but the user_cpus_ptr will still be updated in this corner case. A warning will be printed in this corner case.
--- kernel/sched/core.c | 59 ++++++++++++++++++++++++++++----------------- 1 file changed, 37 insertions(+), 22 deletions(-)
kernel/sched/core.c +37 -22
@@ -111,6 +111,7 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(sched_util_est_se_tp);EXPORT_TRACEPOINT_SYMBOL_GPL (sched_update_nr_running_tp); DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues); +DEFINE_PER_CPU(struct cpumask **, pending_user_mask);#ifdef CONFIG_SCHED_DEBUG /*
@@ -2199,6 +2200,7 @@ __do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask, u32static int __set_cpus_allowed_ptr (struct task_struct *p,const struct cpumask *new_mask, +struct cpumask **puser_mask,u32 flags);static void migrate_disable_switch (struct rq *rq,struct task_struct *p)
@@ -2249,7 +2251,8 @@ void migrate_enable(void)*/ preempt_disable ();if (p->cpus_ptr != &p->cpus_mask) -__set_cpus_allowed_ptr (p, &p->cpus_mask,SCA_MIGRATE_ENABLE ); +__set_cpus_allowed_ptr (p, &p->cpus_mask,NULL , +SCA_MIGRATE_ENABLE );/* * Mustn't clear migration_disabled() until cpus_ptr points back at the * regular cpus_mask, otherwise things that race (eg.
@@ -2538,6 +2541,12 @@ void set_cpus_allowed_common(struct task_struct *p, const struct cpumask *new_macpumask_copy (&p->cpus_mask, new_mask); p->nr_cpus_allowed =cpumask_weight (new_mask); + +/* +* Swap in the new user_cpus_ptr if SCA_USER flag set +*/ +if (flags &SCA_USER ) +swap (p->user_cpus_ptr, *__this_cpu_read (pending_user_mask)); } static void
@@ -2926,12 +2935,19 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p,* call is not atomic; no spinlocks may be held. */ static int __set_cpus_allowed_ptr (struct task_struct *p, -const struct cpumask *new_mask,u32 flags) +const struct cpumask *new_mask, +struct cpumask **puser_mask, +u32 flags) {struct rq_flags rf;struct rq *rq; rq =task_rq_lock (p, &rf); +/* +* CPU won't be preempted or interrupted while holding task_rq_lock(). +*/ +__this_cpu_write (pending_user_mask, puser_mask); +if (p->user_cpus_ptr && !(flags &SCA_USER ) &&cpumask_and (rq->scratch_mask, new_mask, p->user_cpus_ptr)) new_mask = rq->scratch_mask;
@@ -2941,7 +2957,7 @@ static int __set_cpus_allowed_ptr(struct task_struct *p,int set_cpus_allowed_ptr (struct task_struct *p,const struct cpumask *new_mask) { -return __set_cpus_allowed_ptr (p, new_mask,0 ); +return __set_cpus_allowed_ptr (p, new_mask,NULL ,0 ); }EXPORT_SYMBOL_GPL (set_cpus_allowed_ptr);
@@ -3032,7 +3048,8 @@ void force_compatible_cpus_allowed_ptr(struct task_struct *p) }static int -__sched_setaffinity (struct task_struct *p,const struct cpumask *mask,int flags); +__sched_setaffinity (struct task_struct *p,const struct cpumask *mask, +struct cpumask **puser_mask,int flags);/* * Restore the affinity of a task @p which was previously restricted by a
@@ -3049,7 +3066,7 @@ void relax_compatible_cpus_allowed_ptr(struct task_struct *p)* Try to restore the old affinity mask with __sched_setaffinity(). * Cpuset masking will be done there too. */ - ret =__sched_setaffinity (p,task_user_cpus (p),0 ); + ret =__sched_setaffinity (p,task_user_cpus (p),NULL ,0 );WARN_ON_ONCE (ret); }
@@ -3529,6 +3546,7 @@ void sched_set_stop_task(int cpu, struct task_struct *stop)static inline int __set_cpus_allowed_ptr (struct task_struct *p,const struct cpumask *new_mask, +struct cpumask *user_mask,u32 flags) {return set_cpus_allowed_ptr (p, new_mask);
@@ -8053,7 +8071,8 @@ int dl_task_check_affinity(struct task_struct *p, const struct cpumask *mask)#endif static int -__sched_setaffinity (struct task_struct *p,const struct cpumask *mask,int flags) +__sched_setaffinity (struct task_struct *p,const struct cpumask *mask, +struct cpumask **puser_mask,int flags) {int retval;cpumask_var_t cpus_allowed, new_mask;
@@ -8072,8 +8091,10 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask, int flags retval =dl_task_check_affinity (p, new_mask);if (retval) goto out_free_new_mask; + + retval =__set_cpus_allowed_ptr (p, new_mask, puser_mask, +SCA_CHECK | flags); again: - retval =__set_cpus_allowed_ptr (p, new_mask,SCA_CHECK | flags);if (retval) goto out_free_new_mask;
@@ -8084,6 +8105,14 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask, int flags* Just reset the cpumask to the cpuset's cpus_allowed. */ cpumask_copy (new_mask, cpus_allowed); + retval =__set_cpus_allowed_ptr (p, new_mask,NULL ,SCA_CHECK ); + +/* +* Warn in case of the unexpected success in updating +* user_cpus_ptr in first __set_cpus_allowed_ptr() but then +* fails in a subsequent retry. +*/ +WARN_ON_ONCE (retval && (flags |SCA_USER )); goto again; }
@@ -8138,21 +8167,7 @@ long sched_setaffinity(pid_t pid, const struct cpumask *in_mask) }cpumask_copy (user_mask, in_mask); - retval =__sched_setaffinity (p, in_mask,SCA_USER ); - -/* -* Save in_mask into user_cpus_ptr after a successful -* __sched_setaffinity() call. pi_lock is used to synchronize -* changes to user_cpus_ptr. -*/ -if (!retval) { -unsigned long flags; - -/* Use pi_lock to synchronize changes to user_cpus_ptr */ -raw_spin_lock_irqsave (&p->pi_lock, flags); -swap (p->user_cpus_ptr, user_mask); -raw_spin_unlock_irqrestore (&p->pi_lock, flags); - } + retval =__sched_setaffinity (p, in_mask, &user_mask,SCA_USER );kfree (user_mask); out_put_task:
Signature · 1 line
2.31.1
Peter Zijlstra
maintainerRe: [PATCH v7 4/5] sched: Handle set_cpus_allowed_ptr() & sched_setaffinity() race
Quoted 21 lines · Waiman Long
Racing is possible between
set_cpus_allowed_ptr()andsched_setaffinity()or between multiplesched_setaffinity()calls from different CPUs. To resolve these race conditions, we need to update bothuser_cpus_ptrandcpus_maskin a single lock critical section instead of separated ones. This requires moving theuser_cpus_ptrupdate toset_cpus_allowed_common().The
SCA_USERflag will be used to signify that auser_cpus_ptrupdate will have to be done. The newuser_cpus_ptrwill be put into the a percpu variablepending_user_maskat the beginning of the lock crtical section. The pending user mask will then be taken up inset_cpus_allowed_common().Ideally,
user_cpus_ptrshould only be updated if thesched_setaffinity()is successful. However, this patch will updateuser_cpus_ptrwhen the first call to__set_cpus_allowed_ptr()is successful. However, if there is racing betweensched_setaffinity()and cpuset update, the subsequent calls to__set_cpus_allowed_ptr()may fail but theuser_cpus_ptrwill still be updated in this corner case. A warning will be printed in this corner case.
Quoted 1 line
Signed-off-by Waiman Long <[email protected]>
OK, so obviously this is terrible :/
What's wrong with something like so ?
--- kernel/sched/core.c | 220 ++++++++++++++++++++++++++++++------------------ kernel/sched/deadline.c | 7 +- kernel/sched/sched.h | 22 ++++- 3 files changed, 157 insertions(+), 92 deletions(-)
kernel/sched/core.c +136 -84
@@ -2195,14 +2195,19 @@ void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags)#ifdef CONFIG_SMP static void -__do_set_cpus_allowed (struct task_struct *p,const struct cpumask *new_mask,u32 flags); +__do_set_cpus_allowed (struct task_struct *p,struct affinity_context *ctx);static int __set_cpus_allowed_ptr (struct task_struct *p, -const struct cpumask *new_mask, -u32 flags); +struct affinity_context *ctx);static void migrate_disable_switch (struct rq *rq,struct task_struct *p) { +struct affinity_context ac = { + .user_mask =NULL , + .new_mask =cpumask_of (rq->cpu), + .flags =SCA_MIGRATE_DISABLE , + }; +if (likely (!p->migration_disabled))return ;
@@ -2212,7 +2217,7 @@ static void migrate_disable_switch(struct rq *rq, struct task_struct *p)/* * Violates locking rules! see comment in __do_set_cpus_allowed(). */ -__do_set_cpus_allowed (p,cpumask_of (rq->cpu),SCA_MIGRATE_DISABLE ); +__do_set_cpus_allowed (p, &ac); }void migrate_disable (void )
@@ -2234,6 +2239,11 @@ EXPORT_SYMBOL_GPL(migrate_disable);void migrate_enable (void ) {struct task_struct *p = current; +struct affinity_context ac = { + .user_mask =NULL , + .new_mask = &p->cpus_mask, + .flags =SCA_MIGRATE_ENABLE , + };if (p->migration_disabled >1 ) { p->migration_disabled--;
@@ -2249,7 +2259,7 @@ void migrate_enable(void)*/ preempt_disable ();if (p->cpus_ptr != &p->cpus_mask) -__set_cpus_allowed_ptr (p, &p->cpus_mask,SCA_MIGRATE_ENABLE ); +__set_cpus_allowed_ptr (p, &ac);/* * Mustn't clear migration_disabled() until cpus_ptr points back at the * regular cpus_mask, otherwise things that race (eg.
@@ -2529,19 +2539,22 @@ int push_cpu_stop(void *arg)* sched_class::set_cpus_allowed must do the below, but is not required to * actually call this function. */ -void set_cpus_allowed_common (struct task_struct *p,const struct cpumask *new_mask,u32 flags) +void set_cpus_allowed_common (struct task_struct *p,struct affinity_context *ctx) { -if (flags & (SCA_MIGRATE_ENABLE |SCA_MIGRATE_DISABLE )) { - p->cpus_ptr = new_mask; +if (ctx->flags & (SCA_MIGRATE_ENABLE |SCA_MIGRATE_DISABLE )) { + p->cpus_ptr = ctx->new_mask;return ; } -cpumask_copy (&p->cpus_mask, new_mask); - p->nr_cpus_allowed =cpumask_weight (new_mask); +if (ctx->flags &SCA_USER ) +swap (p->user_cpus_ptr, ctx->user_mask); + +cpumask_copy (&p->cpus_mask, ctx->new_mask); + p->nr_cpus_allowed =cpumask_weight (ctx->new_mask); }static void -__do_set_cpus_allowed (struct task_struct *p,const struct cpumask *new_mask,u32 flags) +__do_set_cpus_allowed (struct task_struct *p,struct affinity_context *ctx) {struct rq *rq =task_rq (p);bool queued, running;
@@ -2558,7 +2571,7 @@ __do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask, u32* * XXX do further audits, this smells like something putrid. */ -if (flags &SCA_MIGRATE_DISABLE ) +if (ctx->flags &SCA_MIGRATE_DISABLE )SCHED_WARN_ON (!p->on_cpu);else lockdep_assert_held (&p->pi_lock);
@@ -2577,7 +2590,7 @@ __do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask, u32if (running)put_prev_task (rq, p); - p->sched_class->set_cpus_allowed (p, new_mask, flags); + p->sched_class->set_cpus_allowed (p, ctx);if (queued)enqueue_task (rq, p,ENQUEUE_RESTORE |ENQUEUE_NOCLOCK );
@@ -2585,13 +2598,23 @@ __do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask, u32set_next_task (rq, p); } +/* +* Used for kthread_bind() and select_fallback_rq(), in both cases the user +* affinity (if any) should be destroyed too. +*/ void do_set_cpus_allowed (struct task_struct *p,const struct cpumask *new_mask) { -__do_set_cpus_allowed (p, new_mask,0 ); +struct affinity_context ac = { + .user_mask =NULL , + .new_mask = new_mask, + .flags =SCA_USER ,/* clear the user requested mask */ + }; + +__do_set_cpus_allowed (p, &ac); +kfree (ac.user_mask); } -int dup_user_cpus_ptr (struct task_struct *dst,struct task_struct *src, -int node) +int dup_user_cpus_ptr (struct task_struct *dst,struct task_struct *src,int node) {if (!src->user_cpus_ptr)return 0 ;
@@ -2696,6 +2719,8 @@ void release_user_cpus_ptr(struct task_struct *p)*/ static int affine_move_task (struct rq *rq,struct task_struct *p,struct rq_flags *rf,int dest_cpu,unsigned int flags) + __releases(rq->lock) + __releases(p->pi_lock) {struct set_affinity_pending my_pending = { }, *pending =NULL ;bool stop_pending, complete = false;
@@ -2838,8 +2863,7 @@ static int affine_move_task(struct rq *rq, struct task_struct *p, struct rq_flag* Called with both p->pi_lock and rq->lock held; drops both before returning. */ static int __set_cpus_allowed_ptr_locked(struct task_struct *p, - const struct cpumask *new_mask, - u32 flags, + struct affinity_context *ctx, struct rq *rq, struct rq_flags *rf) __releases(rq->lock)
@@ -2848,7 +2872,6 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p,const struct cpumask *cpu_allowed_mask =task_cpu_possible_mask (p);const struct cpumask *cpu_valid_mask = cpu_active_mask;bool kthread = p->flags &PF_KTHREAD ; -struct cpumask *user_mask =NULL ;unsigned int dest_cpu;int ret =0 ;
@@ -2868,7 +2891,7 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p, cpu_valid_mask = cpu_online_mask; } -if (!kthread && !cpumask_subset (new_mask, cpu_allowed_mask)) { +if (!kthread && !cpumask_subset (ctx->new_mask, cpu_allowed_mask)) { ret = -EINVAL ; goto out; }
@@ -2877,18 +2900,18 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p,* Must re-check here, to close a race against __kthread_bind(), * sched_setaffinity() is not guaranteed to observe the flag. */ -if ((flags &SCA_CHECK ) && (p->flags &PF_NO_SETAFFINITY )) { +if ((ctx->flags &SCA_CHECK ) && (p->flags &PF_NO_SETAFFINITY )) { ret = -EINVAL ; goto out; } -if (!(flags &SCA_MIGRATE_ENABLE )) { -if (cpumask_equal (&p->cpus_mask, new_mask)) +if (!(ctx->flags &SCA_MIGRATE_ENABLE )) { +if (cpumask_equal (&p->cpus_mask, ctx->new_mask)) goto out;if (WARN_ON_ONCE (p == current &&is_migration_disabled (p) && - !cpumask_test_cpu (task_cpu (p), new_mask))) { + !cpumask_test_cpu (task_cpu (p), ctx->new_mask))) { ret = -EBUSY ; goto out; }
@@ -2899,22 +2922,15 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p,* for groups of tasks (ie. cpuset), so that load balancing is not * immediately required to distribute the tasks within their new mask. */ - dest_cpu =cpumask_any_and_distribute (cpu_valid_mask, new_mask); + dest_cpu =cpumask_any_and_distribute (cpu_valid_mask, ctx->new_mask);if (dest_cpu >= nr_cpu_ids) { ret = -EINVAL ; goto out; } -__do_set_cpus_allowed (p, new_mask, flags); +__do_set_cpus_allowed (p, ctx); -if (flags &SCA_USER ) - user_mask =clear_user_cpus_ptr (p); - - ret =affine_move_task (rq, p, rf, dest_cpu, flags); - -kfree (user_mask); - -return ret; +return affine_move_task (rq, p, rf, dest_cpu, ctx->flags); out:task_rq_unlock (rq, p, rf);
@@ -2932,25 +2948,46 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p,* call is not atomic; no spinlocks may be held. */ static int __set_cpus_allowed_ptr (struct task_struct *p, -const struct cpumask *new_mask,u32 flags) +struct affinity_context *ctx) {struct rq_flags rf;struct rq *rq; rq =task_rq_lock (p, &rf); -return __set_cpus_allowed_ptr_locked (p, new_mask, flags, rq, &rf); + +/* +* When this is not a user requestd affinity change, ensure the +* affinity request respects the previous user affinity if at all +* possible. +* +* XXX why can't we allocated scratch_mask before task_rq_lock() +* and return -ENOMEM here? +*/ +if (p->user_cpus_ptr && !(ctx->flags &SCA_USER ) && +cpumask_and (rq->scratch_mask, ctx->new_mask, p->user_cpus_ptr)) + ctx->new_mask = rq->scratch_mask; + +return __set_cpus_allowed_ptr_locked (p, ctx, rq, &rf); }int set_cpus_allowed_ptr (struct task_struct *p,const struct cpumask *new_mask) { -return __set_cpus_allowed_ptr (p, new_mask,0 ); +struct affinity_context ac = { + .user_mask =NULL , + .new_mask = new_mask, + .flags =0 , + }; + +return __set_cpus_allowed_ptr (p, &ac); }EXPORT_SYMBOL_GPL (set_cpus_allowed_ptr);/* * Change a given task's CPU affinity to the intersection of its current -* affinity mask and @subset_mask, writing the resulting mask to @new_mask -* and pointing @p->user_cpus_ptr to a copy of the old mask. +* affinity mask and @subset_mask, writing the resulting mask to @new_mask. +* If user_cpus_ptr is defined, use it as the basis for restricting CPU +* affinity or use cpu_online_mask instead. +* * If the resulting mask is empty, leave the affinity unchanged and return * -EINVAL. */
@@ -2958,17 +2995,15 @@ static int restrict_cpus_allowed_ptr(struct task_struct *p,struct cpumask *new_mask, const struct cpumask *subset_mask) { - struct cpumask *user_mask = NULL; + struct affinity_context ac = { + .user_mask =NULL , + .new_mask = new_mask, + .flags =0 , + };struct rq_flags rf;struct rq *rq;int err; -if (!p->user_cpus_ptr) { - user_mask =kmalloc (cpumask_size (),GFP_KERNEL ); -if (!user_mask) -return -ENOMEM ; - } - rq =task_rq_lock (p, &rf);/*
@@ -2981,31 +3016,21 @@ static int restrict_cpus_allowed_ptr(struct task_struct *p, goto err_unlock; } -if (!cpumask_and (new_mask, &p->cpus_mask, subset_mask)) { +if (!cpumask_and (new_mask,task_user_cpus (p), subset_mask)) { err = -EINVAL ; goto err_unlock; } -/* -* We're about to butcher the task affinity, so keep track of what -* the user asked for in case we're able to restore it later on. -*/ -if (user_mask) { -cpumask_copy (user_mask, p->cpus_ptr); - p->user_cpus_ptr = user_mask; - } - -return __set_cpus_allowed_ptr_locked (p, new_mask,0 , rq, &rf); +return __set_cpus_allowed_ptr_locked (p, &ac, rq, &rf); err_unlock:task_rq_unlock (rq, p, &rf); -kfree (user_mask);return err; }/* * Restrict the CPU affinity of task @p so that it is a subset of -* task_cpu_possible_mask() and point @p->user_cpu_ptr to a copy of the +* task_cpu_possible_mask() and point @p->user_cpus_ptr to a copy of the * old affinity mask. If the resulting mask is empty, we warn and walk * up the cpuset hierarchy until we find a suitable mask. */
@@ -3049,34 +3074,30 @@ void force_compatible_cpus_allowed_ptr(struct task_struct *p) }static int -__sched_setaffinity (struct task_struct *p,const struct cpumask *mask); +__sched_setaffinity (struct task_struct *p,struct affinity_context *ctx);/* * Restore the affinity of a task @p which was previously restricted by a -* call to force_compatible_cpus_allowed_ptr(). This will clear (and free) -* @p->user_cpus_ptr. +* call to force_compatible_cpus_allowed_ptr(). * * It is the caller's responsibility to serialise this with any calls to * force_compatible_cpus_allowed_ptr(@p). */ void relax_compatible_cpus_allowed_ptr (struct task_struct *p) { -struct cpumask *user_mask = p->user_cpus_ptr; -unsigned long flags; +struct affinity_context ac = { + .user_mask =NULL , + .new_mask =task_user_cpus (p), + .flags =0 , + }; +int ret;/* -* Try to restore the old affinity mask. If this fails, then -* we free the mask explicitly to avoid it being inherited across -* a subsequent fork(). +* Try to restore the old affinity mask with __sched_setaffinity(). +* Cpuset masking will be done there too. */ -if (!user_mask || !__sched_setaffinity (p, user_mask)) -return ; - -raw_spin_lock_irqsave (&p->pi_lock, flags); - user_mask =clear_user_cpus_ptr (p); -raw_spin_unlock_irqrestore (&p->pi_lock, flags); - -kfree (user_mask); + ret =__sched_setaffinity (p, &ac); +WARN_ON_ONCE (ret); }void set_task_cpu (struct task_struct *p,unsigned int new_cpu)
@@ -3554,10 +3575,9 @@ void sched_set_stop_task(int cpu, struct task_struct *stop)#else /* CONFIG_SMP */ static inline int __set_cpus_allowed_ptr (struct task_struct *p, -const struct cpumask *new_mask, -u32 flags) +struct affinity_context *ctx) { -return set_cpus_allowed_ptr (p, new_mask); +return set_cpus_allowed_ptr (p, ctx->new_mask); }static inline void migrate_disable_switch (struct rq *rq,struct task_struct *p) { }
@@ -8079,10 +8099,10 @@ int dl_task_check_affinity(struct task_struct *p, const struct cpumask *mask)#endif static int -__sched_setaffinity (struct task_struct *p,const struct cpumask *mask) +__sched_setaffinity (struct task_struct *p,struct affinity_context *ctx) { -int retval;cpumask_var_t cpus_allowed, new_mask; +int retval;if (!alloc_cpumask_var (&cpus_allowed,GFP_KERNEL ))return -ENOMEM ;
@@ -8093,13 +8113,16 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask) }cpuset_cpus_allowed (p, cpus_allowed); -cpumask_and (new_mask, mask, cpus_allowed); +cpumask_and (new_mask, ctx->new_mask, cpus_allowed); + + ctx->new_mask = new_mask; + ctx->flags |=SCA_CHECK ; retval =dl_task_check_affinity (p, new_mask);if (retval) goto out_free_new_mask; again: - retval =__set_cpus_allowed_ptr (p, new_mask,SCA_CHECK |SCA_USER ); + retval =__set_cpus_allowed_ptr (p, ctx);if (retval) goto out_free_new_mask;
@@ -8108,6 +8131,8 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask)/* * We must have raced with a concurrent cpuset update. * Just reset the cpumask to the cpuset's cpus_allowed. +* +* XXX can we do better here? */ cpumask_copy (new_mask, cpus_allowed); goto again;
@@ -8122,6 +8147,8 @@ __sched_setaffinity(struct task_struct *p, const struct cpumask *mask)long sched_setaffinity (pid_t pid,const struct cpumask *in_mask) { +struct affinity_context ac; +struct cpumask *user_mask;struct task_struct *p;int retval;
@@ -8156,7 +8183,23 @@ long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)if (retval) goto out_put_task; - retval =__sched_setaffinity (p, in_mask); + user_mask =kmalloc (cpumask_size (),GFP_KERNEL ); +if (!user_mask) { + retval = -ENOMEM ; + goto out_put_task; + } +cpumask_copy (user_mask, in_mask); + + ac = (struct affinity_context ){ + .user_mask = user_mask, + .new_mask = in_mask, + .flags =SCA_USER , + }; + + retval =__sched_setaffinity (p, &ac); + +kfree (user_mask); + out_put_task:put_task_struct (p);return retval;
@@ -8938,6 +8981,7 @@ void show_state_filter(unsigned int state_filter)void __init init_idle (struct task_struct *idle,int cpu) {struct rq *rq =cpu_rq (cpu); +struct affinity_context ac;unsigned long flags;__sched_fork (0 , idle);
@@ -8955,13 +8999,18 @@ void __init init_idle(struct task_struct *idle, int cpu)kthread_set_per_cpu (idle, cpu);#ifdef CONFIG_SMP + ac = (struct affinity_context ) { + .user_mask =NULL , + .new_mask =cpumask_of (cpu), + .flags =0 , + };/* * It's possible that init_idle() gets called multiple times on a task, * in that case do_set_cpus_allowed() will not do the right thing. * * And since this is boot we can forgo the serialization. */ -set_cpus_allowed_common (idle,cpumask_of (cpu),0 ); +set_cpus_allowed_common (idle, &ac);#endif /* * We're having a chicken and egg problem, even though we are
@@ -9653,6 +9702,9 @@ void __init sched_init(void) cpumask_size(), GFP_KERNEL, cpu_to_node(i));per_cpu (select_rq_mask, i) = (cpumask_var_t )kzalloc_node (cpumask_size (),GFP_KERNEL ,cpu_to_node (i)); +per_cpu (runqueues.scratch_mask, i) = + (cpumask_var_t )kzalloc_node (cpumask_size (), + GFP_KERNEL, cpu_to_node(i)); }#endif /* CONFIG_CPUMASK_OFFSTACK */
kernel/sched/deadline.c +3 -4
@@ -2486,8 +2486,7 @@ static void task_woken_dl(struct rq *rq, struct task_struct *p) }static void set_cpus_allowed_dl (struct task_struct *p, -const struct cpumask *new_mask, -u32 flags) +struct affinity_context *ctx) {struct root_domain *src_rd;struct rq *rq;
@@ -2502,7 +2501,7 @@ static void set_cpus_allowed_dl(struct task_struct *p,* update. We already made space for us in the destination * domain (see cpuset_can_attach()). */ -if (!cpumask_intersects (src_rd->span, new_mask)) { +if (!cpumask_intersects (src_rd->span, ctx->new_mask)) {struct dl_bw *src_dl_b; src_dl_b =dl_bw_of (cpu_of (rq));
@@ -2516,7 +2515,7 @@ static void set_cpus_allowed_dl(struct task_struct *p,raw_spin_unlock (&src_dl_b->lock); } -set_cpus_allowed_common (p, new_mask, flags); +set_cpus_allowed_common (p, ctx); }/* Assumes rq->lock is held */
kernel/sched/sched.h +18 -4
@@ -1159,6 +1159,9 @@ struct rq {unsigned int core_forceidle_occupation;u64 core_forceidle_start;#endif + +/* Scratch cpumask to be temporarily used under rq_lock */ +cpumask_var_t scratch_mask; };#ifdef CONFIG_FAIR_GROUP_SCHED
@@ -1881,6 +1884,13 @@ static inline void dirty_sched_domain_sysctl(int cpu)#endif extern int sched_update_scaling (void ); + +static inline const struct cpumask *task_user_cpus (struct task_struct *p) +{ +if (!p->user_cpus_ptr) +return cpu_possible_mask;/* &init_task.cpus_mask */ +return p->user_cpus_ptr; +}#endif /* CONFIG_SMP */ #include "stats.h"
@@ -2147,6 +2157,12 @@ extern const u32 sched_prio_to_wmult[40];#define RETRY_TASK ((void *)-1UL) +struct affinity_context { +struct cpumask *user_mask; +const struct cpumask *new_mask; +unsigned int flags; +}; +struct sched_class {#ifdef CONFIG_UCLAMP_TASK
@@ -2175,9 +2191,7 @@ struct sched_class {void (*task_woken)(struct rq *this_rq,struct task_struct *task); -void (*set_cpus_allowed)(struct task_struct *p, -const struct cpumask *newmask, -u32 flags); +void (*set_cpus_allowed)(struct task_struct *p,struct affinity_context *ctx);void (*rq_online)(struct rq *rq);void (*rq_offline)(struct rq *rq);
@@ -2291,7 +2305,7 @@ extern void update_group_capacity(struct sched_domain *sd, int cpu);extern void trigger_load_balance (struct rq *rq); -extern void set_cpus_allowed_common (struct task_struct *p,const struct cpumask *new_mask,u32 flags); +extern void set_cpus_allowed_common (struct task_struct *p,struct affinity_context *ctx);static inline struct task_struct *get_push_task (struct rq *rq) {
Re: [PATCH v7 4/5] sched: Handle set_cpus_allowed_ptr() & sched_setaffinity() race
Quoted 22 lines · Peter Zijlstra
Quoted 21 lines · Waiman Long
Racing is possible between
set_cpus_allowed_ptr()andsched_setaffinity()or between multiplesched_setaffinity()calls from different CPUs. To resolve these race conditions, we need to update bothuser_cpus_ptrandcpus_maskin a single lock critical section instead of separated ones. This requires moving theuser_cpus_ptrupdate toset_cpus_allowed_common().The
SCA_USERflag will be used to signify that auser_cpus_ptrupdate will have to be done. The newuser_cpus_ptrwill be put into the a percpu variablepending_user_maskat the beginning of the lock crtical section. The pending user mask will then be taken up inset_cpus_allowed_common().Ideally,
user_cpus_ptrshould only be updated if thesched_setaffinity()is successful. However, this patch will updateuser_cpus_ptrwhen the first call to__set_cpus_allowed_ptr()is successful. However, if there is racing betweensched_setaffinity()and cpuset update, the subsequent calls to__set_cpus_allowed_ptr()may fail but theuser_cpus_ptrwill still be updated in this corner case. A warning will be printed in this corner case.
Quoted 4 lines
Quoted 1 line
Signed-off-by Waiman Long <[email protected]>OK, so obviously this is terrible :/
What's wrong with something like so ?
Thanks for the suggestion. I have no problem adding an affinity_context structure to pass around the functions. Will incorporate your suggestion in the next version of the patch.
Thanks,
Longman
PATCH v7 5/5 sched: Fix sched_setaffinity() and fork/clone() race
In reply to Waiman Longsched_setaffinity() can also race with a concurrent fork/clone() syscall calling dup_user_cpus_ptr(). That may lead to a use after free problem. Fix that by protecting the cpumask copying using pi_lock of the source task.
--- kernel/sched/core.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/sched/core.c +5 -0
@@ -2602,6 +2602,8 @@ void do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask)int dup_user_cpus_ptr (struct task_struct *dst,struct task_struct *src,int node) { +unsigned long flags; +if (!src->user_cpus_ptr)return 0 ;
@@ -2609,7 +2611,10 @@ int dup_user_cpus_ptr(struct task_struct *dst, struct task_struct *src,if (!dst->user_cpus_ptr)return -ENOMEM ; +/* Use pi_lock to protect content of user_cpus_ptr */ +raw_spin_lock_irqsave (&src->pi_lock, flags);cpumask_copy (dst->user_cpus_ptr, src->user_cpus_ptr); +raw_spin_unlock_irqrestore (&src->pi_lock, flags);return 0 ; }
Signature · 1 line
2.31.1