mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2026-02-28 19:06:51 +01:00
dd0a046069
The kernel sets SYSCALL_WORK_RSEQ_SLICE when it grants a time slice extension. This allows to handle the rseq_slice_yield() syscall, which is used by user space to relinquish the CPU after finishing the critical section for which it requested an extension. In case the kernel state is still GRANTED, the kernel resets both kernel and user space state with a set of sanity checks. If the kernel state is already cleared, then this raced against the timer or some other interrupt and just clears the work bit. Doing it in syscall entry work allows to catch misbehaving user space, which issues an arbitrary syscall, i.e. not rseq_slice_yield(), from the critical section. Contrary to the initial strict requirement to use rseq_slice_yield() arbitrary syscalls are not considered a violation of the ABI contract anymore to allow onion architecture applications, which cannot control the code inside a critical section, to utilize this as well. If the code detects inconsistent user space that result in a SIGSEGV for the application. If the grant was still active and the task was not preempted yet, the work code reschedules immediately before continuing through the syscall. Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org> Link: https://patch.msgid.link/20251215155709.005777059@linutronix.de
239 lines
6.7 KiB
C
239 lines
6.7 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/* thread_info.h: common low-level thread information accessors
|
|
*
|
|
* Copyright (C) 2002 David Howells (dhowells@redhat.com)
|
|
* - Incorporating suggestions made by Linus Torvalds
|
|
*/
|
|
|
|
#ifndef _LINUX_THREAD_INFO_H
|
|
#define _LINUX_THREAD_INFO_H
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/limits.h>
|
|
#include <linux/bug.h>
|
|
#include <linux/restart_block.h>
|
|
#include <linux/errno.h>
|
|
|
|
#ifdef CONFIG_THREAD_INFO_IN_TASK
|
|
/*
|
|
* For CONFIG_THREAD_INFO_IN_TASK kernels we need <asm/current.h> for the
|
|
* definition of current, but for !CONFIG_THREAD_INFO_IN_TASK kernels,
|
|
* including <asm/current.h> can cause a circular dependency on some platforms.
|
|
*/
|
|
#include <asm/current.h>
|
|
#define current_thread_info() ((struct thread_info *)current)
|
|
#endif
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
/*
|
|
* For per-arch arch_within_stack_frames() implementations, defined in
|
|
* asm/thread_info.h.
|
|
*/
|
|
enum {
|
|
BAD_STACK = -1,
|
|
NOT_STACK = 0,
|
|
GOOD_FRAME,
|
|
GOOD_STACK,
|
|
};
|
|
|
|
#ifdef CONFIG_GENERIC_ENTRY
|
|
enum syscall_work_bit {
|
|
SYSCALL_WORK_BIT_SECCOMP,
|
|
SYSCALL_WORK_BIT_SYSCALL_TRACEPOINT,
|
|
SYSCALL_WORK_BIT_SYSCALL_TRACE,
|
|
SYSCALL_WORK_BIT_SYSCALL_EMU,
|
|
SYSCALL_WORK_BIT_SYSCALL_AUDIT,
|
|
SYSCALL_WORK_BIT_SYSCALL_USER_DISPATCH,
|
|
SYSCALL_WORK_BIT_SYSCALL_EXIT_TRAP,
|
|
SYSCALL_WORK_BIT_SYSCALL_RSEQ_SLICE,
|
|
};
|
|
|
|
#define SYSCALL_WORK_SECCOMP BIT(SYSCALL_WORK_BIT_SECCOMP)
|
|
#define SYSCALL_WORK_SYSCALL_TRACEPOINT BIT(SYSCALL_WORK_BIT_SYSCALL_TRACEPOINT)
|
|
#define SYSCALL_WORK_SYSCALL_TRACE BIT(SYSCALL_WORK_BIT_SYSCALL_TRACE)
|
|
#define SYSCALL_WORK_SYSCALL_EMU BIT(SYSCALL_WORK_BIT_SYSCALL_EMU)
|
|
#define SYSCALL_WORK_SYSCALL_AUDIT BIT(SYSCALL_WORK_BIT_SYSCALL_AUDIT)
|
|
#define SYSCALL_WORK_SYSCALL_USER_DISPATCH BIT(SYSCALL_WORK_BIT_SYSCALL_USER_DISPATCH)
|
|
#define SYSCALL_WORK_SYSCALL_EXIT_TRAP BIT(SYSCALL_WORK_BIT_SYSCALL_EXIT_TRAP)
|
|
#define SYSCALL_WORK_SYSCALL_RSEQ_SLICE BIT(SYSCALL_WORK_BIT_SYSCALL_RSEQ_SLICE)
|
|
#endif
|
|
|
|
#include <asm/thread_info.h>
|
|
|
|
#ifndef TIF_NEED_RESCHED_LAZY
|
|
#ifdef CONFIG_ARCH_HAS_PREEMPT_LAZY
|
|
#error Inconsistent PREEMPT_LAZY
|
|
#endif
|
|
#define TIF_NEED_RESCHED_LAZY TIF_NEED_RESCHED
|
|
#define _TIF_NEED_RESCHED_LAZY _TIF_NEED_RESCHED
|
|
#endif
|
|
|
|
#ifndef TIF_RSEQ
|
|
# define TIF_RSEQ TIF_NOTIFY_RESUME
|
|
# define _TIF_RSEQ _TIF_NOTIFY_RESUME
|
|
#endif
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
#ifndef arch_set_restart_data
|
|
#define arch_set_restart_data(restart) do { } while (0)
|
|
#endif
|
|
|
|
static inline long set_restart_fn(struct restart_block *restart,
|
|
long (*fn)(struct restart_block *))
|
|
{
|
|
restart->fn = fn;
|
|
arch_set_restart_data(restart);
|
|
return -ERESTART_RESTARTBLOCK;
|
|
}
|
|
|
|
#ifndef THREAD_ALIGN
|
|
#define THREAD_ALIGN THREAD_SIZE
|
|
#endif
|
|
|
|
#define THREADINFO_GFP (GFP_KERNEL_ACCOUNT | __GFP_ZERO)
|
|
|
|
/*
|
|
* flag set/clear/test wrappers
|
|
* - pass TIF_xxxx constants to these functions
|
|
*/
|
|
|
|
static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
|
|
{
|
|
set_bit(flag, (unsigned long *)&ti->flags);
|
|
}
|
|
|
|
static inline void clear_ti_thread_flag(struct thread_info *ti, int flag)
|
|
{
|
|
clear_bit(flag, (unsigned long *)&ti->flags);
|
|
}
|
|
|
|
static inline void update_ti_thread_flag(struct thread_info *ti, int flag,
|
|
bool value)
|
|
{
|
|
if (value)
|
|
set_ti_thread_flag(ti, flag);
|
|
else
|
|
clear_ti_thread_flag(ti, flag);
|
|
}
|
|
|
|
static inline int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
|
|
{
|
|
return test_and_set_bit(flag, (unsigned long *)&ti->flags);
|
|
}
|
|
|
|
static inline int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
|
|
{
|
|
return test_and_clear_bit(flag, (unsigned long *)&ti->flags);
|
|
}
|
|
|
|
static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
|
|
{
|
|
return test_bit(flag, (unsigned long *)&ti->flags);
|
|
}
|
|
|
|
/*
|
|
* This may be used in noinstr code, and needs to be __always_inline to prevent
|
|
* inadvertent instrumentation.
|
|
*/
|
|
static __always_inline unsigned long read_ti_thread_flags(struct thread_info *ti)
|
|
{
|
|
return READ_ONCE(ti->flags);
|
|
}
|
|
|
|
#define set_thread_flag(flag) \
|
|
set_ti_thread_flag(current_thread_info(), flag)
|
|
#define clear_thread_flag(flag) \
|
|
clear_ti_thread_flag(current_thread_info(), flag)
|
|
#define update_thread_flag(flag, value) \
|
|
update_ti_thread_flag(current_thread_info(), flag, value)
|
|
#define test_and_set_thread_flag(flag) \
|
|
test_and_set_ti_thread_flag(current_thread_info(), flag)
|
|
#define test_and_clear_thread_flag(flag) \
|
|
test_and_clear_ti_thread_flag(current_thread_info(), flag)
|
|
#define test_thread_flag(flag) \
|
|
test_ti_thread_flag(current_thread_info(), flag)
|
|
#define read_thread_flags() \
|
|
read_ti_thread_flags(current_thread_info())
|
|
|
|
#define read_task_thread_flags(t) \
|
|
read_ti_thread_flags(task_thread_info(t))
|
|
|
|
#ifdef CONFIG_GENERIC_ENTRY
|
|
#define set_syscall_work(fl) \
|
|
set_bit(SYSCALL_WORK_BIT_##fl, ¤t_thread_info()->syscall_work)
|
|
#define test_syscall_work(fl) \
|
|
test_bit(SYSCALL_WORK_BIT_##fl, ¤t_thread_info()->syscall_work)
|
|
#define clear_syscall_work(fl) \
|
|
clear_bit(SYSCALL_WORK_BIT_##fl, ¤t_thread_info()->syscall_work)
|
|
|
|
#define set_task_syscall_work(t, fl) \
|
|
set_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)
|
|
#define test_task_syscall_work(t, fl) \
|
|
test_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)
|
|
#define clear_task_syscall_work(t, fl) \
|
|
clear_bit(SYSCALL_WORK_BIT_##fl, &task_thread_info(t)->syscall_work)
|
|
|
|
#else /* CONFIG_GENERIC_ENTRY */
|
|
|
|
#define set_syscall_work(fl) \
|
|
set_ti_thread_flag(current_thread_info(), TIF_##fl)
|
|
#define test_syscall_work(fl) \
|
|
test_ti_thread_flag(current_thread_info(), TIF_##fl)
|
|
#define clear_syscall_work(fl) \
|
|
clear_ti_thread_flag(current_thread_info(), TIF_##fl)
|
|
|
|
#define set_task_syscall_work(t, fl) \
|
|
set_ti_thread_flag(task_thread_info(t), TIF_##fl)
|
|
#define test_task_syscall_work(t, fl) \
|
|
test_ti_thread_flag(task_thread_info(t), TIF_##fl)
|
|
#define clear_task_syscall_work(t, fl) \
|
|
clear_ti_thread_flag(task_thread_info(t), TIF_##fl)
|
|
#endif /* !CONFIG_GENERIC_ENTRY */
|
|
|
|
#ifdef _ASM_GENERIC_BITOPS_INSTRUMENTED_NON_ATOMIC_H
|
|
|
|
static __always_inline bool tif_test_bit(int bit)
|
|
{
|
|
return arch_test_bit(bit,
|
|
(unsigned long *)(¤t_thread_info()->flags));
|
|
}
|
|
|
|
#else
|
|
|
|
static __always_inline bool tif_test_bit(int bit)
|
|
{
|
|
return test_bit(bit,
|
|
(unsigned long *)(¤t_thread_info()->flags));
|
|
}
|
|
|
|
#endif /* _ASM_GENERIC_BITOPS_INSTRUMENTED_NON_ATOMIC_H */
|
|
|
|
static __always_inline bool tif_need_resched(void)
|
|
{
|
|
return tif_test_bit(TIF_NEED_RESCHED);
|
|
}
|
|
|
|
#ifndef CONFIG_HAVE_ARCH_WITHIN_STACK_FRAMES
|
|
static inline int arch_within_stack_frames(const void * const stack,
|
|
const void * const stackend,
|
|
const void *obj, unsigned long len)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef arch_setup_new_exec
|
|
static inline void arch_setup_new_exec(void) { }
|
|
#endif
|
|
|
|
void arch_task_cache_init(void); /* for CONFIG_SH */
|
|
void arch_release_task_struct(struct task_struct *tsk);
|
|
int arch_dup_task_struct(struct task_struct *dst,
|
|
struct task_struct *src);
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
#endif /* _LINUX_THREAD_INFO_H */
|