arm64: entry: migrate more code to C
Mark Rutland
reviewerv4 cover arm64: entry: migrate more code to C
This series (based on v5.13-rc2) migrates most of the remaining exception triage assembly to C. All the exception vectors are given C handlers, so that we can defer all decision making to C code, and the assembly code can be made simpler and more uniform. At the same time, I've tried to consolidate all the entry sequencing (e.g. reading exception registers and calling accounting code) in entry-common.c so that this is easier to maintain.
I was recently informed that noinstr wasn't protecting entry sequences from KCOV instrumentation, so I've refactored things so that we can avoid this by preventing KCOV instrumentation for the entirety of entry-common.c. I've done likewise for the low-level idle sequences which have the same problems with instrumentation when RCU isn't watching, etc.
I've stopped short of converting the ret_to_user / work_pending loop. Converting this cleanly will probably need something like the wrappers generated by SYSCALL_DEFINE() to handle the common entry/exit logic, and this is easier to build once all the handlers have been converted to C. Similar is true for portions of kernel_entry and kernel_exit that could be converted to C.
It should also be possible to generate the vectors and their associated assembly handlers in one go by placing these in separate sections and using .pushsection and .popsection. I've held off doing this for now as this probably requires some changes to the linker script, and regardless it should be easier to make that change atop this series.
So far this has seen some light boot testing, and a day's worth of fuzzing under Syzkaller, which I intend to leave to soak for a while.
I've pushed the series to my arm64/entry/rework branch on kernel.org:
https://git.kernel.org/pub/scm/linux/kernel/git/mark/linux.git/log/?h=arm64/entry/rework
git://git.kernel.org/pub/scm/linux/kernel/git/mark/linux.git arm64/entry/rework
I've tagged this version as arm64-entry-rework-20210525.
Since v1 [1]
* Rebase to v5.13-rc2
* Fold NMI entry/exit sequencing into entry-common.c
* Make NMI entry/exit helpers private to entry-comomn.c
* Prevent KCOV instrumentation of entry-common.c
* Prevent KCOV instrumentation of idle code
Since v2 [2]:
* Correct commit message description in patch 2
* Use el0t prefix for EL0 handlers for consistency with el1h and el1t
* Remove user_exit_irqoff macro
* Remove leftover bad_mode() prototype
* Add patch to replace el1_inv() with a direct call to __panic_unhandled()
* Accumulate Reviewed-by tags
* Typo fixes
Since v3 [3]:
* Fix preemption check logic to check thread_info::{count,need_resched}
* Clean up alignment of assembly handlers using SYM_CODE_START_LOCAL()
* Make ht a required asm macro argument in kernel_ventry and entry_handler
* Add comment for KCOV opt-out
* Typo and grammar fixes
* Accumulate tags
[1] https://lore.kernel.org/r/[email protected]
[2] https://lore.kernel.org/r/[email protected]
[3] https://lore.kernel.org/r/[email protected]
Thanks,
Mark.
Mark Rutland (20):
arm64: remove redundant local_daif_mask() in bad_mode()
arm64: entry: unmask IRQ+FIQ after EL0 handling
arm64: entry: convert SError handlers to C
arm64: entry: move arm64_preempt_schedule_irq to entry-common.c
arm64: entry: move NMI preempt logic to C
arm64: entry: add a call_on_irq_stack helper
arm64: entry: convert IRQ+FIQ handlers to C
arm64: entry: organise entry handlers consistently
arm64: entry: organise entry vectors consistently
arm64: entry: consolidate EL1 exception returns
arm64: entry: move bad_mode() to entry-common.c
arm64: entry: improve bad_mode()
arm64: entry: template the entry asm functions
arm64: entry: handle all vectors with C
arm64: entry: fold el1_inv() into el1h_64_sync_handler()
arm64: entry: split bad stack entry
arm64: entry: split SDEI entry
arm64: entry: make NMI entry/exit functions static
arm64: entry: don't instrument entry code with KCOV
arm64: idle: don't instrument idle code with KCOV
arch/arm64/include/asm/exception.h | 34 +++- arch/arm64/include/asm/processor.h | 2 - arch/arm64/include/asm/sdei.h | 3 + arch/arm64/kernel/Makefile | 8 +- arch/arm64/kernel/entry-common.c | 256 ++++++++++++++++++++++++-- arch/arm64/kernel/entry.S | 359 ++++++++++--------------------------- arch/arm64/kernel/idle.c | 69 +++++++ arch/arm64/kernel/process.c | 74 -------- arch/arm64/kernel/sdei.c | 48 +---- arch/arm64/kernel/traps.c | 40 +---- arch/arm64/mm/fault.c | 7 - 11 files changed, 440 insertions(+), 460 deletions(-) create mode 100644 arch/arm64/kernel/idle.c
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 1/20 arm64: remove redundant local_daif_mask() in bad_mode()
Upon taking an exception, the CPU sets all the DAIF bits. We never clear any of these bits prior to calling bad_mode(), and bad_mode() itself never clears any of these bits, so there's no need to call local_daif_mask().
This patch removes the redundant call.
--- arch/arm64/kernel/traps.c | 1 - 1 file changed, 1 deletion(-)
arch/arm64/kernel/traps.c +0 -1
@@ -765,7 +765,6 @@ asmlinkage void notrace bad_mode(struct pt_regs *regs, int reason, unsigned int esr_get_class_string(esr));__show_regs (regs); -local_daif_mask ();panic ("bad mode" ); }
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 2/20 arm64: entry: unmask IRQ+FIQ after EL0 handling
In reply to Mark RutlandFor non-fatal exceptions taken from EL0, we expect that at some point during exception handling it is possible to return to a regular process context with all exceptions unmasked (e.g. as we do in do_notify_resume()), and we generally aim to unmask exceptions wherever possible.
While handling SError and debug exceptions from EL0, we need to leave some exceptions masked during handling. Handling SError requires us to mask SError (which also requires masking IRQ+FIQ), and handing debug exceptions requires us to mask debug (which also requires masking SError+IRQ+FIQ).
Once do_serror() or do_debug_exception() has returned, we no longer need to mask exceptions, and can unmask them all, which is what we did prior to commit:
9034f6251572a474 ("arm64: Do not enable IRQs for ct_user_exit")
... where we had to mask IRQs as for context_tracking_user_exit() expected IRQs to be masked.
Since then, we realised that our context tracking wasn't entirely correct, and reworked the entry code to fix this. As of commit:
23529049c6842382 ("arm64: entry: fix non-NMI user<->kernel transitions")
... we replaced the call to context_tracking_user_exit() with a call to user_exit_irqoff() as part of enter_from_user_mode(), which occurs earlier, before we run the body of the handler and unmask exceptions in DAIF.
When we return to userspace, we go via ret_to_user(), which masks exceptions in DAIF prior to calling user_enter_irqoff() as part of exit_to_user_mode().
Thus, there's no longer a reason to leave IRQs or FIQs masked at the end of the EL0 debug or error handlers, as neither the user exit context tracking nor the user entry context tracking requires this. Let's bring these into line with other EL0 exception handlers and ensure that IRQ and FIQ are unmasked in DAIF at some point during the handler.
--- arch/arm64/kernel/entry-common.c | 2 +- arch/arm64/kernel/entry.S | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
arch/arm64/kernel/entry-common.c +1 -1
@@ -398,7 +398,7 @@ static void noinstr el0_dbg(struct pt_regs *regs, unsigned long esr)enter_from_user_mode ();do_debug_exception (far, esr, regs); -local_daif_restore (DAIF_PROCCTX_NOIRQ ); +local_daif_restore (DAIF_PROCCTX ); } static void noinstr el0_svc(struct pt_regs *regs)
arch/arm64/kernel/entry.S +1 -1
@@ -794,7 +794,7 @@ el0_error_naked: mov x0, sp mov x1, x25 bl do_serror - enable_da + enable_daif b ret_to_user SYM_CODE_END(el0_error)
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 3/20 arm64: entry: convert SError handlers to C
In reply to Mark RutlandFor various reasons we'd like to convert the bulk of arm64's exception triage logic to C. As a step towards that, this patch converts the EL1 and EL0 SError triage logic to C.
Separate C functions are added for the native and compat cases so that in subsequent patches we can handle native/compat differences in C.
There should be no functional change as a result of this patch.
--- arch/arm64/include/asm/exception.h | 4 ++++ arch/arm64/kernel/entry-common.c | 32 ++++++++++++++++++++++++++++++++ arch/arm64/kernel/entry.S | 16 +++++----------- arch/arm64/kernel/traps.c | 6 +----- 4 files changed, 42 insertions(+), 16 deletions(-)
arch/arm64/include/asm/exception.h +4 -0
@@ -32,8 +32,11 @@ static inline u32 disr_to_esr(u64 disr) } asmlinkage void el1_sync_handler(struct pt_regs *regs); +asmlinkage void el1_error_handler(struct pt_regs *regs); asmlinkage void el0_sync_handler(struct pt_regs *regs); +asmlinkage void el0_error_handler(struct pt_regs *regs); asmlinkage void el0_sync_compat_handler(struct pt_regs *regs); +asmlinkage void el0_error_compat_handler(struct pt_regs *regs); asmlinkage void noinstr enter_el1_irq_or_nmi(struct pt_regs *regs); asmlinkage void noinstr exit_el1_irq_or_nmi(struct pt_regs *regs);
@@ -57,4 +60,5 @@ void do_cp15instr(unsigned int esr, struct pt_regs *regs);void do_el0_svc (struct pt_regs *regs);void do_el0_svc_compat (struct pt_regs *regs);void do_ptrauth_fault (struct pt_regs *regs,unsigned int esr); +void do_serror (struct pt_regs *regs,unsigned int esr);#endif /* __ASM_EXCEPTION_H */
arch/arm64/kernel/entry-common.c +32 -0
@@ -279,6 +279,16 @@ asmlinkage void noinstr el1_sync_handler(struct pt_regs *regs) } } +asmlinkage void noinstr el1_error_handler(struct pt_regs *regs) +{ +unsigned long esr =read_sysreg (esr_el1); + +local_daif_restore (DAIF_ERRCTX ); +arm64_enter_nmi (regs); +do_serror (regs, esr); +arm64_exit_nmi (regs); +} + asmlinkage void noinstr enter_from_user_mode(void) {lockdep_hardirqs_off (CALLER_ADDR0 );
@@ -468,6 +478,23 @@ asmlinkage void noinstr el0_sync_handler(struct pt_regs *regs) } } +static void __el0_error_handler_common (struct pt_regs *regs) +{ +unsigned long esr =read_sysreg (esr_el1); + +enter_from_user_mode (); +local_daif_restore (DAIF_ERRCTX ); +arm64_enter_nmi (regs); +do_serror (regs, esr); +arm64_exit_nmi (regs); +local_daif_restore (DAIF_PROCCTX ); +} + +asmlinkage void noinstr el0_error_handler(struct pt_regs *regs) +{ +__el0_error_handler_common (regs); +} +#ifdef CONFIG_COMPAT static void noinstr el0_cp15(struct pt_regs *regs, unsigned long esr) {
@@ -526,4 +553,9 @@ asmlinkage void noinstr el0_sync_compat_handler(struct pt_regs *regs) el0_inv(regs, esr); } } + +asmlinkage void noinstr el0_error_compat_handler(struct pt_regs *regs) +{ +__el0_error_handler_common (regs); +}#endif /* CONFIG_COMPAT */
arch/arm64/kernel/entry.S +5 -11
@@ -757,7 +757,9 @@ SYM_CODE_END(el0_fiq_compat) SYM_CODE_START_LOCAL_NOALIGN(el0_error_compat) kernel_entry 0, 32 - b el0_error_naked + mov x0, sp + bl el0_error_compat_handler + b ret_to_user SYM_CODE_END(el0_error_compat) #endif
@@ -778,23 +780,15 @@ SYM_CODE_END(el0_fiq) SYM_CODE_START_LOCAL(el1_error) kernel_entry 1 - mrs x1, esr_el1 - enable_dbg mov x0, sp - bl do_serror + bl el1_error_handler kernel_exit 1 SYM_CODE_END(el1_error) SYM_CODE_START_LOCAL(el0_error) kernel_entry 0 -el0_error_naked: - mrs x25, esr_el1 - user_exit_irqoff - enable_dbg mov x0, sp - mov x1, x25 - bl do_serror - enable_daif + bl el0_error_handler b ret_to_user SYM_CODE_END(el0_error)
arch/arm64/kernel/traps.c +1 -5
@@ -869,15 +869,11 @@ bool arm64_is_fatal_ras_serror(struct pt_regs *regs, unsigned int esr) } } -asmlinkage void noinstr do_serror(struct pt_regs *regs, unsigned int esr) +void do_serror (struct pt_regs *regs,unsigned int esr) { -arm64_enter_nmi (regs); -/* non-RAS errors are not containable */ if (!arm64_is_ras_serror (esr) ||arm64_is_fatal_ras_serror (regs, esr))arm64_serror_panic (regs, esr); - -arm64_exit_nmi (regs); }/* GENERIC_BUG traps */
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 4/20 arm64: entry: move arm64_preempt_schedule_irq to entry-common.c
In reply to Mark RutlandSubsequent patches will pull more of the IRQ entry handling into C. To keep this in one place, let's move arm64_preempt_schedule_irq() into entry-common.c along with the other entry management functions.
We no longer need to include <linux/lockdep.h> in process.c, so the include directive is removed.
There should be no functional change as a result of this patch.
Reviewed-by Joey Gouly <[email protected]>
Cc: James Morse <[email protected]>
Cc: Will Deacon <[email protected]>
--- arch/arm64/kernel/entry-common.c | 20 ++++++++++++++++++++ arch/arm64/kernel/process.c | 17 ----------------- 2 files changed, 20 insertions(+), 17 deletions(-)
arch/arm64/kernel/entry-common.c +20 -0
@@ -6,7 +6,11 @@*/ #include <linux/context_tracking.h> +#include <linux/linkage.h> +#include <linux/lockdep.h> #include <linux/ptrace.h> +#include <linux/sched.h> +#include <linux/sched/debug.h> #include <linux/thread_info.h> #include <asm/cpufeature.h>
@@ -113,6 +117,22 @@ asmlinkage void noinstr exit_el1_irq_or_nmi(struct pt_regs *regs)exit_to_kernel_mode (regs); } +asmlinkage void __sched arm64_preempt_schedule_irq(void) +{ +lockdep_assert_irqs_disabled (); + +/* +* Preempting a task from an IRQ means we leave copies of PSTATE +* on the stack. cpufeature's enable calls may modify PSTATE, but +* resuming one of these preempted tasks would undo those changes. +* +* Only allow a task to be preempted once cpufeatures have been +* enabled. +*/ +if (system_capabilities_finalized ()) +preempt_schedule_irq (); +} +#ifdef CONFIG_ARM64_ERRATUM_1463225 static DEFINE_PER_CPU(int, __in_cortex_a76_erratum_1463225_wa);
arch/arm64/kernel/process.c +0 -17
@@ -18,7 +18,6 @@#include <linux/sched/task.h> #include <linux/sched/task_stack.h> #include <linux/kernel.h> -#include <linux/lockdep.h> #include <linux/mman.h> #include <linux/mm.h> #include <linux/nospec.h>
@@ -724,22 +723,6 @@ static int __init tagged_addr_init(void)core_initcall (tagged_addr_init);#endif /* CONFIG_ARM64_TAGGED_ADDR_ABI */ -asmlinkage void __sched arm64_preempt_schedule_irq(void) -{ -lockdep_assert_irqs_disabled (); - -/* -* Preempting a task from an IRQ means we leave copies of PSTATE -* on the stack. cpufeature's enable calls may modify PSTATE, but -* resuming one of these preempted tasks would undo those changes. -* -* Only allow a task to be preempted once cpufeatures have been -* enabled. -*/ -if (system_capabilities_finalized ()) -preempt_schedule_irq (); -} -#ifdef CONFIG_BINFMT_ELF int arch_elf_adjust_prot (int prot,const struct arch_elf_state *state,bool has_interp,bool is_interp)
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 5/20 arm64: entry: move NMI preempt logic to C
In reply to Mark RutlandCurrently portions of our preempt logic are written in C while other parts are written in assembly. Let's clean this up a little bit by moving the NMI preempt checks to C. For now, the preempt count (and need_resched) checking is left in assembly, and will be converted with the body of the IRQ handler in subsequent patches.
Other than the increased lockdep coverage there should be no functional change as a result of this patch.
--- arch/arm64/kernel/entry-common.c | 9 +++++++++ arch/arm64/kernel/entry.S | 12 +----------- 2 files changed, 10 insertions(+), 11 deletions(-)
arch/arm64/kernel/entry-common.c +9 -0
@@ -122,6 +122,15 @@ asmlinkage void __sched arm64_preempt_schedule_irq(void)lockdep_assert_irqs_disabled ();/* +* DAIF.DA are cleared at the start of IRQ/FIQ handling, and when GIC +* priority masking is used the GIC irqchip driver will clear DAIF.IF +* using gic_arch_enable_irqs() for normal IRQs. If anything is set in +* DAIF we must have handled an NMI, so skip preemption. +*/ +if (system_uses_irq_prio_masking () &&read_sysreg (daif)) +return ; + +/* * Preempting a task from an IRQ means we leave copies of PSTATE * on the stack. cpufeature's enable calls may modify PSTATE, but * resuming one of these preempted tasks would undo those changes.
arch/arm64/kernel/entry.S +1 -11
@@ -562,17 +562,7 @@ tsk .req x28 // current thread_info #ifdef CONFIG_PREEMPTION ldr x24, [tsk, #TSK_TI_PREEMPT] // get preempt count -alternative_if ARM64_HAS_IRQ_PRIO_MASKING - /* - * DA were cleared at start of handling, and IF are cleared by - * the GIC irqchip driver using gic_arch_enable_irqs() for - * normal IRQs. If anything is set, it means we come back from - * an NMI instead of a normal IRQ, so skip preemption - */ - mrs x0, daif - orr x24, x24, x0 -alternative_else_nop_endif - cbnz x24, 1f // preempt count != 0 || NMI return path + cbnz x24, 1f // preempt count != 0 bl arm64_preempt_schedule_irq // irq en/disable is done inside 1: #endif
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 6/20 arm64: entry: add a call_on_irq_stack helper
In reply to Mark RutlandWhen handling IRQ/FIQ exceptions the entry assembly may transition from a task's stack to a CPU's IRQ stack (and IRQ shadow call stack).
In subsequent patches we want to migrate the IRQ/FIQ triage logic to C, and as we want to perform some actions on the task stack (e.g. EL1 preemption), we need to switch stacks within the C handler. So that we can do so, this patch adds a helper to call a function on a CPU's IRQ stack (and shadow stack as appropriate).
Subsequent patches will make use of the new helper function.
--- arch/arm64/include/asm/exception.h | 2 ++ arch/arm64/kernel/entry.S | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+)
arch/arm64/include/asm/exception.h +2 -0
@@ -40,6 +40,8 @@ asmlinkage void el0_error_compat_handler(struct pt_regs *regs); asmlinkage void noinstr enter_el1_irq_or_nmi(struct pt_regs *regs); asmlinkage void noinstr exit_el1_irq_or_nmi(struct pt_regs *regs); +asmlinkage void call_on_irq_stack(struct pt_regs *regs, +void (*func)(struct pt_regs *)); asmlinkage void enter_from_user_mode(void); asmlinkage void exit_to_user_mode(void);void arm64_enter_nmi (struct pt_regs *regs);
arch/arm64/kernel/entry.S +36 -0
@@ -982,6 +982,42 @@ SYM_CODE_START(ret_from_fork) SYM_CODE_END(ret_from_fork) NOKPROBE(ret_from_fork) +/* + * void call_on_irq_stack(struct pt_regs *regs, + * void (*func)(struct pt_regs *)); + * + * Calls func(regs) using this CPU's irq stack and shadow irq stack. + */ +SYM_FUNC_START(call_on_irq_stack) +#ifdef CONFIG_SHADOW_CALL_STACK + stp scs_sp, xzr, [sp, #-16]! + ldr_this_cpu scs_sp, irq_shadow_call_stack_ptr, x17 +#endif + /* Create a frame record to save our LR and SP (implicit in FP) */ + stp x29, x30, [sp, #-16]! + mov x29, sp + + ldr_this_cpu x16, irq_stack_ptr, x17 + mov x15, #IRQ_STACK_SIZE + add x16, x16, x15 + + /* Move to the new stack and call the function there */ + mov sp, x16 + blr x1 + + /* + * Restore the SP from the FP, and restore the FP and LR from the frame + * record. + */ + mov sp, x29 + ldp x29, x30, [sp], #16 +#ifdef CONFIG_SHADOW_CALL_STACK + ldp scs_sp, xzr, [sp], #16 +#endif + ret +SYM_FUNC_END(call_on_irq_stack) +NOKPROBE(call_on_irq_stack) + #ifdef CONFIG_ARM_SDE_INTERFACE #include <asm/sdei.h>
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 7/20 arm64: entry: convert IRQ+FIQ handlers to C
In reply to Mark RutlandFor various reasons we'd like to convert the bulk of arm64's exception triage logic to C. As a step towards that, this patch converts the EL1 and EL0 IRQ+FIQ triage logic to C.
Separate C functions are added for the native and compat cases so that in subsequent patches we can handle native/compat differences in C.
Since the triage functions can now call arm64_apply_bp_hardening() directly, the do_el0_irq_bp_hardening() wrapper function is removed.
Since the user_exit_irqoff macro is now unused, it is removed. The user_enter_irqoff macro is still used by the ret_to_user code, and cannot be removed at this time.
--- arch/arm64/include/asm/exception.h | 8 ++- arch/arm64/include/asm/processor.h | 2 - arch/arm64/kernel/entry-common.c | 93 ++++++++++++++++++++++++++++++-- arch/arm64/kernel/entry.S | 108 +++++-------------------------------- arch/arm64/mm/fault.c | 7 --- 5 files changed, 110 insertions(+), 108 deletions(-)
arch/arm64/include/asm/exception.h +6 -2
@@ -32,14 +32,18 @@ static inline u32 disr_to_esr(u64 disr) } asmlinkage void el1_sync_handler(struct pt_regs *regs); +asmlinkage void el1_irq_handler(struct pt_regs *regs); +asmlinkage void el1_fiq_handler(struct pt_regs *regs); asmlinkage void el1_error_handler(struct pt_regs *regs); asmlinkage void el0_sync_handler(struct pt_regs *regs); +asmlinkage void el0_irq_handler(struct pt_regs *regs); +asmlinkage void el0_fiq_handler(struct pt_regs *regs); asmlinkage void el0_error_handler(struct pt_regs *regs); asmlinkage void el0_sync_compat_handler(struct pt_regs *regs); +asmlinkage void el0_irq_compat_handler(struct pt_regs *regs); +asmlinkage void el0_fiq_compat_handler(struct pt_regs *regs); asmlinkage void el0_error_compat_handler(struct pt_regs *regs); -asmlinkage void noinstr enter_el1_irq_or_nmi(struct pt_regs *regs); -asmlinkage void noinstr exit_el1_irq_or_nmi(struct pt_regs *regs); asmlinkage void call_on_irq_stack(struct pt_regs *regs,void (*func)(struct pt_regs *)); asmlinkage void enter_from_user_mode(void);
arch/arm64/include/asm/processor.h +0 -2
@@ -257,8 +257,6 @@ void set_task_sctlr_el1(u64 sctlr);extern struct task_struct *cpu_switch_to (struct task_struct *prev,struct task_struct *next); -asmlinkage void arm64_preempt_schedule_irq(void); -#define task_pt_regs (p) \ ((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)
arch/arm64/kernel/entry-common.c +90 -3
141 lines not on this page · raw message
arch/arm64/kernel/entry.S +14 -94
164 lines not on this page · raw message
arch/arm64/mm/fault.c +0 -7
@@ -836,13 +836,6 @@ void do_mem_abort(unsigned long far, unsigned int esr, struct pt_regs *regs) }NOKPROBE_SYMBOL (do_mem_abort); -void do_el0_irq_bp_hardening (void ) -{ -/* PC has already been checked in entry.S */ -arm64_apply_bp_hardening (); -} -NOKPROBE_SYMBOL (do_el0_irq_bp_hardening); -void do_sp_pc_abort (unsigned long addr,unsigned int esr,struct pt_regs *regs) { arm64_notify_die("SP/PC alignment exception", regs, SIGBUS, BUS_ADRALN,
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 8/20 arm64: entry: organise entry handlers consistently
In reply to Mark RutlandIn entry.S we have two comments which distinguish EL0 and EL1 exception handlers, but the code isn't actually laid out to match, and there are a few other inconsistencies that would be good to clear up.
This patch organizes the entry handers consistently:
* The handlers are laid out in order of the vectors, to make them easier to navigate.
* The inconsistently-applied alignment is removed
* The handlers are consistently marked with SYM_CODE_START_LOCAL() rather than SYM_CODE_START_LOCAL_NOALIGN(), giving them the same default alignment as other assembly code snippets.
There should be no functional change as a result of this patch.
--- arch/arm64/kernel/entry.S | 78 ++++++++++++++++++++++------------------------- 1 file changed, 36 insertions(+), 42 deletions(-)
arch/arm64/kernel/entry.S +36 -42
@@ -607,65 +607,88 @@ SYM_CODE_END(el1_error_invalid) /* * EL1 mode handlers. */ - .align 6 -SYM_CODE_START_LOCAL_NOALIGN(el1_sync) +SYM_CODE_START_LOCAL(el1_sync) kernel_entry 1 mov x0, sp bl el1_sync_handler kernel_exit 1 SYM_CODE_END(el1_sync) - .align 6 -SYM_CODE_START_LOCAL_NOALIGN(el1_irq) +SYM_CODE_START_LOCAL(el1_irq) kernel_entry 1 mov x0, sp bl el1_irq_handler kernel_exit 1 SYM_CODE_END(el1_irq) -SYM_CODE_START_LOCAL_NOALIGN(el1_fiq) +SYM_CODE_START_LOCAL(el1_fiq) kernel_entry 1 mov x0, sp bl el1_fiq_handler kernel_exit 1 SYM_CODE_END(el1_fiq) +SYM_CODE_START_LOCAL(el1_error) + kernel_entry 1 + mov x0, sp + bl el1_error_handler + kernel_exit 1 +SYM_CODE_END(el1_error) + /* * EL0 mode handlers. */ - .align 6 -SYM_CODE_START_LOCAL_NOALIGN(el0_sync) +SYM_CODE_START_LOCAL(el0_sync) kernel_entry 0 mov x0, sp bl el0_sync_handler b ret_to_user SYM_CODE_END(el0_sync) +SYM_CODE_START_LOCAL(el0_irq) + kernel_entry 0 + mov x0, sp + bl el0_irq_handler + b ret_to_user +SYM_CODE_END(el0_irq) + +SYM_CODE_START_LOCAL(el0_fiq) + kernel_entry 0 + mov x0, sp + bl el0_fiq_handler + b ret_to_user +SYM_CODE_END(el0_fiq) + +SYM_CODE_START_LOCAL(el0_error) + kernel_entry 0 + mov x0, sp + bl el0_error_handler + b ret_to_user +SYM_CODE_END(el0_error) + #ifdef CONFIG_COMPAT - .align 6 -SYM_CODE_START_LOCAL_NOALIGN(el0_sync_compat) +SYM_CODE_START_LOCAL(el0_sync_compat) kernel_entry 0, 32 mov x0, sp bl el0_sync_compat_handler b ret_to_user SYM_CODE_END(el0_sync_compat) - .align 6 -SYM_CODE_START_LOCAL_NOALIGN(el0_irq_compat) +SYM_CODE_START_LOCAL(el0_irq_compat) kernel_entry 0, 32 mov x0, sp bl el0_irq_compat_handler b ret_to_user SYM_CODE_END(el0_irq_compat) -SYM_CODE_START_LOCAL_NOALIGN(el0_fiq_compat) +SYM_CODE_START_LOCAL(el0_fiq_compat) kernel_entry 0, 32 mov x0, sp bl el0_fiq_compat_handler b ret_to_user SYM_CODE_END(el0_fiq_compat) -SYM_CODE_START_LOCAL_NOALIGN(el0_error_compat) +SYM_CODE_START_LOCAL(el0_error_compat) kernel_entry 0, 32 mov x0, sp bl el0_error_compat_handler
@@ -673,35 +696,6 @@ SYM_CODE_START_LOCAL_NOALIGN(el0_error_compat) SYM_CODE_END(el0_error_compat) #endif - .align 6 -SYM_CODE_START_LOCAL_NOALIGN(el0_irq) - kernel_entry 0 - mov x0, sp - bl el0_irq_handler - b ret_to_user -SYM_CODE_END(el0_irq) - -SYM_CODE_START_LOCAL_NOALIGN(el0_fiq) - kernel_entry 0 - mov x0, sp - bl el0_fiq_handler - b ret_to_user -SYM_CODE_END(el0_fiq) - -SYM_CODE_START_LOCAL(el1_error) - kernel_entry 1 - mov x0, sp - bl el1_error_handler - kernel_exit 1 -SYM_CODE_END(el1_error) - -SYM_CODE_START_LOCAL(el0_error) - kernel_entry 0 - mov x0, sp - bl el0_error_handler - b ret_to_user -SYM_CODE_END(el0_error) - /* * "slow" syscall return path. */
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 9/20 arm64: entry: organise entry vectors consistently
In reply to Mark RutlandIn subsequent patches we'll rename the entry handlers based on their original EL, register width, and exception class. To do so, we need to make all 3 mandatory arguments to the kernel_ventry macro, and distinguish EL1h from EL1t.
In preparation for this, let's make the current set of arguments mandatory, and move the regsize column before the branch label suffix, making the vectors easier to read column-wise.
There should be no functional change as a result of this patch.
--- arch/arm64/kernel/entry.S | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-)
arch/arm64/kernel/entry.S +21 -21
@@ -54,7 +54,7 @@ #define BAD_FIQ 2 #define BAD_ERROR 3 - .macro kernel_ventry, el, label, regsize = 64 + .macro kernel_ventry, el:req, regsize:req, label:req .align 7 #ifdef CONFIG_UNMAP_KERNEL_AT_EL0 .if \el == 0
@@ -504,31 +504,31 @@ tsk .req x28 // current thread_info .align 11 SYM_CODE_START(vectors) - kernel_ventry 1, sync_invalid // Synchronous EL1t - kernel_ventry 1, irq_invalid // IRQ EL1t - kernel_ventry 1, fiq_invalid // FIQ EL1t - kernel_ventry 1, error_invalid // Error EL1t + kernel_ventry 1, 64, sync_invalid // Synchronous EL1t + kernel_ventry 1, 64, irq_invalid // IRQ EL1t + kernel_ventry 1, 64, fiq_invalid // FIQ EL1t + kernel_ventry 1, 64, error_invalid // Error EL1t - kernel_ventry 1, sync // Synchronous EL1h - kernel_ventry 1, irq // IRQ EL1h - kernel_ventry 1, fiq // FIQ EL1h - kernel_ventry 1, error // Error EL1h + kernel_ventry 1, 64, sync // Synchronous EL1h + kernel_ventry 1, 64, irq // IRQ EL1h + kernel_ventry 1, 64, fiq // FIQ EL1h + kernel_ventry 1, 64, error // Error EL1h - kernel_ventry 0, sync // Synchronous 64-bit EL0 - kernel_ventry 0, irq // IRQ 64-bit EL0 - kernel_ventry 0, fiq // FIQ 64-bit EL0 - kernel_ventry 0, error // Error 64-bit EL0 + kernel_ventry 0, 64, sync // Synchronous 64-bit EL0 + kernel_ventry 0, 64, irq // IRQ 64-bit EL0 + kernel_ventry 0, 64, fiq // FIQ 64-bit EL0 + kernel_ventry 0, 64, error // Error 64-bit EL0 #ifdef CONFIG_COMPAT - kernel_ventry 0, sync_compat, 32 // Synchronous 32-bit EL0 - kernel_ventry 0, irq_compat, 32 // IRQ 32-bit EL0 - kernel_ventry 0, fiq_compat, 32 // FIQ 32-bit EL0 - kernel_ventry 0, error_compat, 32 // Error 32-bit EL0 + kernel_ventry 0, 32, sync_compat // Synchronous 32-bit EL0 + kernel_ventry 0, 32, irq_compat // IRQ 32-bit EL0 + kernel_ventry 0, 32, fiq_compat // FIQ 32-bit EL0 + kernel_ventry 0, 32, error_compat // Error 32-bit EL0 #else - kernel_ventry 0, sync_invalid, 32 // Synchronous 32-bit EL0 - kernel_ventry 0, irq_invalid, 32 // IRQ 32-bit EL0 - kernel_ventry 0, fiq_invalid, 32 // FIQ 32-bit EL0 - kernel_ventry 0, error_invalid, 32 // Error 32-bit EL0 + kernel_ventry 0, 32, sync_invalid // Synchronous 32-bit EL0 + kernel_ventry 0, 32, irq_invalid // IRQ 32-bit EL0 + kernel_ventry 0, 32, fiq_invalid // FIQ 32-bit EL0 + kernel_ventry 0, 32, error_invalid // Error 32-bit EL0 #endif SYM_CODE_END(vectors)
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 10/20 arm64: entry: consolidate EL1 exception returns
In reply to Mark RutlandFollowing the example of ret_to_user, let's consolidate all the EL1 return paths with a ret_to_kernel helper, rather than each entry point having its own copy of the return code.
There should be no functional change as a result of this patch.
--- arch/arm64/kernel/entry.S | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
arch/arm64/kernel/entry.S +8 -4
@@ -611,30 +611,34 @@ SYM_CODE_START_LOCAL(el1_sync) kernel_entry 1 mov x0, sp bl el1_sync_handler - kernel_exit 1 + b ret_to_kernel SYM_CODE_END(el1_sync) SYM_CODE_START_LOCAL(el1_irq) kernel_entry 1 mov x0, sp bl el1_irq_handler - kernel_exit 1 + b ret_to_kernel SYM_CODE_END(el1_irq) SYM_CODE_START_LOCAL(el1_fiq) kernel_entry 1 mov x0, sp bl el1_fiq_handler - kernel_exit 1 + b ret_to_kernel SYM_CODE_END(el1_fiq) SYM_CODE_START_LOCAL(el1_error) kernel_entry 1 mov x0, sp bl el1_error_handler - kernel_exit 1 + b ret_to_kernel SYM_CODE_END(el1_error) +SYM_CODE_START_LOCAL(ret_to_kernel) + kernel_exit 1 +SYM_CODE_END(ret_to_kernel) + /* * EL0 mode handlers. */
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 11/20 arm64: entry: move bad_mode() to entry-common.c
In reply to Mark RutlandIn subsequent patches we'll rework the way bad_mode() is called by exception entry code. In preparation for this, let's move bad_mode() itself into entry-common.c.
Let's also mark it as noinstr (e.g. to prevent it being kprobed), and let's also make the handler array a local variable, as this is only use by bad_mode(), and will be removed entirely in a subsequent patch.
There should be no functional change as a result of this patch.
--- arch/arm64/kernel/entry-common.c | 27 +++++++++++++++++++++++++++ arch/arm64/kernel/traps.c | 25 ------------------------- 2 files changed, 27 insertions(+), 25 deletions(-)
arch/arm64/kernel/entry-common.c +27 -0
@@ -22,6 +22,7 @@#include <asm/processor.h> #include <asm/stacktrace.h> #include <asm/sysreg.h> +#include <asm/system_misc.h> /* * This is intended to match the logic in irqentry_enter(), handling the kernel
@@ -156,6 +157,32 @@ static void do_interrupt_handler(struct pt_regs *regs,extern void (*handle_arch_irq)(struct pt_regs *);extern void (*handle_arch_fiq)(struct pt_regs *); +/* +* bad_mode handles the impossible case in the exception vector. This is always +* fatal. +*/ +asmlinkage void noinstr bad_mode(struct pt_regs *regs, int reason, unsigned int esr) +{ +const char *handler[] = { +"Synchronous Abort" , +"IRQ" , +"FIQ" , +"Error" + }; + +arm64_enter_nmi (regs); + +console_verbose (); + +pr_crit ("Bad mode in %s handler detected on CPU%d, code 0x%08x -- %s\n" , + handler[reason],smp_processor_id (), esr, +esr_get_class_string (esr)); + +__show_regs (regs); +panic ("bad mode" ); +} + +#ifdef CONFIG_ARM64_ERRATUM_1463225 static DEFINE_PER_CPU(int, __in_cortex_a76_erratum_1463225_wa);
arch/arm64/kernel/traps.c +0 -25
@@ -45,13 +45,6 @@#include <asm/system_misc.h> #include <asm/sysreg.h> -static const char *handler[] = { -"Synchronous Abort" , -"IRQ" , -"FIQ" , -"Error" -}; -int show_unhandled_signals =0 ;static void dump_kernel_instr (const char *lvl,struct pt_regs *regs)
@@ -751,24 +744,6 @@ const char *esr_get_class_string(u32 esr) }/* -* bad_mode handles the impossible case in the exception vector. This is always -* fatal. -*/ -asmlinkage void notrace bad_mode(struct pt_regs *regs, int reason, unsigned int esr) -{ -arm64_enter_nmi (regs); - -console_verbose (); - -pr_crit ("Bad mode in %s handler detected on CPU%d, code 0x%08x -- %s\n" , - handler[reason],smp_processor_id (), esr, -esr_get_class_string (esr)); - -__show_regs (regs); -panic ("bad mode" ); -} - -/* * bad_el0_sync handles unexpected, but potentially recoverable synchronous * exceptions taken from EL0. Unlike bad_mode, this returns. */
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 12/20 arm64: entry: improve bad_mode()
In reply to Mark RutlandOur use of bad_mode() has a few rough edges:
* AArch64 doesn't use the term "mode", and refers to "Execution states", "Exception levels", and "Selected stack pointer".
* We log the exception type (SYNC/IRQ/FIQ/SError), but not the actual "mode" (though this can be decoded from the SPSR value).
* We use bad_mode() as a second-level handler for unexpected synchronous exceptions, where the "mode" is legitimate, but the specific exception is not.
* We dump the ESR value, but call this "code", and so it's not clear to all readers that this is the ESR.
... and all of this can be somewhat opaque to those who aren't extremely familiar with the code.
Let's make this a bit clearer by having bad_mode() log "Unhandled ${TYPE} exception" rather than "Bad mode in ${TYPE} handler", using "ESR" rather than "code", and having the final panic() log "Unhandled exception" rather than "Bad mode".
In future we'd like to log the specific architectural vector rather than just the type of exception, so we also split the core of bad_mode() out into a helper called __panic_unhandled(), which takes the vector as a string argument.
--- arch/arm64/kernel/entry-common.c | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-)
arch/arm64/kernel/entry-common.c +16 -15
@@ -157,31 +157,32 @@ static void do_interrupt_handler(struct pt_regs *regs,extern void (*handle_arch_irq)(struct pt_regs *);extern void (*handle_arch_fiq)(struct pt_regs *); -/* -* bad_mode handles the impossible case in the exception vector. This is always -* fatal. -*/ -asmlinkage void noinstr bad_mode(struct pt_regs *regs, int reason, unsigned int esr) +static void noinstr __panic_unhandled(struct pt_regs *regs, const char *vector, +unsigned int esr) { -const char *handler[] = { -"Synchronous Abort" , -"IRQ" , -"FIQ" , -"Error" - }; -arm64_enter_nmi (regs);console_verbose (); -pr_crit ("Bad mode in %s handler detected on CPU%d, code 0x%08x -- %s\n" , - handler[reason],smp_processor_id (), esr, +pr_crit ("Unhandled %s exception on CPU%d, ESR 0x%08x -- %s\n" , + vector,smp_processor_id (), esr,esr_get_class_string (esr));__show_regs (regs); -panic ("bad mode" ); +panic ("Unhandled exception" ); } +asmlinkage void noinstr bad_mode(struct pt_regs *regs, int reason, unsigned int esr) +{ +const char *handler[] = { +"Synchronous Abort" , +"IRQ" , +"FIQ" , +"Error" + }; + +__panic_unhandled (regs, handler[reason], esr); +}#ifdef CONFIG_ARM64_ERRATUM_1463225 static DEFINE_PER_CPU(int, __in_cortex_a76_erratum_1463225_wa);
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 13/20 arm64: entry: template the entry asm functions
In reply to Mark RutlandNow that the majority of the exception triage logic has been converted to C, the entry assembly functions all have a uniform structure.
Let's generate them all with an assembly macro to reduce the amount of code and to ensure they all remain in sync if we make changes in future.
There should be no functional change as a result of this patch.
--- arch/arm64/kernel/entry.S | 113 +++++++++++----------------------------------- 1 file changed, 27 insertions(+), 86 deletions(-)
arch/arm64/kernel/entry.S +27 -86
@@ -604,102 +604,43 @@ SYM_CODE_START_LOCAL(el1_error_invalid) inv_entry 1, BAD_ERROR SYM_CODE_END(el1_error_invalid) -/* - * EL1 mode handlers. - */ -SYM_CODE_START_LOCAL(el1_sync) - kernel_entry 1 - mov x0, sp - bl el1_sync_handler - b ret_to_kernel -SYM_CODE_END(el1_sync) - -SYM_CODE_START_LOCAL(el1_irq) - kernel_entry 1 - mov x0, sp - bl el1_irq_handler - b ret_to_kernel -SYM_CODE_END(el1_irq) - -SYM_CODE_START_LOCAL(el1_fiq) - kernel_entry 1 - mov x0, sp - bl el1_fiq_handler - b ret_to_kernel -SYM_CODE_END(el1_fiq) - -SYM_CODE_START_LOCAL(el1_error) - kernel_entry 1 + .macro entry_handler el:req, regsize:req, label:req +SYM_CODE_START_LOCAL(el\el\()_\label) + kernel_entry \el, \regsize mov x0, sp - bl el1_error_handler + bl el\el\()_\label\()_handler + .if \el == 0 + b ret_to_user + .else b ret_to_kernel -SYM_CODE_END(el1_error) - -SYM_CODE_START_LOCAL(ret_to_kernel) - kernel_exit 1 -SYM_CODE_END(ret_to_kernel) + .endif +SYM_CODE_END(el\el\()_\label) + .endm /* - * EL0 mode handlers. + * Early exception handlers */ -SYM_CODE_START_LOCAL(el0_sync) - kernel_entry 0 - mov x0, sp - bl el0_sync_handler - b ret_to_user -SYM_CODE_END(el0_sync) + entry_handler 1, 64, sync + entry_handler 1, 64, irq + entry_handler 1, 64, fiq + entry_handler 1, 64, error -SYM_CODE_START_LOCAL(el0_irq) - kernel_entry 0 - mov x0, sp - bl el0_irq_handler - b ret_to_user -SYM_CODE_END(el0_irq) - -SYM_CODE_START_LOCAL(el0_fiq) - kernel_entry 0 - mov x0, sp - bl el0_fiq_handler - b ret_to_user -SYM_CODE_END(el0_fiq) - -SYM_CODE_START_LOCAL(el0_error) - kernel_entry 0 - mov x0, sp - bl el0_error_handler - b ret_to_user -SYM_CODE_END(el0_error) + entry_handler 0, 64, sync + entry_handler 0, 64, irq + entry_handler 0, 64, fiq + entry_handler 0, 64, error #ifdef CONFIG_COMPAT -SYM_CODE_START_LOCAL(el0_sync_compat) - kernel_entry 0, 32 - mov x0, sp - bl el0_sync_compat_handler - b ret_to_user -SYM_CODE_END(el0_sync_compat) - -SYM_CODE_START_LOCAL(el0_irq_compat) - kernel_entry 0, 32 - mov x0, sp - bl el0_irq_compat_handler - b ret_to_user -SYM_CODE_END(el0_irq_compat) - -SYM_CODE_START_LOCAL(el0_fiq_compat) - kernel_entry 0, 32 - mov x0, sp - bl el0_fiq_compat_handler - b ret_to_user -SYM_CODE_END(el0_fiq_compat) - -SYM_CODE_START_LOCAL(el0_error_compat) - kernel_entry 0, 32 - mov x0, sp - bl el0_error_compat_handler - b ret_to_user -SYM_CODE_END(el0_error_compat) + entry_handler 0, 32, sync_compat + entry_handler 0, 32, irq_compat + entry_handler 0, 32, fiq_compat + entry_handler 0, 32, error_compat #endif +SYM_CODE_START_LOCAL(ret_to_kernel) + kernel_exit 1 +SYM_CODE_END(ret_to_kernel) + /* * "slow" syscall return path. */
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 14/20 arm64: entry: handle all vectors with C
In reply to Mark RutlandWe have 16 architectural exception vectors, and depending on kernel configuration we handle 8 or 12 of these with C code, with the remaining 8 or 4 of these handled as special cases in the entry assembly.
It would be nicer if the entry assembly were uniform for all exceptions, and we deferred any specific handling of the exceptions to C code. This way the entry assembly can be more easily templated without ifdeffery or special cases, and it's easier to modify the handling of these cases in future (e.g. to dump additional registers other context).
This patch reworks the entry code so that we always have a C handler for every architectural exception vector, with the entry assembly being completely uniform. We now have to handle exceptions from EL1t and EL1h, and also have to handle exceptions from AArch32 even when the kernel is built without CONFIG_COMPAT. To make this clear and to simplify templating, we rename the top-level exception handlers with a consistent naming scheme:
asm: <el+sp>_<regsize>_<type>
c: <el+sp>_<regsize>_<type>_handler
.. where:
<el+sp> is el1t, el1h, or el0t
<regsize> is 64 or 32
<type> is sync, irq, fiq, or error
... e.g.
asm: el1h_64_sync
c: el1h_64_sync_handler
... with lower-level handlers simply using "el1" and "compat" as today.
For unexpected exceptions, this information is passed to __panic_unhandled(), so it can report the specific vector an unexpected exception was taken from, e.g.
| Unhandled 64-bit el1t sync exception
For vectors we never expect to enter legitimately, the C code is generated using a macro to avoid code duplication. The exceptions are handled via __panic_unhandled(), replacing bad_mode() (which is removed).
The kernel_ventry and entry_handler assembly macros are updated to handle the new naming scheme. In theory it should be possible to generate the entry functions at the same time as the vectors using a single table, but this will require reworking the linker script to split the two into separate sections, so for now we have separate tables.
--- arch/arm64/include/asm/exception.h | 32 ++++---- arch/arm64/kernel/entry-common.c | 51 +++++++------ arch/arm64/kernel/entry.S | 146 ++++++++++++------------------------- arch/arm64/kernel/traps.c | 2 +- 4 files changed, 93 insertions(+), 138 deletions(-)
arch/arm64/include/asm/exception.h +19 -13
@@ -31,18 +31,25 @@ static inline u32 disr_to_esr(u64 disr)return esr; } -asmlinkage void el1_sync_handler(struct pt_regs *regs); -asmlinkage void el1_irq_handler(struct pt_regs *regs); -asmlinkage void el1_fiq_handler(struct pt_regs *regs); -asmlinkage void el1_error_handler(struct pt_regs *regs); -asmlinkage void el0_sync_handler(struct pt_regs *regs); -asmlinkage void el0_irq_handler(struct pt_regs *regs); -asmlinkage void el0_fiq_handler(struct pt_regs *regs); -asmlinkage void el0_error_handler(struct pt_regs *regs); -asmlinkage void el0_sync_compat_handler(struct pt_regs *regs); -asmlinkage void el0_irq_compat_handler(struct pt_regs *regs); -asmlinkage void el0_fiq_compat_handler(struct pt_regs *regs); -asmlinkage void el0_error_compat_handler(struct pt_regs *regs); +asmlinkage void el1t_64_sync_handler(struct pt_regs *regs); +asmlinkage void el1t_64_irq_handler(struct pt_regs *regs); +asmlinkage void el1t_64_fiq_handler(struct pt_regs *regs); +asmlinkage void el1t_64_error_handler(struct pt_regs *regs); + +asmlinkage void el1h_64_sync_handler(struct pt_regs *regs); +asmlinkage void el1h_64_irq_handler(struct pt_regs *regs); +asmlinkage void el1h_64_fiq_handler(struct pt_regs *regs); +asmlinkage void el1h_64_error_handler(struct pt_regs *regs); + +asmlinkage void el0t_64_sync_handler(struct pt_regs *regs); +asmlinkage void el0t_64_irq_handler(struct pt_regs *regs); +asmlinkage void el0t_64_fiq_handler(struct pt_regs *regs); +asmlinkage void el0t_64_error_handler(struct pt_regs *regs); + +asmlinkage void el0t_32_sync_handler(struct pt_regs *regs); +asmlinkage void el0t_32_irq_handler(struct pt_regs *regs); +asmlinkage void el0t_32_fiq_handler(struct pt_regs *regs); +asmlinkage void el0t_32_error_handler(struct pt_regs *regs); asmlinkage void call_on_irq_stack(struct pt_regs *regs,void (*func)(struct pt_regs *));
@@ -53,7 +60,6 @@ void arm64_exit_nmi(struct pt_regs *regs);void do_mem_abort (unsigned long far,unsigned int esr,struct pt_regs *regs);void do_undefinstr (struct pt_regs *regs);void do_bti (struct pt_regs *regs); -asmlinkage void bad_mode(struct pt_regs *regs, int reason, unsigned int esr);void do_debug_exception (unsigned long addr_if_watchpoint,unsigned int esr,struct pt_regs *regs);void do_fpsimd_acc (unsigned int esr,struct pt_regs *regs);
arch/arm64/kernel/entry-common.c +28 -23
134 lines not on this page · raw message
arch/arm64/kernel/entry.S +45 -101
189 lines not on this page · raw message
arch/arm64/kernel/traps.c +1 -1
@@ -745,7 +745,7 @@ const char *esr_get_class_string(u32 esr)/* * bad_el0_sync handles unexpected, but potentially recoverable synchronous -* exceptions taken from EL0. Unlike bad_mode, this returns. +* exceptions taken from EL0. */ void bad_el0_sync (struct pt_regs *regs,int reason,unsigned int esr) {
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 15/20 arm64: entry: fold el1_inv() into el1h_64_sync_handler()
In reply to Mark RutlandAn unexpected synchronous exception from EL1h could happen at any time, and for robustness we should treat this as an NMI, making minimal assumptions about the context the exception was taken from.
Currently el1_inv() assumes we can use enter_from_kernel_mode(), and also assumes that we should inherit the original DAIF value. Neither of these are desireable when we take an unexpected exception. Further, after el1_inv() calls __panic_unhandled(), the remainder of the function is unreachable, and therefore superfluous.
Let's address this and simplify things by having el1h_64_sync_handler() call __panic_unhandled() directly, without any of the redundant logic.
--- arch/arm64/kernel/entry-common.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-)
arch/arm64/kernel/entry-common.c +1 -10
@@ -264,15 +264,6 @@ static void noinstr el1_undef(struct pt_regs *regs)exit_to_kernel_mode (regs); } -static void noinstr el1_inv(struct pt_regs *regs, unsigned long esr) -{ -enter_from_kernel_mode (regs); -local_daif_inherit (regs); -__panic_unhandled (regs,"64-bit el1h sync" , esr); -local_daif_mask (); -exit_to_kernel_mode (regs); -} - static void noinstr arm64_enter_el1_dbg(struct pt_regs *regs) { regs->lockdep_hardirqs =lockdep_hardirqs_enabled ();
@@ -346,7 +337,7 @@ asmlinkage void noinstr el1h_64_sync_handler(struct pt_regs *regs)el1_fpac (regs, esr);break ;default : -el1_inv (regs, esr); +__panic_unhandled (regs,"64-bit el1h sync" , esr); } }
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 16/20 arm64: entry: split bad stack entry
In reply to Mark RutlandWe'd like to keep all the entry sequencing in entry-common.c, as this will allow us to ensure this is consistent, and free from any unsound instrumentation.
Currently handle_bad_stack() performs the NMI entry sequence in traps.c. Let's split the low-level entry sequence from the reporting, moving the former to entry-common.c and keeping the latter in traps.c. To make it clear that reporting function never returns, it is renamed to panic_bad_stack().
--- arch/arm64/include/asm/exception.h | 4 ++++ arch/arm64/kernel/entry-common.c | 11 +++++++++++ arch/arm64/kernel/traps.c | 6 +----- 3 files changed, 16 insertions(+), 5 deletions(-)
arch/arm64/include/asm/exception.h +4 -0
@@ -31,6 +31,8 @@ static inline u32 disr_to_esr(u64 disr)return esr; } +asmlinkage void handle_bad_stack(struct pt_regs *regs); + asmlinkage void el1t_64_sync_handler(struct pt_regs *regs); asmlinkage void el1t_64_irq_handler(struct pt_regs *regs); asmlinkage void el1t_64_fiq_handler(struct pt_regs *regs);
@@ -73,4 +75,6 @@ void do_el0_svc(struct pt_regs *regs);void do_el0_svc_compat (struct pt_regs *regs);void do_ptrauth_fault (struct pt_regs *regs,unsigned int esr);void do_serror (struct pt_regs *regs,unsigned int esr); + +void panic_bad_stack (struct pt_regs *regs,unsigned int esr,unsigned long far);#endif /* __ASM_EXCEPTION_H */
arch/arm64/kernel/entry-common.c +11 -0
@@ -699,3 +699,14 @@ UNHANDLED(el0t, 32, irq) UNHANDLED(el0t, 32, fiq) UNHANDLED(el0t, 32, error)#endif /* CONFIG_COMPAT */ + +#ifdef CONFIG_VMAP_STACK +asmlinkage void noinstr handle_bad_stack(struct pt_regs *regs) +{ +unsigned int esr =read_sysreg (esr_el1); +unsigned long far =read_sysreg (far_el1); + +arm64_enter_nmi (regs); +panic_bad_stack (regs, esr, far); +} +#endif /* CONFIG_VMAP_STACK */
arch/arm64/kernel/traps.c +1 -5
@@ -763,15 +763,11 @@ void bad_el0_sync(struct pt_regs *regs, int reason, unsigned int esr) DEFINE_PER_CPU(unsigned long [OVERFLOW_STACK_SIZE/sizeof(long)], overflow_stack)__aligned(16) ; -asmlinkage void noinstr handle_bad_stack(struct pt_regs *regs) +void panic_bad_stack (struct pt_regs *regs,unsigned int esr,unsigned long far) {unsigned long tsk_stk = (unsigned long )current->stack;unsigned long irq_stk = (unsigned long )this_cpu_read (irq_stack_ptr);unsigned long ovf_stk = (unsigned long )this_cpu_ptr (overflow_stack); -unsigned int esr =read_sysreg (esr_el1); -unsigned long far =read_sysreg (far_el1); - -arm64_enter_nmi (regs);console_verbose ();pr_emerg ("Insufficient stack space to handle exception!" );
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 17/20 arm64: entry: split SDEI entry
In reply to Mark RutlandWe'd like to keep all the entry sequencing in entry-common.c, as this will allow us to ensure this is consistent, and free from any unsound instrumentation.
Currently __sdei_handler() performs the NMI entry/exit sequences in sdei.c. Let's split the low-level entry sequence from the event handling, moving the former to entry-common.c and keeping the latter in sdei.c. The event handling function is renamed to do_sdei_event(), matching the do_${FOO}() pattern used for other exception handlers.
--- arch/arm64/include/asm/sdei.h | 3 +++ arch/arm64/kernel/entry-common.c | 37 +++++++++++++++++++++++++++++++ arch/arm64/kernel/sdei.c | 48 +++------------------------------------- 3 files changed, 43 insertions(+), 45 deletions(-)
arch/arm64/include/asm/sdei.h +3 -0
@@ -37,6 +37,9 @@ struct sdei_registered_event;asmlinkage unsigned long __sdei_handler (struct pt_regs *regs,struct sdei_registered_event *arg); +unsigned long do_sdei_event (struct pt_regs *regs, +struct sdei_registered_event *arg); +unsigned long sdei_arch_get_entry_point (int conduit);#define sdei_arch_get_entry_point (x) sdei_arch_get_entry_point(x)
arch/arm64/kernel/entry-common.c +37 -0
@@ -20,6 +20,7 @@#include <asm/kprobes.h> #include <asm/mmu.h> #include <asm/processor.h> +#include <asm/sdei.h> #include <asm/stacktrace.h> #include <asm/sysreg.h> #include <asm/system_misc.h>
@@ -710,3 +711,39 @@ asmlinkage void noinstr handle_bad_stack(struct pt_regs *regs)panic_bad_stack (regs, esr, far); }#endif /* CONFIG_VMAP_STACK */ + +#ifdef CONFIG_ARM_SDE_INTERFACE +asmlinkage noinstr unsigned long +__sdei_handler (struct pt_regs *regs,struct sdei_registered_event *arg) +{ +unsigned long ret; + +/* +* We didn't take an exception to get here, so the HW hasn't +* set/cleared bits in PSTATE that we may rely on. +* +* The original SDEI spec (ARM DEN 0054A) can be read ambiguously as to +* whether PSTATE bits are inherited unchanged or generated from +* scratch, and the TF-A implementation always clears PAN and always +* clears UAO. There are no other known implementations. +* +* Subsequent revisions (ARM DEN 0054B) follow the usual rules for how +* PSTATE is modified upon architectural exceptions, and so PAN is +* either inherited or set per SCTLR_ELx.SPAN, and UAO is always +* cleared. +* +* We must explicitly reset PAN to the expected state, including +* clearing it when the host isn't using it, in case a VM had it set. +*/ +if (system_uses_hw_pan ()) +set_pstate_pan (1 ); +else if (cpu_has_pan ()) +set_pstate_pan (0 ); + +arm64_enter_nmi (regs); + ret =do_sdei_event (regs, arg); +arm64_exit_nmi (regs); + +return ret; +} +#endif /* CONFIG_ARM_SDE_INTERFACE */
arch/arm64/kernel/sdei.c +3 -45
61 lines not on this page · raw message
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 18/20 arm64: entry: make NMI entry/exit functions static
In reply to Mark RutlandNow that we only call arm64_enter_nmi() and arm64_exit_nmi() from within entry-common.c, let's make these static to ensure this remains the case.
--- arch/arm64/include/asm/exception.h | 2 -- arch/arm64/kernel/entry-common.c | 4 ++-- 2 files changed, 2 insertions(+), 4 deletions(-)
arch/arm64/include/asm/exception.h +0 -2
@@ -57,8 +57,6 @@ asmlinkage void call_on_irq_stack(struct pt_regs *regs, void (*func)(struct pt_regs *)); asmlinkage void enter_from_user_mode(void); asmlinkage void exit_to_user_mode(void); -void arm64_enter_nmi (struct pt_regs *regs); -void arm64_exit_nmi (struct pt_regs *regs);void do_mem_abort (unsigned long far,unsigned int esr,struct pt_regs *regs);void do_undefinstr (struct pt_regs *regs);void do_bti (struct pt_regs *regs);
arch/arm64/kernel/entry-common.c +2 -2
@@ -75,7 +75,7 @@ static void noinstr exit_to_kernel_mode(struct pt_regs *regs) } } -void noinstr arm64_enter_nmi(struct pt_regs *regs) +static void noinstr arm64_enter_nmi(struct pt_regs *regs) { regs->lockdep_hardirqs =lockdep_hardirqs_enabled ();
@@ -88,7 +88,7 @@ void noinstr arm64_enter_nmi(struct pt_regs *regs)ftrace_nmi_enter (); } -void noinstr arm64_exit_nmi(struct pt_regs *regs) +static void noinstr arm64_exit_nmi(struct pt_regs *regs) {bool restore = regs->lockdep_hardirqs;
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 19/20 arm64: entry: don't instrument entry code with KCOV
In reply to Mark RutlandThe code in entry-common.c runs at exception entry and return boundaries, where portions of the kernel environment aren't available. For example, RCU may not be watching, and lockdep state may be out-of-sync with the hardware. Due to this, it is not sound to instrument this code.
We generally avoid instrumentation by marking the entry functions as noinstr, but currently this doesn't inhibit KCOV instrumentation. Prevent this by disabling KCOV for the entire compilation unit.
--- arch/arm64/kernel/Makefile | 5 +++++ 1 file changed, 5 insertions(+)
arch/arm64/kernel/Makefile +5 -0
@@ -14,6 +14,11 @@ CFLAGS_REMOVE_return_address.o = $(CC_FLAGS_FTRACE) CFLAGS_REMOVE_syscall.o = -fstack-protector -fstack-protector-strong CFLAGS_syscall.o += -fno-stack-protector +# It's not safe to invoke KCOV when portions of the kernel environment aren't +# available or are out-of-sync with HW state. Since `noinstr` doesn't always +# inhibit KCOV instrumentation, disable it for the entire compilation unit. +KCOV_INSTRUMENT_entry.o := n + # Object file lists. obj-y := debug-monitors.o entry.o irq.o fpsimd.o \ entry-common.o entry-fpsimd.o process.o ptrace.o \
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Mark Rutland
reviewerPATCH v4 20/20 arm64: idle: don't instrument idle code with KCOV
In reply to Mark RutlandThe low-level idle code in arch_cpu_idle() and its callees runs at a time where where portions of the kernel environment aren't available. For example, RCU may not be watching, and lockdep state may be out-of-sync with the hardware. Due to this, it is not sound to instrument this code.
We generally avoid instrumentation by marking the entry functions as noinstr, but currently this doesn't inhibit KCOV instrumentation. Prevent this by factoring these functions into a new idle.c so that we can disable KCOV for the entire compilation unit, as is done for the core idle code in kernel/sched/idle.c.
We'd like to keep instrumentation of the rest of process.c, and for the existing code in cpuidle.c, so a new compilation unit is preferable. The arch_cpu_idle_dead() function in process.c is a cpu hotplug function that is safe to instrument, so it is left as-is in process.c.
--- arch/arm64/kernel/Makefile | 3 +- arch/arm64/kernel/idle.c | 69 +++++++++++++++++++++++++++++++++++++++++++++ arch/arm64/kernel/process.c | 57 ------------------------------------- 3 files changed, 71 insertions(+), 58 deletions(-) create mode 100644 arch/arm64/kernel/idle.c
arch/arm64/kernel/Makefile +2 -1
@@ -18,6 +18,7 @@ CFLAGS_syscall.o += -fno-stack-protector # available or are out-of-sync with HW state. Since `noinstr` doesn't always # inhibit KCOV instrumentation, disable it for the entire compilation unit. KCOV_INSTRUMENT_entry.o := n +KCOV_INSTRUMENT_idle.o := n # Object file lists. obj-y := debug-monitors.o entry.o irq.o fpsimd.o \
@@ -27,7 +28,7 @@ obj-y := debug-monitors.o entry.o irq.o fpsimd.o \ return_address.o cpuinfo.o cpu_errata.o \ cpufeature.o alternative.o cacheinfo.o \ smp.o smp_spin_table.o topology.o smccc-call.o \ - syscall.o proton-pack.o idreg-override.o + syscall.o proton-pack.o idreg-override.o idle.o targets += efi-entry.o
arch/arm64/kernel/idle.c new file +69 -0
69 lines not on this page · raw message
arch/arm64/kernel/process.c +0 -57
63 lines not on this page · raw message
Signature · 7 lines
2.11.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 9 lines · Mark Rutland
This series (based on v5.13-rc2) migrates most of the remaining exception triage assembly to C. All the exception vectors are given C handlers, so that we can defer all decision making to C code, and the assembly code can be made simpler and more uniform. At the same time, I've tried to consolidate all the entry sequencing (e.g. reading exception registers and calling accounting code) in
entry-common.cso that this is easier to maintain.[...]
Applied to arm64 (for-next/entry), thanks!
[01/20] arm64: remove redundant local_daif_mask() in bad_mode()
https://git.kernel.org/arm64/c/382dcdd66ce8 [02/20] arm64: entry: unmask IRQ+FIQ after EL0 handling https://git.kernel.org/arm64/c/f7c706f0391d [03/20] arm64: entry: convert SError handlers to C https://git.kernel.org/arm64/c/bb8e93a287a5 [04/20] arm64: entry: move arm64_preempt_schedule_irq to entry-common.c https://git.kernel.org/arm64/c/33a3581a76f3 [05/20] arm64: entry: move NMI preempt logic to C https://git.kernel.org/arm64/c/101a5b665dcd [06/20] arm64: entry: add a call_on_irq_stack helper https://git.kernel.org/arm64/c/f8049488e7d3 [07/20] arm64: entry: convert IRQ+FIQ handlers to C https://git.kernel.org/arm64/c/064dbfb41691 [08/20] arm64: entry: organise entry handlers consistently https://git.kernel.org/arm64/c/2f2bbaa4eda0 [09/20] arm64: entry: organise entry vectors consistently https://git.kernel.org/arm64/c/e931fa03c6bf [10/20] arm64: entry: consolidate EL1 exception returns https://git.kernel.org/arm64/c/af541cbbf9c6 [11/20] arm64: entry: move bad_mode() to entry-common.c https://git.kernel.org/arm64/c/cbed5f8d3feb [12/20] arm64: entry: improve bad_mode() https://git.kernel.org/arm64/c/ca0c2647f54c [13/20] arm64: entry: template the entry asm functions https://git.kernel.org/arm64/c/a5b43a87a760 [14/20] arm64: entry: handle all vectors with C https://git.kernel.org/arm64/c/ec841aab8d3c [15/20] arm64: entry: fold el1_inv() into el1h_64_sync_handler() https://git.kernel.org/arm64/c/afd05e28c911 [16/20] arm64: entry: split bad stack entry https://git.kernel.org/arm64/c/8168f098867f [17/20] arm64: entry: split SDEI entry https://git.kernel.org/arm64/c/d60b228fd199 [18/20] arm64: entry: make NMI entry/exit functions static https://git.kernel.org/arm64/c/6ecbc78c3d06 [19/20] arm64: entry: don't instrument entry code with KCOV https://git.kernel.org/arm64/c/bf6fa2c0dda7 [20/20] arm64: idle: don't instrument idle code with KCOV https://git.kernel.org/arm64/c/b5df5b8307b1
Cheers,
Signature · 10 lines
Will https://fixes.arm64.dev https://next.arm64.dev https://will.arm64.dev _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel