Add support for 32-bit tasks on asymmetric AArch32 systems
Subsystems (9)
Will Deacon
maintainerv9 cover Add support for 32-bit tasks on asymmetric AArch32 systems
Hi everyone,
The sun is shining and its time for your weekly dose of asymmetric 32-bit support patches, previously seen at:
v1: https://lore.kernel.org/r/[email protected]
v2: https://lore.kernel.org/r/[email protected]
v3: https://lore.kernel.org/r/[email protected]
v4: https://lore.kernel.org/r/[email protected]
v5: https://lore.kernel.org/r/[email protected]
v6: https://lore.kernel.org/r/[email protected]
v7: https://lore.kernel.org/r/[email protected]
v8: https://lore.kernel.org/r/[email protected]
There was also a nice LWN writeup in case you've forgotten what this is about:
https://lwn.net/Articles/838339/
Changes since v8 include:
* Renamed task_cpus_dl_admissible() and changed return type [Daniel]
* Renamed update_mismatched_32bit_el0_cpu_features() [Mark R]
* Improved comments [Mark R and Valentin]
* Cleaned up cpuset_cpus_allowed_fallback() [Valentin]
* Remove redundant rcu_read_{lock,unlock}() in cpuset_cpus_allowed()
* Added some more acks/reviewed-by tags
Cheers,
Will
--->8
Will Deacon (20):
arm64: cpuinfo: Split AArch32 registers out into a separate struct
arm64: Allow mismatched 32-bit EL0 support
KVM: arm64: Kill 32-bit vCPUs on systems with mismatched EL0 support
arm64: Kill 32-bit applications scheduled on 64-bit-only CPUs
sched: Introduce task_cpu_possible_mask() to limit fallback rq
selection
cpuset: Don't use the cpu_possible_mask as a last resort for cgroup v1
cpuset: Honour task_cpu_possible_mask() in guarantee_online_cpus()
cpuset: Cleanup cpuset_cpus_allowed_fallback() use in
select_fallback_rq()
sched: Reject CPU affinity changes based on task_cpu_possible_mask()
sched: Introduce task_struct::user_cpus_ptr to track requested
affinity
sched: Split the guts of sched_setaffinity() into a helper function
sched: Allow task CPU affinity to be restricted on asymmetric systems
sched: Introduce dl_task_check_affinity() to check proposed affinity
arm64: Implement task_cpu_possible_mask()
arm64: exec: Adjust affinity for compat tasks with mismatched 32-bit
EL0
arm64: Prevent offlining first CPU with 32-bit EL0 on mismatched
system
arm64: Advertise CPUs capable of running 32-bit applications in sysfs
arm64: Hook up cmdline parameter to allow mismatched 32-bit EL0
arm64: Remove logic to kill 32-bit tasks on 64-bit-only cores
Documentation: arm64: describe asymmetric 32-bit support
.../ABI/testing/sysfs-devices-system-cpu | 9 + .../admin-guide/kernel-parameters.txt | 11 + Documentation/arm64/asymmetric-32bit.rst | 155 ++++++++ Documentation/arm64/index.rst | 1 + arch/arm64/include/asm/cpu.h | 44 +-- arch/arm64/include/asm/cpufeature.h | 8 +- arch/arm64/include/asm/elf.h | 6 +- arch/arm64/include/asm/mmu_context.h | 13 + arch/arm64/kernel/cpufeature.c | 232 +++++++++--- arch/arm64/kernel/cpuinfo.c | 53 +-- arch/arm64/kernel/process.c | 44 ++- arch/arm64/kvm/arm.c | 11 +- arch/arm64/tools/cpucaps | 3 +- include/linux/cpuset.h | 8 +- include/linux/mmu_context.h | 14 + include/linux/sched.h | 21 ++ init/init_task.c | 1 + kernel/cgroup/cpuset.c | 59 +-- kernel/fork.c | 2 + kernel/sched/core.c | 340 ++++++++++++++---- kernel/sched/sched.h | 1 + 21 files changed, 841 insertions(+), 195 deletions(-) create mode 100644 Documentation/arm64/asymmetric-32bit.rst
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 1/20 arm64: cpuinfo: Split AArch32 registers out into a separate struct
In preparation for late initialisation of the "sanitised" AArch32 register state, move the AArch32 registers out of 'struct cpuinfo' and into their own struct definition.
--- arch/arm64/include/asm/cpu.h | 44 +++++++++++---------- arch/arm64/kernel/cpufeature.c | 71 ++++++++++++++++++---------------- arch/arm64/kernel/cpuinfo.c | 53 +++++++++++++------------ 3 files changed, 89 insertions(+), 79 deletions(-)
arch/arm64/include/asm/cpu.h +24 -20
@@ -12,26 +12,7 @@/* * Records attributes of an individual CPU. */ -struct cpuinfo_arm64 { -struct cpu cpu; -struct kobject kobj; -u32 reg_ctr; -u32 reg_cntfrq; -u32 reg_dczid; -u32 reg_midr; -u32 reg_revidr; - -u64 reg_id_aa64dfr0; -u64 reg_id_aa64dfr1; -u64 reg_id_aa64isar0; -u64 reg_id_aa64isar1; -u64 reg_id_aa64mmfr0; -u64 reg_id_aa64mmfr1; -u64 reg_id_aa64mmfr2; -u64 reg_id_aa64pfr0; -u64 reg_id_aa64pfr1; -u64 reg_id_aa64zfr0; - +struct cpuinfo_32bit {u32 reg_id_dfr0;u32 reg_id_dfr1;u32 reg_id_isar0;
@@ -54,6 +35,29 @@ struct cpuinfo_arm64 {u32 reg_mvfr0;u32 reg_mvfr1;u32 reg_mvfr2; +}; + +struct cpuinfo_arm64 { +struct cpu cpu; +struct kobject kobj; +u32 reg_ctr; +u32 reg_cntfrq; +u32 reg_dczid; +u32 reg_midr; +u32 reg_revidr; + +u64 reg_id_aa64dfr0; +u64 reg_id_aa64dfr1; +u64 reg_id_aa64isar0; +u64 reg_id_aa64isar1; +u64 reg_id_aa64mmfr0; +u64 reg_id_aa64mmfr1; +u64 reg_id_aa64mmfr2; +u64 reg_id_aa64pfr0; +u64 reg_id_aa64pfr1; +u64 reg_id_aa64zfr0; + +struct cpuinfo_32bit aarch32;/* pseudo-ZCR for recording maximum ZCR_EL1 LEN value: */ u64 reg_zcr;
arch/arm64/kernel/cpufeature.c +37 -34
102 lines not on this page · raw message
arch/arm64/kernel/cpuinfo.c +28 -25
65 lines not on this page · raw message
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 2/20 arm64: Allow mismatched 32-bit EL0 support
In reply to Will DeaconWhen confronted with a mixture of CPUs, some of which support 32-bit applications and others which don't, we quite sensibly treat the system as 64-bit only for userspace and prevent execve() of 32-bit binaries.
Unfortunately, some crazy folks have decided to build systems like this with the intention of running 32-bit applications, so relax our sanitisation logic to continue to advertise 32-bit support to userspace on these systems and track the real 32-bit capable cores in a cpumask instead. For now, the default behaviour remains but will be tied to a command-line option in a later patch.
--- arch/arm64/include/asm/cpufeature.h | 8 +- arch/arm64/kernel/cpufeature.c | 114 ++++++++++++++++++++++++---- arch/arm64/tools/cpucaps | 3 +- 3 files changed, 110 insertions(+), 15 deletions(-)
arch/arm64/include/asm/cpufeature.h +7 -1
@@ -630,9 +630,15 @@ static inline bool cpu_supports_mixed_endian_el0(void)return id_aa64mmfr0_mixed_endian_el0 (read_cpuid (ID_AA64MMFR0_EL1 )); } +const struct cpumask *system_32bit_el0_cpumask (void ); +DECLARE_STATIC_KEY_FALSE (arm64_mismatched_32bit_el0); +static inline bool system_supports_32bit_el0 (void ) { -return cpus_have_const_cap (ARM64_HAS_32BIT_EL0 ); +u64 pfr0 =read_sanitised_ftr_reg (SYS_ID_AA64PFR0_EL1 ); + +return static_branch_unlikely (&arm64_mismatched_32bit_el0) || +id_aa64pfr0_32bit_el0 (pfr0); }static inline bool system_supports_4kb_granule (void )
arch/arm64/kernel/cpufeature.c +101 -13
193 lines not on this page · raw message
arch/arm64/tools/cpucaps +2 -1
@@ -3,7 +3,8 @@ # Internal CPU capabilities constants, keep this list sorted BTI -HAS_32BIT_EL0 +# Unreliable: use system_supports_32bit_el0() instead. +HAS_32BIT_EL0_DO_NOT_USE HAS_32BIT_EL1 HAS_ADDRESS_AUTH HAS_ADDRESS_AUTH_ARCH
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 3/20 KVM: arm64: Kill 32-bit vCPUs on systems with mismatched EL0 support
In reply to Will DeaconIf a vCPU is caught running 32-bit code on a system with mismatched support at EL0, then we should kill it.
--- arch/arm64/kvm/arm.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
arch/arm64/kvm/arm.c +10 -1
@@ -692,6 +692,15 @@ static void check_vcpu_requests(struct kvm_vcpu *vcpu) } } +static bool vcpu_mode_is_bad_32bit (struct kvm_vcpu *vcpu) +{ +if (likely (!vcpu_mode_is_32bit (vcpu))) +return false; + +return !system_supports_32bit_el0 () || +static_branch_unlikely (&arm64_mismatched_32bit_el0); +} +/** * kvm_arch_vcpu_ioctl_run - the main VCPU run function to execute guest code * @vcpu: The VCPU pointer
@@ -875,7 +884,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)* with the asymmetric AArch32 case), return to userspace with * a fatal error. */ -if (!system_supports_32bit_el0 () &&vcpu_mode_is_32bit (vcpu)) { +if (vcpu_mode_is_bad_32bit (vcpu)) {/* * As we have caught the guest red-handed, decide that * it isn't fit for purpose anymore by making the vcpu
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 4/20 arm64: Kill 32-bit applications scheduled on 64-bit-only CPUs
In reply to Will DeaconScheduling a 32-bit application on a 64-bit-only CPU is a bad idea.
Ensure that 32-bit applications always take the slow-path when returning to userspace on a system with mismatched support at EL0, so that we can avoid trying to run on a 64-bit-only CPU and force a SIGKILL instead.
--- arch/arm64/kernel/process.c | 19 ++++++++++++++++++- arch/arm64/kernel/signal.c | 26 ++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 1 deletion(-)
arch/arm64/kernel/process.c +18 -1
@@ -527,6 +527,15 @@ static void erratum_1418040_thread_switch(struct task_struct *prev,write_sysreg (val, cntkctl_el1); } +static void compat_thread_switch (struct task_struct *next) +{ +if (!is_compat_thread (task_thread_info (next))) +return ; + +if (static_branch_unlikely (&arm64_mismatched_32bit_el0)) +set_tsk_thread_flag (next,TIF_NOTIFY_RESUME ); +} +static void update_sctlr_el1 (u64 sctlr) {/*
@@ -568,6 +577,7 @@ __notrace_funcgraph struct task_struct *__switch_to(struct task_struct *prev,ssbs_thread_switch (next);erratum_1418040_thread_switch (prev, next);ptrauth_thread_switch_user (next); +compat_thread_switch (next);/* * Complete any pending TLB or cache maintenance on this CPU in case
@@ -633,8 +643,15 @@ unsigned long arch_align_stack(unsigned long sp)*/ void arch_setup_new_exec (void ) { - current->mm->context.flags =is_compat_task () ?MMCF_AARCH32 :0 ; +unsigned long mmflags =0 ; + +if (is_compat_task ()) { + mmflags =MMCF_AARCH32 ; +if (static_branch_unlikely (&arm64_mismatched_32bit_el0)) +set_tsk_thread_flag (current,TIF_NOTIFY_RESUME ); + } + current->mm->context.flags = mmflags;ptrauth_thread_init_user ();mte_thread_init_user ();
arch/arm64/kernel/signal.c +26 -0
@@ -911,6 +911,19 @@ static void do_signal(struct pt_regs *regs)restore_saved_sigmask (); } +static bool cpu_affinity_invalid (struct pt_regs *regs) +{ +if (!compat_user_mode (regs)) +return false; + +/* +* We're preemptible, but a reschedule will cause us to check the +* affinity again. +*/ +return !cpumask_test_cpu (raw_smp_processor_id (), +system_32bit_el0_cpumask ()); +} + asmlinkage void do_notify_resume(struct pt_regs *regs,unsigned long thread_flags) {
@@ -938,6 +951,19 @@ asmlinkage void do_notify_resume(struct pt_regs *regs,if (thread_flags & _TIF_NOTIFY_RESUME) {tracehook_notify_resume (regs);rseq_handle_notify_resume (NULL , regs); + +/* +* If we reschedule after checking the affinity +* then we must ensure that TIF_NOTIFY_RESUME +* is set so that we check the affinity again. +* Since tracehook_notify_resume() clears the +* flag, ensure that the compiler doesn't move +* it after the affinity check. +*/ +barrier (); + +if (cpu_affinity_invalid (regs)) +force_sig (SIGKILL ); }if (thread_flags & _TIF_FOREIGN_FPSTATE)
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 5/20 sched: Introduce task_cpu_possible_mask() to limit fallback rq selection
In reply to Will DeaconAsymmetric systems may not offer the same level of userspace ISA support across all CPUs, meaning that some applications cannot be executed by some CPUs. As a concrete example, upcoming arm64 big.LITTLE designs do not feature support for 32-bit applications on both clusters.
On such a system, we must take care not to migrate a task to an unsupported CPU when forcefully moving tasks in select_fallback_rq() in response to a CPU hot-unplug operation.
Introduce a task_cpu_possible_mask() hook which, given a task argument, allows an architecture to return a cpumask of CPUs that are capable of executing that task. The default implementation returns the cpu_possible_mask, since sane machines do not suffer from per-cpu ISA limitations that affect scheduling. The new mask is used when selecting the fallback runqueue as a last resort before forcing a migration to the first active CPU.
--- include/linux/mmu_context.h | 14 ++++++++++++++ kernel/sched/core.c | 5 ++--- 2 files changed, 16 insertions(+), 3 deletions(-)
include/linux/mmu_context.h +14 -0
@@ -14,4 +14,18 @@static inline void leave_mm (int cpu) { }#endif +/* +* CPUs that are capable of running user task @p. Must contain at least one +* active CPU. It is assumed that the kernel can run on all CPUs, so calling +* this for a kernel thread is pointless. +* +* By default, we assume a sane, homogeneous system. +*/ +#ifndef task_cpu_possible_mask +# define task_cpu_possible_mask (p) cpu_possible_mask +# define task_cpu_possible (cpu, p) true +#else +# define task_cpu_possible (cpu, p) cpumask_test_cpu((cpu), task_cpu_possible_mask(p)) +#endif +#endif
kernel/sched/core.c +2 -3
@@ -1814,7 +1814,7 @@ static inline bool is_cpu_allowed(struct task_struct *p, int cpu)/* Non kernel threads are not allowed during either online or offline. */ if (!(p->flags &PF_KTHREAD )) -return cpu_active (cpu); +return cpu_active (cpu) &&task_cpu_possible (cpu, p);/* KTHREAD_IS_PER_CPU is always allowed. */ if (kthread_is_per_cpu (p))
@@ -2792,10 +2792,9 @@ static int select_fallback_rq(int cpu, struct task_struct *p)* * More yuck to audit. */ -do_set_cpus_allowed (p, cpu_possible_mask); +do_set_cpus_allowed (p,task_cpu_possible_mask (p)); state = fail;break ; -case fail:BUG ();break ;
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 6/20 cpuset: Don't use the cpu_possible_mask as a last resort for cgroup v1
In reply to Will DeaconIf the scheduler cannot find an allowed CPU for a task, cpuset_cpus_allowed_fallback() will widen the affinity to cpu_possible_mask if cgroup v1 is in use.
In preparation for allowing architectures to provide their own fallback mask, just return early if we're either using cgroup v1 or we're using cgroup v2 with a mask that contains invalid CPUs. This will allow select_fallback_rq() to figure out the mask by itself.
--- include/linux/cpuset.h | 1 + kernel/cgroup/cpuset.c | 8 ++++++-- 2 files changed, 7 insertions(+), 2 deletions(-)
include/linux/cpuset.h +1 -0
@@ -15,6 +15,7 @@#include <linux/cpumask.h> #include <linux/nodemask.h> #include <linux/mm.h> +#include <linux/mmu_context.h> #include <linux/jump_label.h> #ifdef CONFIG_CPUSETS
kernel/cgroup/cpuset.c +6 -2
@@ -3322,9 +3322,13 @@ void cpuset_cpus_allowed(struct task_struct *tsk, struct cpumask *pmask)void cpuset_cpus_allowed_fallback (struct task_struct *tsk) { +const struct cpumask *cs_mask; +const struct cpumask *possible_mask =task_cpu_possible_mask (tsk); +rcu_read_lock (); -do_set_cpus_allowed (tsk,is_in_v2_mode () ? -task_cs (tsk)->cpus_allowed : cpu_possible_mask); + cs_mask =task_cs (tsk)->cpus_allowed; +if (is_in_v2_mode () &&cpumask_subset (cs_mask, possible_mask)) +do_set_cpus_allowed (tsk, cs_mask);rcu_read_unlock ();/*
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 7/20 cpuset: Honour task_cpu_possible_mask() in guarantee_online_cpus()
In reply to Will DeaconAsymmetric systems may not offer the same level of userspace ISA support across all CPUs, meaning that some applications cannot be executed by some CPUs. As a concrete example, upcoming arm64 big.LITTLE designs do not feature support for 32-bit applications on both clusters.
Modify guarantee_online_cpus() to take task_cpu_possible_mask() into account when trying to find a suitable set of online CPUs for a given task. This will avoid passing an invalid mask to set_cpus_allowed_ptr() during ->attach() and will subsequently allow the cpuset hierarchy to be taken into account when forcefully overriding the affinity mask for a task which requires migration to a compatible CPU.
--- include/linux/cpuset.h | 2 +- kernel/cgroup/cpuset.c | 43 +++++++++++++++++++++++++----------------- 2 files changed, 27 insertions(+), 18 deletions(-)
include/linux/cpuset.h +1 -1
@@ -185,7 +185,7 @@ static inline void cpuset_read_unlock(void) { }static inline void cpuset_cpus_allowed (struct task_struct *p,struct cpumask *mask) { -cpumask_copy (mask, cpu_possible_mask); +cpumask_copy (mask,task_cpu_possible_mask (p)); }static inline void cpuset_cpus_allowed_fallback (struct task_struct *p)
kernel/cgroup/cpuset.c +26 -17
79 lines not on this page · raw message
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 8/20 cpuset: Cleanup cpuset_cpus_allowed_fallback() use in select_fallback_rq()
In reply to Will Deaconselect_fallback_rq() only needs to recheck for an allowed CPU if the affinity mask of the task has changed since the last check.
Return a 'bool' from cpuset_cpus_allowed_fallback() to indicate whether the affinity mask was updated, and use this to elide the allowed check when the mask has been left alone.
No functional change.
--- include/linux/cpuset.h | 5 +++-- kernel/cgroup/cpuset.c | 10 ++++++++-- kernel/sched/core.c | 3 +-- 3 files changed, 12 insertions(+), 6 deletions(-)
include/linux/cpuset.h +3 -2
@@ -59,7 +59,7 @@ extern void cpuset_wait_for_hotplug(void);extern void cpuset_read_lock (void );extern void cpuset_read_unlock (void );extern void cpuset_cpus_allowed (struct task_struct *p,struct cpumask *mask); -extern void cpuset_cpus_allowed_fallback (struct task_struct *p); +extern bool cpuset_cpus_allowed_fallback (struct task_struct *p);extern nodemask_t cpuset_mems_allowed (struct task_struct *p);#define cpuset_current_mems_allowed (current->mems_allowed)void cpuset_init_current_mems_allowed (void );
@@ -188,8 +188,9 @@ static inline void cpuset_cpus_allowed(struct task_struct *p,cpumask_copy (mask,task_cpu_possible_mask (p)); } -static inline void cpuset_cpus_allowed_fallback (struct task_struct *p) +static inline bool cpuset_cpus_allowed_fallback (struct task_struct *p) { +return false; }static inline nodemask_t cpuset_mems_allowed (struct task_struct *p)
kernel/cgroup/cpuset.c +8 -2
@@ -3327,17 +3327,22 @@ void cpuset_cpus_allowed(struct task_struct *tsk, struct cpumask *pmask)* which will not contain a sane cpumask during cases such as cpu hotplugging. * This is the absolute last resort for the scheduler and it is only used if * _every_ other avenue has been traveled. +* +* Returns true if the affinity of @tsk was changed, false otherwise. **/ -void cpuset_cpus_allowed_fallback (struct task_struct *tsk) +bool cpuset_cpus_allowed_fallback (struct task_struct *tsk) {const struct cpumask *cs_mask; +bool changed = false;const struct cpumask *possible_mask =task_cpu_possible_mask (tsk);rcu_read_lock (); cs_mask =task_cs (tsk)->cpus_allowed; -if (is_in_v2_mode () &&cpumask_subset (cs_mask, possible_mask)) +if (is_in_v2_mode () &&cpumask_subset (cs_mask, possible_mask)) {do_set_cpus_allowed (tsk, cs_mask); + changed = true; + }rcu_read_unlock ();/*
@@ -3357,6 +3362,7 @@ void cpuset_cpus_allowed_fallback(struct task_struct *tsk)* select_fallback_rq() will fix things ups and set cpu_possible_mask * if required. */ +return changed; }void __init cpuset_init_current_mems_allowed (void )
kernel/sched/core.c +1 -2
@@ -2779,8 +2779,7 @@ static int select_fallback_rq(int cpu, struct task_struct *p)/* No more Mr. Nice Guy. */ switch (state) {case cpuset: -if (IS_ENABLED (CONFIG_CPUSETS )) { -cpuset_cpus_allowed_fallback (p); +if (cpuset_cpus_allowed_fallback (p)) { state = possible;break ; }
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 9/20 sched: Reject CPU affinity changes based on task_cpu_possible_mask()
In reply to Will DeaconReject explicit requests to change the affinity mask of a task via set_cpus_allowed_ptr() if the requested mask is not a subset of the mask returned by task_cpu_possible_mask(). This ensures that the 'cpus_mask' for a given task cannot contain CPUs which are incapable of executing it, except in cases where the affinity is forced.
--- kernel/sched/core.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
kernel/sched/core.c +8 -1
@@ -2347,15 +2347,17 @@ static int __set_cpus_allowed_ptr(struct task_struct *p, u32 flags) {const struct cpumask *cpu_valid_mask = cpu_active_mask; +const struct cpumask *cpu_allowed_mask =task_cpu_possible_mask (p);unsigned int dest_cpu;struct rq_flags rf;struct rq *rq;int ret =0 ; +bool kthread = p->flags &PF_KTHREAD ; rq =task_rq_lock (p, &rf);update_rq_clock (rq); -if (p->flags &PF_KTHREAD ||is_migration_disabled (p)) { +if (kthread ||is_migration_disabled (p)) {/* * Kernel threads are allowed on online && !active CPUs, * however, during cpu-hot-unplug, even these might get pushed
@@ -2369,6 +2371,11 @@ static int __set_cpus_allowed_ptr(struct task_struct *p, cpu_valid_mask = cpu_online_mask; } +if (!kthread && !cpumask_subset (new_mask, cpu_allowed_mask)) { + ret = -EINVAL ; + goto out; + } +/* * Must re-check here, to close a race against __kthread_bind(), * sched_setaffinity() is not guaranteed to observe the flag.
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 10/20 sched: Introduce task_struct::user_cpus_ptr to track requested affinity
In reply to Will DeaconIn preparation for saving and restoring the user-requested CPU affinity mask of a task, add a new cpumask_t pointer to 'struct task_struct'.
If the pointer is non-NULL, then the mask is copied across fork() and freed on task exit.
--- include/linux/sched.h | 13 +++++++++++++ init/init_task.c | 1 + kernel/fork.c | 2 ++ kernel/sched/core.c | 20 ++++++++++++++++++++ 4 files changed, 36 insertions(+)
include/linux/sched.h +13 -0
@@ -730,6 +730,7 @@ struct task_struct {unsigned int policy;int nr_cpus_allowed;const cpumask_t *cpus_ptr; +cpumask_t *user_cpus_ptr;cpumask_t cpus_mask;void *migration_pending;#ifdef CONFIG_SMP
@@ -1688,6 +1689,8 @@ extern int task_can_attach(struct task_struct *p, const struct cpumask *cs_cpus_#ifdef CONFIG_SMP extern void do_set_cpus_allowed (struct task_struct *p,const struct cpumask *new_mask);extern int set_cpus_allowed_ptr (struct task_struct *p,const struct cpumask *new_mask); +extern int dup_user_cpus_ptr (struct task_struct *dst,struct task_struct *src,int node); +extern void release_user_cpus_ptr (struct task_struct *p);#else static inline void do_set_cpus_allowed (struct task_struct *p,const struct cpumask *new_mask) {
@@ -1698,6 +1701,16 @@ static inline int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumareturn -EINVAL ; return 0; } +static inline int dup_user_cpus_ptr (struct task_struct *dst,struct task_struct *src,int node) +{ +if (src->user_cpus_ptr) +return -EINVAL ; +return 0 ; +} +static inline void release_user_cpus_ptr (struct task_struct *p) +{ +WARN_ON (p->user_cpus_ptr); +}#endif extern int yield_to (struct task_struct *p,bool preempt);
init/init_task.c +1 -0
@@ -80,6 +80,7 @@ struct task_struct init_task .normal_prio = MAX_PRIO - 20, .policy = SCHED_NORMAL, .cpus_ptr = &init_task.cpus_mask, + .user_cpus_ptr = NULL, .cpus_mask = CPU_MASK_ALL, .nr_cpus_allowed= NR_CPUS, .mm = NULL,
kernel/fork.c +2 -0
@@ -446,6 +446,7 @@ void put_task_stack(struct task_struct *tsk)void free_task (struct task_struct *tsk) { +release_user_cpus_ptr (tsk);scs_release (tsk);#ifndef CONFIG_THREAD_INFO_IN_TASK
@@ -918,6 +919,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node)#endif if (orig->cpus_ptr == &orig->cpus_mask) tsk->cpus_ptr = &tsk->cpus_mask; +dup_user_cpus_ptr (tsk, orig, node);/* * One for the user space visible state that goes away when reaped.
kernel/sched/core.c +20 -0
@@ -2126,6 +2126,26 @@ void do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask)__do_set_cpus_allowed (p, new_mask,0 ); } +int dup_user_cpus_ptr (struct task_struct *dst,struct task_struct *src, +int node) +{ +if (!src->user_cpus_ptr) +return 0 ; + + dst->user_cpus_ptr =kmalloc_node (cpumask_size (),GFP_KERNEL , node); +if (!dst->user_cpus_ptr) +return -ENOMEM ; + +cpumask_copy (dst->user_cpus_ptr, src->user_cpus_ptr); +return 0 ; +} + +void release_user_cpus_ptr (struct task_struct *p) +{ +kfree (p->user_cpus_ptr); + p->user_cpus_ptr =NULL ; +} +/* * This function is wildly self concurrent; here be dragons. *
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 11/20 sched: Split the guts of sched_setaffinity() into a helper function
In reply to Will DeaconIn preparation for replaying user affinity requests using a saved mask, split sched_setaffinity() up so that the initial task lookup and security checks are only performed when the request is coming directly from userspace.
--- kernel/sched/core.c | 105 ++++++++++++++++++++++++-------------------- 1 file changed, 57 insertions(+), 48 deletions(-)
kernel/sched/core.c +57 -48
@@ -6787,53 +6787,22 @@ SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr,return retval; } -long sched_setaffinity (pid_t pid,const struct cpumask *in_mask) +static int +__sched_setaffinity (struct task_struct *p,const struct cpumask *mask) { -cpumask_var_t cpus_allowed, new_mask; -struct task_struct *p;int retval; +cpumask_var_t cpus_allowed, new_mask; -rcu_read_lock (); - - p =find_process_by_pid (pid); -if (!p) { -rcu_read_unlock (); -return -ESRCH ; - } - -/* Prevent p going away */ -get_task_struct (p); -rcu_read_unlock (); +if (!alloc_cpumask_var (&cpus_allowed,GFP_KERNEL )) +return -ENOMEM ; -if (p->flags &PF_NO_SETAFFINITY ) { - retval = -EINVAL ; - goto out_put_task; - } -if (!alloc_cpumask_var (&cpus_allowed,GFP_KERNEL )) { - retval = -ENOMEM ; - goto out_put_task; - }if (!alloc_cpumask_var (&new_mask,GFP_KERNEL )) { retval = -ENOMEM ; goto out_free_cpus_allowed; } - retval = -EPERM ; -if (!check_same_owner (p)) { -rcu_read_lock (); -if (!ns_capable (__task_cred (p)->user_ns,CAP_SYS_NICE )) { -rcu_read_unlock (); - goto out_free_new_mask; - } -rcu_read_unlock (); - } - - retval =security_task_setscheduler (p); -if (retval) - goto out_free_new_mask; -cpuset_cpus_allowed (p, cpus_allowed); -cpumask_and (new_mask, in_mask, cpus_allowed); +cpumask_and (new_mask, mask, cpus_allowed);/* * Since bandwidth control happens on root_domain basis,
@@ -6854,23 +6823,63 @@ long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)#endif again: retval =__set_cpus_allowed_ptr (p, new_mask,SCA_CHECK ); +if (retval) + goto out_free_new_mask; -if (!retval) { -cpuset_cpus_allowed (p, cpus_allowed); -if (!cpumask_subset (new_mask, cpus_allowed)) { -/* -* We must have raced with a concurrent cpuset -* update. Just reset the cpus_allowed to the -* cpuset's cpus_allowed -*/ -cpumask_copy (new_mask, cpus_allowed); - goto again; - } +cpuset_cpus_allowed (p, cpus_allowed); +if (!cpumask_subset (new_mask, cpus_allowed)) { +/* +* We must have raced with a concurrent cpuset update. +* Just reset the cpumask to the cpuset's cpus_allowed. +*/ +cpumask_copy (new_mask, cpus_allowed); + goto again; } + out_free_new_mask:free_cpumask_var (new_mask); out_free_cpus_allowed:free_cpumask_var (cpus_allowed); +return retval; +} + +long sched_setaffinity (pid_t pid,const struct cpumask *in_mask) +{ +struct task_struct *p; +int retval; + +rcu_read_lock (); + + p =find_process_by_pid (pid); +if (!p) { +rcu_read_unlock (); +return -ESRCH ; + } + +/* Prevent p going away */ +get_task_struct (p); +rcu_read_unlock (); + +if (p->flags &PF_NO_SETAFFINITY ) { + retval = -EINVAL ; + goto out_put_task; + } + +if (!check_same_owner (p)) { +rcu_read_lock (); +if (!ns_capable (__task_cred (p)->user_ns,CAP_SYS_NICE )) { +rcu_read_unlock (); + retval = -EPERM ; + goto out_put_task; + } +rcu_read_unlock (); + } + + retval =security_task_setscheduler (p); +if (retval) + goto out_put_task; + + retval =__sched_setaffinity (p, in_mask); out_put_task:put_task_struct (p);return retval;
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 12/20 sched: Allow task CPU affinity to be restricted on asymmetric systems
In reply to Will DeaconAsymmetric systems may not offer the same level of userspace ISA support across all CPUs, meaning that some applications cannot be executed by some CPUs. As a concrete example, upcoming arm64 big.LITTLE designs do not feature support for 32-bit applications on both clusters.
Although userspace can carefully manage the affinity masks for such tasks, one place where it is particularly problematic is execve() because the CPU on which the execve() is occurring may be incompatible with the new application image. In such a situation, it is desirable to restrict the affinity mask of the task and ensure that the new image is entered on a compatible CPU. From userspace's point of view, this looks the same as if the incompatible CPUs have been hotplugged off in the task's affinity mask. Similarly, if a subsequent execve() reverts to a compatible image, then the old affinity is restored if it is still valid.
In preparation for restricting the affinity mask for compat tasks on arm64 systems without uniform support for 32-bit applications, introduce {force,relax}_compatible_cpus_allowed_ptr(), which respectively restrict and restore the affinity mask for a task based on the compatible CPUs.
--- include/linux/sched.h | 2 + kernel/sched/core.c | 180 ++++++++++++++++++++++++++++++++++++++---- kernel/sched/sched.h | 1 + 3 files changed, 167 insertions(+), 16 deletions(-)
include/linux/sched.h +2 -0
@@ -1691,6 +1691,8 @@ extern void do_set_cpus_allowed(struct task_struct *p, const struct cpumask *newextern int set_cpus_allowed_ptr (struct task_struct *p,const struct cpumask *new_mask);extern int dup_user_cpus_ptr (struct task_struct *dst,struct task_struct *src,int node);extern void release_user_cpus_ptr (struct task_struct *p); +extern void force_compatible_cpus_allowed_ptr (struct task_struct *p); +extern void relax_compatible_cpus_allowed_ptr (struct task_struct *p);#else static inline void do_set_cpus_allowed (struct task_struct *p,const struct cpumask *new_mask) {
kernel/sched/core.c +164 -16
218 lines not on this page · raw message
kernel/sched/sched.h +1 -0
@@ -1956,6 +1956,7 @@ extern struct task_struct *pick_next_task_idle(struct rq *rq);#define SCA_CHECK 0x01#define SCA_MIGRATE_DISABLE 0x02#define SCA_MIGRATE_ENABLE 0x04 +#define SCA_USER 0x08#ifdef CONFIG_SMP
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 13/20 sched: Introduce dl_task_check_affinity() to check proposed affinity
In reply to Will DeaconIn preparation for restricting the affinity of a task during execve() on arm64, introduce a new dl_task_check_affinity() helper function to give an indication as to whether the restricted mask is admissible for a deadline task.
--- include/linux/sched.h | 6 ++++++ kernel/sched/core.c | 46 +++++++++++++++++++++++++++---------------- 2 files changed, 35 insertions(+), 17 deletions(-)
include/linux/sched.h +6 -0
@@ -1691,6 +1691,7 @@ extern void do_set_cpus_allowed(struct task_struct *p, const struct cpumask *newextern int set_cpus_allowed_ptr (struct task_struct *p,const struct cpumask *new_mask);extern int dup_user_cpus_ptr (struct task_struct *dst,struct task_struct *src,int node);extern void release_user_cpus_ptr (struct task_struct *p); +extern int dl_task_check_affinity (struct task_struct *p,const struct cpumask *mask);extern void force_compatible_cpus_allowed_ptr (struct task_struct *p);extern void relax_compatible_cpus_allowed_ptr (struct task_struct *p);#else
@@ -1713,6 +1714,11 @@ static inline void release_user_cpus_ptr(struct task_struct *p) {WARN_ON (p->user_cpus_ptr); } + +static inline int dl_task_check_affinity (struct task_struct *p,const struct cpumask *mask) +{ +return 0 ; +}#endif extern int yield_to (struct task_struct *p,bool preempt);
kernel/sched/core.c +29 -17
58 lines not on this page · raw message
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 14/20 arm64: Implement task_cpu_possible_mask()
In reply to Will DeaconProvide an implementation of task_cpu_possible_mask() so that we can prevent 64-bit-only cores being added to the 'cpus_mask' for compat tasks on systems with mismatched 32-bit support at EL0,
--- arch/arm64/include/asm/mmu_context.h | 13 +++++++++++++ 1 file changed, 13 insertions(+)
arch/arm64/include/asm/mmu_context.h +13 -0
@@ -231,6 +231,19 @@ switch_mm(struct mm_struct *prev, struct mm_struct *next,update_saved_ttbr0 (tsk, next); } +static inline const struct cpumask * +task_cpu_possible_mask (struct task_struct *p) +{ +if (!static_branch_unlikely (&arm64_mismatched_32bit_el0)) +return cpu_possible_mask; + +if (!is_compat_thread (task_thread_info (p))) +return cpu_possible_mask; + +return system_32bit_el0_cpumask (); +} +#define task_cpu_possible_mask task_cpu_possible_mask +void verify_cpu_asid_bits (void );void post_ttbr_update_workaround (void );
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 15/20 arm64: exec: Adjust affinity for compat tasks with mismatched 32-bit EL0
In reply to Will DeaconWhen exec'ing a 32-bit task on a system with mismatched support for 32-bit EL0, try to ensure that it starts life on a CPU that can actually run it.
Similarly, when exec'ing a 64-bit task on such a system, try to restore the old affinity mask if it was previously restricted.
--- arch/arm64/include/asm/elf.h | 6 ++---- arch/arm64/kernel/process.c | 39 +++++++++++++++++++++++++++++++++++- 2 files changed, 40 insertions(+), 5 deletions(-)
arch/arm64/include/asm/elf.h +2 -4
@@ -213,10 +213,8 @@ typedef compat_elf_greg_t compat_elf_gregset_t[COMPAT_ELF_NGREG];/* AArch32 EABI. */ #define EF_ARM_EABI_MASK 0xff000000 -#define compat_elf_check_arch (x) (system_supports_32bit_el0() && \ - ((x)->e_machine == EM_ARM) && \ - ((x)->e_flags & EF_ARM_EABI_MASK)) - +int compat_elf_check_arch (const struct elf32_hdr *); +#define compat_elf_check_arch compat_elf_check_arch#define compat_start_thread compat_start_thread/* * Unlike the native SET_PERSONALITY macro, the compat version maintains
arch/arm64/kernel/process.c +38 -1
@@ -22,6 +22,7 @@#include <linux/mman.h> #include <linux/mm.h> #include <linux/nospec.h> +#include <linux/sched.h> #include <linux/stddef.h> #include <linux/sysctl.h> #include <linux/unistd.h>
@@ -638,6 +639,28 @@ unsigned long arch_align_stack(unsigned long sp)return sp & ~0xf ; } +#ifdef CONFIG_COMPAT +int compat_elf_check_arch (const struct elf32_hdr *hdr) +{ +if (!system_supports_32bit_el0 ()) +return false; + +if ((hdr)->e_machine !=EM_ARM ) +return false; + +if (!((hdr)->e_flags &EF_ARM_EABI_MASK )) +return false; + +/* +* Prevent execve() of a 32-bit program from a deadline task +* if the restricted affinity mask would be inadmissible on an +* asymmetric system. +*/ +return !static_branch_unlikely (&arm64_mismatched_32bit_el0) || + !dl_task_check_affinity (current,system_32bit_el0_cpumask ()); +} +#endif +/* * Called from setup_new_exec() after (COMPAT_)SET_PERSONALITY. */
@@ -647,8 +670,22 @@ void arch_setup_new_exec(void)if (is_compat_task ()) { mmflags =MMCF_AARCH32 ; -if (static_branch_unlikely (&arm64_mismatched_32bit_el0)) + +/* +* Restrict the CPU affinity mask for a 32-bit task so that +* it contains only 32-bit-capable CPUs. +* +* From the perspective of the task, this looks similar to +* what would happen if the 64-bit-only CPUs were hot-unplugged +* at the point of execve(), although we try a bit harder to +* honour the cpuset hierarchy. +*/ +if (static_branch_unlikely (&arm64_mismatched_32bit_el0)) { +force_compatible_cpus_allowed_ptr (current);set_tsk_thread_flag (current,TIF_NOTIFY_RESUME ); + } + }else if (static_branch_unlikely (&arm64_mismatched_32bit_el0)) { +relax_compatible_cpus_allowed_ptr (current); } current->mm->context.flags = mmflags;
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 16/20 arm64: Prevent offlining first CPU with 32-bit EL0 on mismatched system
In reply to Will DeaconIf we want to support 32-bit applications, then when we identify a CPU with mismatched 32-bit EL0 support we must ensure that we will always have an active 32-bit CPU available to us from then on. This is important for the scheduler, because is_cpu_allowed() will be constrained to 32-bit CPUs for compat tasks and forced migration due to a hotplug event will hang if no 32-bit CPUs are available.
On detecting a mismatch, prevent offlining of either the mismatching CPU if it is 32-bit capable, or find the first active 32-bit capable CPU otherwise.
--- arch/arm64/kernel/cpufeature.c | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-)
arch/arm64/kernel/cpufeature.c +24 -1
@@ -2877,15 +2877,38 @@ void __init setup_cpu_features(void)static int enable_mismatched_32bit_el0 (unsigned int cpu) { +/* +* The first 32-bit-capable CPU we detected and so can no longer +* be offlined by userspace. -1 indicates we haven't yet onlined +* a 32-bit-capable CPU. +*/ +static int lucky_winner =-1 ; +struct cpuinfo_arm64 *info = &per_cpu (cpu_data, cpu);bool cpu_32bit =id_aa64pfr0_32bit_el0 (info->reg_id_aa64pfr0);if (cpu_32bit) {cpumask_set_cpu (cpu, cpu_32bit_el0_mask);static_branch_enable_cpuslocked (&arm64_mismatched_32bit_el0); -setup_elf_hwcaps (compat_elf_hwcaps); } +if (cpumask_test_cpu (0 , cpu_32bit_el0_mask) == cpu_32bit) +return 0 ; + +if (lucky_winner >=0 ) +return 0 ; + +/* +* We've detected a mismatch. We need to keep one of our CPUs with +* 32-bit EL0 online so that is_cpu_allowed() doesn't end up rejecting +* every CPU in the system for a 32-bit task. +*/ + lucky_winner = cpu_32bit ? cpu :cpumask_any_and (cpu_32bit_el0_mask, + cpu_active_mask); +get_cpu_device (lucky_winner)->offline_disabled = true; +setup_elf_hwcaps (compat_elf_hwcaps); +pr_info ("Asymmetric 32-bit EL0 support detected on CPU %u; CPU hot-unplug disabled on CPU %u\n" , + cpu, lucky_winner);return 0 ; }
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 17/20 arm64: Advertise CPUs capable of running 32-bit applications in sysfs
In reply to Will DeaconSince 32-bit applications will be killed if they are caught trying to execute on a 64-bit-only CPU in a mismatched system, advertise the set of 32-bit capable CPUs to userspace in sysfs.
--- .../ABI/testing/sysfs-devices-system-cpu | 9 +++++++++ arch/arm64/kernel/cpufeature.c | 19 +++++++++++++++++++ 2 files changed, 28 insertions(+)
Documentation/ABI/testing/sysfs-devices-system-cpu +9 -0
@@ -494,6 +494,15 @@ Description: AArch64 CPU registers 'identification' directory exposes the CPU ID registers for identifying model and revision of the CPU. +What: /sys/devices/system/cpu/aarch32_el0 +Date: May 2021 +Contact: Linux ARM Kernel Mailing list <[email protected]> +Description: Identifies the subset of CPUs in the system that can execute + AArch32 (32-bit ARM) applications. If present, the same format as + /sys/devices/system/cpu/{offline,online,possible,present} is used. + If absent, then all or none of the CPUs can execute AArch32 + applications and execve() will behave accordingly. + What: /sys/devices/system/cpu/cpu#/cpu_capacity Date: December 2016 Contact: Linux kernel mailing list <[email protected]>
arch/arm64/kernel/cpufeature.c +19 -0
@@ -67,6 +67,7 @@#include <linux/crash_dump.h> #include <linux/sort.h> #include <linux/stop_machine.h> +#include <linux/sysfs.h> #include <linux/types.h> #include <linux/minmax.h> #include <linux/mm.h>
@@ -1297,6 +1298,24 @@ const struct cpumask *system_32bit_el0_cpumask(void)return cpu_possible_mask; } +static ssize_t aarch32_el0_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +const struct cpumask *mask =system_32bit_el0_cpumask (); + +return sysfs_emit (buf,"%*pbl\n" ,cpumask_pr_args (mask)); +} +static const DEVICE_ATTR_RO (aarch32_el0); + +static int __init aarch32_el0_sysfs_init (void ) +{ +if (!allow_mismatched_32bit_el0) +return 0 ; + +return device_create_file (cpu_subsys.dev_root, &dev_attr_aarch32_el0); +} +device_initcall (aarch32_el0_sysfs_init); +static bool has_32bit_el0 (const struct arm64_cpu_capabilities *entry,int scope) {if (!has_cpuid_feature (entry, scope))
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 18/20 arm64: Hook up cmdline parameter to allow mismatched 32-bit EL0
In reply to Will DeaconAllow systems with mismatched 32-bit support at EL0 to run 32-bit applications based on a new kernel parameter.
--- Documentation/admin-guide/kernel-parameters.txt | 8 ++++++++ arch/arm64/kernel/cpufeature.c | 7 +++++++ 2 files changed, 15 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +8 -0
@@ -287,6 +287,14 @@ do not want to use tracing_snapshot_alloc() as it needs to be done where GFP_KERNEL allocations are allowed. + allow_mismatched_32bit_el0 [ARM64] + Allow execve() of 32-bit applications and setting of the + PER_LINUX32 personality on systems where only a strict + subset of the CPUs support 32-bit EL0. When this + parameter is present, the set of CPUs supporting 32-bit + EL0 is indicated by /sys/devices/system/cpu/aarch32_el0 + and hot-unplug operations may be restricted. + amd_iommu= [HW,X86-64] Pass parameters to the AMD IOMMU driver in the system. Possible values are:
arch/arm64/kernel/cpufeature.c +7 -0
@@ -1298,6 +1298,13 @@ const struct cpumask *system_32bit_el0_cpumask(void)return cpu_possible_mask; } +static int __init parse_32bit_el0_param (char *str) +{ + allow_mismatched_32bit_el0 = true; +return 0 ; +} +early_param ("allow_mismatched_32bit_el0" , parse_32bit_el0_param); +static ssize_t aarch32_el0_show (struct device *dev,struct device_attribute *attr,char *buf) {
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 19/20 arm64: Remove logic to kill 32-bit tasks on 64-bit-only cores
In reply to Will DeaconThe scheduler now knows enough about these braindead systems to place 32-bit tasks accordingly, so throw out the safety checks and allow the ret-to-user path to avoid do_notify_resume() if there is nothing to do.
--- arch/arm64/kernel/process.c | 14 +------------- arch/arm64/kernel/signal.c | 26 -------------------------- 2 files changed, 1 insertion(+), 39 deletions(-)
arch/arm64/kernel/process.c +1 -13
@@ -528,15 +528,6 @@ static void erratum_1418040_thread_switch(struct task_struct *prev,write_sysreg (val, cntkctl_el1); } -static void compat_thread_switch (struct task_struct *next) -{ -if (!is_compat_thread (task_thread_info (next))) -return ; - -if (static_branch_unlikely (&arm64_mismatched_32bit_el0)) -set_tsk_thread_flag (next,TIF_NOTIFY_RESUME ); -} -static void update_sctlr_el1 (u64 sctlr) {/*
@@ -578,7 +569,6 @@ __notrace_funcgraph struct task_struct *__switch_to(struct task_struct *prev,ssbs_thread_switch (next);erratum_1418040_thread_switch (prev, next);ptrauth_thread_switch_user (next); -compat_thread_switch (next);/* * Complete any pending TLB or cache maintenance on this CPU in case
@@ -680,10 +670,8 @@ void arch_setup_new_exec(void)* at the point of execve(), although we try a bit harder to * honour the cpuset hierarchy. */ -if (static_branch_unlikely (&arm64_mismatched_32bit_el0)) { +if (static_branch_unlikely (&arm64_mismatched_32bit_el0))force_compatible_cpus_allowed_ptr (current); -set_tsk_thread_flag (current,TIF_NOTIFY_RESUME ); - } }else if (static_branch_unlikely (&arm64_mismatched_32bit_el0)) {relax_compatible_cpus_allowed_ptr (current); }
arch/arm64/kernel/signal.c +0 -26
@@ -911,19 +911,6 @@ static void do_signal(struct pt_regs *regs)restore_saved_sigmask (); } -static bool cpu_affinity_invalid (struct pt_regs *regs) -{ -if (!compat_user_mode (regs)) -return false; - -/* -* We're preemptible, but a reschedule will cause us to check the -* affinity again. -*/ -return !cpumask_test_cpu (raw_smp_processor_id (), -system_32bit_el0_cpumask ()); -} - asmlinkage void do_notify_resume(struct pt_regs *regs,unsigned long thread_flags) {
@@ -951,19 +938,6 @@ asmlinkage void do_notify_resume(struct pt_regs *regs,if (thread_flags & _TIF_NOTIFY_RESUME) {tracehook_notify_resume (regs);rseq_handle_notify_resume (NULL , regs); - -/* -* If we reschedule after checking the affinity -* then we must ensure that TIF_NOTIFY_RESUME -* is set so that we check the affinity again. -* Since tracehook_notify_resume() clears the -* flag, ensure that the compiler doesn't move -* it after the affinity check. -*/ -barrier (); - -if (cpu_affinity_invalid (regs)) -force_sig (SIGKILL ); }if (thread_flags & _TIF_FOREIGN_FPSTATE)
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Will Deacon
maintainerPATCH v9 20/20 Documentation: arm64: describe asymmetric 32-bit support
In reply to Will DeaconDocument support for running 32-bit tasks on asymmetric 32-bit systems and its impact on the user ABI when enabled.
--- .../admin-guide/kernel-parameters.txt | 3 + Documentation/arm64/asymmetric-32bit.rst | 155 ++++++++++++++++++ Documentation/arm64/index.rst | 1 + 3 files changed, 159 insertions(+) create mode 100644 Documentation/arm64/asymmetric-32bit.rst
Documentation/admin-guide/kernel-parameters.txt +3 -0
@@ -295,6 +295,9 @@ EL0 is indicated by /sys/devices/system/cpu/aarch32_el0 and hot-unplug operations may be restricted. + See Documentation/arm64/asymmetric-32bit.rst for more + information. + amd_iommu= [HW,X86-64] Pass parameters to the AMD IOMMU driver in the system. Possible values are:
Documentation/arm64/asymmetric-32bit.rst new file +155 -0
155 lines not on this page · raw message
Documentation/arm64/index.rst +1 -0
@@ -10,6 +10,7 @@ ARM64 Architecture acpi_object_usage amu arm-acpi + asymmetric-32bit booting cpu-feature-registers elf_hwcaps
Signature · 1 line
2.32.0.rc1.229.g3e70b5a671-goog
Re: [PATCH v9 06/20] cpuset: Don't use the cpu_possible_mask as a last resort for cgroup v1
In reply to Will DeaconQuoted 9 lines · Will Deacon
If the scheduler cannot find an allowed CPU for a task,
cpuset_cpus_allowed_fallback()will widen the affinity tocpu_possible_maskif cgroup v1 is in use.In preparation for allowing architectures to provide their own fallback mask, just return early if we're either using cgroup v1 or we're using cgroup v2 with a mask that contains invalid CPUs. This will allow
select_fallback_rq()to figure out the mask by itself.
Quoted 4 lines
Cc Tejun Heo <[email protected]>Cc Johannes Weiner <[email protected]>Reviewed-by Quentin Perret <[email protected]>Signed-off-by Will Deacon <[email protected]>
Re: [PATCH v9 08/20] cpuset: Cleanup cpuset_cpus_allowed_fallback() use in select_fallback_rq()
In reply to Will DeaconQuoted 11 lines · Will Deacon
select_fallback_rq()only needs to recheck for an allowed CPU if the affinity mask of the task has changed since the last check.Return a 'bool' from
cpuset_cpus_allowed_fallback()to indicate whether the affinity mask was updated, and use this to elide the allowed check when the mask has been left alone.No functional change.
Suggested-by Valentin Schneider <[email protected]>Signed-off-by Will Deacon <[email protected]>
Thanks!
Re: [PATCH v9 12/20] sched: Allow task CPU affinity to be restricted on asymmetric systems
In reply to Will DeaconQuoted 16 lines · Will Deacon
Asymmetric systems may not offer the same level of userspace ISA support across all CPUs, meaning that some applications cannot be executed by some CPUs. As a concrete example, upcoming arm64 big.LITTLE designs do not feature support for 32-bit applications on both clusters.
Although userspace can carefully manage the affinity masks for such tasks, one place where it is particularly problematic is
execve()because the CPU on which theexecve()is occurring may be incompatible with the new application image. In such a situation, it is desirable to restrict the affinity mask of the task and ensure that the new image is entered on a compatible CPU. From userspace's point of view, this looks the same as if the incompatible CPUs have been hotplugged off in the task's affinity mask. Similarly, if a subsequentexecve()reverts to a compatible image, then the old affinity is restored if it is still valid.
Quoted 7 lines
In preparation for restricting the affinity mask for compat tasks on arm64 systems without uniform support for 32-bit applications, introduce {force,relax}_compatible_cpus_allowed_ptr(), which respectively restrict and restore the affinity mask for a task based on the compatible CPUs.
Reviewed-by Quentin Perret <[email protected]>Signed-off-by Will Deacon <[email protected]>
Will Deacon
maintainerQuoted 12 lines · Will Deacon
The sun is shining and its time for your weekly dose of asymmetric 32-bit support patches, previously seen at:
v1: https://lore.kernel.org/r/[email protected]
v2: https://lore.kernel.org/r/[email protected]
v3: https://lore.kernel.org/r/[email protected]
v4: https://lore.kernel.org/r/[email protected]
v5: https://lore.kernel.org/r/[email protected]
v6: https://lore.kernel.org/r/[email protected]
v7: https://lore.kernel.org/r/[email protected]
v8: https://lore.kernel.org/r/[email protected]
Quoted 1 line
[...]
Since patches 1-4 are all arm64, don't do any harm on their own and conflict significantly with other arm64 changes queued for 5.14, I've queued them in the arm64 tree on the stable for-next/cpufeature branch:
[01/20] arm64: cpuinfo: Split AArch32 registers out into a separate struct
https://git.kernel.org/arm64/c/930a58b4093e [02/20] arm64: Allow mismatched 32-bit EL0 support https://git.kernel.org/arm64/c/2122a833316f [03/20] KVM: arm64: Kill 32-bit vCPUs on systems with mismatched EL0 support https://git.kernel.org/arm64/c/2f6a49bbc01d [04/20] arm64: Kill 32-bit applications scheduled on 64-bit-only CPUs https://git.kernel.org/arm64/c/873c3e89777c
Cheers,
Signature · 5 lines
Will https://fixes.arm64.dev https://next.arm64.dev https://will.arm64.dev