arm64: Set SSBS for user threads while creation
Subsystems (2)
PATCH 1/1 arm64: Set SSBS for user threads while creation
Current SSBS implementation takes care of setting the SSBS bit in start_thread() for user threads. While this works for tasks launched with fork/clone followed by execve, for cases where userspace would just call fork (eg, Java applications) this leaves the SSBS bit unset. This results in performance regression for such tasks.
It is understood that commit cbdf8a189a66 ("arm64: Force SSBS on context switch") masks this issue, but that was done for a different reason where heterogeneous CPUs(both SSBS supported and unsupported) are present. It is appropriate to take care of the SSBS bit for all threads while creation itself.
--- arch/arm64/kernel/process.c | 7 +++++++ 1 file changed, 7 insertions(+)
arch/arm64/kernel/process.c +7 -0
@@ -399,6 +399,13 @@ int copy_thread(unsigned long clone_flags, unsigned long stack_start,*/ if (clone_flags &CLONE_SETTLS ) p->thread.uw.tp_value = childregs->regs[3 ]; + +if (arm64_get_ssbd_state () !=ARM64_SSBD_FORCE_ENABLE ) { +if (is_compat_thread (task_thread_info (p))) +set_compat_ssbs_bit (childregs); +else +set_ssbs_bit (childregs); + } }else {memset (childregs,0 ,sizeof (struct pt_regs )); childregs->pstate = PSR_MODE_EL1h;
Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
Quoted 7 lines · Srinivas Ramana
Current SSBS implementation takes care of setting the SSBS bit in
start_thread()for user threads. While this works for tasks launched with fork/clone followed by execve, for cases where userspace would just call fork (eg, Java applications) this leaves the SSBS bit unset. This results in performance regression for such tasks.
Quoted 5 lines
It is understood that commit
cbdf8a189a66("arm64: Force SSBS on context switch") masks this issue, but that was done for a different reason where heterogeneous CPUs(both SSBS supported and unsupported) are present. It is appropriate to take care of the SSBS bit for all threads while creation itself.
So this fixes the situation (i.e low performance) from the creation time of a task with fork() which will never see a subsequent execve, till it gets context switched for the very first time ?
Quoted 26 lines
Fixes 8f04e8e6e29c ("arm64: ssbd: Add support for PSTATE.SSBS rather than trapping to EL3")Signed-off-by Srinivas Ramana <[email protected]>--- arch/arm64/kernel/process.c | 7 +++++++ 1 file changed, 7 insertions(+)arch/arm64/kernel/process.c +7
-0@@ -399,6 +399,13 @@ int copy_thread(unsigned long clone_flags, unsigned long stack_start,*/ if (clone_flags &CLONE_SETTLS ) p->thread.uw.tp_value = childregs->regs[3 ]; + +if (arm64_get_ssbd_state () !=ARM64_SSBD_FORCE_ENABLE ) { +if (is_compat_thread (task_thread_info (p))) +set_compat_ssbs_bit (childregs); +else +set_ssbs_bit (childregs); + } }else {memset (childregs,0 ,sizeof (struct pt_regs )); childregs->pstate = PSR_MODE_EL1h;
Quoted 16 lines · Anshuman Khandual
Quoted 7 lines · Srinivas Ramana
Current SSBS implementation takes care of setting the SSBS bit in
start_thread()for user threads. While this works for tasks launched with fork/clone followed by execve, for cases where userspace would just call fork (eg, Java applications) this leaves the SSBS bit unset. This results in performance regression for such tasks.Quoted 5 lines
It is understood that commit
cbdf8a189a66("arm64: Force SSBS on context switch") masks this issue, but that was done for a different reason where heterogeneous CPUs(both SSBS supported and unsupported) are present. It is appropriate to take care of the SSBS bit for all threads while creation itself.
Quoted 4 lines
So this fixes the situation (i.e low performance) from the creation time of a task with
fork()which will never see a subsequent execve, till it gets context switched for the very first time ?
Yes, that is correct.
Quoted 18 lines
Quoted 18 lines
Fixes 8f04e8e6e29c ("arm64: ssbd: Add support for PSTATE.SSBS rather than trapping to EL3")Signed-off-by Srinivas Ramana <[email protected]>--- arch/arm64/kernel/process.c | 7 +++++++ 1 file changed, 7 insertions(+)arch/arm64/kernel/process.c +3
-0@@ -399,6 +399,13 @@ int copy_thread(unsigned long clone_flags, unsigned long stack_start,*/ if (clone_flags &CLONE_SETTLS ) p->thread.uw.tp_value = childregs->regs[3 ]; + +if (arm64_get_ssbd_state () !=ARM64_SSBD_FORCE_ENABLE ) { +if (is_compat_thread (task_thread_info (p)))
Quoted 8 lines
arch/arm64/kernel/process.c int copy_thread(unsigned long clone_flags, unsigned long stack_start, · line 411
Quoted 8 lines
arch/arm64/kernel/process.c +4
-0+set_compat_ssbs_bit (childregs); + else +set_ssbs_bit (childregs ); + } }else {memset (childregs,0 ,sizeof (struct pt_regs )); childregs->pstate = PSR_MODE_EL1h;
Thanks,
-- Srinivas R
Signature · 3 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
Catalin Marinas
maintainerQuoted 7 lines · Srinivas Ramana
Current SSBS implementation takes care of setting the SSBS bit in
start_thread()for user threads. While this works for tasks launched with fork/clone followed by execve, for cases where userspace would just call fork (eg, Java applications) this leaves the SSBS bit unset. This results in performance regression for such tasks.
Quoted 8 lines
It is understood that commit
cbdf8a189a66("arm64: Force SSBS on context switch") masks this issue, but that was done for a different reason where heterogeneous CPUs(both SSBS supported and unsupported) are present. It is appropriate to take care of the SSBS bit for all threads while creation itself.Fixes 8f04e8e6e29c ("arm64: ssbd: Add support for PSTATE.SSBS rather than trapping to EL3")Signed-off-by Srinivas Ramana <[email protected]>
I suppose the parent process cleared SSBS explicitly. Isn't the child after fork() supposed to be nearly identical to the parent? If we did as you suggest, someone else might complain that SSBS has been set in the child after fork().
I think the fix is for user space to set SSBS in the child if it no longer needs it.
Signature · 1 line
Catalin
Will Deacon
maintainerQuoted 14 lines · Catalin Marinas
Quoted 13 lines · Srinivas Ramana
Current SSBS implementation takes care of setting the SSBS bit in
start_thread()for user threads. While this works for tasks launched with fork/clone followed by execve, for cases where userspace would just call fork (eg, Java applications) this leaves the SSBS bit unset. This results in performance regression for such tasks.It is understood that commit
cbdf8a189a66("arm64: Force SSBS on context switch") masks this issue, but that was done for a different reason where heterogeneous CPUs(both SSBS supported and unsupported) are present. It is appropriate to take care of the SSBS bit for all threads while creation itself.
Quoted 7 lines
Quoted 2 lines
Fixes 8f04e8e6e29c ("arm64: ssbd: Add support for PSTATE.SSBS rather than trapping to EL3")Signed-off-by Srinivas Ramana <[email protected]>I suppose the parent process cleared SSBS explicitly. Isn't the child after
fork()supposed to be nearly identical to the parent? If we did as you suggest, someone else might complain that SSBS has been set in the child afterfork().
Right, I'd expect the parent SSBS to be inherited when we copy the pstate field along with the other regs, and I think this is the correct behaviour.
Is that broken somehow?
Will
Quoted 14 lines · Catalin Marinas
Quoted 13 lines · Srinivas Ramana
Current SSBS implementation takes care of setting the SSBS bit in
start_thread()for user threads. While this works for tasks launched with fork/clone followed by execve, for cases where userspace would just call fork (eg, Java applications) this leaves the SSBS bit unset. This results in performance regression for such tasks.It is understood that commit
cbdf8a189a66("arm64: Force SSBS on context switch") masks this issue, but that was done for a different reason where heterogeneous CPUs(both SSBS supported and unsupported) are present. It is appropriate to take care of the SSBS bit for all threads while creation itself.
Quoted 4 lines
Quoted 2 lines
Fixes 8f04e8e6e29c ("arm64: ssbd: Add support for PSTATE.SSBS rather than trapping to EL3")Signed-off-by Srinivas Ramana <[email protected]>I suppose the parent process cleared SSBS explicitly. Isn't the child
Actually we observe that parent(in case of android, zygote that launches the app) does have SSBS bit set. However child doesn't have the bit set.
Quoted 3 lines
after
fork()supposed to be nearly identical to the parent? If we did as you suggest, someone else might complain that SSBS has been set in the child afterfork().
I am also wondering why would a userspace process clear SSBS bit loosing the performance benefit.
Quoted 4 lines
I think the fix is for user space to set SSBS in the child if it no longer needs it.
Sorry for the late response on this.
Thanks,
-- Srinivas R
Signature · 3 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc., is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
Will Deacon
maintainerQuoted 15 lines · Srinivas Ramana
Quoted 14 lines · Catalin Marinas
Quoted 13 lines · Srinivas Ramana
Current SSBS implementation takes care of setting the SSBS bit in
start_thread()for user threads. While this works for tasks launched with fork/clone followed by execve, for cases where userspace would just call fork (eg, Java applications) this leaves the SSBS bit unset. This results in performance regression for such tasks.It is understood that commit
cbdf8a189a66("arm64: Force SSBS on context switch") masks this issue, but that was done for a different reason where heterogeneous CPUs(both SSBS supported and unsupported) are present. It is appropriate to take care of the SSBS bit for all threads while creation itself.
Quoted 7 lines
Quoted 4 lines
Quoted 2 lines
Fixes 8f04e8e6e29c ("arm64: ssbd: Add support for PSTATE.SSBS rather than trapping to EL3")Signed-off-by Srinivas Ramana <[email protected]>I suppose the parent process cleared SSBS explicitly. Isn't the child
Actually we observe that
parent(in case of android, zygote that launches the app)does have SSBS bit set. However child doesn't have the bit set.
On which SoC? Your commit message talks about heterogeneous systems (wrt SSBS) as though they don't apply in your case. Could you provide us with a reproducer?
Quoted 6 lines
Quoted 3 lines
after
fork()supposed to be nearly identical to the parent? If we did as you suggest, someone else might complain that SSBS has been set in the child afterfork().I am also wondering why would a userspace process clear SSBS bit loosing the performance benefit.
I guess it could happen during sigreturn if the signal handler wasn't careful about preserving bits in pstate, although it doesn't feel like something you'd regularly run into.
But hang on a sec -- it looks like the context switch logic in cbdf8a189a66 actually does the wrong thing for systems where all of the CPUs implement SSBS. I don't think it explains the behaviour you're seeing, but I do think it could end up in situations where SSBS is unexpectedly *set*.
Diff below.
Will
--->8
arch/arm64/kernel/process.c +7 -0
@@ -466,6 +466,13 @@ static void ssbs_thread_switch(struct task_struct *next)if (unlikely (next->flags &PF_KTHREAD ))return ; +/* +* If all CPUs implement the SSBS instructions, then we just +* need to context-switch the PSTATE field. +*/ +if (cpu_have_feature (cpu_feature (SSBS ))) +return ; +/* If the mitigation is enabled, then we leave SSBS clear. */ if ((arm64_get_ssbd_state () ==ARM64_SSBD_FORCE_ENABLE ) ||test_tsk_thread_flag (next,TIF_SSBD ))