2020-07-23 05:59:56 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
|
|
|
|
#ifndef __LINUX_ENTRYCOMMON_H
|
|
|
|
|
#define __LINUX_ENTRYCOMMON_H
|
|
|
|
|
|
2021-01-18 22:12:22 +08:00
|
|
|
#include <linux/static_call_types.h>
|
2022-01-28 01:46:37 +08:00
|
|
|
#include <linux/ptrace.h>
|
2020-07-23 05:59:56 +08:00
|
|
|
#include <linux/syscalls.h>
|
|
|
|
|
#include <linux/seccomp.h>
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
|
|
|
|
|
#include <asm/entry-common.h>
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Define dummy _TIF work flags if not defined by the architecture or for
|
|
|
|
|
* disabled functionality.
|
|
|
|
|
*/
|
2020-07-23 05:59:57 +08:00
|
|
|
#ifndef _TIF_PATCH_PENDING
|
|
|
|
|
# define _TIF_PATCH_PENDING (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _TIF_UPROBE
|
|
|
|
|
# define _TIF_UPROBE (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
2020-07-23 05:59:56 +08:00
|
|
|
/*
|
2020-11-17 01:42:05 +08:00
|
|
|
* SYSCALL_WORK flags handled in syscall_enter_from_user_mode()
|
2020-07-23 05:59:56 +08:00
|
|
|
*/
|
2020-11-17 01:42:05 +08:00
|
|
|
#ifndef ARCH_SYSCALL_WORK_ENTER
|
|
|
|
|
# define ARCH_SYSCALL_WORK_ENTER (0)
|
2020-07-23 05:59:56 +08:00
|
|
|
#endif
|
|
|
|
|
|
2020-07-23 05:59:57 +08:00
|
|
|
/*
|
2020-11-17 01:42:05 +08:00
|
|
|
* SYSCALL_WORK flags handled in syscall_exit_to_user_mode()
|
2020-07-23 05:59:57 +08:00
|
|
|
*/
|
2020-11-17 01:42:05 +08:00
|
|
|
#ifndef ARCH_SYSCALL_WORK_EXIT
|
|
|
|
|
# define ARCH_SYSCALL_WORK_EXIT (0)
|
2020-07-23 05:59:57 +08:00
|
|
|
#endif
|
|
|
|
|
|
2020-11-17 01:42:01 +08:00
|
|
|
#define SYSCALL_WORK_ENTER (SYSCALL_WORK_SECCOMP | \
|
2020-11-17 01:42:02 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_TRACEPOINT | \
|
2020-11-17 01:42:03 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_TRACE | \
|
2020-11-17 01:42:04 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_EMU | \
|
2020-11-17 01:42:05 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_AUDIT | \
|
2020-11-28 03:32:35 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_USER_DISPATCH | \
|
2020-11-17 01:42:05 +08:00
|
|
|
ARCH_SYSCALL_WORK_ENTER)
|
2020-11-17 01:42:02 +08:00
|
|
|
#define SYSCALL_WORK_EXIT (SYSCALL_WORK_SYSCALL_TRACEPOINT | \
|
2020-11-17 01:42:04 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_TRACE | \
|
2020-11-17 01:42:05 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_AUDIT | \
|
2020-11-28 03:32:35 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_USER_DISPATCH | \
|
2021-02-04 02:00:48 +08:00
|
|
|
SYSCALL_WORK_SYSCALL_EXIT_TRAP | \
|
2020-11-17 01:42:05 +08:00
|
|
|
ARCH_SYSCALL_WORK_EXIT)
|
2020-11-17 01:41:59 +08:00
|
|
|
|
2020-07-23 05:59:57 +08:00
|
|
|
/*
|
|
|
|
|
* TIF flags handled in exit_to_user_mode_loop()
|
|
|
|
|
*/
|
|
|
|
|
#ifndef ARCH_EXIT_TO_USER_MODE_WORK
|
|
|
|
|
# define ARCH_EXIT_TO_USER_MODE_WORK (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define EXIT_TO_USER_MODE_WORK \
|
|
|
|
|
(_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_UPROBE | \
|
2020-10-27 04:32:28 +08:00
|
|
|
_TIF_NEED_RESCHED | _TIF_PATCH_PENDING | _TIF_NOTIFY_SIGNAL | \
|
2020-07-23 05:59:57 +08:00
|
|
|
ARCH_EXIT_TO_USER_MODE_WORK)
|
|
|
|
|
|
2020-07-23 05:59:56 +08:00
|
|
|
/**
|
2022-05-04 14:23:50 +08:00
|
|
|
* arch_enter_from_user_mode - Architecture specific sanity check for user mode regs
|
2020-07-23 05:59:56 +08:00
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
*
|
|
|
|
|
* Defaults to an empty implementation. Can be replaced by architecture
|
|
|
|
|
* specific code.
|
|
|
|
|
*
|
|
|
|
|
* Invoked from syscall_enter_from_user_mode() in the non-instrumentable
|
|
|
|
|
* section. Use __always_inline so the compiler cannot push it out of line
|
|
|
|
|
* and make it instrumentable.
|
|
|
|
|
*/
|
2022-05-04 14:23:50 +08:00
|
|
|
static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs);
|
2020-07-23 05:59:56 +08:00
|
|
|
|
2022-05-04 14:23:50 +08:00
|
|
|
#ifndef arch_enter_from_user_mode
|
|
|
|
|
static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs) {}
|
2020-07-23 05:59:56 +08:00
|
|
|
#endif
|
|
|
|
|
|
2020-12-01 22:27:53 +08:00
|
|
|
/**
|
|
|
|
|
* enter_from_user_mode - Establish state when coming from user mode
|
|
|
|
|
*
|
|
|
|
|
* Syscall/interrupt entry disables interrupts, but user mode is traced as
|
|
|
|
|
* interrupts enabled. Also with NO_HZ_FULL RCU might be idle.
|
|
|
|
|
*
|
|
|
|
|
* 1) Tell lockdep that interrupts are disabled
|
|
|
|
|
* 2) Invoke context tracking if enabled to reactivate RCU
|
|
|
|
|
* 3) Trace interrupts off state
|
|
|
|
|
*
|
|
|
|
|
* Invoked from architecture specific syscall entry code with interrupts
|
|
|
|
|
* disabled. The calling code has to be non-instrumentable. When the
|
|
|
|
|
* function returns all state is correct and interrupts are still
|
|
|
|
|
* disabled. The subsequent functions can be instrumented.
|
|
|
|
|
*
|
|
|
|
|
* This is invoked when there is architecture specific functionality to be
|
|
|
|
|
* done between establishing state and enabling interrupts. The caller must
|
|
|
|
|
* enable interrupts before invoking syscall_enter_from_user_mode_work().
|
|
|
|
|
*/
|
|
|
|
|
void enter_from_user_mode(struct pt_regs *regs);
|
|
|
|
|
|
2020-07-23 05:59:56 +08:00
|
|
|
/**
|
2020-09-02 07:50:54 +08:00
|
|
|
* syscall_enter_from_user_mode_prepare - Establish state and enable interrupts
|
2020-07-23 05:59:56 +08:00
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
*
|
|
|
|
|
* Invoked from architecture specific syscall entry code with interrupts
|
|
|
|
|
* disabled. The calling code has to be non-instrumentable. When the
|
2020-09-02 07:50:54 +08:00
|
|
|
* function returns all state is correct, interrupts are enabled and the
|
|
|
|
|
* subsequent functions can be instrumented.
|
|
|
|
|
*
|
2020-12-01 22:27:53 +08:00
|
|
|
* This handles lockdep, RCU (context tracking) and tracing state, i.e.
|
|
|
|
|
* the functionality provided by enter_from_user_mode().
|
2020-09-02 07:50:54 +08:00
|
|
|
*
|
|
|
|
|
* This is invoked when there is extra architecture specific functionality
|
|
|
|
|
* to be done between establishing state and handling user mode entry work.
|
|
|
|
|
*/
|
|
|
|
|
void syscall_enter_from_user_mode_prepare(struct pt_regs *regs);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* syscall_enter_from_user_mode_work - Check and handle work before invoking
|
|
|
|
|
* a syscall
|
|
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
* @syscall: The syscall number
|
|
|
|
|
*
|
|
|
|
|
* Invoked from architecture specific syscall entry code with interrupts
|
|
|
|
|
* enabled after invoking syscall_enter_from_user_mode_prepare() and extra
|
|
|
|
|
* architecture specific work.
|
2020-07-23 05:59:56 +08:00
|
|
|
*
|
|
|
|
|
* Returns: The original or a modified syscall number
|
|
|
|
|
*
|
|
|
|
|
* If the returned syscall number is -1 then the syscall should be
|
|
|
|
|
* skipped. In this case the caller may invoke syscall_set_error() or
|
|
|
|
|
* syscall_set_return_value() first. If neither of those are called and -1
|
|
|
|
|
* is returned, then the syscall will fail with ENOSYS.
|
|
|
|
|
*
|
2020-09-02 07:50:54 +08:00
|
|
|
* It handles the following work items:
|
2020-07-23 05:59:56 +08:00
|
|
|
*
|
2020-11-17 01:42:05 +08:00
|
|
|
* 1) syscall_work flag dependent invocations of
|
2022-01-28 02:00:55 +08:00
|
|
|
* ptrace_report_syscall_entry(), __secure_computing(), trace_sys_enter()
|
2020-09-02 07:50:54 +08:00
|
|
|
* 2) Invocation of audit_syscall_entry()
|
|
|
|
|
*/
|
|
|
|
|
long syscall_enter_from_user_mode_work(struct pt_regs *regs, long syscall);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* syscall_enter_from_user_mode - Establish state and check and handle work
|
|
|
|
|
* before invoking a syscall
|
|
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
* @syscall: The syscall number
|
|
|
|
|
*
|
|
|
|
|
* Invoked from architecture specific syscall entry code with interrupts
|
|
|
|
|
* disabled. The calling code has to be non-instrumentable. When the
|
|
|
|
|
* function returns all state is correct, interrupts are enabled and the
|
|
|
|
|
* subsequent functions can be instrumented.
|
|
|
|
|
*
|
|
|
|
|
* This is combination of syscall_enter_from_user_mode_prepare() and
|
|
|
|
|
* syscall_enter_from_user_mode_work().
|
|
|
|
|
*
|
|
|
|
|
* Returns: The original or a modified syscall number. See
|
|
|
|
|
* syscall_enter_from_user_mode_work() for further explanation.
|
2020-07-23 05:59:56 +08:00
|
|
|
*/
|
|
|
|
|
long syscall_enter_from_user_mode(struct pt_regs *regs, long syscall);
|
|
|
|
|
|
2020-07-23 05:59:57 +08:00
|
|
|
/**
|
|
|
|
|
* local_irq_enable_exit_to_user - Exit to user variant of local_irq_enable()
|
|
|
|
|
* @ti_work: Cached TIF flags gathered with interrupts disabled
|
|
|
|
|
*
|
|
|
|
|
* Defaults to local_irq_enable(). Can be supplied by architecture specific
|
|
|
|
|
* code.
|
|
|
|
|
*/
|
|
|
|
|
static inline void local_irq_enable_exit_to_user(unsigned long ti_work);
|
|
|
|
|
|
|
|
|
|
#ifndef local_irq_enable_exit_to_user
|
|
|
|
|
static inline void local_irq_enable_exit_to_user(unsigned long ti_work)
|
|
|
|
|
{
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* local_irq_disable_exit_to_user - Exit to user variant of local_irq_disable()
|
|
|
|
|
*
|
|
|
|
|
* Defaults to local_irq_disable(). Can be supplied by architecture specific
|
|
|
|
|
* code.
|
|
|
|
|
*/
|
|
|
|
|
static inline void local_irq_disable_exit_to_user(void);
|
|
|
|
|
|
|
|
|
|
#ifndef local_irq_disable_exit_to_user
|
|
|
|
|
static inline void local_irq_disable_exit_to_user(void)
|
|
|
|
|
{
|
|
|
|
|
local_irq_disable();
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* arch_exit_to_user_mode_work - Architecture specific TIF work for exit
|
|
|
|
|
* to user mode.
|
|
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
* @ti_work: Cached TIF flags gathered with interrupts disabled
|
|
|
|
|
*
|
|
|
|
|
* Invoked from exit_to_user_mode_loop() with interrupt enabled
|
|
|
|
|
*
|
|
|
|
|
* Defaults to NOOP. Can be supplied by architecture specific code.
|
|
|
|
|
*/
|
|
|
|
|
static inline void arch_exit_to_user_mode_work(struct pt_regs *regs,
|
|
|
|
|
unsigned long ti_work);
|
|
|
|
|
|
|
|
|
|
#ifndef arch_exit_to_user_mode_work
|
|
|
|
|
static inline void arch_exit_to_user_mode_work(struct pt_regs *regs,
|
|
|
|
|
unsigned long ti_work)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* arch_exit_to_user_mode_prepare - Architecture specific preparation for
|
|
|
|
|
* exit to user mode.
|
|
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
* @ti_work: Cached TIF flags gathered with interrupts disabled
|
|
|
|
|
*
|
|
|
|
|
* Invoked from exit_to_user_mode_prepare() with interrupt disabled as the last
|
|
|
|
|
* function before return. Defaults to NOOP.
|
|
|
|
|
*/
|
|
|
|
|
static inline void arch_exit_to_user_mode_prepare(struct pt_regs *regs,
|
|
|
|
|
unsigned long ti_work);
|
|
|
|
|
|
|
|
|
|
#ifndef arch_exit_to_user_mode_prepare
|
|
|
|
|
static inline void arch_exit_to_user_mode_prepare(struct pt_regs *regs,
|
|
|
|
|
unsigned long ti_work)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* arch_exit_to_user_mode - Architecture specific final work before
|
|
|
|
|
* exit to user mode.
|
|
|
|
|
*
|
|
|
|
|
* Invoked from exit_to_user_mode() with interrupt disabled as the last
|
|
|
|
|
* function before return. Defaults to NOOP.
|
|
|
|
|
*
|
|
|
|
|
* This needs to be __always_inline because it is non-instrumentable code
|
|
|
|
|
* invoked after context tracking switched to user mode.
|
|
|
|
|
*
|
|
|
|
|
* An architecture implementation must not do anything complex, no locking
|
|
|
|
|
* etc. The main purpose is for speculation mitigations.
|
|
|
|
|
*/
|
|
|
|
|
static __always_inline void arch_exit_to_user_mode(void);
|
|
|
|
|
|
|
|
|
|
#ifndef arch_exit_to_user_mode
|
|
|
|
|
static __always_inline void arch_exit_to_user_mode(void) { }
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
2020-10-27 04:32:28 +08:00
|
|
|
* arch_do_signal_or_restart - Architecture specific signal delivery function
|
2020-07-23 05:59:57 +08:00
|
|
|
* @regs: Pointer to currents pt_regs
|
2020-10-27 04:32:28 +08:00
|
|
|
* @has_signal: actual signal to handle
|
2020-07-23 05:59:57 +08:00
|
|
|
*
|
|
|
|
|
* Invoked from exit_to_user_mode_loop().
|
|
|
|
|
*/
|
2022-02-09 23:51:14 +08:00
|
|
|
void arch_do_signal_or_restart(struct pt_regs *regs);
|
2020-07-23 05:59:57 +08:00
|
|
|
|
2020-12-01 22:27:54 +08:00
|
|
|
/**
|
|
|
|
|
* exit_to_user_mode - Fixup state when exiting to user mode
|
|
|
|
|
*
|
|
|
|
|
* Syscall/interrupt exit enables interrupts, but the kernel state is
|
|
|
|
|
* interrupts disabled when this is invoked. Also tell RCU about it.
|
|
|
|
|
*
|
|
|
|
|
* 1) Trace interrupts on state
|
|
|
|
|
* 2) Invoke context tracking if enabled to adjust RCU state
|
|
|
|
|
* 3) Invoke architecture specific last minute exit code, e.g. speculation
|
|
|
|
|
* mitigations, etc.: arch_exit_to_user_mode()
|
|
|
|
|
* 4) Tell lockdep that interrupts are enabled
|
|
|
|
|
*
|
|
|
|
|
* Invoked from architecture specific code when syscall_exit_to_user_mode()
|
|
|
|
|
* is not suitable as the last step before returning to userspace. Must be
|
|
|
|
|
* invoked with interrupts disabled and the caller must be
|
|
|
|
|
* non-instrumentable.
|
2020-12-01 22:27:55 +08:00
|
|
|
* The caller has to invoke syscall_exit_to_user_mode_work() before this.
|
2020-12-01 22:27:54 +08:00
|
|
|
*/
|
|
|
|
|
void exit_to_user_mode(void);
|
|
|
|
|
|
2020-12-01 22:27:55 +08:00
|
|
|
/**
|
|
|
|
|
* syscall_exit_to_user_mode_work - Handle work before returning to user mode
|
|
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
*
|
|
|
|
|
* Same as step 1 and 2 of syscall_exit_to_user_mode() but without calling
|
|
|
|
|
* exit_to_user_mode() to perform the final transition to user mode.
|
|
|
|
|
*
|
|
|
|
|
* Calling convention is the same as for syscall_exit_to_user_mode() and it
|
|
|
|
|
* returns with all work handled and interrupts disabled. The caller must
|
|
|
|
|
* invoke exit_to_user_mode() before actually switching to user mode to
|
|
|
|
|
* make the final state transitions. Interrupts must stay disabled between
|
|
|
|
|
* return from this function and the invocation of exit_to_user_mode().
|
|
|
|
|
*/
|
|
|
|
|
void syscall_exit_to_user_mode_work(struct pt_regs *regs);
|
|
|
|
|
|
2020-07-23 05:59:57 +08:00
|
|
|
/**
|
|
|
|
|
* syscall_exit_to_user_mode - Handle work before returning to user mode
|
|
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
*
|
|
|
|
|
* Invoked with interrupts enabled and fully valid regs. Returns with all
|
|
|
|
|
* work handled, interrupts disabled such that the caller can immediately
|
|
|
|
|
* switch to user mode. Called from architecture specific syscall and ret
|
|
|
|
|
* from fork code.
|
|
|
|
|
*
|
|
|
|
|
* The call order is:
|
|
|
|
|
* 1) One-time syscall exit work:
|
|
|
|
|
* - rseq syscall exit
|
|
|
|
|
* - audit
|
|
|
|
|
* - syscall tracing
|
2022-01-28 02:00:55 +08:00
|
|
|
* - ptrace (single stepping)
|
2020-07-23 05:59:57 +08:00
|
|
|
*
|
|
|
|
|
* 2) Preparatory work
|
|
|
|
|
* - Exit to user mode loop (common TIF handling). Invokes
|
|
|
|
|
* arch_exit_to_user_mode_work() for architecture specific TIF work
|
|
|
|
|
* - Architecture specific one time work arch_exit_to_user_mode_prepare()
|
|
|
|
|
* - Address limit and lockdep checks
|
|
|
|
|
*
|
2020-12-01 22:27:54 +08:00
|
|
|
* 3) Final transition (lockdep, tracing, context tracking, RCU), i.e. the
|
|
|
|
|
* functionality in exit_to_user_mode().
|
2020-12-01 22:27:55 +08:00
|
|
|
*
|
|
|
|
|
* This is a combination of syscall_exit_to_user_mode_work() (1,2) and
|
|
|
|
|
* exit_to_user_mode(). This function is preferred unless there is a
|
2021-03-22 10:55:50 +08:00
|
|
|
* compelling architectural reason to use the separate functions.
|
2020-07-23 05:59:57 +08:00
|
|
|
*/
|
|
|
|
|
void syscall_exit_to_user_mode(struct pt_regs *regs);
|
|
|
|
|
|
2020-07-23 05:59:56 +08:00
|
|
|
/**
|
|
|
|
|
* irqentry_enter_from_user_mode - Establish state before invoking the irq handler
|
|
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
*
|
|
|
|
|
* Invoked from architecture specific entry code with interrupts disabled.
|
|
|
|
|
* Can only be called when the interrupt entry came from user mode. The
|
|
|
|
|
* calling code must be non-instrumentable. When the function returns all
|
|
|
|
|
* state is correct and the subsequent functions can be instrumented.
|
|
|
|
|
*
|
|
|
|
|
* The function establishes state (lockdep, RCU (context tracking), tracing)
|
|
|
|
|
*/
|
|
|
|
|
void irqentry_enter_from_user_mode(struct pt_regs *regs);
|
|
|
|
|
|
2020-07-23 05:59:57 +08:00
|
|
|
/**
|
|
|
|
|
* irqentry_exit_to_user_mode - Interrupt exit work
|
|
|
|
|
* @regs: Pointer to current's pt_regs
|
|
|
|
|
*
|
2021-03-22 10:55:50 +08:00
|
|
|
* Invoked with interrupts disabled and fully valid regs. Returns with all
|
2020-07-23 05:59:57 +08:00
|
|
|
* work handled, interrupts disabled such that the caller can immediately
|
|
|
|
|
* switch to user mode. Called from architecture specific interrupt
|
|
|
|
|
* handling code.
|
|
|
|
|
*
|
|
|
|
|
* The call order is #2 and #3 as described in syscall_exit_to_user_mode().
|
|
|
|
|
* Interrupt exit is not invoking #1 which is the syscall specific one time
|
|
|
|
|
* work.
|
|
|
|
|
*/
|
|
|
|
|
void irqentry_exit_to_user_mode(struct pt_regs *regs);
|
|
|
|
|
|
2020-07-23 05:59:58 +08:00
|
|
|
#ifndef irqentry_state
|
2020-11-03 04:53:16 +08:00
|
|
|
/**
|
|
|
|
|
* struct irqentry_state - Opaque object for exception state storage
|
|
|
|
|
* @exit_rcu: Used exclusively in the irqentry_*() calls; signals whether the
|
2022-06-08 22:40:26 +08:00
|
|
|
* exit path has to invoke ct_irq_exit().
|
2020-11-03 04:53:16 +08:00
|
|
|
* @lockdep: Used exclusively in the irqentry_nmi_*() calls; ensures that
|
|
|
|
|
* lockdep state is restored correctly on exit from nmi.
|
|
|
|
|
*
|
|
|
|
|
* This opaque object is filled in by the irqentry_*_enter() functions and
|
|
|
|
|
* must be passed back into the corresponding irqentry_*_exit() functions
|
|
|
|
|
* when the exception is complete.
|
|
|
|
|
*
|
|
|
|
|
* Callers of irqentry_*_[enter|exit]() must consider this structure opaque
|
|
|
|
|
* and all members private. Descriptions of the members are provided to aid in
|
|
|
|
|
* the maintenance of the irqentry_*() functions.
|
|
|
|
|
*/
|
2020-07-23 05:59:58 +08:00
|
|
|
typedef struct irqentry_state {
|
2020-11-03 04:53:16 +08:00
|
|
|
union {
|
|
|
|
|
bool exit_rcu;
|
|
|
|
|
bool lockdep;
|
|
|
|
|
};
|
2020-07-23 05:59:58 +08:00
|
|
|
} irqentry_state_t;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irqentry_enter - Handle state tracking on ordinary interrupt entries
|
|
|
|
|
* @regs: Pointer to pt_regs of interrupted context
|
|
|
|
|
*
|
|
|
|
|
* Invokes:
|
|
|
|
|
* - lockdep irqflag state tracking as low level ASM entry disabled
|
|
|
|
|
* interrupts.
|
|
|
|
|
*
|
|
|
|
|
* - Context tracking if the exception hit user mode.
|
|
|
|
|
*
|
|
|
|
|
* - The hardirq tracer to keep the state consistent as low level ASM
|
|
|
|
|
* entry disabled interrupts.
|
|
|
|
|
*
|
|
|
|
|
* As a precondition, this requires that the entry came from user mode,
|
|
|
|
|
* idle, or a kernel context in which RCU is watching.
|
|
|
|
|
*
|
|
|
|
|
* For kernel mode entries RCU handling is done conditional. If RCU is
|
|
|
|
|
* watching then the only RCU requirement is to check whether the tick has
|
2022-06-08 22:40:26 +08:00
|
|
|
* to be restarted. If RCU is not watching then ct_irq_enter() has to be
|
|
|
|
|
* invoked on entry and ct_irq_exit() on exit.
|
2020-07-23 05:59:58 +08:00
|
|
|
*
|
2022-06-08 22:40:26 +08:00
|
|
|
* Avoiding the ct_irq_enter/exit() calls is an optimization but also
|
2020-07-23 05:59:58 +08:00
|
|
|
* solves the problem of kernel mode pagefaults which can schedule, which
|
2022-06-08 22:40:26 +08:00
|
|
|
* is not possible after invoking ct_irq_enter() without undoing it.
|
2020-07-23 05:59:58 +08:00
|
|
|
*
|
|
|
|
|
* For user mode entries irqentry_enter_from_user_mode() is invoked to
|
|
|
|
|
* establish the proper context for NOHZ_FULL. Otherwise scheduling on exit
|
|
|
|
|
* would not be possible.
|
|
|
|
|
*
|
|
|
|
|
* Returns: An opaque object that must be passed to idtentry_exit()
|
|
|
|
|
*/
|
|
|
|
|
irqentry_state_t noinstr irqentry_enter(struct pt_regs *regs);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irqentry_exit_cond_resched - Conditionally reschedule on return from interrupt
|
|
|
|
|
*
|
|
|
|
|
* Conditional reschedule with additional sanity checks.
|
|
|
|
|
*/
|
2022-02-15 00:52:12 +08:00
|
|
|
void raw_irqentry_exit_cond_resched(void);
|
2021-01-18 22:12:22 +08:00
|
|
|
#ifdef CONFIG_PREEMPT_DYNAMIC
|
sched/preempt: Add PREEMPT_DYNAMIC using static keys
Where an architecture selects HAVE_STATIC_CALL but not
HAVE_STATIC_CALL_INLINE, each static call has an out-of-line trampoline
which will either branch to a callee or return to the caller.
On such architectures, a number of constraints can conspire to make
those trampolines more complicated and potentially less useful than we'd
like. For example:
* Hardware and software control flow integrity schemes can require the
addition of "landing pad" instructions (e.g. `BTI` for arm64), which
will also be present at the "real" callee.
* Limited branch ranges can require that trampolines generate or load an
address into a register and perform an indirect branch (or at least
have a slow path that does so). This loses some of the benefits of
having a direct branch.
* Interaction with SW CFI schemes can be complicated and fragile, e.g.
requiring that we can recognise idiomatic codegen and remove
indirections understand, at least until clang proves more helpful
mechanisms for dealing with this.
For PREEMPT_DYNAMIC, we don't need the full power of static calls, as we
really only need to enable/disable specific preemption functions. We can
achieve the same effect without a number of the pain points above by
using static keys to fold early returns into the preemption functions
themselves rather than in an out-of-line trampoline, effectively
inlining the trampoline into the start of the function.
For arm64, this results in good code generation. For example, the
dynamic_cond_resched() wrapper looks as follows when enabled. When
disabled, the first `B` is replaced with a `NOP`, resulting in an early
return.
| <dynamic_cond_resched>:
| bti c
| b <dynamic_cond_resched+0x10> // or `nop`
| mov w0, #0x0
| ret
| mrs x0, sp_el0
| ldr x0, [x0, #8]
| cbnz x0, <dynamic_cond_resched+0x8>
| paciasp
| stp x29, x30, [sp, #-16]!
| mov x29, sp
| bl <preempt_schedule_common>
| mov w0, #0x1
| ldp x29, x30, [sp], #16
| autiasp
| ret
... compared to the regular form of the function:
| <__cond_resched>:
| bti c
| mrs x0, sp_el0
| ldr x1, [x0, #8]
| cbz x1, <__cond_resched+0x18>
| mov w0, #0x0
| ret
| paciasp
| stp x29, x30, [sp, #-16]!
| mov x29, sp
| bl <preempt_schedule_common>
| mov w0, #0x1
| ldp x29, x30, [sp], #16
| autiasp
| ret
Any architecture which implements static keys should be able to use this
to implement PREEMPT_DYNAMIC with similar cost to non-inlined static
calls. Since this is likely to have greater overhead than (inlined)
static calls, PREEMPT_DYNAMIC is only defaulted to enabled when
HAVE_PREEMPT_DYNAMIC_CALL is selected.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Ard Biesheuvel <ardb@kernel.org>
Acked-by: Frederic Weisbecker <frederic@kernel.org>
Link: https://lore.kernel.org/r/20220214165216.2231574-6-mark.rutland@arm.com
2022-02-15 00:52:14 +08:00
|
|
|
#if defined(CONFIG_HAVE_PREEMPT_DYNAMIC_CALL)
|
2022-02-15 00:52:12 +08:00
|
|
|
#define irqentry_exit_cond_resched_dynamic_enabled raw_irqentry_exit_cond_resched
|
2022-02-15 00:52:11 +08:00
|
|
|
#define irqentry_exit_cond_resched_dynamic_disabled NULL
|
2022-02-15 00:52:12 +08:00
|
|
|
DECLARE_STATIC_CALL(irqentry_exit_cond_resched, raw_irqentry_exit_cond_resched);
|
|
|
|
|
#define irqentry_exit_cond_resched() static_call(irqentry_exit_cond_resched)()
|
sched/preempt: Add PREEMPT_DYNAMIC using static keys
Where an architecture selects HAVE_STATIC_CALL but not
HAVE_STATIC_CALL_INLINE, each static call has an out-of-line trampoline
which will either branch to a callee or return to the caller.
On such architectures, a number of constraints can conspire to make
those trampolines more complicated and potentially less useful than we'd
like. For example:
* Hardware and software control flow integrity schemes can require the
addition of "landing pad" instructions (e.g. `BTI` for arm64), which
will also be present at the "real" callee.
* Limited branch ranges can require that trampolines generate or load an
address into a register and perform an indirect branch (or at least
have a slow path that does so). This loses some of the benefits of
having a direct branch.
* Interaction with SW CFI schemes can be complicated and fragile, e.g.
requiring that we can recognise idiomatic codegen and remove
indirections understand, at least until clang proves more helpful
mechanisms for dealing with this.
For PREEMPT_DYNAMIC, we don't need the full power of static calls, as we
really only need to enable/disable specific preemption functions. We can
achieve the same effect without a number of the pain points above by
using static keys to fold early returns into the preemption functions
themselves rather than in an out-of-line trampoline, effectively
inlining the trampoline into the start of the function.
For arm64, this results in good code generation. For example, the
dynamic_cond_resched() wrapper looks as follows when enabled. When
disabled, the first `B` is replaced with a `NOP`, resulting in an early
return.
| <dynamic_cond_resched>:
| bti c
| b <dynamic_cond_resched+0x10> // or `nop`
| mov w0, #0x0
| ret
| mrs x0, sp_el0
| ldr x0, [x0, #8]
| cbnz x0, <dynamic_cond_resched+0x8>
| paciasp
| stp x29, x30, [sp, #-16]!
| mov x29, sp
| bl <preempt_schedule_common>
| mov w0, #0x1
| ldp x29, x30, [sp], #16
| autiasp
| ret
... compared to the regular form of the function:
| <__cond_resched>:
| bti c
| mrs x0, sp_el0
| ldr x1, [x0, #8]
| cbz x1, <__cond_resched+0x18>
| mov w0, #0x0
| ret
| paciasp
| stp x29, x30, [sp, #-16]!
| mov x29, sp
| bl <preempt_schedule_common>
| mov w0, #0x1
| ldp x29, x30, [sp], #16
| autiasp
| ret
Any architecture which implements static keys should be able to use this
to implement PREEMPT_DYNAMIC with similar cost to non-inlined static
calls. Since this is likely to have greater overhead than (inlined)
static calls, PREEMPT_DYNAMIC is only defaulted to enabled when
HAVE_PREEMPT_DYNAMIC_CALL is selected.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Ard Biesheuvel <ardb@kernel.org>
Acked-by: Frederic Weisbecker <frederic@kernel.org>
Link: https://lore.kernel.org/r/20220214165216.2231574-6-mark.rutland@arm.com
2022-02-15 00:52:14 +08:00
|
|
|
#elif defined(CONFIG_HAVE_PREEMPT_DYNAMIC_KEY)
|
|
|
|
|
DECLARE_STATIC_KEY_TRUE(sk_dynamic_irqentry_exit_cond_resched);
|
|
|
|
|
void dynamic_irqentry_exit_cond_resched(void);
|
|
|
|
|
#define irqentry_exit_cond_resched() dynamic_irqentry_exit_cond_resched()
|
2021-01-18 22:12:22 +08:00
|
|
|
#endif
|
sched/preempt: Add PREEMPT_DYNAMIC using static keys
Where an architecture selects HAVE_STATIC_CALL but not
HAVE_STATIC_CALL_INLINE, each static call has an out-of-line trampoline
which will either branch to a callee or return to the caller.
On such architectures, a number of constraints can conspire to make
those trampolines more complicated and potentially less useful than we'd
like. For example:
* Hardware and software control flow integrity schemes can require the
addition of "landing pad" instructions (e.g. `BTI` for arm64), which
will also be present at the "real" callee.
* Limited branch ranges can require that trampolines generate or load an
address into a register and perform an indirect branch (or at least
have a slow path that does so). This loses some of the benefits of
having a direct branch.
* Interaction with SW CFI schemes can be complicated and fragile, e.g.
requiring that we can recognise idiomatic codegen and remove
indirections understand, at least until clang proves more helpful
mechanisms for dealing with this.
For PREEMPT_DYNAMIC, we don't need the full power of static calls, as we
really only need to enable/disable specific preemption functions. We can
achieve the same effect without a number of the pain points above by
using static keys to fold early returns into the preemption functions
themselves rather than in an out-of-line trampoline, effectively
inlining the trampoline into the start of the function.
For arm64, this results in good code generation. For example, the
dynamic_cond_resched() wrapper looks as follows when enabled. When
disabled, the first `B` is replaced with a `NOP`, resulting in an early
return.
| <dynamic_cond_resched>:
| bti c
| b <dynamic_cond_resched+0x10> // or `nop`
| mov w0, #0x0
| ret
| mrs x0, sp_el0
| ldr x0, [x0, #8]
| cbnz x0, <dynamic_cond_resched+0x8>
| paciasp
| stp x29, x30, [sp, #-16]!
| mov x29, sp
| bl <preempt_schedule_common>
| mov w0, #0x1
| ldp x29, x30, [sp], #16
| autiasp
| ret
... compared to the regular form of the function:
| <__cond_resched>:
| bti c
| mrs x0, sp_el0
| ldr x1, [x0, #8]
| cbz x1, <__cond_resched+0x18>
| mov w0, #0x0
| ret
| paciasp
| stp x29, x30, [sp, #-16]!
| mov x29, sp
| bl <preempt_schedule_common>
| mov w0, #0x1
| ldp x29, x30, [sp], #16
| autiasp
| ret
Any architecture which implements static keys should be able to use this
to implement PREEMPT_DYNAMIC with similar cost to non-inlined static
calls. Since this is likely to have greater overhead than (inlined)
static calls, PREEMPT_DYNAMIC is only defaulted to enabled when
HAVE_PREEMPT_DYNAMIC_CALL is selected.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Ard Biesheuvel <ardb@kernel.org>
Acked-by: Frederic Weisbecker <frederic@kernel.org>
Link: https://lore.kernel.org/r/20220214165216.2231574-6-mark.rutland@arm.com
2022-02-15 00:52:14 +08:00
|
|
|
#else /* CONFIG_PREEMPT_DYNAMIC */
|
|
|
|
|
#define irqentry_exit_cond_resched() raw_irqentry_exit_cond_resched()
|
|
|
|
|
#endif /* CONFIG_PREEMPT_DYNAMIC */
|
2020-07-23 05:59:58 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irqentry_exit - Handle return from exception that used irqentry_enter()
|
|
|
|
|
* @regs: Pointer to pt_regs (exception entry regs)
|
|
|
|
|
* @state: Return value from matching call to irqentry_enter()
|
|
|
|
|
*
|
|
|
|
|
* Depending on the return target (kernel/user) this runs the necessary
|
2020-11-05 07:01:57 +08:00
|
|
|
* preemption and work checks if possible and required and returns to
|
2020-07-23 05:59:58 +08:00
|
|
|
* the caller with interrupts disabled and no further work pending.
|
|
|
|
|
*
|
|
|
|
|
* This is the last action before returning to the low level ASM code which
|
|
|
|
|
* just needs to return to the appropriate context.
|
|
|
|
|
*
|
|
|
|
|
* Counterpart to irqentry_enter().
|
|
|
|
|
*/
|
|
|
|
|
void noinstr irqentry_exit(struct pt_regs *regs, irqentry_state_t state);
|
|
|
|
|
|
2020-11-03 04:53:16 +08:00
|
|
|
/**
|
|
|
|
|
* irqentry_nmi_enter - Handle NMI entry
|
|
|
|
|
* @regs: Pointer to currents pt_regs
|
|
|
|
|
*
|
|
|
|
|
* Similar to irqentry_enter() but taking care of the NMI constraints.
|
|
|
|
|
*/
|
|
|
|
|
irqentry_state_t noinstr irqentry_nmi_enter(struct pt_regs *regs);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* irqentry_nmi_exit - Handle return from NMI handling
|
|
|
|
|
* @regs: Pointer to pt_regs (NMI entry regs)
|
|
|
|
|
* @irq_state: Return value from matching call to irqentry_nmi_enter()
|
|
|
|
|
*
|
2020-11-05 07:01:57 +08:00
|
|
|
* Last action before returning to the low level assembly code.
|
2020-11-03 04:53:16 +08:00
|
|
|
*
|
|
|
|
|
* Counterpart to irqentry_nmi_enter().
|
|
|
|
|
*/
|
|
|
|
|
void noinstr irqentry_nmi_exit(struct pt_regs *regs, irqentry_state_t irq_state);
|
|
|
|
|
|
2020-07-23 05:59:56 +08:00
|
|
|
#endif
|