arm64: return address signing
Subsystems (6)
v7 cover arm64: return address signing
Hi,
This series improves function return address protection for the arm64 kernel, by compiling the kernel with ARMv8.3 Pointer Authentication instructions (referred ptrauth hereafter). This should help protect the kernel against attacks using return-oriented programming.
Changes since v6 [1]:
- Dropped patch "arm64: create macro to park cpu in an infinite loop" as this clean up patch is not relevant for this series.
- Fixed backtrace when Function graph tracer is used as pointed by James.
- Added DYNAMIC_FTRACE_WITH_REGS config dependency as pointed by James.
- Several minor comments from Vincenzo.
- Added Reviewed-bys from James and Vincenzo.
- Rebased the patch series to v5.6-rc5.
Changes since v5 [2]:
- Added a new patch(arm64: cpufeature: Move cpu capability..) to move cpucapability type helpers in cpufeature.c file. This makes adding new cpucapability easier.
- Moved kernel key restore to function __cpu_setup(proc.S) as suggested by Catalin.
- More comments for as-option Kconfig option for concerns raised by Masahiro.
- Clarified comments for -march=armv8.3-a non-integrated assembler option.
Some additional work not implemented below will be taken up separately:
- kdump tools may need some rework to work with ptrauth. The kdump tools may need the ptrauth information to strip PAC bits. This will be sent in a separate patch.
- Few more ptrauth generic lkdtm tests as requested by Kees Cook.
- Generate compile time warnings if requested Kconfig feature not supported by compilers.
- KVM host will now need just APIA key to be saved and restored. Userpace should also behave according to it. More details here [3].
This complete series can be found at (git://linux-arm.org/linux-ak.git PAC_mainline_v7) for reference.
Patch 5 in this series "arm64: ptrauth: Add bootup/runtime flags for __cpu_setup" will have minor conflict with Ionela's commit "87a1f063464afd9 (arm64: trap to EL1 accesses to AMU counters from EL0)" in -next.
Feedback welcome!
Thanks,
Amit Daniel
[1]: http://lists.infradead.org/pipermail/linux-arm-kernel/2020-March/716268.html
[2]: http://lists.infradead.org/pipermail/linux-arm-kernel/2020-February/711699.html
[3]: http://lists.infradead.org/pipermail/linux-arm-kernel/2020-March/717847.html
Amit Daniel Kachhap (8):
arm64: cpufeature: Fix meta-capability cpufeature check
arm64: ptrauth: Add bootup/runtime flags for __cpu_setup
arm64: cpufeature: Move cpu capability helpers inside C file
arm64: initialize ptrauth keys for kernel booting task
arm64: mask PAC bits of __builtin_return_address
arm64: __show_regs: strip PAC from lr in printk
arm64: suspend: restore the kernel ptrauth keys
lkdtm: arm64: test kernel pointer authentication
Kristina Martsenko (7):
arm64: cpufeature: add pointer auth meta-capabilities
arm64: rename ptrauth key structures to be user-specific
arm64: install user ptrauth keys at kernel exit time
arm64: cpufeature: handle conflicts based on capability
arm64: enable ptrauth earlier
arm64: initialize and switch ptrauth kernel keys
arm64: compile the kernel with ptrauth return address signing
Mark Rutland (1):
arm64: unwind: strip PAC from kernel addresses
Vincenzo Frascino (1):
kconfig: Add support for 'as-option'
arch/arm64/Kconfig | 31 ++++++++++- arch/arm64/Makefile | 11 ++++ arch/arm64/include/asm/asm_pointer_auth.h | 65 +++++++++++++++++++++ arch/arm64/include/asm/compiler.h | 24 ++++++++ arch/arm64/include/asm/cpucaps.h | 4 +- arch/arm64/include/asm/cpufeature.h | 39 +++++++------ arch/arm64/include/asm/pointer_auth.h | 50 ++++++++--------- arch/arm64/include/asm/processor.h | 3 +- arch/arm64/include/asm/smp.h | 12 ++++ arch/arm64/include/asm/stackprotector.h | 5 ++ arch/arm64/kernel/asm-offsets.c | 16 ++++++ arch/arm64/kernel/cpufeature.c | 93 +++++++++++++++++++++++-------- arch/arm64/kernel/entry.S | 6 ++ arch/arm64/kernel/head.S | 2 + arch/arm64/kernel/pointer_auth.c | 7 +-- arch/arm64/kernel/process.c | 5 +- arch/arm64/kernel/ptrace.c | 16 +++--- arch/arm64/kernel/sleep.S | 2 + arch/arm64/kernel/smp.c | 8 +++ arch/arm64/kernel/stacktrace.c | 5 +- arch/arm64/mm/proc.S | 71 +++++++++++++++++++---- drivers/misc/lkdtm/bugs.c | 36 ++++++++++++ drivers/misc/lkdtm/core.c | 1 + drivers/misc/lkdtm/lkdtm.h | 1 + include/linux/stackprotector.h | 2 +- scripts/Kconfig.include | 6 ++ 26 files changed, 422 insertions(+), 99 deletions(-) create mode 100644 arch/arm64/include/asm/asm_pointer_auth.h create mode 100644 arch/arm64/include/asm/compiler.h
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 1/17 arm64: cpufeature: Fix meta-capability cpufeature check
Some existing/future meta cpucaps match need the presence of individual cpucaps. Currently the individual cpucaps checks it via an array based flag and this introduces dependency on the array entry order. This limitation exists only for system scope cpufeature.
This patch introduces an internal helper function (__system_matches_cap) to invoke the matching handler for system scope. This helper has to be used during a narrow window when,
- The system wide safe registers are set with all the SMP CPUs and,
- The SYSTEM_FEATURE cpu_hwcaps may not have been set.
Normal users should use the existing cpus_have_{const_}cap() global function.
---
Changes since v6:
* Added description for __system_matches_cap.
arch/arm64/kernel/cpufeature.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-)
arch/arm64/kernel/cpufeature.c +20 -1
@@ -116,6 +116,8 @@ cpufeature_pan_not_uao(const struct arm64_cpu_capabilities *entry, int __unused)static void cpu_enable_cnp (struct arm64_cpu_capabilities const *cap); +static bool __system_matches_cap (unsigned int n); +/* * NOTE: Any changes to the visibility of features should be kept in * sync with the documentation of the CPU feature register ABI.
@@ -2146,6 +2148,23 @@ bool this_cpu_has_cap(unsigned int n)return false; } +/* +* This helper function is used in a narrow window when, +* - The system wide safe registers are set with all the SMP CPUs and, +* - The SYSTEM_FEATURE cpu_hwcaps may not have been set. +* In all other cases cpus_have_{const_}cap() should be used. +*/ +static bool __system_matches_cap (unsigned int n) +{ +if (n <ARM64_NCAPS ) { +const struct arm64_cpu_capabilities *cap = cpu_hwcaps_ptrs[n]; + +if (cap) +return cap->matches (cap,SCOPE_SYSTEM ); + } +return false; +} +void cpu_set_feature (unsigned int num) {WARN_ON (num >=MAX_CPU_FEATURES );
@@ -2218,7 +2237,7 @@ void __init setup_cpu_features(void)static bool __maybe_unused cpufeature_pan_not_uao (const struct arm64_cpu_capabilities *entry,int __unused) { -return (cpus_have_const_cap (ARM64_HAS_PAN ) && !cpus_have_const_cap (ARM64_HAS_UAO )); +return (__system_matches_cap (ARM64_HAS_PAN ) && !__system_matches_cap (ARM64_HAS_UAO )); }static void __maybe_unused cpu_enable_cnp (struct arm64_cpu_capabilities const *cap)
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 2/17 arm64: cpufeature: add pointer auth meta-capabilities
In reply to Amit Daniel KachhapFrom: Kristina Martsenko <[email protected]>
To enable pointer auth for the kernel, we're going to need to check for the presence of address auth and generic auth using alternative_if. We currently have two cpucaps for each, but alternative_if needs to check a single cpucap. So define meta-capabilities that are present when either of the current two capabilities is present.
Leave the existing four cpucaps in place, as they are still needed to check for mismatched systems where one CPU has the architected algorithm but another has the IMP DEF algorithm.
Note, the meta-capabilities were present before but were removed in commit a56005d32105 ("arm64: cpufeature: Reduce number of pointer auth CPU caps from 6 to 4") and commit 1e013d06120c ("arm64: cpufeature: Rework ptr auth hwcaps using multi_entry_cap_matches"), as they were not needed then. Note, unlike before, the current patch checks the cpucap values directly, instead of reading the CPU ID register value.
--- arch/arm64/include/asm/cpucaps.h | 4 +++- arch/arm64/include/asm/cpufeature.h | 6 ++---- arch/arm64/kernel/cpufeature.c | 25 ++++++++++++++++++++++++- 3 files changed, 29 insertions(+), 6 deletions(-)
arch/arm64/include/asm/cpucaps.h +3 -1
@@ -58,7 +58,9 @@#define ARM64_WORKAROUND_SPECULATIVE_AT_NVHE 48#define ARM64_HAS_E0PD 49#define ARM64_HAS_RNG 50 +#define ARM64_HAS_ADDRESS_AUTH 51 +#define ARM64_HAS_GENERIC_AUTH 52 -#define ARM64_NCAPS 51 +#define ARM64_NCAPS 53#endif /* __ASM_CPUCAPS_H */
arch/arm64/include/asm/cpufeature.h +2 -4
@@ -590,15 +590,13 @@ static __always_inline bool system_supports_cnp(void)static inline bool system_supports_address_auth (void ) {return IS_ENABLED (CONFIG_ARM64_PTR_AUTH ) && - (cpus_have_const_cap (ARM64_HAS_ADDRESS_AUTH_ARCH ) || -cpus_have_const_cap (ARM64_HAS_ADDRESS_AUTH_IMP_DEF )); +cpus_have_const_cap (ARM64_HAS_ADDRESS_AUTH ); }static inline bool system_supports_generic_auth (void ) {return IS_ENABLED (CONFIG_ARM64_PTR_AUTH ) && - (cpus_have_const_cap (ARM64_HAS_GENERIC_AUTH_ARCH ) || -cpus_have_const_cap (ARM64_HAS_GENERIC_AUTH_IMP_DEF )); +cpus_have_const_cap (ARM64_HAS_GENERIC_AUTH ); }static inline bool system_uses_irq_prio_masking (void )
arch/arm64/kernel/cpufeature.c +24 -1
@@ -1323,6 +1323,20 @@ static void cpu_enable_address_auth(struct arm64_cpu_capabilities const *cap)sysreg_clear_set (sctlr_el1,0 , SCTLR_ELx_ENIA | SCTLR_ELx_ENIB | SCTLR_ELx_ENDA | SCTLR_ELx_ENDB); } + +static bool has_address_auth (const struct arm64_cpu_capabilities *entry, +int __unused) +{ +return __system_matches_cap (ARM64_HAS_ADDRESS_AUTH_ARCH ) || +__system_matches_cap (ARM64_HAS_ADDRESS_AUTH_IMP_DEF ); +} + +static bool has_generic_auth (const struct arm64_cpu_capabilities *entry, +int __unused) +{ +return __system_matches_cap (ARM64_HAS_GENERIC_AUTH_ARCH ) || +__system_matches_cap (ARM64_HAS_GENERIC_AUTH_IMP_DEF ); +}#endif /* CONFIG_ARM64_PTR_AUTH */ #ifdef CONFIG_ARM64_E0PD
@@ -1600,7 +1614,6 @@ static const struct arm64_cpu_capabilities arm64_features[] = { .field_pos = ID_AA64ISAR1_APA_SHIFT, .min_field_value = ID_AA64ISAR1_APA_ARCHITECTED, .matches = has_cpuid_feature, - .cpu_enable = cpu_enable_address_auth, }, { .desc = "Address authentication (IMP DEF algorithm)",
@@ -1611,6 +1624,11 @@ static const struct arm64_cpu_capabilities arm64_features[] = { .field_pos = ID_AA64ISAR1_API_SHIFT, .min_field_value = ID_AA64ISAR1_API_IMP_DEF, .matches = has_cpuid_feature, + }, + { + .capability = ARM64_HAS_ADDRESS_AUTH, + .type = ARM64_CPUCAP_SYSTEM_FEATURE, + .matches = has_address_auth, .cpu_enable = cpu_enable_address_auth, }, {
@@ -1633,6 +1651,11 @@ static const struct arm64_cpu_capabilities arm64_features[] = { .min_field_value = ID_AA64ISAR1_GPI_IMP_DEF, .matches = has_cpuid_feature, }, + { + .capability = ARM64_HAS_GENERIC_AUTH, + .type = ARM64_CPUCAP_SYSTEM_FEATURE, + .matches = has_generic_auth, + },#endif /* CONFIG_ARM64_PTR_AUTH */ #ifdef CONFIG_ARM64_PSEUDO_NMI {
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 3/17 arm64: rename ptrauth key structures to be user-specific
In reply to Amit Daniel KachhapFrom: Kristina Martsenko <[email protected]>
We currently enable ptrauth for userspace, but do not use it within the kernel. We're going to enable it for the kernel, and will need to manage a separate set of ptrauth keys for the kernel.
We currently keep all 5 keys in struct ptrauth_keys. However, as the kernel will only need to use 1 key, it is a bit wasteful to allocate a whole ptrauth_keys struct for every thread.
Therefore, a subsequent patch will define a separate struct, with only 1 key, for the kernel. In preparation for that, rename the existing struct (and associated macros and functions) to reflect that they are specific to userspace.
--- arch/arm64/include/asm/pointer_auth.h | 12 ++++++------ arch/arm64/include/asm/processor.h | 2 +- arch/arm64/kernel/pointer_auth.c | 8 ++++---- arch/arm64/kernel/ptrace.c | 16 ++++++++-------- 4 files changed, 19 insertions(+), 19 deletions(-)
arch/arm64/include/asm/pointer_auth.h +6 -6
@@ -22,7 +22,7 @@ struct ptrauth_key {* We give each process its own keys, which are shared by all threads. The keys * are inherited upon fork(), and reinitialised upon exec*(). */ -struct ptrauth_keys { +struct ptrauth_keys_user {struct ptrauth_key apia;struct ptrauth_key apib;struct ptrauth_key apda;
@@ -30,7 +30,7 @@ struct ptrauth_keys {struct ptrauth_key apga; }; -static inline void ptrauth_keys_init (struct ptrauth_keys *keys) +static inline void ptrauth_keys_init_user (struct ptrauth_keys_user *keys) {if (system_supports_address_auth ()) {get_random_bytes (&keys->apia,sizeof (keys->apia));
@@ -50,7 +50,7 @@ do { \ write_sysreg_s(__pki_v.hi, SYS_ ## k ## KEYHI_EL1); \ } while (0) -static inline void ptrauth_keys_switch (struct ptrauth_keys *keys) +static inline void ptrauth_keys_switch_user (struct ptrauth_keys_user *keys) {if (system_supports_address_auth ()) {__ptrauth_key_install (APIA , keys->apia);
@@ -80,12 +80,12 @@ static inline unsigned long ptrauth_strip_insn_pac(unsigned long ptr)#define ptrauth_thread_init_user (tsk) \ do { \ struct task_struct *__ptiu_tsk = (tsk); \ - ptrauth_keys_init(&__ptiu_tsk->thread.keys_user); \ - ptrauth_keys_switch(&__ptiu_tsk->thread.keys_user); \ + ptrauth_keys_init_user(&__ptiu_tsk->thread.keys_user); \ + ptrauth_keys_switch_user(&__ptiu_tsk->thread.keys_user); \ } while (0)#define ptrauth_thread_switch (tsk) \ - ptrauth_keys_switch(&(tsk)->thread.keys_user) + ptrauth_keys_switch_user(&(tsk)->thread.keys_user)#else /* CONFIG_ARM64_PTR_AUTH */ #define ptrauth_prctl_reset_keys (tsk, arg) (-EINVAL)
arch/arm64/include/asm/processor.h +1 -1
@@ -146,7 +146,7 @@ struct thread_struct {unsigned long fault_code;/* ESR_EL1 value */ struct debug_info debug;/* debugging */ #ifdef CONFIG_ARM64_PTR_AUTH -struct ptrauth_keys keys_user; +struct ptrauth_keys_user keys_user;#endif };
arch/arm64/kernel/pointer_auth.c +4 -4
@@ -9,7 +9,7 @@int ptrauth_prctl_reset_keys (struct task_struct *tsk,unsigned long arg) { -struct ptrauth_keys *keys = &tsk->thread.keys_user; +struct ptrauth_keys_user *keys = &tsk->thread.keys_user;unsigned long addr_key_mask =PR_PAC_APIAKEY |PR_PAC_APIBKEY |PR_PAC_APDAKEY |PR_PAC_APDBKEY ;unsigned long key_mask = addr_key_mask |PR_PAC_APGAKEY ;
@@ -18,8 +18,8 @@ int ptrauth_prctl_reset_keys(struct task_struct *tsk, unsigned long arg)return -EINVAL ;if (!arg) { -ptrauth_keys_init (keys); -ptrauth_keys_switch (keys); +ptrauth_keys_init_user (keys); +ptrauth_keys_switch_user (keys);return 0 ; }
@@ -41,7 +41,7 @@ int ptrauth_prctl_reset_keys(struct task_struct *tsk, unsigned long arg)if (arg &PR_PAC_APGAKEY )get_random_bytes (&keys->apga,sizeof (keys->apga)); -ptrauth_keys_switch (keys); +ptrauth_keys_switch_user (keys);return 0 ; }
arch/arm64/kernel/ptrace.c +8 -8
@@ -999,7 +999,7 @@ static struct ptrauth_key pac_key_from_user(__uint128_t ukey) }static void pac_address_keys_to_user (struct user_pac_address_keys *ukeys, -const struct ptrauth_keys *keys) +const struct ptrauth_keys_user *keys) { ukeys->apiakey =pac_key_to_user (&keys->apia); ukeys->apibkey =pac_key_to_user (&keys->apib);
@@ -1007,7 +1007,7 @@ static void pac_address_keys_to_user(struct user_pac_address_keys *ukeys, ukeys->apdbkey =pac_key_to_user (&keys->apdb); } -static void pac_address_keys_from_user (struct ptrauth_keys *keys, +static void pac_address_keys_from_user (struct ptrauth_keys_user *keys,const struct user_pac_address_keys *ukeys) { keys->apia =pac_key_from_user (ukeys->apiakey);
@@ -1021,7 +1021,7 @@ static int pac_address_keys_get(struct task_struct *target, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { - struct ptrauth_keys *keys = &target->thread.keys_user; + struct ptrauth_keys_user *keys = &target->thread.keys_user;struct user_pac_address_keys user_keys;if (!system_supports_address_auth ())
@@ -1038,7 +1038,7 @@ static int pac_address_keys_set(struct task_struct *target, unsigned int pos, unsigned int count, const void *kbuf, const void __user *ubuf) { - struct ptrauth_keys *keys = &target->thread.keys_user; + struct ptrauth_keys_user *keys = &target->thread.keys_user;struct user_pac_address_keys user_keys;int ret;
@@ -1056,12 +1056,12 @@ static int pac_address_keys_set(struct task_struct *target, }static void pac_generic_keys_to_user (struct user_pac_generic_keys *ukeys, -const struct ptrauth_keys *keys) +const struct ptrauth_keys_user *keys) { ukeys->apgakey =pac_key_to_user (&keys->apga); } -static void pac_generic_keys_from_user (struct ptrauth_keys *keys, +static void pac_generic_keys_from_user (struct ptrauth_keys_user *keys,const struct user_pac_generic_keys *ukeys) { keys->apga =pac_key_from_user (ukeys->apgakey);
@@ -1072,7 +1072,7 @@ static int pac_generic_keys_get(struct task_struct *target, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { - struct ptrauth_keys *keys = &target->thread.keys_user; + struct ptrauth_keys_user *keys = &target->thread.keys_user;struct user_pac_generic_keys user_keys;if (!system_supports_generic_auth ())
@@ -1089,7 +1089,7 @@ static int pac_generic_keys_set(struct task_struct *target, unsigned int pos, unsigned int count, const void *kbuf, const void __user *ubuf) { - struct ptrauth_keys *keys = &target->thread.keys_user; + struct ptrauth_keys_user *keys = &target->thread.keys_user;struct user_pac_generic_keys user_keys;int ret;
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 4/17 arm64: install user ptrauth keys at kernel exit time
In reply to Amit Daniel KachhapFrom: Kristina Martsenko <[email protected]>
As we're going to enable pointer auth within the kernel and use a different APIAKey for the kernel itself, so move the user APIAKey switch to EL0 exception return.
The other 4 keys could remain switched during task switch, but are also moved to keep things consistent.
---
Changes since v6:
* Small change in comment.
arch/arm64/include/asm/asm_pointer_auth.h | 49 +++++++++++++++++++++++++++++++ arch/arm64/include/asm/pointer_auth.h | 23 +-------------- arch/arm64/kernel/asm-offsets.c | 11 +++++++ arch/arm64/kernel/entry.S | 3 ++ arch/arm64/kernel/pointer_auth.c | 3 -- arch/arm64/kernel/process.c | 1 - 6 files changed, 64 insertions(+), 26 deletions(-) create mode 100644 arch/arm64/include/asm/asm_pointer_auth.h
arch/arm64/include/asm/asm_pointer_auth.h new file +49 -0
@@ -0,0 +1,49 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ASM_ASM_POINTER_AUTH_H +#define __ASM_ASM_POINTER_AUTH_H + +#include <asm/alternative.h> +#include <asm/asm-offsets.h> +#include <asm/cpufeature.h> +#include <asm/sysreg.h> + +#ifdef CONFIG_ARM64_PTR_AUTH +/* + * thread.keys_user.ap* as offset exceeds the #imm offset range + * so use the base value of ldp as thread.keys_user and offset as + * thread.keys_user.ap*. + */ + .macro ptrauth_keys_install_user tsk, tmp1, tmp2, tmp3 + mov \tmp1, #THREAD_KEYS_USER + add \tmp1, \tsk, \tmp1 +alternative_if_not ARM64_HAS_ADDRESS_AUTH + b .Laddr_auth_skip_\@ +alternative_else_nop_endif + ldp \tmp2, \tmp3, [\tmp1, #PTRAUTH_USER_KEY_APIA] + msr_s SYS_APIAKEYLO_EL1, \tmp2 + msr_s SYS_APIAKEYHI_EL1, \tmp3 + ldp \tmp2, \tmp3, [\tmp1, #PTRAUTH_USER_KEY_APIB] + msr_s SYS_APIBKEYLO_EL1, \tmp2 + msr_s SYS_APIBKEYHI_EL1, \tmp3 + ldp \tmp2, \tmp3, [\tmp1, #PTRAUTH_USER_KEY_APDA] + msr_s SYS_APDAKEYLO_EL1, \tmp2 + msr_s SYS_APDAKEYHI_EL1, \tmp3 + ldp \tmp2, \tmp3, [\tmp1, #PTRAUTH_USER_KEY_APDB] + msr_s SYS_APDBKEYLO_EL1, \tmp2 + msr_s SYS_APDBKEYHI_EL1, \tmp3 +.Laddr_auth_skip_\@: +alternative_if ARM64_HAS_GENERIC_AUTH + ldp \tmp2, \tmp3, [\tmp1, #PTRAUTH_USER_KEY_APGA] + msr_s SYS_APGAKEYLO_EL1, \tmp2 + msr_s SYS_APGAKEYHI_EL1, \tmp3 +alternative_else_nop_endif + .endm + +#else /* CONFIG_ARM64_PTR_AUTH */ + + .macro ptrauth_keys_install_user tsk, tmp1, tmp2, tmp3 + .endm + +#endif /* CONFIG_ARM64_PTR_AUTH */ + +#endif /* __ASM_ASM_POINTER_AUTH_H */
arch/arm64/include/asm/pointer_auth.h +1 -22
@@ -50,19 +50,6 @@ do { \ write_sysreg_s(__pki_v.hi, SYS_ ## k ## KEYHI_EL1); \ } while (0) -static inline void ptrauth_keys_switch_user (struct ptrauth_keys_user *keys) -{ -if (system_supports_address_auth ()) { -__ptrauth_key_install (APIA , keys->apia); -__ptrauth_key_install (APIB , keys->apib); -__ptrauth_key_install (APDA , keys->apda); -__ptrauth_key_install (APDB , keys->apdb); - } - -if (system_supports_generic_auth ()) -__ptrauth_key_install (APGA , keys->apga); -} -extern int ptrauth_prctl_reset_keys (struct task_struct *tsk,unsigned long arg);/*
@@ -78,20 +65,12 @@ static inline unsigned long ptrauth_strip_insn_pac(unsigned long ptr) }#define ptrauth_thread_init_user (tsk) \ -do { \ - struct task_struct *__ptiu_tsk = (tsk); \ - ptrauth_keys_init_user(&__ptiu_tsk->thread.keys_user); \ - ptrauth_keys_switch_user(&__ptiu_tsk->thread.keys_user); \ -} while (0) - -#define ptrauth_thread_switch (tsk) \ - ptrauth_keys_switch_user(&(tsk)->thread.keys_user) + ptrauth_keys_init_user(&(tsk)->thread.keys_user)#else /* CONFIG_ARM64_PTR_AUTH */ #define ptrauth_prctl_reset_keys (tsk, arg) (-EINVAL)#define ptrauth_strip_insn_pac (lr) (lr)#define ptrauth_thread_init_user (tsk) -#define ptrauth_thread_switch (tsk)#endif /* CONFIG_ARM64_PTR_AUTH */ #endif /* __ASM_POINTER_AUTH_H */
arch/arm64/kernel/asm-offsets.c +11 -0
@@ -40,6 +40,9 @@ int main(void)#endif BLANK (); DEFINE(THREAD_CPU_CONTEXT, offsetof(struct task_struct, thread.cpu_context)); +#ifdef CONFIG_ARM64_PTR_AUTH + DEFINE(THREAD_KEYS_USER, offsetof(struct task_struct, thread.keys_user)); +#endif BLANK (); DEFINE(S_X0, offsetof(struct pt_regs, regs[0])); DEFINE(S_X2, offsetof(struct pt_regs, regs[2]));
@@ -128,5 +131,13 @@ int main(void)DEFINE (SDEI_EVENT_INTREGS , offsetof(struct sdei_registered_event , interrupted_regs));DEFINE (SDEI_EVENT_PRIORITY , offsetof(struct sdei_registered_event , priority));#endif +#ifdef CONFIG_ARM64_PTR_AUTH +DEFINE (PTRAUTH_USER_KEY_APIA , offsetof(struct ptrauth_keys_user , apia)); +DEFINE (PTRAUTH_USER_KEY_APIB , offsetof(struct ptrauth_keys_user , apib)); +DEFINE (PTRAUTH_USER_KEY_APDA , offsetof(struct ptrauth_keys_user , apda)); +DEFINE (PTRAUTH_USER_KEY_APDB , offsetof(struct ptrauth_keys_user , apdb)); +DEFINE (PTRAUTH_USER_KEY_APGA , offsetof(struct ptrauth_keys_user , apga)); +BLANK (); +#endif return 0 ; }
arch/arm64/kernel/entry.S +3 -0
@@ -14,6 +14,7 @@ #include <asm/alternative.h> #include <asm/assembler.h> #include <asm/asm-offsets.h> +#include <asm/asm_pointer_auth.h> #include <asm/cpufeature.h> #include <asm/errno.h> #include <asm/esr.h>
@@ -341,6 +342,8 @@ alternative_else_nop_endif msr cntkctl_el1, x1 4: #endif + ptrauth_keys_install_user tsk, x0, x1, x2 + apply_ssbd 0, x0, x1 .endif
arch/arm64/kernel/pointer_auth.c +0 -3
@@ -19,7 +19,6 @@ int ptrauth_prctl_reset_keys(struct task_struct *tsk, unsigned long arg)if (!arg) {ptrauth_keys_init_user (keys); -ptrauth_keys_switch_user (keys);return 0 ; }
@@ -41,7 +40,5 @@ int ptrauth_prctl_reset_keys(struct task_struct *tsk, unsigned long arg)if (arg &PR_PAC_APGAKEY )get_random_bytes (&keys->apga,sizeof (keys->apga)); -ptrauth_keys_switch_user (keys); -return 0 ; }
arch/arm64/kernel/process.c +0 -1
@@ -512,7 +512,6 @@ __notrace_funcgraph struct task_struct *__switch_to(struct task_struct *prev,contextidr_thread_switch (next);entry_task_switch (next);uao_thread_switch (next); -ptrauth_thread_switch (next);ssbs_thread_switch (next);/*
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 5/17 arm64: ptrauth: Add bootup/runtime flags for __cpu_setup
In reply to Amit Daniel KachhapThis patch allows __cpu_setup to be invoked with one of these flags, ARM64_CPU_BOOT_PRIMARY, ARM64_CPU_BOOT_SECONDARY or ARM64_CPU_RUNTIME. This is required as some cpufeatures need different handling during different scenarios.
The input parameter in x0 is preserved till the end to be used inside this function.
There should be no functional change with this patch and is useful for the subsequent ptrauth patch which utilizes it. Some upcoming arm cpufeatures can also utilize these flags.
---
Changes since v6:
- Added more description as asked by Vincenzo.
arch/arm64/include/asm/smp.h | 8 ++++++++ arch/arm64/kernel/head.S | 2 ++ arch/arm64/kernel/sleep.S | 2 ++ arch/arm64/mm/proc.S | 26 +++++++++++++++----------- 4 files changed, 27 insertions(+), 11 deletions(-)
arch/arm64/include/asm/smp.h +8 -0
@@ -23,6 +23,14 @@#define CPU_STUCK_REASON_52_BIT_VA (UL(1) << CPU_STUCK_REASON_SHIFT)#define CPU_STUCK_REASON_NO_GRAN (UL(2) << CPU_STUCK_REASON_SHIFT) +/* Possible options for __cpu_setup */ +/* Option to setup primary cpu */ +#define ARM64_CPU_BOOT_PRIMARY (1) +/* Option to setup secondary cpus */ +#define ARM64_CPU_BOOT_SECONDARY (2) +/* Option to setup cpus for different cpu run time services */ +#define ARM64_CPU_RUNTIME (3) +#ifndef __ASSEMBLY__#include <asm/percpu.h>
arch/arm64/kernel/head.S +2 -0
@@ -118,6 +118,7 @@ ENTRY(stext) * On return, the CPU will be ready for the MMU to be turned on and * the TCR will have been set. */ + mov x0, #ARM64_CPU_BOOT_PRIMARY bl __cpu_setup // initialise processor b __primary_switch ENDPROC(stext)
@@ -712,6 +713,7 @@ secondary_startup: * Common entry point for secondary CPUs. */ bl __cpu_secondary_check52bitva + mov x0, #ARM64_CPU_BOOT_SECONDARY bl __cpu_setup // initialise processor adrp x1, swapper_pg_dir bl __enable_mmu
arch/arm64/kernel/sleep.S +2 -0
@@ -3,6 +3,7 @@ #include <linux/linkage.h> #include <asm/asm-offsets.h> #include <asm/assembler.h> +#include <asm/smp.h> .text /*
@@ -99,6 +100,7 @@ ENDPROC(__cpu_suspend_enter) .pushsection ".idmap.text", "awx" ENTRY(cpu_resume) bl el2_setup // if in EL2 drop to EL1 cleanly + mov x0, #ARM64_CPU_RUNTIME bl __cpu_setup /* enable the MMU early - so we can access sleep_save_stash by va */ adrp x1, swapper_pg_dir
arch/arm64/mm/proc.S +15 -11
@@ -408,31 +408,31 @@ SYM_FUNC_END(idmap_kpti_install_ng_mappings) /* * __cpu_setup * - * Initialise the processor for turning the MMU on. Return in x0 the - * value of the SCTLR_EL1 register. + * Initialise the processor for turning the MMU on. + * + * Input: + * x0 with a flag ARM64_CPU_BOOT_PRIMARY/ARM64_CPU_BOOT_SECONDARY/ARM64_CPU_RUNTIME. + * Output: + * Return in x0 the value of the SCTLR_EL1 register. */ .pushsection ".idmap.text", "awx" SYM_FUNC_START(__cpu_setup) tlbi vmalle1 // Invalidate local TLB dsb nsh - mov x0, #3 << 20 - msr cpacr_el1, x0 // Enable FP/ASIMD - mov x0, #1 << 12 // Reset mdscr_el1 and disable - msr mdscr_el1, x0 // access to the DCC from EL0 + mov x1, #3 << 20 + msr cpacr_el1, x1 // Enable FP/ASIMD + mov x1, #1 << 12 // Reset mdscr_el1 and disable + msr mdscr_el1, x1 // access to the DCC from EL0 isb // Unmask debug exceptions now, enable_dbg // since this is per-cpu - reset_pmuserenr_el0 x0 // Disable PMU access from EL0 + reset_pmuserenr_el0 x1 // Disable PMU access from EL0 /* * Memory region attributes */ mov_q x5, MAIR_EL1_SET msr mair_el1, x5 /* - * Prepare SCTLR - */ - mov_q x0, SCTLR_EL1_SET - /* * Set/prepare TCR and TTBR. We use 512GB (39-bit) address range for * both user and kernel. */
@@ -468,5 +468,9 @@ SYM_FUNC_START(__cpu_setup) 1: #endif /* CONFIG_ARM64_HW_AFDBM */ msr tcr_el1, x10 + /* + * Prepare SCTLR + */ + mov_q x0, SCTLR_EL1_SET ret // return to head.S SYM_FUNC_END(__cpu_setup)
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 6/17 arm64: cpufeature: Move cpu capability helpers inside C file
In reply to Amit Daniel KachhapThese helpers are used only by functions inside cpufeature.c and hence makes sense to be moved from cpufeature.h to cpufeature.c as they are not expected to be used globally.
This change helps in reducing the header file size as well as to add future cpu capability types without confusion. Only a cpu capability type macro is sufficient to expose those capabilities globally.
--- arch/arm64/include/asm/cpufeature.h | 12 ------------ arch/arm64/kernel/cpufeature.c | 13 +++++++++++++ 2 files changed, 13 insertions(+), 12 deletions(-)
arch/arm64/include/asm/cpufeature.h +0 -12
@@ -340,18 +340,6 @@ static inline int cpucap_default_scope(const struct arm64_cpu_capabilities *cap)return cap->type &ARM64_CPUCAP_SCOPE_MASK ; } -static inline bool -cpucap_late_cpu_optional (const struct arm64_cpu_capabilities *cap) -{ -return !!(cap->type &ARM64_CPUCAP_OPTIONAL_FOR_LATE_CPU ); -} - -static inline bool -cpucap_late_cpu_permitted (const struct arm64_cpu_capabilities *cap) -{ -return !!(cap->type &ARM64_CPUCAP_PERMITTED_FOR_LATE_CPU ); -} -/* * Generic helper for handling capabilties with multiple (match,enable) pairs * of call backs, sharing the same capability bit.
arch/arm64/kernel/cpufeature.c +13 -0
@@ -1363,6 +1363,19 @@ static bool can_use_gic_priorities(const struct arm64_cpu_capabilities *entry, }#endif +/* Internal helper functions to match cpu capability type */ +static bool +cpucap_late_cpu_optional (const struct arm64_cpu_capabilities *cap) +{ +return !!(cap->type &ARM64_CPUCAP_OPTIONAL_FOR_LATE_CPU ); +} + +static bool +cpucap_late_cpu_permitted (const struct arm64_cpu_capabilities *cap) +{ +return !!(cap->type &ARM64_CPUCAP_PERMITTED_FOR_LATE_CPU ); +} +static const struct arm64_cpu_capabilities arm64_features[] = { { .desc ="GIC system register CPU interface" ,
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 7/17 arm64: cpufeature: handle conflicts based on capability
In reply to Amit Daniel KachhapFrom: Kristina Martsenko <[email protected]>
Each system capability can be of either boot, local, or system scope, depending on when the state of the capability is finalized. When we detect a conflict on a late CPU, we either offline the CPU or panic the system. We currently always panic if the conflict is caused by a boot scope capability, and offline the CPU if the conflict is caused by a local or system scope capability.
We're going to want to add a new capability (for pointer authentication) which needs to be boot scope but doesn't need to panic the system when a conflict is detected. So add a new flag to specify whether the capability requires the system to panic or not. Current boot scope capabilities are updated to set the flag, so there should be no functional change as a result of this patch.
--- arch/arm64/include/asm/cpufeature.h | 12 ++++++++++-- arch/arm64/kernel/cpufeature.c | 29 +++++++++++++++-------------- 2 files changed, 25 insertions(+), 16 deletions(-)
arch/arm64/include/asm/cpufeature.h +10 -2
@@ -208,6 +208,10 @@ extern struct arm64_ftr_reg arm64_ftr_reg_ctrel0;* In some non-typical cases either both (a) and (b), or neither, * should be permitted. This can be described by including neither * or both flags in the capability's type field. +* +* In case of a conflict, the CPU is prevented from booting. If the +* ARM64_CPUCAP_PANIC_ON_CONFLICT flag is specified for the capability, +* then a kernel panic is triggered. */
@@ -240,6 +244,8 @@ extern struct arm64_ftr_reg arm64_ftr_reg_ctrel0;#define ARM64_CPUCAP_PERMITTED_FOR_LATE_CPU ((u16)BIT(4))/* Is it safe for a late CPU to miss this capability when system has it */ #define ARM64_CPUCAP_OPTIONAL_FOR_LATE_CPU ((u16)BIT(5)) +/* Panic when a conflict is detected */ +#define ARM64_CPUCAP_PANIC_ON_CONFLICT ((u16)BIT(6))/* * CPU errata workarounds that need to be enabled at boot time if one or
@@ -279,9 +285,11 @@ extern struct arm64_ftr_reg arm64_ftr_reg_ctrel0;/* * CPU feature used early in the boot based on the boot CPU. All secondary -* CPUs must match the state of the capability as detected by the boot CPU. +* CPUs must match the state of the capability as detected by the boot CPU. In +* case of a conflict, a kernel panic is triggered. */ -#define ARM64_CPUCAP_STRICT_BOOT_CPU_FEATURE ARM64_CPUCAP_SCOPE_BOOT_CPU +#define ARM64_CPUCAP_STRICT_BOOT_CPU_FEATURE \ + (ARM64_CPUCAP_SCOPE_BOOT_CPU | ARM64_CPUCAP_PANIC_ON_CONFLICT)struct arm64_cpu_capabilities {const char *desc;
arch/arm64/kernel/cpufeature.c +15 -14
@@ -1376,6 +1376,12 @@ cpucap_late_cpu_permitted(const struct arm64_cpu_capabilities *cap)return !!(cap->type &ARM64_CPUCAP_PERMITTED_FOR_LATE_CPU ); } +static bool +cpucap_panic_on_conflict (const struct arm64_cpu_capabilities *cap) +{ +return !!(cap->type &ARM64_CPUCAP_PANIC_ON_CONFLICT ); +} +static const struct arm64_cpu_capabilities arm64_features[] = { { .desc ="GIC system register CPU interface" ,
@@ -2018,10 +2024,8 @@ static void __init enable_cpu_capabilities(u16 scope_mask)* Run through the list of capabilities to check for conflicts. * If the system has already detected a capability, take necessary * action on this CPU. -* -* Returns "false" on conflicts. */ -static bool verify_local_cpu_caps (u16 scope_mask) +static void verify_local_cpu_caps (u16 scope_mask) {int i;bool cpu_has_cap, system_has_cap;
@@ -2066,10 +2070,12 @@ static bool verify_local_cpu_caps(u16 scope_mask)pr_crit ("CPU%d: Detected conflict for capability %d (%s), System: %d, CPU: %d\n" ,smp_processor_id (), caps->capability, caps->desc, system_has_cap, cpu_has_cap); -return false; - } -return true; +if (cpucap_panic_on_conflict (caps)) +cpu_panic_kernel (); +else +cpu_die_early (); + } }/*
@@ -2079,12 +2085,8 @@ static bool verify_local_cpu_caps(u16 scope_mask)static void check_early_cpu_features (void ) {verify_cpu_asid_bits (); -/* -* Early features are used by the kernel already. If there -* is a conflict, we cannot proceed further. -*/ -if (!verify_local_cpu_caps (SCOPE_BOOT_CPU )) -cpu_panic_kernel (); + +verify_local_cpu_caps (SCOPE_BOOT_CPU ); } static void
@@ -2132,8 +2134,7 @@ static void verify_local_cpu_capabilities(void)* check_early_cpu_features(), as they need to be verified * on all secondary CPUs. */ -if (!verify_local_cpu_caps (SCOPE_ALL & ~SCOPE_BOOT_CPU )) -cpu_die_early (); +verify_local_cpu_caps (SCOPE_ALL & ~SCOPE_BOOT_CPU );verify_local_elf_hwcaps (arm64_elf_hwcaps);
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 8/17 arm64: enable ptrauth earlier
In reply to Amit Daniel KachhapFrom: Kristina Martsenko <[email protected]>
When the kernel is compiled with pointer auth instructions, the boot CPU needs to start using address auth very early, so change the cpucap to account for this.
Pointer auth must be enabled before we call C functions, because it is not possible to enter a function with pointer auth disabled and exit it with pointer auth enabled. Note, mismatches between architected and IMPDEF algorithms will still be caught by the cpufeature framework (the separate *_ARCH and *_IMP_DEF cpucaps).
Note the change in behavior: if the boot CPU has address auth and a late CPU does not, then the late CPU is parked by the cpufeature framework. This is possible as kernel will only have NOP space intructions for PAC so such mismatched late cpu will silently ignore those instructions in C functions. Also, if the boot CPU does not have address auth and the late CPU has then the late cpu will still boot but with ptrauth feature disabled.
Leave generic authentication as a "system scope" cpucap for now, since initially the kernel will only use address authentication.
---
Change since v6:
* Removed refernces of unused CPU_STUCK_REASON_NO_PTRAUTH.
* Updated commit logs.
arch/arm64/Kconfig | 6 ++++++ arch/arm64/include/asm/cpufeature.h | 9 +++++++++ arch/arm64/kernel/cpufeature.c | 13 +++---------- arch/arm64/mm/proc.S | 31 +++++++++++++++++++++++++++++++ 4 files changed, 49 insertions(+), 10 deletions(-)
arch/arm64/Kconfig +6 -0
@@ -1515,6 +1515,12 @@ config ARM64_PTR_AUTH be enabled. However, KVM guest also require VHE mode and hence CONFIG_ARM64_VHE=y option to use this feature. + If the feature is present on the boot CPU but not on a late CPU, then + the late CPU will be parked. Also, if the boot CPU does not have + address auth and the late CPU has then the late CPU will still boot + but with the feature disabled. On such a system, this option should + not be selected. + endmenu menu "ARMv8.5 architectural features"
arch/arm64/include/asm/cpufeature.h +9 -0
@@ -291,6 +291,15 @@ extern struct arm64_ftr_reg arm64_ftr_reg_ctrel0;#define ARM64_CPUCAP_STRICT_BOOT_CPU_FEATURE \ (ARM64_CPUCAP_SCOPE_BOOT_CPU | ARM64_CPUCAP_PANIC_ON_CONFLICT) +/* +* CPU feature used early in the boot based on the boot CPU. It is safe for a +* late CPU to have this feature even though the boot CPU hasn't enabled it, +* although the feature will not be used by Linux in this case. If the boot CPU +* has enabled this feature already, then every late CPU must have it. +*/ +#define ARM64_CPUCAP_BOOT_CPU_FEATURE \ + (ARM64_CPUCAP_SCOPE_BOOT_CPU | ARM64_CPUCAP_PERMITTED_FOR_LATE_CPU) +struct arm64_cpu_capabilities {const char *desc;u16 capability;
arch/arm64/kernel/cpufeature.c +3 -10
@@ -1318,12 +1318,6 @@ static void cpu_clear_disr(const struct arm64_cpu_capabilities *__unused)#endif /* CONFIG_ARM64_RAS_EXTN */ #ifdef CONFIG_ARM64_PTR_AUTH -static void cpu_enable_address_auth (struct arm64_cpu_capabilities const *cap) -{ -sysreg_clear_set (sctlr_el1,0 , SCTLR_ELx_ENIA | SCTLR_ELx_ENIB | - SCTLR_ELx_ENDA | SCTLR_ELx_ENDB); -} -static bool has_address_auth (const struct arm64_cpu_capabilities *entry,int __unused) {
@@ -1627,7 +1621,7 @@ static const struct arm64_cpu_capabilities arm64_features[] = { { .desc = "Address authentication (architected algorithm)", .capability = ARM64_HAS_ADDRESS_AUTH_ARCH, - .type = ARM64_CPUCAP_SYSTEM_FEATURE, + .type = ARM64_CPUCAP_BOOT_CPU_FEATURE, .sys_reg = SYS_ID_AA64ISAR1_EL1, .sign = FTR_UNSIGNED, .field_pos = ID_AA64ISAR1_APA_SHIFT,
@@ -1637,7 +1631,7 @@ static const struct arm64_cpu_capabilities arm64_features[] = { { .desc = "Address authentication (IMP DEF algorithm)", .capability = ARM64_HAS_ADDRESS_AUTH_IMP_DEF, - .type = ARM64_CPUCAP_SYSTEM_FEATURE, + .type = ARM64_CPUCAP_BOOT_CPU_FEATURE, .sys_reg = SYS_ID_AA64ISAR1_EL1, .sign = FTR_UNSIGNED, .field_pos = ID_AA64ISAR1_API_SHIFT,
@@ -1646,9 +1640,8 @@ static const struct arm64_cpu_capabilities arm64_features[] = { }, { .capability = ARM64_HAS_ADDRESS_AUTH, - .type = ARM64_CPUCAP_SYSTEM_FEATURE, + .type = ARM64_CPUCAP_BOOT_CPU_FEATURE, .matches = has_address_auth, - .cpu_enable = cpu_enable_address_auth, }, { .desc = "Generic authentication (architected algorithm)",
arch/arm64/mm/proc.S +31 -0
@@ -16,6 +16,7 @@ #include <asm/pgtable-hwdef.h> #include <asm/cpufeature.h> #include <asm/alternative.h> +#include <asm/smp.h> #ifdef CONFIG_ARM64_64K_PAGES #define TCR_TG_FLAGS TCR_TG0_64K | TCR_TG1_64K
@@ -468,9 +469,39 @@ SYM_FUNC_START(__cpu_setup) 1: #endif /* CONFIG_ARM64_HW_AFDBM */ msr tcr_el1, x10 + mov x1, x0 /* * Prepare SCTLR */ mov_q x0, SCTLR_EL1_SET + +#ifdef CONFIG_ARM64_PTR_AUTH + /* No ptrauth setup for run time cpus */ + cmp x1, #ARM64_CPU_RUNTIME + b.eq 3f + + /* Check if the CPU supports ptrauth */ + mrs x2, id_aa64isar1_el1 + ubfx x2, x2, #ID_AA64ISAR1_APA_SHIFT, #8 + cbz x2, 3f + + msr_s SYS_APIAKEYLO_EL1, xzr + msr_s SYS_APIAKEYHI_EL1, xzr + + /* Just enable ptrauth for primary cpu */ + cmp x1, #ARM64_CPU_BOOT_PRIMARY + b.eq 2f + + /* if !system_supports_address_auth() then skip enable */ +alternative_if_not ARM64_HAS_ADDRESS_AUTH + b 3f +alternative_else_nop_endif + +2: /* Enable ptrauth instructions */ + ldr x2, =SCTLR_ELx_ENIA | SCTLR_ELx_ENIB | \ + SCTLR_ELx_ENDA | SCTLR_ELx_ENDB + orr x0, x0, x2 +3: +#endif ret // return to head.S SYM_FUNC_END(__cpu_setup)
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 9/17 arm64: initialize and switch ptrauth kernel keys
In reply to Amit Daniel KachhapFrom: Kristina Martsenko <[email protected]>
Set up keys to use pointer authentication within the kernel. The kernel will be compiled with APIAKey instructions, the other keys are currently unused. Each task is given its own APIAKey, which is initialized during fork. The key is changed during context switch and on kernel entry from EL0.
The keys for idle threads need to be set before calling any C functions, because it is not possible to enter and exit a function with different keys.
--- arch/arm64/include/asm/asm_pointer_auth.h | 14 ++++++++++++++ arch/arm64/include/asm/pointer_auth.h | 13 +++++++++++++ arch/arm64/include/asm/processor.h | 1 + arch/arm64/include/asm/smp.h | 4 ++++ arch/arm64/kernel/asm-offsets.c | 5 +++++ arch/arm64/kernel/entry.S | 3 +++ arch/arm64/kernel/process.c | 2 ++ arch/arm64/kernel/smp.c | 8 ++++++++ arch/arm64/mm/proc.S | 12 ++++++++++++ 9 files changed, 62 insertions(+)
arch/arm64/include/asm/asm_pointer_auth.h +14 -0
@@ -39,11 +39,25 @@ alternative_if ARM64_HAS_GENERIC_AUTH alternative_else_nop_endif .endm + .macro ptrauth_keys_install_kernel tsk, tmp1, tmp2, tmp3 +alternative_if ARM64_HAS_ADDRESS_AUTH + mov \tmp1, #THREAD_KEYS_KERNEL + add \tmp1, \tsk, \tmp1 + ldp \tmp2, \tmp3, [\tmp1, #PTRAUTH_KERNEL_KEY_APIA] + msr_s SYS_APIAKEYLO_EL1, \tmp2 + msr_s SYS_APIAKEYHI_EL1, \tmp3 + isb +alternative_else_nop_endif + .endm + #else /* CONFIG_ARM64_PTR_AUTH */ .macro ptrauth_keys_install_user tsk, tmp1, tmp2, tmp3 .endm + .macro ptrauth_keys_install_kernel tsk, tmp1, tmp2, tmp3 + .endm + #endif /* CONFIG_ARM64_PTR_AUTH */ #endif /* __ASM_ASM_POINTER_AUTH_H */
arch/arm64/include/asm/pointer_auth.h +13 -0
@@ -30,6 +30,10 @@ struct ptrauth_keys_user {struct ptrauth_key apga; }; +struct ptrauth_keys_kernel { +struct ptrauth_key apia; +}; +static inline void ptrauth_keys_init_user (struct ptrauth_keys_user *keys) {if (system_supports_address_auth ()) {
@@ -50,6 +54,12 @@ do { \ write_sysreg_s(__pki_v.hi, SYS_ ## k ## KEYHI_EL1); \ } while (0) +static inline void ptrauth_keys_init_kernel (struct ptrauth_keys_kernel *keys) +{ +if (system_supports_address_auth ()) +get_random_bytes (&keys->apia,sizeof (keys->apia)); +} +extern int ptrauth_prctl_reset_keys (struct task_struct *tsk,unsigned long arg);/*
@@ -66,11 +76,14 @@ static inline unsigned long ptrauth_strip_insn_pac(unsigned long ptr)#define ptrauth_thread_init_user (tsk) \ ptrauth_keys_init_user(&(tsk)->thread.keys_user) +#define ptrauth_thread_init_kernel (tsk) \ + ptrauth_keys_init_kernel(&(tsk)->thread.keys_kernel)#else /* CONFIG_ARM64_PTR_AUTH */ #define ptrauth_prctl_reset_keys (tsk, arg) (-EINVAL)#define ptrauth_strip_insn_pac (lr) (lr)#define ptrauth_thread_init_user (tsk) +#define ptrauth_thread_init_kernel (tsk)#endif /* CONFIG_ARM64_PTR_AUTH */ #endif /* __ASM_POINTER_AUTH_H */
arch/arm64/include/asm/processor.h +1 -0
@@ -147,6 +147,7 @@ struct thread_struct {struct debug_info debug;/* debugging */ #ifdef CONFIG_ARM64_PTR_AUTH struct ptrauth_keys_user keys_user; +struct ptrauth_keys_kernel keys_kernel;#endif };
arch/arm64/include/asm/smp.h +4 -0
@@ -38,6 +38,7 @@#include <linux/threads.h> #include <linux/cpumask.h> #include <linux/thread_info.h> +#include <asm/pointer_auth.h> DECLARE_PER_CPU_READ_MOSTLY (int, cpu_number);
@@ -95,6 +96,9 @@ asmlinkage void secondary_start_kernel(void);struct secondary_data {void *stack;struct task_struct *task; +#ifdef CONFIG_ARM64_PTR_AUTH +struct ptrauth_keys_kernel ptrauth_key; +#endif long status; };
arch/arm64/kernel/asm-offsets.c +5 -0
@@ -42,6 +42,7 @@ int main(void) DEFINE(THREAD_CPU_CONTEXT, offsetof(struct task_struct, thread.cpu_context));#ifdef CONFIG_ARM64_PTR_AUTH DEFINE(THREAD_KEYS_USER, offsetof(struct task_struct, thread.keys_user)); + DEFINE(THREAD_KEYS_KERNEL, offsetof(struct task_struct, thread.keys_kernel));#endif BLANK (); DEFINE(S_X0, offsetof(struct pt_regs, regs[0]));
@@ -91,6 +92,9 @@ int main(void)BLANK ();DEFINE (CPU_BOOT_STACK , offsetof(struct secondary_data , stack));DEFINE (CPU_BOOT_TASK , offsetof(struct secondary_data , task)); +#ifdef CONFIG_ARM64_PTR_AUTH +DEFINE (CPU_BOOT_PTRAUTH_KEY , offsetof(struct secondary_data , ptrauth_key)); +#endif BLANK ();#ifdef CONFIG_KVM_ARM_HOST DEFINE(VCPU_CONTEXT, offsetof(struct kvm_vcpu, arch.ctxt));
@@ -137,6 +141,7 @@ int main(void)DEFINE (PTRAUTH_USER_KEY_APDA , offsetof(struct ptrauth_keys_user , apda));DEFINE (PTRAUTH_USER_KEY_APDB , offsetof(struct ptrauth_keys_user , apdb));DEFINE (PTRAUTH_USER_KEY_APGA , offsetof(struct ptrauth_keys_user , apga)); +DEFINE (PTRAUTH_KERNEL_KEY_APIA , offsetof(struct ptrauth_keys_kernel , apia));BLANK ();#endif return 0 ;
arch/arm64/kernel/entry.S +3 -0
@@ -178,6 +178,7 @@ alternative_cb_end apply_ssbd 1, x22, x23 + ptrauth_keys_install_kernel tsk, x20, x22, x23 .else add x21, sp, #S_FRAME_SIZE get_current_task tsk
@@ -342,6 +343,7 @@ alternative_else_nop_endif msr cntkctl_el1, x1 4: #endif + /* No kernel C function calls after this as user keys are set. */ ptrauth_keys_install_user tsk, x0, x1, x2 apply_ssbd 0, x0, x1
@@ -898,6 +900,7 @@ ENTRY(cpu_switch_to) ldr lr, [x8] mov sp, x9 msr sp_el0, x1 + ptrauth_keys_install_kernel x1, x8, x9, x10 ret ENDPROC(cpu_switch_to) NOKPROBE(cpu_switch_to)
arch/arm64/kernel/process.c +2 -0
@@ -376,6 +376,8 @@ int copy_thread_tls(unsigned long clone_flags, unsigned long stack_start,*/ fpsimd_flush_task_state (p); +ptrauth_thread_init_kernel (p); +if (likely (!(p->flags &PF_KTHREAD ))) { *childregs = *current_pt_regs (); childregs->regs[0 ] =0 ;
arch/arm64/kernel/smp.c +8 -0
@@ -112,6 +112,10 @@ int __cpu_up(unsigned int cpu, struct task_struct *idle)*/ secondary_data.task = idle; secondary_data.stack =task_stack_page (idle) +THREAD_SIZE ; +#if defined(CONFIG_ARM64_PTR_AUTH ) + secondary_data.ptrauth_key.apia.lo = idle->thread.keys_kernel.apia.lo; + secondary_data.ptrauth_key.apia.hi = idle->thread.keys_kernel.apia.hi; +#endif update_cpu_boot_status (CPU_MMU_OFF );__flush_dcache_area (&secondary_data,sizeof (secondary_data));
@@ -138,6 +142,10 @@ int __cpu_up(unsigned int cpu, struct task_struct *idle) secondary_data.task =NULL ; secondary_data.stack =NULL ; +#if defined(CONFIG_ARM64_PTR_AUTH ) + secondary_data.ptrauth_key.apia.lo =0 ; + secondary_data.ptrauth_key.apia.hi =0 ; +#endif __flush_dcache_area (&secondary_data,sizeof (secondary_data)); status =READ_ONCE (secondary_data.status);if (ret && status) {
arch/arm64/mm/proc.S +12 -0
@@ -485,6 +485,10 @@ SYM_FUNC_START(__cpu_setup) ubfx x2, x2, #ID_AA64ISAR1_APA_SHIFT, #8 cbz x2, 3f + /* + * The primary cpu keys are reset here and can be + * re-initialised with some proper values later. + */ msr_s SYS_APIAKEYLO_EL1, xzr msr_s SYS_APIAKEYHI_EL1, xzr
@@ -497,6 +501,14 @@ alternative_if_not ARM64_HAS_ADDRESS_AUTH b 3f alternative_else_nop_endif + /* Install ptrauth key for secondary cpus */ + adr_l x2, secondary_data + ldr x3, [x2, #CPU_BOOT_TASK] // get secondary_data.task + cbz x3, 2f // check for slow booting cpus + ldp x3, x4, [x2, #CPU_BOOT_PTRAUTH_KEY] + msr_s SYS_APIAKEYLO_EL1, x3 + msr_s SYS_APIAKEYHI_EL1, x4 + 2: /* Enable ptrauth instructions */ ldr x2, =SCTLR_ELx_ENIA | SCTLR_ELx_ENIB | \ SCTLR_ELx_ENDA | SCTLR_ELx_ENDB
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 10/17 arm64: initialize ptrauth keys for kernel booting task
In reply to Amit Daniel KachhapThis patch uses the existing boot_init_stack_canary arch function to initialize the ptrauth keys for the booting task in the primary core. The requirement here is that it should be always inline and the caller must never return.
As pointer authentication too detects a subset of stack corruption so it makes sense to place this code here.
Both pointer authentication and stack canary codes are protected by their respective config option.
--- arch/arm64/include/asm/pointer_auth.h | 11 ++++++++++- arch/arm64/include/asm/stackprotector.h | 5 +++++ include/linux/stackprotector.h | 2 +- 3 files changed, 16 insertions(+), 2 deletions(-)
arch/arm64/include/asm/pointer_auth.h +10 -1
@@ -54,12 +54,18 @@ do { \ write_sysreg_s(__pki_v.hi, SYS_ ## k ## KEYHI_EL1); \ }while (0 ) -static inline void ptrauth_keys_init_kernel (struct ptrauth_keys_kernel *keys) +static __always_inline void ptrauth_keys_init_kernel(struct ptrauth_keys_kernel *keys) {if (system_supports_address_auth ())get_random_bytes (&keys->apia,sizeof (keys->apia)); } +static __always_inline void ptrauth_keys_switch_kernel(struct ptrauth_keys_kernel *keys) +{ +if (system_supports_address_auth ()) +__ptrauth_key_install (APIA , keys->apia); +} +extern int ptrauth_prctl_reset_keys (struct task_struct *tsk,unsigned long arg);/*
@@ -78,12 +84,15 @@ static inline unsigned long ptrauth_strip_insn_pac(unsigned long ptr) ptrauth_keys_init_user(&(tsk)->thread.keys_user)#define ptrauth_thread_init_kernel (tsk) \ ptrauth_keys_init_kernel(&(tsk)->thread.keys_kernel) +#define ptrauth_thread_switch_kernel (tsk) \ + ptrauth_keys_switch_kernel(&(tsk)->thread.keys_kernel)#else /* CONFIG_ARM64_PTR_AUTH */ #define ptrauth_prctl_reset_keys (tsk, arg) (-EINVAL)#define ptrauth_strip_insn_pac (lr) (lr)#define ptrauth_thread_init_user (tsk)#define ptrauth_thread_init_kernel (tsk) +#define ptrauth_thread_switch_kernel (tsk)#endif /* CONFIG_ARM64_PTR_AUTH */ #endif /* __ASM_POINTER_AUTH_H */
arch/arm64/include/asm/stackprotector.h +5 -0
@@ -15,6 +15,7 @@#include <linux/random.h> #include <linux/version.h> +#include <asm/pointer_auth.h> extern unsigned long __stack_chk_guard;
@@ -26,6 +27,7 @@ extern unsigned long __stack_chk_guard;*/ static __always_inline void boot_init_stack_canary(void) { +#if defined(CONFIG_STACKPROTECTOR )unsigned long canary;/* Try to get a semi random initial value. */
@@ -36,6 +38,9 @@ static __always_inline void boot_init_stack_canary(void) current->stack_canary = canary;if (!IS_ENABLED (CONFIG_STACKPROTECTOR_PER_TASK )) __stack_chk_guard = current->stack_canary; +#endif +ptrauth_thread_init_kernel (current); + ptrauth_thread_switch_kernel(current); }#endif /* _ASM_STACKPROTECTOR_H */
include/linux/stackprotector.h +1 -1
@@ -6,7 +6,7 @@#include <linux/sched.h> #include <linux/random.h> -#ifdef CONFIG_STACKPROTECTOR +#if defined(CONFIG_STACKPROTECTOR ) || defined(CONFIG_ARM64_PTR_AUTH )# include <asm/stackprotector.h> #else static inline void boot_init_stack_canary (void )
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 11/17 arm64: mask PAC bits of __builtin_return_address
In reply to Amit Daniel KachhapFunctions like vmap() record how much memory has been allocated by their callers, and callers are identified using __builtin_return_address(). Once the kernel is using pointer-auth the return address will be signed. This means it will not match any kernel symbol, and will vary between threads even for the same caller.
The output of /proc/vmallocinfo in this case may look like,
0x(____ptrval____)-0x(____ptrval____) 20480 0x86e28000100e7c60 pages=4 vmalloc N0=4 0x(____ptrval____)-0x(____ptrval____) 20480 0x86e28000100e7c60 pages=4 vmalloc N0=4 0x(____ptrval____)-0x(____ptrval____) 20480 0xc5c78000100e7c60 pages=4 vmalloc N0=4
The above three 64bit values should be the same symbol name and not different LR values.
Use the pre-processor to add logic to clear the PAC to __builtin_return_address() callers. This patch adds a new file asm/compiler.h and is transitively included via include/compiler_types.h on the compiler command line so it is guaranteed to be loaded and the users of this macro will not find a wrong version.
Helper macros ptrauth_kernel_pac_mask/ptrauth_clear_pac are created for this purpose and added in this file. Existing macro ptrauth_user_pac_mask moved from asm/pointer_auth.h.
---
Changes since v6:
* Added ptrauth_user_pac_mask check along with ptrauth_kernel_pac_mask in __builtin_return_address as pointed by James.
* Updated commit message.
arch/arm64/Kconfig | 1 + arch/arm64/include/asm/compiler.h | 24 ++++++++++++++++++++++++ arch/arm64/include/asm/pointer_auth.h | 9 +-------- 3 files changed, 26 insertions(+), 8 deletions(-) create mode 100644 arch/arm64/include/asm/compiler.h
arch/arm64/Kconfig +1 -0
@@ -118,6 +118,7 @@ config ARM64 select HAVE_ALIGNED_STRUCT_PAGE if SLUB select HAVE_ARCH_AUDITSYSCALL select HAVE_ARCH_BITREVERSE + select HAVE_ARCH_COMPILER_H select HAVE_ARCH_HUGE_VMAP select HAVE_ARCH_JUMP_LABEL select HAVE_ARCH_JUMP_LABEL_RELATIVE
arch/arm64/include/asm/compiler.h new file +24 -0
@@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ASM_COMPILER_H +#define __ASM_COMPILER_H + +#if defined(CONFIG_ARM64_PTR_AUTH ) + +/* +* The EL0/EL1 pointer bits used by a pointer authentication code. +* This is dependent on TBI0/TBI1 being enabled, or bits 63:56 would also apply. +*/ +#define ptrauth_user_pac_mask () GENMASK_ULL(54, vabits_actual) +#define ptrauth_kernel_pac_mask () GENMASK_ULL(63, vabits_actual) + +/* Valid for EL0 TTBR0 and EL1 TTBR1 instruction pointers */ +#define ptrauth_clear_pac (ptr) \ + ((ptr & BIT_ULL(55)) ? (ptr | ptrauth_kernel_pac_mask()) : \ + (ptr & ~ptrauth_user_pac_mask())) + +#define __builtin_return_address (val) \ + (void *)(ptrauth_clear_pac((unsigned long)__builtin_return_address(val))) + +#endif /* CONFIG_ARM64_PTR_AUTH */ + +#endif /* __ASM_COMPILER_H */
arch/arm64/include/asm/pointer_auth.h +1 -8
@@ -68,16 +68,9 @@ static __always_inline void ptrauth_keys_switch_kernel(struct ptrauth_keys_kerneextern int ptrauth_prctl_reset_keys (struct task_struct *tsk,unsigned long arg); -/* -* The EL0 pointer bits used by a pointer authentication code. -* This is dependent on TBI0 being enabled, or bits 63:56 would also apply. -*/ -#define ptrauth_user_pac_mask () GENMASK(54, vabits_actual) - -/* Only valid for EL0 TTBR0 instruction pointers */ static inline unsigned long ptrauth_strip_insn_pac (unsigned long ptr) { -return ptr & ~ptrauth_user_pac_mask (); +return ptrauth_clear_pac (ptr); }#define ptrauth_thread_init_user (tsk) \
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 12/17 arm64: unwind: strip PAC from kernel addresses
In reply to Amit Daniel KachhapFrom: Mark Rutland <[email protected]>
When we enable pointer authentication in the kernel, LR values saved to the stack will have a PAC which we must strip in order to retrieve the real return address.
Strip PACs when unwinding the stack in order to account for this.
When function graph tracer is used with patchable-function-entry then return_to_handler will also have pac bits so strip it too.
---
Changes since v6:
* Mask PAC bits of return_to_handler in case of FUNCTION_GRAPH_TRACER.
incase
arch/arm64/kernel/stacktrace.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
arch/arm64/kernel/stacktrace.c +4 -1
@@ -14,6 +14,7 @@#include <linux/stacktrace.h> #include <asm/irq.h> +#include <asm/pointer_auth.h> #include <asm/stack_pointer.h> #include <asm/stacktrace.h>
@@ -86,7 +87,7 @@ int notrace unwind_frame(struct task_struct *tsk, struct stackframe *frame)#ifdef CONFIG_FUNCTION_GRAPH_TRACER if (tsk->ret_stack && - (frame->pc == (unsigned long )return_to_handler)) { + (ptrauth_strip_insn_pac (frame->pc) == (unsigned long )return_to_handler)) {struct ftrace_ret_stack *ret_stack;/* * This is a case where function graph tracer has
@@ -101,6 +102,8 @@ int notrace unwind_frame(struct task_struct *tsk, struct stackframe *frame) }#endif /* CONFIG_FUNCTION_GRAPH_TRACER */ + frame->pc =ptrauth_strip_insn_pac (frame->pc); +/* * Frames created upon entry from EL0 have NULL FP and PC values, so * don't bother reporting these. Frames created by __noreturn functions
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 13/17 arm64: __show_regs: strip PAC from lr in printk
In reply to Amit Daniel Kachhaplr is printed with %pS which will try to find an entry in kallsyms. After enabling pointer authentication, this match will fail due to PAC present in the lr.
Strip PAC from the lr to display the correct symbol name.
--- arch/arm64/kernel/process.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm64/kernel/process.c +1 -1
@@ -262,7 +262,7 @@ void __show_regs(struct pt_regs *regs)if (!user_mode (regs)) {printk ("pc : %pS\n" , (void *)regs->pc); -printk ("lr : %pS\n" , (void *)lr); +printk ("lr : %pS\n" , (void *)ptrauth_strip_insn_pac (lr)); }else {printk ("pc : %016llx\n" , regs->pc);printk ("lr : %016llx\n" , lr);
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 14/17 arm64: suspend: restore the kernel ptrauth keys
In reply to Amit Daniel KachhapThis patch restores the kernel keys from current task during cpu resume after the mmu is turned on and ptrauth is enabled.
A flag is added in macro ptrauth_keys_install_kernel to check if isb instruction needs to be executed.
--- arch/arm64/include/asm/asm_pointer_auth.h | 6 ++++-- arch/arm64/kernel/entry.S | 4 ++-- arch/arm64/mm/proc.S | 2 ++ 3 files changed, 8 insertions(+), 4 deletions(-)
arch/arm64/include/asm/asm_pointer_auth.h +4 -2
@@ -39,14 +39,16 @@ alternative_if ARM64_HAS_GENERIC_AUTH alternative_else_nop_endif .endm - .macro ptrauth_keys_install_kernel tsk, tmp1, tmp2, tmp3 + .macro ptrauth_keys_install_kernel tsk, sync, tmp1, tmp2, tmp3 alternative_if ARM64_HAS_ADDRESS_AUTH mov \tmp1, #THREAD_KEYS_KERNEL add \tmp1, \tsk, \tmp1 ldp \tmp2, \tmp3, [\tmp1, #PTRAUTH_KERNEL_KEY_APIA] msr_s SYS_APIAKEYLO_EL1, \tmp2 msr_s SYS_APIAKEYHI_EL1, \tmp3 + .if \sync == 1 isb + .endif alternative_else_nop_endif .endm
@@ -55,7 +57,7 @@ alternative_else_nop_endif .macro ptrauth_keys_install_user tsk, tmp1, tmp2, tmp3 .endm - .macro ptrauth_keys_install_kernel tsk, tmp1, tmp2, tmp3 + .macro ptrauth_keys_install_kernel tsk, sync, tmp1, tmp2, tmp3 .endm #endif /* CONFIG_ARM64_PTR_AUTH */
arch/arm64/kernel/entry.S +2 -2
@@ -178,7 +178,7 @@ alternative_cb_end apply_ssbd 1, x22, x23 - ptrauth_keys_install_kernel tsk, x20, x22, x23 + ptrauth_keys_install_kernel tsk, 1, x20, x22, x23 .else add x21, sp, #S_FRAME_SIZE get_current_task tsk
@@ -900,7 +900,7 @@ ENTRY(cpu_switch_to) ldr lr, [x8] mov sp, x9 msr sp_el0, x1 - ptrauth_keys_install_kernel x1, x8, x9, x10 + ptrauth_keys_install_kernel x1, 1, x8, x9, x10 ret ENDPROC(cpu_switch_to) NOKPROBE(cpu_switch_to)
arch/arm64/mm/proc.S +2 -0
@@ -11,6 +11,7 @@ #include <linux/linkage.h> #include <asm/assembler.h> #include <asm/asm-offsets.h> +#include <asm/asm_pointer_auth.h> #include <asm/hwcap.h> #include <asm/pgtable.h> #include <asm/pgtable-hwdef.h>
@@ -137,6 +138,7 @@ alternative_if ARM64_HAS_RAS_EXTN msr_s SYS_DISR_EL1, xzr alternative_else_nop_endif + ptrauth_keys_install_kernel x14, 0, x1, x2, x3 isb ret SYM_FUNC_END(cpu_do_resume)
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 15/17 kconfig: Add support for 'as-option'
In reply to Amit Daniel KachhapFrom: Vincenzo Frascino <[email protected]>
Currently kconfig does not have a feature that allows to detect if the used assembler supports a specific compilation option.
Introduce 'as-option' to serve this purpose in the context of Kconfig:
config X
def_bool $(as-option,...)--- scripts/Kconfig.include | 6 ++++++ 1 file changed, 6 insertions(+)
scripts/Kconfig.include +6 -0
@@ -31,6 +31,12 @@ cc-option = $(success,$(CC) -Werror $(CLANG_FLAGS) $(1) -S -x c /dev/null -o /de # Return y if the linker supports <flag>, n otherwise ld-option = $(success,$(LD) -v $(1)) +# $(as-option,<flag>) +# /dev/zero is used as output instead of /dev/null as some assembler cribs when +# both input and output are same. Also both of them have same write behaviour so +# can be easily substituted. +as-option = $(success, $(CC) $(CLANG_FLAGS) $(1) -c -x assembler /dev/null -o /dev/zero) + # $(as-instr,<instr>) # Return y if the assembler supports <instr>, n otherwise as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler -o /dev/null -)
Signature · 1 line
2.7.4
Re: [PATCH v7 15/17] kconfig: Add support for 'as-option'
Hi Amit,
Quoted 6 lines · Amit Daniel Kachhap
From: Vincenzo Frascino <[email protected]>
Currently kconfig does not have a feature that allows to detect if the used assembler supports a specific compilation option.
Quoted 7 lines
Introduce 'as-option' to serve this purpose in the context of
Kconfig:config X def_bool $(as-option,...)Cc Masahiro Yamada <[email protected]>
If you have a chance for v8,
could you please drop these Cc lines?
I had already given Ack, and am satisfied.
I have no more comment.
Thanks.
Quoted 27 lines
Acked-by Masahiro Yamada <[email protected]>Signed-off-by Vincenzo Frascino <[email protected]>Signed-off-by Amit Daniel Kachhap <[email protected]>--- scripts/Kconfig.include | 6 ++++++ 1 file changed, 6 insertions(+)scripts/Kconfig.include +6
-1@@ -31,6 +31,12 @@ cc-option = $(success,$(CC) -Werror $(CLANG_FLAGS) $(1) -S -x c /dev/null -o /de # Return y if the linker supports <flag>, n otherwise ld-option = $(success,$(LD) -v $(1)) +# $(as-option,<flag>) +# /dev/zero is used as output instead of /dev/null as some assembler cribs when +# both input and output are same. Also both of them have same write behaviour so +# can be easily substituted. +as-option = $(success, $(CC) $(CLANG_FLAGS) $(1) -c -x assembler /dev/null -o /dev/zero) + # $(as-instr,<instr>) # Return y if the assembler supports <instr>, n otherwise as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler -o /dev/null -) --2.7.4
Signature · 2 lines
Best Regards Masahiro Yamada
Re: [PATCH v7 15/17] kconfig: Add support for 'as-option'
Hi,
Quoted 15 lines · Masahiro Yamada
Hi Amit,
Quoted 11 lines · Amit Daniel Kachhap
From: Vincenzo Frascino <[email protected]>
Currently kconfig does not have a feature that allows to detect if the used assembler supports a specific compilation option.
Introduce 'as-option' to serve this purpose in the context of
Kconfig:config X def_bool $(as-option,...)
Quoted 6 lines
Quoted 2 lines
Cc Masahiro Yamada <[email protected]>If you have a chance for v8,
could you please drop these Cc lines?
Ok sure I will remember.
Cheers,
Amit
Quoted 37 lines
I had already given Ack, and am satisfied.
I have no more comment.Thanks.
Quoted 27 lines
Acked-by Masahiro Yamada <[email protected]>Signed-off-by Vincenzo Frascino <[email protected]>Signed-off-by Amit Daniel Kachhap <[email protected]>--- scripts/Kconfig.include | 6 ++++++ 1 file changed, 6 insertions(+)scripts/Kconfig.include +6
-1@@ -31,6 +31,12 @@ cc-option = $(success,$(CC) -Werror $(CLANG_FLAGS) $(1) -S -x c /dev/null -o /de # Return y if the linker supports <flag>, n otherwise ld-option = $(success,$(LD) -v $(1)) +# $(as-option,<flag>) +# /dev/zero is used as output instead of /dev/null as some assembler cribs when +# both input and output are same. Also both of them have same write behaviour so +# can be easily substituted. +as-option = $(success, $(CC) $(CLANG_FLAGS) $(1) -c -x assembler /dev/null -o /dev/zero) + # $(as-instr,<instr>) # Return y if the assembler supports <instr>, n otherwise as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler -o /dev/null -) --2.7.4
PATCH v7 16/17 arm64: compile the kernel with ptrauth return address signing
In reply to Amit Daniel KachhapFrom: Kristina Martsenko <[email protected]>
Compile all functions with two ptrauth instructions: PACIASP in the prologue to sign the return address, and AUTIASP in the epilogue to authenticate the return address (from the stack). If authentication fails, the return will cause an instruction abort to be taken, followed by an oops and killing the task.
This should help protect the kernel against attacks using return-oriented programming. As ptrauth protects the return address, it can also serve as a replacement for CONFIG_STACKPROTECTOR, although note that it does not protect other parts of the stack.
The new instructions are in the HINT encoding space, so on a system without ptrauth they execute as NOPs.
CONFIG_ARM64_PTR_AUTH now not only enables ptrauth for userspace and KVM guests, but also automatically builds the kernel with ptrauth instructions if the compiler supports it. If there is no compiler support, we do not warn that the kernel was built without ptrauth instructions.
GCC 7 and 8 support the -msign-return-address option, while GCC 9 deprecates that option and replaces it with -mbranch-protection. Support both options.
Clang uses an external assembler hence this patch makes sure that the correct parameters (-march=armv8.3-a) are passed down to help it recognize the ptrauth instructions.
Ftrace function tracer works properly with Ptrauth only when patchable-function-entry feature is present and is ensured by the Kconfig dependency.
---
Changes since v6:
* Added Kconfig dependency that if FUNCTION_GRAPH_TRACER is there then DYNAMIC_FTRACE_WITH_REGS should also be present as suggested by James.
arch/arm64/Kconfig | 24 +++++++++++++++++++++++- arch/arm64/Makefile | 11 +++++++++++ 2 files changed, 34 insertions(+), 1 deletion(-)
arch/arm64/Kconfig +23 -1
@@ -1499,6 +1499,8 @@ config ARM64_PTR_AUTH bool "Enable support for pointer authentication" default y depends on !KVM || ARM64_VHE + depends on (CC_HAS_SIGN_RETURN_ADDRESS || CC_HAS_BRANCH_PROT_PAC_RET) && AS_HAS_PAC + depends on (!FUNCTION_GRAPH_TRACER || DYNAMIC_FTRACE_WITH_REGS) help Pointer authentication (part of the ARMv8.3 Extensions) provides instructions for signing and authenticating pointers against secret
@@ -1506,11 +1508,17 @@ config ARM64_PTR_AUTH and other attacks. This option enables these instructions at EL0 (i.e. for userspace). - Choosing this option will cause the kernel to initialise secret keys for each process at exec() time, with these keys being context-switched along with the process. + If the compiler supports the -mbranch-protection or + -msign-return-address flag (e.g. GCC 7 or later), then this option + will also cause the kernel itself to be compiled with return address + protection. In this case, and if the target hardware is known to + support pointer authentication, then CONFIG_STACKPROTECTOR can be + disabled with minimal loss of protection. + The feature is detected at runtime. If the feature is not present in hardware it will not be advertised to userspace/KVM guest nor will it be enabled. However, KVM guest also require VHE mode and hence
@@ -1522,6 +1530,20 @@ config ARM64_PTR_AUTH but with the feature disabled. On such a system, this option should not be selected. + This feature works with FUNCTION_GRAPH_TRACER option only if + DYNAMIC_FTRACE_WITH_REGS is enabled. + +config CC_HAS_BRANCH_PROT_PAC_RET + # GCC 9 or later, clang 8 or later + def_bool $(cc-option,-mbranch-protection=pac-ret+leaf) + +config CC_HAS_SIGN_RETURN_ADDRESS + # GCC 7, 8 + def_bool $(cc-option,-msign-return-address=all) + +config AS_HAS_PAC + def_bool $(as-option,-Wa$(comma)-march=armv8.3-a) + endmenu menu "ARMv8.5 architectural features"
arch/arm64/Makefile +11 -0
@@ -65,6 +65,17 @@ stack_protector_prepare: prepare0 include/generated/asm-offsets.h)) endif +ifeq ($(CONFIG_ARM64_PTR_AUTH),y) +branch-prot-flags-$(CONFIG_CC_HAS_SIGN_RETURN_ADDRESS) := -msign-return-address=all +branch-prot-flags-$(CONFIG_CC_HAS_BRANCH_PROT_PAC_RET) := -mbranch-protection=pac-ret+leaf +# -march=armv8.3-a enables the non-nops instructions for PAC, to avoid the +# compiler to generate them and consequently to break the single image contract +# we pass it only to the assembler. This option is utilized only in case of non +# integrated assemblers. +branch-prot-flags-$(CONFIG_AS_HAS_PAC) += -Wa,-march=armv8.3-a +KBUILD_CFLAGS += $(branch-prot-flags-y) +endif + ifeq ($(CONFIG_CPU_BIG_ENDIAN), y) KBUILD_CPPFLAGS += -mbig-endian CHECKFLAGS += -D__AARCH64EB__
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH 1/1 arm64: Kconfig: verify binutils support for ARM64_PTR_AUTH
Clang relies on GNU as from binutils to assemble the Linux kernel, currently. A recent patch to enable the armv8.3-a extension for pointer authentication checked for compiler support of the relevant flags. Everything works with binutils 2.34+, but for older versions we observe assembler errors:
/tmp/vgettimeofday-36a54b.s: Assembler messages:/tmp/vgettimeofday-36a54b.s:40: Error: unknown pseudo-op: `.cfi_negate_ra_state'
When compiling with Clang, require the assembler to support .cfi_negate_ra_state directives, in order to support CONFIG_ARM64_PTR_AUTH.
---
Tested with binutils 2.33.1 and ToT. Boot tested in QEMU. I added this requirement only for Clang.
GCC maybe doesn't produce these assembler directives, or looks like GCC 8.2 produces .cfi_window_save (https://godbolt.org/z/awZWZ5, godbolt doesn't have a newer aarch64-linux-gnu-gcc...) instead of .cfi_negate_ra_state. Maybe ARM can sort out the inconsistency between compilers?
If we plan to add .cfi_negate_ra_state to out of
line assembly, we may want to make AS_HAS_CFI_NEGATE_RA_STATE a hard requirement, regardless of compiler.
Also, rather than CC_IS_GCC, we could do !CC_IS_CLANG || ...
arch/arm64/Kconfig | 4 ++++ 1 file changed, 4 insertions(+)
arch/arm64/Kconfig +4 -0
@@ -1506,6 +1506,7 @@ config ARM64_PTR_AUTH default y depends on !KVM || ARM64_VHE depends on (CC_HAS_SIGN_RETURN_ADDRESS || CC_HAS_BRANCH_PROT_PAC_RET) && AS_HAS_PAC + depends on CC_IS_GCC || (CC_IS_CLANG && AS_HAS_CFI_NEGATE_RA_STATE) depends on (!FUNCTION_GRAPH_TRACER || DYNAMIC_FTRACE_WITH_REGS) help Pointer authentication (part of the ARMv8.3 Extensions) provides
@@ -1550,6 +1551,9 @@ config CC_HAS_SIGN_RETURN_ADDRESS config AS_HAS_PAC def_bool $(as-option,-Wa$(comma)-march=armv8.3-a) +config AS_HAS_CFI_NEGATE_RA_STATE + def_bool $(as-instr,.cfi_startproc\n.cfi_negate_ra_state\n.cfi_endproc\n) + endmenu menu "ARMv8.4 architectural features"
Signature · 7 lines
2.25.1.696.g5e7596f4ac-goog _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH] arm64: Kconfig: verify binutils support for ARM64_PTR_AUTH
Quoted 59 lines · Nick Desaulniers' via Clang Built Linux
Clang relies on GNU as from binutils to assemble the Linux kernel, currently. A recent patch to enable the armv8.3-a extension for pointer authentication checked for compiler support of the relevant flags. Everything works with binutils 2.34+, but for older versions we observe assembler errors:
/tmp/vgettimeofday-36a54b.s: Assembler messages:/tmp/vgettimeofday-36a54b.s:40: Error: unknown pseudo-op: `.cfi_negate_ra_state'When compiling with Clang, require the assembler to support .cfi_negate_ra_state directives, in order to support
CONFIG_ARM64_PTR_AUTH.Signed-off-by Nick Desaulniers <[email protected]>---
Tested with binutils 2.33.1 and ToT. Boot tested in QEMU. I added this requirement only for Clang.GCC maybe doesn't produce these assembler directives, or looks like GCC 8.2 produces .cfi_window_save (https://godbolt.org/z/awZWZ5, godbolt doesn't have a newer aarch64-linux-gnu-gcc...) instead of .cfi_negate_ra_state. Maybe ARM can sort out the inconsistency between compilers?
If we plan to add .cfi_negate_ra_state to out of
line assembly, we may want to makeAS_HAS_CFI_NEGATE_RA_STATEa hard requirement, regardless of compiler.Also, rather than
CC_IS_GCC, we could do !CC_IS_CLANG || ...arch/arm64/Kconfig | 4 ++++ 1 file changed, 4 insertions(+)arch/arm64/Kconfig +4
-0@@ -1506,6 +1506,7 @@ config ARM64_PTR_AUTH default y depends on !KVM || ARM64_VHE depends on (CC_HAS_SIGN_RETURN_ADDRESS || CC_HAS_BRANCH_PROT_PAC_RET) && AS_HAS_PAC + depends on CC_IS_GCC || (CC_IS_CLANG && AS_HAS_CFI_NEGATE_RA_STATE) depends on (!FUNCTION_GRAPH_TRACER || DYNAMIC_FTRACE_WITH_REGS) help Pointer authentication (part of the ARMv8.3 Extensions) provides@@ -1550,6 +1551,9 @@ config CC_HAS_SIGN_RETURN_ADDRESS config AS_HAS_PAC def_bool $(as-option,-Wa$(comma)-march=armv8.3-a) +config AS_HAS_CFI_NEGATE_RA_STATE + def_bool $(as-instr,.cfi_startproc\n.cfi_negate_ra_state\n.cfi_endproc\n) + endmenu menu "ARMv8.4 architectural features"Signature · 1 line
2.25.1.696.g5e7596f4ac-goog
It would be nice to make this kind of check work for both GCC and Clang but like you noted, there appears to be inconsistencies between them so something for another day. CONFIG_ARM64_PTR_AUTH is getting a little gnarly in terms of dependencies but I suppose that makes sense given its nature. I verified that AS_HAS_CFI_NEGATE_RA_STATE gets set with ToT binutils and that it does not with an older version.
This unlocks our CI so hopefully it can get picked up quickly.
https://travis-ci.com/github/ClangBuiltLinux/continuous-integration/jobs/299816618
Cheers,
Nathan
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH] arm64: Kconfig: verify binutils support for ARM64_PTR_AUTH
In reply to Nick DesaulniersQuoted 6 lines · Nick Desaulniers
Clang relies on GNU as from binutils to assemble the Linux kernel, currently. A recent patch to enable the armv8.3-a extension for pointer authentication checked for compiler support of the relevant flags. Everything works with binutils 2.34+, but for older versions we observe assembler errors:
Quoted 8 lines
/tmp/vgettimeofday-36a54b.s: Assembler messages:/tmp/vgettimeofday-36a54b.s:40: Error: unknown pseudo-op: `.cfi_negate_ra_state'When compiling with Clang, require the assembler to support .cfi_negate_ra_state directives, in order to support
CONFIG_ARM64_PTR_AUTH.
Queued. Thanks.
Signature · 6 lines
Catalin _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v7 17/17 lkdtm: arm64: test kernel pointer authentication
In reply to Amit Daniel KachhapThis test is specific for arm64. When in-kernel Pointer Authentication config is enabled, the return address stored in the stack is signed. This feature helps in ROP kind of attack. If any parameters used to generate the pac (<key, sp, lr>) is modified then this will fail in the authentication stage and will lead to abort.
This test changes the input parameter APIA kernel keys to cause abort. The pac computed from the new key can be same as last due to hash collision so this is retried for few times as there is no reliable way to compare the pacs. Even though this test may fail even after retries but this may cause authentication failure at a later stage in earlier function returns.
This test can be invoked as,
echo CORRUPT_PAC > /sys/kernel/debug/provoke-crash/DIRECT
or as below if inserted as a module,
insmod lkdtm.ko cpoint_name=DIRECT cpoint_type=CORRUPT_PAC cpoint_count=1
[ 13.118166] lkdtm: Performing direct entry CORRUPT_PAC [ 13.118298] lkdtm: Clearing PAC from the return address [ 13.118466] Unable to handle kernel paging request at virtual address bfff8000108648ec [ 13.118626] Mem abort info: [ 13.118666] ESR = 0x86000004 [ 13.118866] EC = 0x21: IABT (current EL), IL = 32 bits [ 13.118966] SET = 0, FnV = 0 [ 13.119117] EA = 0, S1PTW = 0
--- drivers/misc/lkdtm/bugs.c | 36 ++++++++++++++++++++++++++++++++++++ drivers/misc/lkdtm/core.c | 1 + drivers/misc/lkdtm/lkdtm.h | 1 + 3 files changed, 38 insertions(+)
drivers/misc/lkdtm/bugs.c +36 -0
@@ -378,3 +378,39 @@ void lkdtm_DOUBLE_FAULT(void)pr_err ("XFAIL: this test is ia32-only\n" );#endif } + +#ifdef CONFIG_ARM64_PTR_AUTH +static noinline void change_pac_parameters(void) +{ +/* Reset the keys of current task */ +ptrauth_thread_init_kernel (current); +ptrauth_thread_switch_kernel (current); +} + +#define CORRUPT_PAC_ITERATE 10 +noinline void lkdtm_CORRUPT_PAC(void) +{ +int i; + +if (!system_supports_address_auth ()) { +pr_err ("FAIL: arm64 pointer authentication feature not present\n" ); +return ; + } + +pr_info ("Change the PAC parameters to force function return failure\n" ); +/* +* Pac is a hash value computed from input keys, return address and +* stack pointer. As pac has fewer bits so there is a chance of +* collision, so iterate few times to reduce the collision probability. +*/ +for (i =0 ; i <CORRUPT_PAC_ITERATE ; i++) +change_pac_parameters (); + +pr_err ("FAIL: %s test failed. Kernel may be unstable from here\n" , __func__); +} +#else /* !CONFIG_ARM64_PTR_AUTH */ +noinline void lkdtm_CORRUPT_PAC(void) +{ +pr_err ("FAIL: arm64 pointer authentication config disabled\n" ); +} +#endif
drivers/misc/lkdtm/core.c +1 -0
@@ -116,6 +116,7 @@ static const struct crashtype crashtypes[] = {CRASHTYPE (STACK_GUARD_PAGE_LEADING ),CRASHTYPE (STACK_GUARD_PAGE_TRAILING ),CRASHTYPE (UNSET_SMEP ), +CRASHTYPE (CORRUPT_PAC ),CRASHTYPE (UNALIGNED_LOAD_STORE_WRITE ),CRASHTYPE (OVERWRITE_ALLOCATION ), CRASHTYPE(WRITE_AFTER_FREE),
drivers/misc/lkdtm/lkdtm.h +1 -0
@@ -31,6 +31,7 @@ void lkdtm_UNSET_SMEP(void);#ifdef CONFIG_X86_32 void lkdtm_DOUBLE_FAULT (void );#endif +void lkdtm_CORRUPT_PAC (void );/* lkdtm_heap.c */ void __init lkdtm_heap_init (void );
Signature · 7 lines
2.7.4 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 19 lines · Amit Daniel Kachhap
Amit Daniel Kachhap (8):
arm64: cpufeature: Fix meta-capability cpufeature check
arm64: ptrauth: Add bootup/runtime flags for__cpu_setup
arm64: cpufeature: Move cpu capability helpers inside C file
arm64: initialize ptrauth keys for kernel booting task
arm64: mask PAC bits of__builtin_return_address
arm64:__show_regs: strip PAC from lr in printk
arm64: suspend: restore the kernel ptrauth keys
lkdtm: arm64: test kernel pointer authenticationKristina Martsenko (7):
arm64: cpufeature: add pointer auth meta-capabilities
arm64: rename ptrauth key structures to be user-specific
arm64: install user ptrauth keys at kernel exit time
arm64: cpufeature: handle conflicts based on capability
arm64: enable ptrauth earlier
arm64: initialize and switch ptrauth kernel keys
arm64: compile the kernel with ptrauth return address signing
Quoted 5 lines
Mark Rutland (1):
arm64: unwind: strip PAC from kernel addressesVincenzo Frascino (1):
kconfig: Add support for 'as-option'
Queued for 5.7. Thanks.
Signature · 6 lines
Catalin _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel