Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/context_tracking.h>#include <linux/entry-common.h>#include <linux/err.h>#include <linux/compat.h>#include <linux/rseq.h>#include <linux/sched/debug.h> /* for show_regs */
#include <asm/kup.h>#include <asm/cputime.h>#include <asm/hw_irq.h>#include <asm/interrupt.h>#include <asm/kprobes.h>#include <asm/paca.h>#include <asm/ptrace.h>#include <asm/reg.h>#include <asm/signal.h>#include <asm/switch_to.h>#include <asm/syscall.h>#include <asm/time.h>#include <asm/tm.h>#include <asm/unistd.h>
#if defined(CONFIG_PPC_ADV_DEBUG_REGS) && defined(CONFIG_PPC32)unsigned long global_dbcr0[NR_CPUS];#endif
#ifdef CONFIG_PPC_BOOK3S_64DEFINE_STATIC_KEY_FALSE(interrupt_exit_not_reentrant);static inline bool exit_must_hard_disable(void){ return static_branch_unlikely(&interrupt_exit_not_reentrant);}#elsestatic inline bool exit_must_hard_disable(void){ return true;}#endif
/* * local irqs must be disabled. Returns false if the caller must re-enable * them, check for new work, and try again. * * This should be called with local irqs disabled, but if they were previously * enabled when the interrupt handler returns (indicating a process-context / * synchronous interrupt) then irqs_enabled should be true. * * restartable is true then EE/RI can be left on because interrupts are handled * with a restart sequence. */static notrace __always_inline bool prep_irq_for_enabled_exit(bool restartable){ bool must_hard_disable = (exit_must_hard_disable() || !restartable);
/* This must be done with RI=1 because tracing may touch vmaps */ trace_hardirqs_on();
if (must_hard_disable) __hard_EE_RI_disable();
#ifdef CONFIG_PPC64 /* This pattern matches prep_irq_for_idle */ if (unlikely(lazy_irq_pending_nocheck())) { if (must_hard_disable) { local_paca->irq_happened |= PACA_IRQ_HARD_DIS; __hard_RI_enable(); } trace_hardirqs_off();
return false; }#endif return true;}
/* * This should be called after a syscall returns, with r3 the return value * from the syscall. If this function returns non-zero, the system call * exit assembly should additionally load all GPR registers and CTR and XER * from the interrupt frame. * * The function graph tracer can not trace the return side of this function, * because RI=0 and soft mask state is "unreconciled", so it is marked notrace. */notrace unsigned long syscall_exit_prepare(unsigned long r3, struct pt_regs *regs, long scv){ unsigned long ti_flags; bool is_not_scv = !IS_ENABLED(CONFIG_PPC_BOOK3S_64) || !scv;
kuap_assert_locked();
regs->result = r3; regs->exit_flags = 0;
ti_flags = read_thread_flags();
if (unlikely(r3 >= (unsigned long)-MAX_ERRNO) && is_not_scv) { if (likely(!(ti_flags & (_TIF_NOERROR | _TIF_RESTOREALL)))) { r3 = -r3; regs->ccr |= 0x10000000; /* Set SO bit in CR */ } }
if (unlikely(ti_flags & _TIF_PERSYSCALL_MASK)) { if (ti_flags & _TIF_RESTOREALL) regs->exit_flags = _TIF_RESTOREALL; else regs->gpr[3] = r3; clear_bits(_TIF_PERSYSCALL_MASK, ¤t_thread_info()->flags); } else { regs->gpr[3] = r3; }
if (unlikely(ti_flags & _TIF_SYSCALL_DOTRACE)) { regs->exit_flags |= _TIF_RESTOREALL; }
syscall_exit_to_user_mode(regs);
again: user_enter_irqoff(); if (!prep_irq_for_enabled_exit(true)) { user_exit_irqoff(); local_irq_enable(); local_irq_disable(); goto again; }
/* Restore user access locks last */ kuap_user_restore(regs);
#ifdef CONFIG_PPC64 regs->exit_result = regs->exit_flags;#endif
return regs->exit_flags;}
#ifdef CONFIG_PPC64notrace unsigned long syscall_exit_restart(unsigned long r3, struct pt_regs *regs){ /* * This is called when detecting a soft-pending interrupt as well as * an alternate-return interrupt. So we can't just have the alternate * return path clear SRR1[MSR] and set PACA_IRQ_HARD_DIS (unless * the soft-pending case were to fix things up as well). RI might be * disabled, in which case it gets re-enabled by __hard_irq_disable(). */ __hard_irq_disable(); local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
#ifdef CONFIG_PPC_BOOK3S_64 set_kuap(AMR_KUAP_BLOCKED);#endif
again: user_enter_irqoff(); if (!prep_irq_for_enabled_exit(true)) { user_exit_irqoff(); local_irq_enable(); local_irq_disable(); goto again; }
kuap_user_restore(regs); regs->exit_result |= regs->exit_flags;
return regs->exit_result;}#endif
notrace unsigned long interrupt_exit_user_prepare(struct pt_regs *regs){ unsigned long ret;
BUG_ON(regs_is_unrecoverable(regs)); BUG_ON(regs_irqs_disabled(regs));
/* * We don't need to restore AMR on the way back to userspace for KUAP. * AMR can only have been unlocked if we interrupted the kernel. */ kuap_assert_locked();
local_irq_disable(); regs->exit_flags = 0;again: check_return_regs_valid(regs); user_enter_irqoff(); if (!prep_irq_for_enabled_exit(true)) { user_exit_irqoff(); local_irq_enable(); local_irq_disable(); goto again; }
/* Restore user access locks last */ kuap_user_restore(regs);
ret = regs->exit_flags;
#ifdef CONFIG_PPC64 regs->exit_result = ret;#endif
return ret;}
void preempt_schedule_irq(void);
notrace unsigned long interrupt_exit_kernel_prepare(struct pt_regs *regs){ unsigned long ret = 0; unsigned long kuap; bool stack_store = read_thread_flags() & _TIF_EMULATE_STACK_STORE;
if (regs_is_unrecoverable(regs)) unrecoverable_exception(regs); /* * CT_WARN_ON comes here via program_check_exception, so avoid * recursion. * * Skip the assertion on PMIs on 64e to work around a problem caused * by NMI PMIs incorrectly taking this interrupt return path, it's * possible for this to hit after interrupt exit to user switches * context to user. See also the comment in the performance monitor * handler in exceptions-64e.S */ if (!IS_ENABLED(CONFIG_PPC_BOOK3E_64) && TRAP(regs) != INTERRUPT_PROGRAM && TRAP(regs) != INTERRUPT_PERFMON) CT_WARN_ON(ct_state() == CT_STATE_USER);
kuap = kuap_get_and_assert_locked();
local_irq_disable();
if (!regs_irqs_disabled(regs)) { /* Returning to a kernel context with local irqs enabled. */ WARN_ON_ONCE(!(regs->msr & MSR_EE));again:
check_return_regs_valid(regs);
/* * Stack store exit can't be restarted because the interrupt * stack frame might have been clobbered. */ if (!prep_irq_for_enabled_exit(unlikely(stack_store))) { /* * Replay pending soft-masked interrupts now. Don't * just local_irq_enabe(); local_irq_disable(); because * if we are returning from an asynchronous interrupt * here, another one might hit after irqs are enabled, * and it would exit via this same path allowing * another to fire, and so on unbounded. */ hard_irq_disable(); replay_soft_interrupts(); /* Took an interrupt, may have more exit work to do. */ goto again; }#ifdef CONFIG_PPC64 /* * An interrupt may clear MSR[EE] and set this concurrently, * but it will be marked pending and the exit will be retried. * This leaves a racy window where MSR[EE]=0 and HARD_DIS is * clear, until interrupt_exit_kernel_restart() calls * hard_irq_disable(), which will set HARD_DIS again. */ local_paca->irq_happened &= ~PACA_IRQ_HARD_DIS;
} else { check_return_regs_valid(regs);
if (unlikely(stack_store)) __hard_EE_RI_disable();#else } else { __hard_EE_RI_disable();#endif /* CONFIG_PPC64 */ }
if (unlikely(stack_store)) { clear_bits(_TIF_EMULATE_STACK_STORE, ¤t_thread_info()->flags); ret = 1; }
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM local_paca->tm_scratch = regs->msr;#endif
/* * 64s does not want to mfspr(SPRN_AMR) here, because this comes after * mtmsr, which would cause Read-After-Write stalls. Hence, take the * AMR value from the check above. */ kuap_kernel_restore(regs, kuap);
return ret;}
#ifdef CONFIG_PPC64notrace unsigned long interrupt_exit_user_restart(struct pt_regs *regs){ __hard_irq_disable(); local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
#ifdef CONFIG_PPC_BOOK3S_64 set_kuap(AMR_KUAP_BLOCKED);#endif
trace_hardirqs_off(); account_cpu_user_entry();
BUG_ON(!user_mode(regs));
regs->exit_result |= interrupt_exit_user_prepare(regs);
return regs->exit_result;}
/* * No real need to return a value here because the stack store case does not * get restarted. */notrace unsigned long interrupt_exit_kernel_restart(struct pt_regs *regs){ __hard_irq_disable(); local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
#ifdef CONFIG_PPC_BOOK3S_64 set_kuap(AMR_KUAP_BLOCKED);#endif
if (regs->softe == IRQS_ENABLED) trace_hardirqs_off();
BUG_ON(user_mode(regs));
return interrupt_exit_kernel_prepare(regs);}#endif