sched: Fix SCHED_FLAG_KEEP_PARAMS side effects
cover sched: Fix SCHED_FLAG_KEEP_PARAMS side effects
SCHED_FLAG_KEEP_PARAMS allows sched_setattr() to update generic task attributes while retaining the task's existing scheduling parameters and class.
Two paths in __sched_setscheduler() still act on the requested policy before the guarded parameter update. One marks the operation as a class change and invokes class transition callbacks even though the class remains unchanged. The other performs deadline admission control and can account bandwidth for a non-deadline task that never enters the deadline class.
Prevent both side effects when SCHED_FLAG_KEEP_PARAMS is set.
Andrea Righi (2):
sched: Skip class callbacks with SCHED_FLAG_KEEP_PARAMS sched/deadline: Skip bandwidth accounting with SCHED_FLAG_KEEP_PARAMS
kernel/sched/syscalls.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
base-commit: bafb78898eb70fcaa979608a2d7ae9bad86124a1
PATCH 1/2 sched: Skip class callbacks with SCHED_FLAG_KEEP_PARAMS
SCHED_FLAG_KEEP_PARAMS suppresses scheduler parameter and class changes, but __sched_setscheduler() can still set DEQUEUE_CLASS when the class computed from the requested policy differs from the task's current class.
This causes the switching_from(), switched_from(), switching_to() and switched_to() callbacks to run even though p->sched_class remains unchanged.
Set DEQUEUE_CLASS only when the sched class is allowed to change.
--- kernel/sched/syscalls.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/sched/syscalls.c +2 -1
@@ -675,7 +675,8 @@ int __sched_setscheduler(struct task_struct *p, prev_class = p->sched_class; next_class =__setscheduler_class (policy, newprio); -if (prev_class != next_class) +if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS ) && + prev_class != next_class) queue_flags |=DEQUEUE_CLASS ; scoped_guard (sched_change, p, queue_flags) {
Signature · 1 line
2.55.0
K Prateek Nayak
reviewerRe: [PATCH 1/2] sched: Skip class callbacks with SCHED_FLAG_KEEP_PARAMS
Hello Andrea,
Quoted 22 lines · Andrea Righi
SCHED_FLAG_KEEP_PARAMSsuppresses scheduler parameter and class changes, but__sched_setscheduler()can still setDEQUEUE_CLASSwhen the class computed from the requested policy differs from the task's current class.This causes the
switching_from(),switched_from(),switching_to()andswitched_to()callbacks to run even thoughp->sched_classremains unchanged.Set
DEQUEUE_CLASSonly when the sched class is allowed to change.Fixes 637b0682821b ("sched: Fold sched_class::switch{ing,ed}_{to,from}() into the change pattern")Signed-off-by Andrea Righi <[email protected]>--- kernel/sched/syscalls.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)kernel/sched/syscalls.c +0
-0
kernel/sched/syscalls.c int __sched_setscheduler(struct task_struct *p, · line 680
Quoted 7 lines
kernel/sched/syscalls.c +2
-1@@ -675,7 +675,8 @@ int __sched_setscheduler(struct task_struct *p, prev_class = p->sched_class; next_class =__setscheduler_class (policy, newprio); -if (prev_class != next_class) +if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS ) && + prev_class != next_class) queue_flags |=DEQUEUE_CLASS ;
It seems there also exists a SCHED_FLAG_KEEP_POLICY which should be used to retain the policy. By a quick look at the syscall path, SCHED_FLAG_KEEP_PARAMS should just do an equivalent of:
get_params(p, &attr, 0)
and match the some properties of sched_attr with that of the task.
The task is still free to switch classes if the attr->sched_policy differs given SCHED_FLAG_KEEP_PARAMS and SCHED_FLAG_KEEP_POLICY are two distinct flags and there is a separate SCHED_FLAG_KEEP_ALL to combines them both.
I'm having a sneaky suspicion that the bit in sched_change guard below should actually check for SCHED_FLAG_KEEP_ALL like:
kernel/sched/syscalls.c +1 -1
@@ -680,7 +680,7 @@ int __sched_setscheduler(struct task_struct *p, scoped_guard (sched_change, p, queue_flags) { -if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS )) { +if ((attr->sched_flags &SCHED_FLAG_KEEP_ALL ) !=SCHED_FLAG_KEEP_ALL ) {__setscheduler_params (p, attr); p->sched_class = next_class; p->prio = newprio;
---
Quoted 2 lines
kernel/sched/syscalls.c +0
-0scoped_guard (sched_change, p, queue_flags) {
Signature · 2 lines
Thanks and Regards, Prateek
Re: [PATCH 1/2] sched: Skip class callbacks with SCHED_FLAG_KEEP_PARAMS
Hi Prateek,
Quoted 37 lines · K Prateek Nayak
Hello Andrea,
Quoted 22 lines · Andrea Righi
SCHED_FLAG_KEEP_PARAMSsuppresses scheduler parameter and class changes, but__sched_setscheduler()can still setDEQUEUE_CLASSwhen the class computed from the requested policy differs from the task's current class.This causes the
switching_from(),switched_from(),switching_to()andswitched_to()callbacks to run even thoughp->sched_classremains unchanged.Set
DEQUEUE_CLASSonly when the sched class is allowed to change.Fixes 637b0682821b ("sched: Fold sched_class::switch{ing,ed}_{to,from}() into the change pattern")Signed-off-by Andrea Righi <[email protected]>--- kernel/sched/syscalls.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)kernel/sched/syscalls.c +0
-0kernel/sched/syscalls.c int __sched_setscheduler(struct task_struct *p, · line 680
Quoted 7 lines
kernel/sched/syscalls.c +2
-1@@ -675,7 +675,8 @@ int __sched_setscheduler(struct task_struct *p, prev_class = p->sched_class; next_class =__setscheduler_class (policy, newprio); -if (prev_class != next_class) +if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS ) && + prev_class != next_class) queue_flags |=DEQUEUE_CLASS ;It seems there also exists a
SCHED_FLAG_KEEP_POLICYwhich should be used to retain the policy. By a quick look at the syscall path,SCHED_FLAG_KEEP_PARAMSshould just do an equivalent of:
Quoted 3 lines
get_params(p, &attr, 0)and match the some properties of
sched_attrwith that of the task.
I think get_params() only copies the parameters relevant to the task's current policy. For example, for a fair task it copies sched_nice, but not sched_priority or the deadline parameters. Allowing an arbitrary cross-class transition could still apply target-class parameters supplied by the caller despite KEEP_PARAMS.
Quoted 14 lines
The task is still free to switch classes if the
attr->sched_policydiffers givenSCHED_FLAG_KEEP_PARAMSandSCHED_FLAG_KEEP_POLICYare two distinct flags and there is a separateSCHED_FLAG_KEEP_ALLto combines them both.I'm having a sneaky suspicion that the bit in
sched_changeguard below should actually check forSCHED_FLAG_KEEP_ALLlike:kernel/sched/syscalls.c +0
-0
kernel/sched/syscalls.c int __sched_setscheduler(struct task_struct *p, · line 683
Quoted 5 lines
kernel/sched/syscalls.c +1
-1@@ -680,7 +680,7 @@ int __sched_setscheduler(struct task_struct *p, scoped_guard (sched_change, p, queue_flags) { -if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS )) { +if ((attr->sched_flags &SCHED_FLAG_KEEP_ALL ) !=SCHED_FLAG_KEEP_ALL ) {
Changing this condition to SCHED_FLAG_KEEP_ALL would execute the full parameter and class update when only SCHED_FLAG_KEEP_PARAMS is set, enabling the problematic cross-class case.
IIUC, SCHED_FLAG_KEEP_POLICY is handled independently: the syscall replaces attr->sched_policy with SETPARAM_POLICY, which is resolved to the task's current policy under the rq lock. Parameter changes are still allowed in that case, so the __setscheduler_params() block must run.
For this fix, I think DEQUEUE_CLASS should follow the existing update condition, so that the class callbacks reflect whether p->sched_class is actually changed.
Thanks,
-Andrea
Quoted 12 lines
kernel/sched/syscalls.c +0
-1__setscheduler_params (p, attr); p->sched_class = next_class; p->prio = newprio; ---Quoted 3 lines
kernel/sched/syscalls.c +0
-0scoped_guard (sched_change, p, queue_flags) {Signature · 2 lines
Thanks and Regards, Prateek
Peter Zijlstra
maintainerRe: [PATCH 1/2] sched: Skip class callbacks with SCHED_FLAG_KEEP_PARAMS
In reply to K Prateek NayakQuoted 54 lines · K Prateek Nayak
Hello Andrea,
Quoted 22 lines · Andrea Righi
SCHED_FLAG_KEEP_PARAMSsuppresses scheduler parameter and class changes, but__sched_setscheduler()can still setDEQUEUE_CLASSwhen the class computed from the requested policy differs from the task's current class.This causes the
switching_from(),switched_from(),switching_to()andswitched_to()callbacks to run even thoughp->sched_classremains unchanged.Set
DEQUEUE_CLASSonly when the sched class is allowed to change.Fixes 637b0682821b ("sched: Fold sched_class::switch{ing,ed}_{to,from}() into the change pattern")Signed-off-by Andrea Righi <[email protected]>--- kernel/sched/syscalls.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)kernel/sched/syscalls.c +0
-0kernel/sched/syscalls.c int __sched_setscheduler(struct task_struct *p, · line 680
Quoted 7 lines
kernel/sched/syscalls.c +2
-1@@ -675,7 +675,8 @@ int __sched_setscheduler(struct task_struct *p, prev_class = p->sched_class; next_class =__setscheduler_class (policy, newprio); -if (prev_class != next_class) +if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS ) && + prev_class != next_class) queue_flags |=DEQUEUE_CLASS ;It seems there also exists a
SCHED_FLAG_KEEP_POLICYwhich should be used to retain the policy. By a quick look at the syscall path,SCHED_FLAG_KEEP_PARAMSshould just do an equivalent of:get_params(p, &attr, 0)and match the some properties of
sched_attrwith that of the task.The task is still free to switch classes if the
attr->sched_policydiffers givenSCHED_FLAG_KEEP_PARAMSandSCHED_FLAG_KEEP_POLICYare two distinct flags and there is a separateSCHED_FLAG_KEEP_ALLto combines them both.I'm having a sneaky suspicion that the bit in
sched_changeguard below should actually check forSCHED_FLAG_KEEP_ALLlike:kernel/sched/syscalls.c +0
-0
kernel/sched/syscalls.c int __sched_setscheduler(struct task_struct *p, · line 686
Quoted 8 lines
kernel/sched/syscalls.c +1
-1@@ -680,7 +680,7 @@ int __sched_setscheduler(struct task_struct *p, scoped_guard (sched_change, p, queue_flags) { -if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS )) { +if ((attr->sched_flags &SCHED_FLAG_KEEP_ALL ) !=SCHED_FLAG_KEEP_ALL ) {__setscheduler_params (p, attr); p->sched_class = next_class; p->prio = newprio;
Hmm, but if we have KEEP_PARAMS then params are loaded with the current set and actually re-setting them doesn't matter. So perhaps we should just remove that conditional entirely?
---
kernel/sched/syscalls.c +8 -7
@@ -680,12 +680,10 @@ int __sched_setscheduler(struct task_struct *p, scoped_guard (sched_change, p, queue_flags) { -if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS )) { -__setscheduler_params (p, attr); - p->sched_class = next_class; - p->prio = newprio; -__setscheduler_dl_pi (newprio, policy, p, scope); - } +__setscheduler_params (p, attr); + p->sched_class = next_class; + p->prio = newprio; +__setscheduler_dl_pi (newprio, policy, p, scope);__setscheduler_uclamp (p, attr);if (scope->queued) {
@@ -979,8 +977,11 @@ SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr,if (!p)return -ESRCH ; -if (attr.sched_flags &SCHED_FLAG_KEEP_PARAMS ) +if (attr.sched_flags &SCHED_FLAG_KEEP_PARAMS ) { +if (attr.sched_policy !=SETPARAM_POLICY && attr.sched_policy != p->policy) +return -EINVAL ;get_params (p, &attr,0 ); + }return sched_setattr (p, &attr); }
Re: [PATCH 1/2] sched: Skip class callbacks with SCHED_FLAG_KEEP_PARAMS
Hi Peter,
Quoted 93 lines · Peter Zijlstra
Quoted 54 lines · K Prateek Nayak
Hello Andrea,
Quoted 22 lines · Andrea Righi
SCHED_FLAG_KEEP_PARAMSsuppresses scheduler parameter and class changes, but__sched_setscheduler()can still setDEQUEUE_CLASSwhen the class computed from the requested policy differs from the task's current class.This causes the
switching_from(),switched_from(),switching_to()andswitched_to()callbacks to run even thoughp->sched_classremains unchanged.Set
DEQUEUE_CLASSonly when the sched class is allowed to change.Fixes 637b0682821b ("sched: Fold sched_class::switch{ing,ed}_{to,from}() into the change pattern")Signed-off-by Andrea Righi <[email protected]>--- kernel/sched/syscalls.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)kernel/sched/syscalls.c +0
-0kernel/sched/syscalls.c int __sched_setscheduler(struct task_struct *p, · line 680
Quoted 7 lines
kernel/sched/syscalls.c +2
-1@@ -675,7 +675,8 @@ int __sched_setscheduler(struct task_struct *p, prev_class = p->sched_class; next_class =__setscheduler_class (policy, newprio); -if (prev_class != next_class) +if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS ) && + prev_class != next_class) queue_flags |=DEQUEUE_CLASS ;It seems there also exists a
SCHED_FLAG_KEEP_POLICYwhich should be used to retain the policy. By a quick look at the syscall path,SCHED_FLAG_KEEP_PARAMSshould just do an equivalent of:get_params(p, &attr, 0)and match the some properties of
sched_attrwith that of the task.The task is still free to switch classes if the
attr->sched_policydiffers givenSCHED_FLAG_KEEP_PARAMSandSCHED_FLAG_KEEP_POLICYare two distinct flags and there is a separateSCHED_FLAG_KEEP_ALLto combines them both.I'm having a sneaky suspicion that the bit in
sched_changeguard below should actually check forSCHED_FLAG_KEEP_ALLlike:kernel/sched/syscalls.c +0
-0kernel/sched/syscalls.c int __sched_setscheduler(struct task_struct *p, · line 686
Quoted 8 lines
kernel/sched/syscalls.c +1
-1@@ -680,7 +680,7 @@ int __sched_setscheduler(struct task_struct *p, scoped_guard (sched_change, p, queue_flags) { -if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS )) { +if ((attr->sched_flags &SCHED_FLAG_KEEP_ALL ) !=SCHED_FLAG_KEEP_ALL ) {__setscheduler_params (p, attr); p->sched_class = next_class; p->prio = newprio;Hmm, but if we have
KEEP_PARAMSthen params are loaded with the current set and actually re-setting them doesn't matter. So perhaps we should just remove that conditional entirely?---
kernel/sched/syscalls.c +4
-6@@ -680,12 +680,10 @@ int __sched_setscheduler(struct task_struct *p, scoped_guard (sched_change, p, queue_flags) { -if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS )) { -__setscheduler_params (p, attr); - p->sched_class = next_class; - p->prio = newprio; -__setscheduler_dl_pi (newprio, policy, p, scope); - } +__setscheduler_params (p, attr); + p->sched_class = next_class; + p->prio = newprio; +__setscheduler_dl_pi (newprio, policy, p, scope);__setscheduler_uclamp (p, attr);if (scope->queued) {@@ -979,8 +977,11 @@ SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr,if (!p)return -ESRCH ;
kernel/sched/syscalls.c SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr, · line 987
Quoted 10 lines
kernel/sched/syscalls.c +4
-1-if (attr.sched_flags &SCHED_FLAG_KEEP_PARAMS ) +if (attr.sched_flags &SCHED_FLAG_KEEP_PARAMS ) { +if (attr.sched_policy !=SETPARAM_POLICY && attr.sched_policy != p->policy) +return -EINVAL ;get_params (p, &attr,0 ); + }return sched_setattr (p, &attr); }
Rejecting a policy change when KEEP_PARAMS is set makes sense to me.
However, I don't think we can remove the conditional and reapply the values returned by get_params(). That snapshot is taken before the rq lock is acquired, so a concurrent scheduler update could change the parameters in between.
What about retaining the existing update conditional and rejecting KEEP_PARAMS with policy != p->policy under the rq lock, after the existing policy recheck?
KEEP_POLICY will already have been resolved to the current policy there. This should prevent both the spurious class callbacks and the deadline bandwidth accounting issue at their source.
Thanks,
-Andrea
PATCH 2/2 sched/deadline: Skip bandwidth accounting with SCHED_FLAG_KEEP_PARAMS
In reply to Andrea RighiA sched_setattr() invocation targeting a non-deadline task can specify SCHED_DEADLINE together with SCHED_FLAG_KEEP_PARAMS. The flag prevents __sched_setscheduler() from applying the requested parameters or class, but deadline admission runs before the guarded update and immediately accounts the requested bandwidth in the root domain. Repeating the invocation can therefore consume bandwidth without creating a deadline task capable of releasing it.
Skip deadline bandwidth admission when SCHED_FLAG_KEEP_PARAMS is set, since neither the deadline policy nor its parameters will change.
--- kernel/sched/syscalls.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/sched/syscalls.c +2 -1
@@ -650,7 +650,8 @@ int __sched_setscheduler(struct task_struct *p,* of a SCHED_DEADLINE task) we need to check if enough bandwidth * is available. */ -if ((dl_policy (policy) ||dl_task (p)) &&sched_dl_overflow (p, policy, attr)) { +if (!(attr->sched_flags &SCHED_FLAG_KEEP_PARAMS ) && + (dl_policy (policy) ||dl_task (p)) &&sched_dl_overflow (p, policy, attr)) { retval = -EBUSY ; goto unlock; }
Signature · 1 line
2.55.0
Peter Zijlstra
maintainerRe: [PATCH 2/2] sched/deadline: Skip bandwidth accounting with SCHED_FLAG_KEEP_PARAMS
Quoted 10 lines · Andrea Righi
A
sched_setattr()invocation targeting a non-deadline task can specifySCHED_DEADLINEtogether withSCHED_FLAG_KEEP_PARAMS. The flag prevents__sched_setscheduler()from applying the requested parameters or class, but deadline admission runs before the guarded update and immediately accounts the requested bandwidth in the root domain. Repeating the invocation can therefore consume bandwidth without creating a deadline task capable of releasing it.Skip deadline bandwidth admission when
SCHED_FLAG_KEEP_PARAMSis set, since neither the deadline policy nor its parameters will change.
I'm thinking this should be fixed by simply not allowing KEEP_PARAM when the policy changes, no?
Peter Zijlstra
maintainerQuoted 3 lines · Andrea Righi
SCHED_FLAG_KEEP_PARAMSallowssched_setattr()to update generic task attributes while retaining the task's existing scheduling parameters and class.
Well, KEEP_PARAMS is only sensible when the policy is unchanged, but that isn't in fact enforced.
Do we want something like so to start with?
---
kernel/sched/syscalls.c +4 -1
@@ -979,8 +979,11 @@ SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr,if (!p)return -ESRCH ; -if (attr.sched_flags &SCHED_FLAG_KEEP_PARAMS ) +if (attr.sched_flags &SCHED_FLAG_KEEP_PARAMS ) { +if (attr.sched_policy != p->policy) +return -EINVAL ;get_params (p, &attr,0 ); + }return sched_setattr (p, &attr); }
Peter Zijlstra
maintainerQuoted 16 lines · Peter Zijlstra
Quoted 3 lines · Andrea Righi
SCHED_FLAG_KEEP_PARAMSallowssched_setattr()to update generic task attributes while retaining the task's existing scheduling parameters and class.Well,
KEEP_PARAMSis only sensible when the policy is unchanged, but that isn't in fact enforced.Do we want something like so to start with?
---
kernel/sched/syscalls.c +0
-0
kernel/sched/syscalls.c SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr, · line 983
Quoted 6 lines
kernel/sched/syscalls.c +2
-1@@ -979,8 +979,11 @@ SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr,if (!p)return -ESRCH ; -if (attr.sched_flags &SCHED_FLAG_KEEP_PARAMS ) +if (attr.sched_flags &SCHED_FLAG_KEEP_PARAMS ) { +if (attr.sched_policy != p->policy)
Ah, it also needs to deal with SETPARAM_POLICY, so something like:
attr.sched_policy != SETPARAM_POLICY && attr.sched_policy != p->policy
I suppose.
Quoted 6 lines
kernel/sched/syscalls.c +2
-0+return -EINVAL ;get_params (p, &attr,0 ); + }return sched_setattr (p, &attr); }