Syscall User Dispatch
Subsystems (12)
v7 cover Syscall User Dispatch
Hi,
This is the v7 of syscall user dispatch. This version is a bit different from v6 on the following points, after the modifications requested on that submission.
* The interface no longer receives <start>,<end> end parameters, but <start>,<length> as suggested by PeterZ.
* Syscall User Dispatch is now done before ptrace, and this means there is some SYSCALL_WORK_EXIT work that needs to be done. No challenges there, but I'd like to draw attention to that region of the code that is new in this submission.
* The previous TIF_SYSCALL_USER_DISPATCH is now handled through SYSCALL_WORK flags.
* Introduced a new test as patch 6, which benchmarks the fast submission path and test the return in blocked selector state.
* Nothing is architecture dependent anymore. No config switches. It only depends on CONFIG_GENERIC_ENTRY.
Other smaller changes are documented one each commit.
This was tested using the kselftests tests in patch 5 and 6 and compiled tested with !CONFIG_GENERIC_ENTRY.
This patchset is based on the core/entry branch of the TIP tree.
A working tree with this patchset is available at:
https://gitlab.collabora.com/krisman/linux -b syscall-user-dispatch-v7
Previous submissions are archived at:
RFC/v1: https://lkml.org/lkml/2020/7/8/96
v2: https://lkml.org/lkml/2020/7/9/17
v3: https://lkml.org/lkml/2020/7/12/4
v4: https://www.spinics.net/lists/linux-kselftest/msg16377.html
v5: https://lkml.org/lkml/2020/8/10/1320
v6: https://lkml.org/lkml/2020/9/4/1122
Gabriel Krisman Bertazi (7):
x86: vdso: Expose sigreturn address on vdso to the kernel
signal: Expose SYS_USER_DISPATCH si_code type
kernel: Implement selective syscall userspace redirection
entry: Support Syscall User Dispatch on common syscall entry
selftests: Add kselftest for syscall user dispatch
selftests: Add benchmark for syscall user dispatch
docs: Document Syscall User Dispatch
.../admin-guide/syscall-user-dispatch.rst | 87 +++++ arch/x86/entry/vdso/vdso2c.c | 2 + arch/x86/entry/vdso/vdso32/sigreturn.S | 2 + arch/x86/entry/vdso/vma.c | 15 + arch/x86/include/asm/elf.h | 2 + arch/x86/include/asm/vdso.h | 2 + arch/x86/kernel/signal_compat.c | 2 +- fs/exec.c | 3 + include/linux/entry-common.h | 2 + include/linux/sched.h | 2 + include/linux/syscall_user_dispatch.h | 40 +++ include/linux/thread_info.h | 2 + include/uapi/asm-generic/siginfo.h | 3 +- include/uapi/linux/prctl.h | 5 + kernel/entry/Makefile | 2 +- kernel/entry/common.c | 17 + kernel/entry/common.h | 16 + kernel/entry/syscall_user_dispatch.c | 102 ++++++ kernel/fork.c | 1 + kernel/sys.c | 5 + tools/testing/selftests/Makefile | 1 + .../syscall_user_dispatch/.gitignore | 3 + .../selftests/syscall_user_dispatch/Makefile | 9 + .../selftests/syscall_user_dispatch/config | 1 + .../syscall_user_dispatch/sud_benchmark.c | 200 +++++++++++ .../syscall_user_dispatch/sud_test.c | 310 ++++++++++++++++++ 26 files changed, 833 insertions(+), 3 deletions(-) create mode 100644 Documentation/admin-guide/syscall-user-dispatch.rst create mode 100644 include/linux/syscall_user_dispatch.h create mode 100644 kernel/entry/common.h create mode 100644 kernel/entry/syscall_user_dispatch.c create mode 100644 tools/testing/selftests/syscall_user_dispatch/.gitignore create mode 100644 tools/testing/selftests/syscall_user_dispatch/Makefile create mode 100644 tools/testing/selftests/syscall_user_dispatch/config create mode 100644 tools/testing/selftests/syscall_user_dispatch/sud_benchmark.c create mode 100644 tools/testing/selftests/syscall_user_dispatch/sud_test.c
Signature · 1 line
2.29.2
PATCH v7 1/7 x86: vdso: Expose sigreturn address on vdso to the kernel
Syscall user redirection requires the signal trampoline code to not be captured, in order to support returning with a locked selector while avoiding recursion back into the signal handler. For ia-32, which has the trampoline in the vDSO, expose the entry points to the kernel, such that it can avoid dispatching syscalls from that region to userspace.
---
Changes since V5
- Change return address to bool (Andy)
--- arch/x86/entry/vdso/vdso2c.c | 2 ++ arch/x86/entry/vdso/vdso32/sigreturn.S | 2 ++ arch/x86/entry/vdso/vma.c | 15 +++++++++++++++ arch/x86/include/asm/elf.h | 2 ++ arch/x86/include/asm/vdso.h | 2 ++ 5 files changed, 23 insertions(+)
arch/x86/entry/vdso/vdso2c.c +2 -0
@@ -101,6 +101,8 @@ struct vdso_sym required_syms[] = { {"__kernel_sigreturn", true}, {"__kernel_rt_sigreturn", true}, {"int80_landing_pad", true}, + {"vdso32_rt_sigreturn_landing_pad", true}, + {"vdso32_sigreturn_landing_pad", true}, }; __attribute__((format(printf, 1, 2))) __attribute__((noreturn))
arch/x86/entry/vdso/vdso32/sigreturn.S +2 -0
@@ -18,6 +18,7 @@ __kernel_sigreturn: movl $__NR_sigreturn, %eax SYSCALL_ENTER_KERNEL .LEND_sigreturn: +SYM_INNER_LABEL(vdso32_sigreturn_landing_pad, SYM_L_GLOBAL) nop .size __kernel_sigreturn,.-.LSTART_sigreturn
@@ -29,6 +30,7 @@ __kernel_rt_sigreturn: movl $__NR_rt_sigreturn, %eax SYSCALL_ENTER_KERNEL .LEND_rt_sigreturn: +SYM_INNER_LABEL(vdso32_rt_sigreturn_landing_pad, SYM_L_GLOBAL) nop .size __kernel_rt_sigreturn,.-.LSTART_rt_sigreturn .previous
arch/x86/entry/vdso/vma.c +15 -0
@@ -436,6 +436,21 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) }#endif +bool arch_syscall_is_vdso_sigreturn (struct pt_regs *regs) +{ +#if defined(CONFIG_X86_32 ) || defined(CONFIG_IA32_EMULATION ) +const struct vdso_image *image = current->mm->context.vdso_image; +unsigned long vdso = (unsigned long ) current->mm->context.vdso; + +if (in_ia32_syscall () && image == &vdso_image_32) { +if (regs->ip == vdso + image->sym_vdso32_sigreturn_landing_pad || + regs->ip == vdso + image->sym_vdso32_rt_sigreturn_landing_pad) +return true; + } +#endif +return false; +} +#ifdef CONFIG_X86_64 static __init int vdso_setup (char *s) {
arch/x86/include/asm/elf.h +2 -0
@@ -388,6 +388,8 @@ extern int compat_arch_setup_additional_pages(struct linux_binprm *bprm,compat_arch_setup_additional_pages (bprm, interpreter, \ (ex->e_machine == EM_X86_64)) +extern bool arch_syscall_is_vdso_sigreturn (struct pt_regs *regs); +/* Do not change the values. See get_align_mask() */ enum align_flags {ALIGN_VA_32 =BIT (0 ),
arch/x86/include/asm/vdso.h +2 -0
@@ -27,6 +27,8 @@ struct vdso_image {long sym___kernel_rt_sigreturn;long sym___kernel_vsyscall;long sym_int80_landing_pad; +long sym_vdso32_sigreturn_landing_pad; +long sym_vdso32_rt_sigreturn_landing_pad; };#ifdef CONFIG_X86_64
Signature · 1 line
2.29.2
PATCH v7 2/7 signal: Expose SYS_USER_DISPATCH si_code type
In reply to Gabriel Krisman BertaziSYS_USER_DISPATCH will be triggered when a syscall is sent to userspace by the Syscall User Dispatch mechanism. This adjusts eventual BUILD_BUG_ON around the tree.
--- arch/x86/kernel/signal_compat.c | 2 +- include/uapi/asm-generic/siginfo.h | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-)
arch/x86/kernel/signal_compat.c +1 -1
@@ -31,7 +31,7 @@ static inline void signal_compat_build_tests(void)BUILD_BUG_ON (NSIGBUS !=5 );BUILD_BUG_ON (NSIGTRAP !=5 );BUILD_BUG_ON (NSIGCHLD !=6 ); -BUILD_BUG_ON (NSIGSYS !=1 ); +BUILD_BUG_ON (NSIGSYS !=2 );/* This is part of the ABI and can never change in size: */ BUILD_BUG_ON (sizeof (compat_siginfo_t) !=128 );
include/uapi/asm-generic/siginfo.h +2 -1
@@ -286,7 +286,8 @@ typedef struct siginfo {* SIGSYS si_codes */ #define SYS_SECCOMP 1/* seccomp triggered */ -#define NSIGSYS 1 +#define SYS_USER_DISPATCH 2/* syscall user dispatch triggered */ +#define NSIGSYS 2/* * SIGEMT si_codes
Signature · 1 line
2.29.2
PATCH v7 3/7 kernel: Implement selective syscall userspace redirection
In reply to Gabriel Krisman BertaziIntroduce a mechanism to quickly disable/enable syscall handling for a specific process and redirect to userspace via SIGSYS. This is useful for processes with parts that require syscall redirection and parts that don't, but who need to perform this boundary crossing really fast, without paying the cost of a system call to reconfigure syscall handling on each boundary transition. This is particularly important for Windows games running over Wine.
The proposed interface looks like this:
prctl(PR_SET_SYSCALL_USER_DISPATCH, <op>, <off>, <length>, [selector])
The range [<offset>,<offset>+len] is a part of the process memory map that is allowed to by-pass the redirection code and dispatch syscalls directly, such that in fast paths a process doesn't need to disable the trap nor the kernel has to check the selector. This is essential to return from SIGSYS to a blocked area without triggering another SIGSYS from rt_sigreturn.
selector is an optional pointer to a char-sized userspace memory region that has a key switch for the mechanism. This key switch is set to either PR_SYS_DISPATCH_ON, PR_SYS_DISPATCH_OFF to enable and disable the redirection without calling the kernel.
The feature is meant to be set per-thread and it is disabled on fork/clone/execv.
Internally, this doesn't add overhead to the syscall hot path, and it requires very little per-architecture support. I avoided using seccomp, even though it duplicates some functionality, due to previous feedback that maybe it shouldn't mix with seccomp since it is not a security mechanism. And obviously, this should never be considered a security mechanism, since any part of the program can by-pass it by using the syscall dispatcher.
For the sysinfo benchmark, which measures the overhead added to executing a native syscall that doesn't require interception, the overhead using only the direct dispatcher region to issue syscalls is pretty much irrelevant. The overhead of using the selector goes around 40ns for a native (unredirected) syscall in my system, and it is (as expected) dominated by the supervisor-mode user-address access. In fact, with SMAP off, the overhead is consistently less than 5ns on my test box.
---
Changes since v6:
(Matthew Wilcox)
- Use unsigned long for mode
(peterZ)
- Change interface to {offset,len}
- Use SYSCALL_WORK interface instead of TIF flags
Changes since v4:
(Andy Lutomirski)
- Allow sigreturn coming from vDSO
- Exit with SIGSYS instead of SIGSEGV on bad selector (Thomas Gleixner)
- Use sizeof selector in access_ok
- Document usage of __get_user
- Use constant for state value
- Split out x86 parts
- Rebase on top of Gleixner's common entry code
- Don't expose do_syscall_user_dispatch
Changes since v3:
- NTR.
Changes since v2:
(Matthew Wilcox suggestions)
- Drop __user on non-ptr type.
- Move #define closer to similar defs
- Allow a memory region that can dispatch directly (Kees Cook suggestions)
- Improve kconfig summary line
- Move flag cleanup on execve to begin_new_exec
- Hint branch predictor in the syscall path (Me)
- Convert selector to char
Changes since RFC:
(Kees Cook suggestions)
- Don't mention personality while explaining the feature
- Use syscall_get_nr
- Remove header guard on several places
- Convert WARN_ON to WARN_ON_ONCE
- Explicit check for state values
- Rename to syscall user dispatcher
--- fs/exec.c | 3 + include/linux/sched.h | 2 + include/linux/syscall_user_dispatch.h | 40 ++++++++++ include/linux/thread_info.h | 2 + include/uapi/linux/prctl.h | 5 ++ kernel/entry/Makefile | 2 +- kernel/entry/common.h | 16 ++++ kernel/entry/syscall_user_dispatch.c | 102 ++++++++++++++++++++++++++ kernel/fork.c | 1 + kernel/sys.c | 5 ++ 10 files changed, 177 insertions(+), 1 deletion(-) create mode 100644 include/linux/syscall_user_dispatch.h create mode 100644 kernel/entry/common.h create mode 100644 kernel/entry/syscall_user_dispatch.c
fs/exec.c +3 -0
@@ -64,6 +64,7 @@#include <linux/compat.h> #include <linux/vmalloc.h> #include <linux/io_uring.h> +#include <linux/syscall_user_dispatch.h> #include <linux/uaccess.h> #include <asm/mmu_context.h>
@@ -1302,6 +1303,8 @@ int begin_new_exec(struct linux_binprm * bprm)flush_thread (); me->personality &= ~bprm->per_clear; +clear_syscall_work_syscall_user_dispatch (me); +/* * We have to apply CLOEXEC before we change whether the process is * dumpable (in setup_new_exec) to avoid a race with a process in userspace
include/linux/sched.h +2 -0
@@ -34,6 +34,7 @@#include <linux/rseq.h> #include <linux/seqlock.h> #include <linux/kcsan.h> +#include <linux/syscall_user_dispatch.h> /* task_struct member predeclarations (sorted alphabetically): */ struct audit_context ;
@@ -965,6 +966,7 @@ struct task_struct {unsigned int sessionid;#endif struct seccomp seccomp; +struct syscall_user_dispatch syscall_dispatch;/* Thread group tracking: */ u64 parent_exec_id;
include/linux/syscall_user_dispatch.h new file +40 -0
@@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Collabora Ltd. +*/ +#ifndef _SYSCALL_USER_DISPATCH_H +#define _SYSCALL_USER_DISPATCH_H + +#include <linux/thread_info.h> + +#ifdef CONFIG_GENERIC_ENTRY + +struct syscall_user_dispatch { +char __user *selector; +unsigned long offset; +unsigned long len; +bool on_dispatch; +}; + +int set_syscall_user_dispatch (unsigned long mode,unsigned long offset, +unsigned long len,char __user *selector); + +#define clear_syscall_work_syscall_user_dispatch (tsk) \ + clear_task_syscall_work(tsk, SYSCALL_USER_DISPATCH) + +#else +struct syscall_user_dispatch {}; + +static inline int set_syscall_user_dispatch (unsigned long mode,unsigned long offset, +unsigned long len,char __user *selector) +{ +return -EINVAL ; +} + +static inline void clear_syscall_work_syscall_user_dispatch (struct task_struct *tsk) +{ +} + +#endif /* CONFIG_GENERIC_ENTRY */ + +#endif /* _SYSCALL_USER_DISPATCH_H */
include/linux/thread_info.h +2 -0
@@ -41,6 +41,7 @@ enum syscall_work_bit {SYSCALL_WORK_BIT_SYSCALL_TRACE ,SYSCALL_WORK_BIT_SYSCALL_EMU ,SYSCALL_WORK_BIT_SYSCALL_AUDIT , + SYSCALL_WORK_BIT_SYSCALL_USER_DISPATCH, };#define SYSCALL_WORK_SECCOMP BIT(SYSCALL_WORK_BIT_SECCOMP)
@@ -48,6 +49,7 @@ enum syscall_work_bit {#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)#include <asm/thread_info.h>
include/uapi/linux/prctl.h +5 -0
@@ -247,4 +247,9 @@ struct prctl_mm_map {#define PR_SET_IO_FLUSHER 57#define PR_GET_IO_FLUSHER 58 +/* Dispatch syscalls to a userspace handler */ +#define PR_SET_SYSCALL_USER_DISPATCH 59 +# define PR_SYS_DISPATCH_OFF 0 +# define PR_SYS_DISPATCH_ON 1 +#endif /* _LINUX_PRCTL_H */
kernel/entry/Makefile +1 -1
@@ -9,5 +9,5 @@ KCOV_INSTRUMENT := n CFLAGS_REMOVE_common.o = -fstack-protector -fstack-protector-strong CFLAGS_common.o += -fno-stack-protector -obj-$(CONFIG_GENERIC_ENTRY) += common.o +obj-$(CONFIG_GENERIC_ENTRY) += common.o syscall_user_dispatch.o obj-$(CONFIG_KVM_XFER_TO_GUEST_WORK) += kvm.o
kernel/entry/common.h new file +16 -0
@@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _COMMON_H +#define _COMMON_H + +bool do_syscall_user_dispatch (struct pt_regs *regs); + +static inline bool on_syscall_dispatch (void ) +{ +if (unlikely (current->syscall_dispatch.on_dispatch)) { + current->syscall_dispatch.on_dispatch = false; +return true; + } +return false; +} + +#endif
kernel/entry/syscall_user_dispatch.c new file +102 -0
102 lines not on this page · raw message
kernel/fork.c +1 -0
@@ -906,6 +906,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node)clear_user_return_notifier (tsk);clear_tsk_need_resched (tsk);set_task_stack_end_magic (tsk); +clear_syscall_work_syscall_user_dispatch (tsk);#ifdef CONFIG_STACKPROTECTOR tsk->stack_canary =get_random_canary ();
kernel/sys.c +5 -0
@@ -42,6 +42,7 @@#include <linux/syscore_ops.h> #include <linux/version.h> #include <linux/ctype.h> +#include <linux/syscall_user_dispatch.h> #include <linux/compat.h> #include <linux/syscalls.h>
@@ -2530,6 +2531,10 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, error = (current->flags &PR_IO_FLUSHER ) ==PR_IO_FLUSHER ;break ; +case PR_SET_SYSCALL_USER_DISPATCH : + error =set_syscall_user_dispatch (arg2, arg3, arg4, + (char __user *) arg5); +break ;default : error = -EINVAL ;break ;
Signature · 1 line
2.29.2
Peter Zijlstra
maintainerRe: [PATCH v7 3/7] kernel: Implement selective syscall userspace redirection
Review
Quoted 6 lines · Gabriel Krisman Bertazi
prctl(PR_SET_SYSCALL_USER_DISPATCH, <op>, <off>, <length>, [selector])The range [<offset>,<offset>+len] is a part of the process memory map
(quoted diff) +2
-0+ if (likely(instruction_pointer(regs) - sd->offset < sd->len)) + return false;
The actual implementation ^ is: [<offset>, <offset>+<length>).
Which seems consistent and right, so I would suggest simply changing the Changelog, something that could be done when applying.
Re: [PATCH v7 3/7] kernel: Implement selective syscall userspace redirection
In reply to Gabriel Krisman BertaziQuoted 7 lines · Gabriel Krisman Bertazi
Introduce a mechanism to quickly disable/enable syscall handling for a specific process and redirect to userspace via SIGSYS. This is useful for processes with parts that require syscall redirection and parts that don't, but who need to perform this boundary crossing really fast, without paying the cost of a system call to reconfigure syscall handling on each boundary transition. This is particularly important for Windows games running over Wine.
I raised a discussion about this on libc-alpha, as requested by Florian. At the moment, there was some back and forth on why the use-case is not done by seccomp, but a more interesting point about user_notif was raised by Rich Felker (cc'ed).
SIGSYS, as a signal handler, is limited in what can be done inside it. Rich suggested the user_notif design is a better solution. I understand that from a Wine perspective, SIGSYS suffices for their work, but would it make sense to extend SUD interface to support a user_notif-like interface? Would this be acceptable as future work to be added when/if needed, or should we design it from the start?
The existing interface could be extended with a flags field as part of the opcode passed in argument 2, which is currently reserved, and then return a FD, just like seccomp(2) does. So it is not like the current patches couldn't be extended in the future if needed, unless I'm mistaken.
Signature · 1 line
Gabriel Krisman Bertazi
Re: [PATCH v7 3/7] kernel: Implement selective syscall userspace redirection
Quoted 5 lines · Gabriel Krisman Bertazi
The existing interface could be extended with a flags field as part of the opcode passed in argument 2, which is currently reserved, and then return a FD, just like seccomp(2) does. So it is not like the current patches couldn't be extended in the future if needed, unless I'm mistaken.
Yes, I'd prefer this series go in as-is, and if there is a need for extending the API, arg2 can have more values added.
Signature · 1 line
Kees Cook
Andy Lutomirski
maintainerRe: [PATCH v7 3/7] kernel: Implement selective syscall userspace redirection
Quoted 10 lines · Kees Cook
Quoted 5 lines · Gabriel Krisman Bertazi
The existing interface could be extended with a flags field as part of the opcode passed in argument 2, which is currently reserved, and then return a FD, just like seccomp(2) does. So it is not like the current patches couldn't be extended in the future if needed, unless I'm mistaken.
Yes, I'd prefer this series go in as-is, and if there is a need for extending the API, arg2 can have more values added.
I agree.
Quoted 3 lines
--
Kees Cook
PATCH v7 4/7 entry: Support Syscall User Dispatch on common syscall entry
In reply to Gabriel Krisman BertaziSyscall User Dispatch (SUD) must take precedence over seccomp and ptrace, since the use case is emulation (it can be invoked with a different ABI) such that seccomp filtering by syscall number doesn't make sense in the first place. In addition, either the syscall is dispatched back to userspace, in which case there is no resource for to trace, or the syscall will be executed, and seccomp/ptrace will execute next.
Since SUD runs before tracepoints, it needs to be a SYSCALL_WORK_EXIT as well, just to prevent a trace exit event when dispatch was triggered. For that, the on_syscall_dispatch() examines context to skip the tracepoint, audit and other work.
---
Changes since v6:
- Update do_syscall_intercept signature (Christian Brauner)
- Move it to before tracepoints
- Use SYSCALL_WORK flags
--- include/linux/entry-common.h | 2 ++ kernel/entry/common.c | 17 +++++++++++++++++ 2 files changed, 19 insertions(+)
include/linux/entry-common.h +2 -0
@@ -44,10 +44,12 @@ SYSCALL_WORK_SYSCALL_TRACE | \ SYSCALL_WORK_SYSCALL_EMU | \ SYSCALL_WORK_SYSCALL_AUDIT | \ + SYSCALL_WORK_SYSCALL_USER_DISPATCH | \ ARCH_SYSCALL_WORK_ENTER)#define SYSCALL_WORK_EXIT (SYSCALL_WORK_SYSCALL_TRACEPOINT | \ SYSCALL_WORK_SYSCALL_TRACE | \ SYSCALL_WORK_SYSCALL_AUDIT | \ + SYSCALL_WORK_SYSCALL_USER_DISPATCH | \ ARCH_SYSCALL_WORK_EXIT)/*
kernel/entry/common.c +17 -0
@@ -5,6 +5,8 @@#include <linux/livepatch.h> #include <linux/audit.h> +#include "common.h" +#define CREATE_TRACE_POINTS #include <trace/events/syscalls.h>
@@ -46,6 +48,16 @@ static long syscall_trace_enter(struct pt_regs *regs, long syscall, {long ret =0 ; +/* +* Handle Syscall User Dispatch. This must comes first, since +* the ABI here can be something that doesn't make sense for +* other syscall_work features. +*/ +if (work &SYSCALL_WORK_SYSCALL_USER_DISPATCH ) { +if (do_syscall_user_dispatch (regs)) +return -1L ; + } +/* Handle ptrace */ if (work & (SYSCALL_WORK_SYSCALL_TRACE |SYSCALL_WORK_SYSCALL_EMU )) { ret =arch_syscall_enter_tracehook (regs);
@@ -230,6 +242,11 @@ static void syscall_exit_work(struct pt_regs *regs, unsigned long work) {bool step; +if (work &SYSCALL_WORK_SYSCALL_USER_DISPATCH ) { +if (on_syscall_dispatch ()) +return ; + } +audit_syscall_exit (regs);if (work &SYSCALL_WORK_SYSCALL_TRACEPOINT )
Signature · 1 line
2.29.2
PATCH v7 5/7 selftests: Add kselftest for syscall user dispatch
In reply to Gabriel Krisman BertaziImplement functionality tests for syscall user dispatch. In order to make the test portable, refrain from open coding syscall dispatchers and calculating glibc memory ranges.
---
Changes since v6:
- Update selftests to reflect {offset,len} api change
Changes since v4:
- Update bad selector test to reflect change in API
Changes since v3:
- Sort entry in Makefile
- Add SPDX header
- Use __NR_syscalls if available
--- tools/testing/selftests/Makefile | 1 + .../syscall_user_dispatch/.gitignore | 3 + .../selftests/syscall_user_dispatch/Makefile | 9 + .../selftests/syscall_user_dispatch/config | 1 + .../syscall_user_dispatch/sud_test.c | 310 ++++++++++++++++++ 5 files changed, 324 insertions(+) create mode 100644 tools/testing/selftests/syscall_user_dispatch/.gitignore create mode 100644 tools/testing/selftests/syscall_user_dispatch/Makefile create mode 100644 tools/testing/selftests/syscall_user_dispatch/config create mode 100644 tools/testing/selftests/syscall_user_dispatch/sud_test.c
tools/testing/selftests/Makefile +1 -0
@@ -56,6 +56,7 @@ TARGETS += sparc64 TARGETS += splice TARGETS += static_keys TARGETS += sync +TARGETS += syscall_user_dispatch TARGETS += sysctl TARGETS += tc-testing TARGETS += timens
tools/testing/selftests/syscall_user_dispatch/.gitignore new file +3 -0
@@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0-only +sud_test +sud_benchmark
tools/testing/selftests/syscall_user_dispatch/Makefile new file +9 -0
@@ -0,0 +1,9 @@ +# SPDX-License-Identifier: GPL-2.0 +top_srcdir = ../../../.. +INSTALL_HDR_PATH = $(top_srcdir)/usr +LINUX_HDR_PATH = $(INSTALL_HDR_PATH)/include/ + +CFLAGS += -Wall -I$(LINUX_HDR_PATH) + +TEST_GEN_PROGS := sud_test +include ../lib.mk
tools/testing/selftests/syscall_user_dispatch/config new file +1 -0
@@ -0,0 +1 @@ +CONFIG_GENERIC_ENTRY=y
tools/testing/selftests/syscall_user_dispatch/sud_test.c new file +310 -0
310 lines not on this page · raw message
Signature · 1 line
2.29.2
PATCH v7 6/7 selftests: Add benchmark for syscall user dispatch
In reply to Gabriel Krisman BertaziThis is the patch I'm using to evaluate the impact syscall user dispatch has on native syscall (syscalls not redirected to userspace) when enabled for the process and submiting syscalls though the unblocked dispatch selector. It works by running a step to define a baseline of the cost of executing sysinfo, then enabling SUD, and rerunning that step.
On my test machine, an AMD Ryzen 5 1500X, I have the following results with the latest version of syscall user dispatch patches.
root@olga:~# syscall_user_dispatch/sud_benchmark Calibrating test set to last ~5 seconds... test iterations = 37500000 Avg syscall time 134ns. Caught sys_ff00 trapped_call_count 1, native_call_count 0. Avg syscall time 147ns. Interception overhead: 9.7% (+13ns).
--- .../selftests/syscall_user_dispatch/Makefile | 2 +- .../syscall_user_dispatch/sud_benchmark.c | 200 ++++++++++++++++++ 2 files changed, 201 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/syscall_user_dispatch/sud_benchmark.c
tools/testing/selftests/syscall_user_dispatch/Makefile +1 -1
@@ -5,5 +5,5 @@ LINUX_HDR_PATH = $(INSTALL_HDR_PATH)/include/ CFLAGS += -Wall -I$(LINUX_HDR_PATH) -TEST_GEN_PROGS := sud_test +TEST_GEN_PROGS := sud_test sud_benchmark include ../lib.mk
tools/testing/selftests/syscall_user_dispatch/sud_benchmark.c new file +200 -0
200 lines not on this page · raw message
Signature · 1 line
2.29.2
PATCH v7 7/7 docs: Document Syscall User Dispatch
In reply to Gabriel Krisman BertaziExplain the interface, provide some background and security notes.
--- .../admin-guide/syscall-user-dispatch.rst | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 Documentation/admin-guide/syscall-user-dispatch.rst
Documentation/admin-guide/syscall-user-dispatch.rst new file +87 -0
@@ -0,0 +1,87 @@ +.. SPDX-License-Identifier: GPL-2.0 + +===================== +Syscall User Dispatch +===================== + +Background +---------- + +Compatibility layers like Wine need a way to efficiently emulate system +calls of only a part of their process - the part that has the +incompatible code - while being able to execute native syscalls without +a high performance penalty on the native part of the process. Seccomp +falls short on this task, since it has limited support to efficiently +filter syscalls based on memory regions, and it doesn't support removing +filters. Therefore a new mechanism is necessary. + +Syscall User Dispatch brings the filtering of the syscall dispatcher +address back to userspace. The application is in control of a flip +switch, indicating the current personality of the process. A +multiple-personality application can then flip the switch without +invoking the kernel, when crossing the compatibility layer API +boundaries, to enable/disable the syscall redirection and execute +syscalls directly (disabled) or send them to be emulated in userspace +through a SIGSYS. + +The goal of this design is to provide very quick compatibility layer +boundary crosses, which is achieved by not executing a syscall to change +personality every time the compatibility layer executes. Instead, a +userspace memory region exposed to the kernel indicates the current +personality, and the application simply modifies that variable to +configure the mechanism. + +There is a relatively high cost associated with handling signals on most +architectures, like x86, but at least for Wine, syscalls issued by +native Windows code are currently not known to be a performance problem, +since they are quite rare, at least for modern gaming applications. + +Since this mechanism is designed to capture syscalls issued by +non-native applications, it must function on syscalls whose invocation +ABI is completely unexpected to Linux. Syscall User Dispatch, therefore +doesn't rely on any of the syscall ABI to make the filtering. It uses +only the syscall dispatcher address and the userspace key. + +Interface +--------- + +A process can setup this mechanism on supported kernels +CONFIG_SYSCALL_USER_DISPATCH) by executing the following prctl: + + prctl(PR_SET_SYSCALL_USER_DISPATCH, <op>, <offset>, <length>, [selector]) + +<op> is either PR_SYS_DISPATCH_ON or PR_SYS_DISPATCH_OFF, to enable and +disable the mechanism globally for that thread. When +PR_SYS_DISPATCH_OFF is used, the other fields must be zero. + +<offset> and <offset+length> delimit a closed memory region interval +from which syscalls are always executed directly, regardless of the +userspace selector. This provides a fast path for the C library, which +includes the most common syscall dispatchers in the native code +applications, and also provides a way for the signal handler to return +without triggering a nested SIGSYS on (rt_)sigreturn. Users of this +interface should make sure that at least the signal trampoline code is +included in this region. In addition, for syscalls that implement the +trampoline code on the vDSO, that trampoline is never intercepted. + +[selector] is a pointer to a char-sized region in the process memory +region, that provides a quick way to enable disable syscall redirection +thread-wide, without the need to invoke the kernel directly. selector +can be set to PR_SYS_DISPATCH_ON or PR_SYS_DISPATCH_OFF. Any other +value should terminate the program with a SIGSYS. + +Security Notes +-------------- + +Syscall User Dispatch provides functionality for compatibility layers to +quickly capture system calls issued by a non-native part of the +application, while not impacting the Linux native regions of the +process. It is not a mechanism for sandboxing system calls, and it +should not be seen as a security mechanism, since it is trivial for a +malicious application to subvert the mechanism by jumping to an allowed +dispatcher region prior to executing the syscall, or to discover the +address and modify the selector value. If the use case requires any +kind of security sandboxing, Seccomp should be used instead. + +Any fork or exec of the existing process resets the mechanism to +PR_SYS_DISPATCH_OFF.
Signature · 1 line
2.29.2
Re: [PATCH v7 7/7] docs: Document Syscall User Dispatch
* Gabriel Krisman Bertazi:
Quoted 17 lines
Documentation/admin-guide/syscall-user-dispatch.rst new file +17
-0+Interface +--------- + +A process can setup this mechanism on supported kernels +CONFIG_SYSCALL_USER_DISPATCH) by executing the following prctl: + + prctl(PR_SET_SYSCALL_USER_DISPATCH, <op>, <offset>, <length>, [selector]) + +<op> is either PR_SYS_DISPATCH_ON or PR_SYS_DISPATCH_OFF, to enable and +disable the mechanism globally for that thread. When +PR_SYS_DISPATCH_OFF is used, the other fields must be zero. + +<offset> and <offset+length> delimit a closed memory region interval +from which syscalls are always executed directly, regardless of the +userspace selector. This provides a fast path for the C library, which +includes the most common syscall dispatchers in the native code +applications, and also provides a way for the signal handler to return
Documentation/admin-guide/syscall-user-dispatch.rst line 71
Quoted 10 lines
Documentation/admin-guide/syscall-user-dispatch.rst new file +10
-0+without triggering a nested SIGSYS on (rt_)sigreturn. Users of this +interface should make sure that at least the signal trampoline code is +included in this region. In addition, for syscalls that implement the +trampoline code on the vDSO, that trampoline is never intercepted. + +[selector] is a pointer to a char-sized region in the process memory +region, that provides a quick way to enable disable syscall redirection +thread-wide, without the need to invoke the kernel directly. selector +can be set to PR_SYS_DISPATCH_ON or PR_SYS_DISPATCH_OFF. Any other +value should terminate the program with a SIGSYS.
Is this a process property or a task/thread property? The last paragraph says “thread-wide”, but the first paragraph says “process”.
Re: [PATCH v7 7/7] docs: Document Syscall User Dispatch
Quoted 24 lines · Florian Weimer
* Gabriel Krisman Bertazi:
Quoted 22 lines
Documentation/admin-guide/syscall-user-dispatch.rst new file +22
-0+Interface +--------- + +A process can setup this mechanism on supported kernels +CONFIG_SYSCALL_USER_DISPATCH) by executing the following prctl: + + prctl(PR_SET_SYSCALL_USER_DISPATCH, <op>, <offset>, <length>, [selector]) + +<op> is either PR_SYS_DISPATCH_ON or PR_SYS_DISPATCH_OFF, to enable and +disable the mechanism globally for that thread. When +PR_SYS_DISPATCH_OFF is used, the other fields must be zero. + +<offset> and <offset+length> delimit a closed memory region interval +from which syscalls are always executed directly, regardless of the +userspace selector. This provides a fast path for the C library, which +includes the most common syscall dispatchers in the native code +applications, and also provides a way for the signal handler to return +without triggering a nested SIGSYS on (rt_)sigreturn. Users of this +interface should make sure that at least the signal trampoline code is +included in this region. In addition, for syscalls that implement the +trampoline code on the vDSO, that trampoline is never intercepted. +
Quoted 8 lines
Documentation/admin-guide/syscall-user-dispatch.rst line 71
Quoted 5 lines
+[selector] is a pointer to a char-sized region in the process memory
Documentation/admin-guide/syscall-user-dispatch.rst new file +4
-0+region, that provides a quick way to enable disable syscall redirection +thread-wide, without the need to invoke the kernel directly. selector +can be set to PR_SYS_DISPATCH_ON or PR_SYS_DISPATCH_OFF. Any other +value should terminate the program with a SIGSYS.Is this a process property or a task/thread property? The last paragraph says “thread-wide”, but the first paragraph says “process”.
It is per-thread, as it doesn't survive across clone/fork syscalls. I will fix the first paragraph of this text.
Signature · 1 line
Gabriel Krisman Bertazi
* Gabriel Krisman Bertazi:
Quoted 3 lines
This is the v7 of syscall user dispatch. This version is a bit different from v6 on the following points, after the modifications requested on that submission.
Is this supposed to work with existing (Linux) libcs, or do you bring your own low-level run-time libraries?
Quoted 8 lines · Florian Weimer
* Gabriel Krisman Bertazi:
Quoted 3 lines
This is the v7 of syscall user dispatch. This version is a bit different from v6 on the following points, after the modifications requested on that submission.
Is this supposed to work with existing (Linux) libcs, or do you bring your own low-level run-time libraries?
Hi Florian,
The main use case is to intercept Windows system calls of an application running over Wine. While Wine is using an unmodified glibc to execute its own native Linux syscalls, the Windows libraries might be directly issuing syscalls that we need to capture. So there is a mix. While this mechanism is compatible with existing libc, we might have other libraries executing a syscall instruction directly.
Signature · 1 line
Gabriel Krisman Bertazi
* Gabriel Krisman Bertazi:
Quoted 6 lines
The main use case is to intercept Windows system calls of an application running over Wine. While Wine is using an unmodified glibc to execute its own native Linux syscalls, the Windows libraries might be directly issuing syscalls that we need to capture. So there is a mix. While this mechanism is compatible with existing libc, we might have other libraries executing a syscall instruction directly.
Please raise this on libc-alpha, it's an unexpected compatibility constraint on glibc. Thanks.
Quoted 8 lines · Gabriel Krisman Bertazi
Gabriel Krisman Bertazi (7):
x86: vdso: Expose sigreturn address on vdso to the kernel
signal: ExposeSYS_USER_DISPATCHsi_codetype
kernel: Implement selective syscall userspace redirection
entry: Support Syscall User Dispatch on common syscall entry
selftests: Add kselftest for syscall user dispatch
selftests: Add benchmark for syscall user dispatch
docs: Document Syscall User Dispatch
Aside from the one little nit this looks good to me.
Quoted 10 lines · Peter Zijlstra
Quoted 8 lines · Gabriel Krisman Bertazi
Gabriel Krisman Bertazi (7):
x86: vdso: Expose sigreturn address on vdso to the kernel
signal: ExposeSYS_USER_DISPATCHsi_codetype
kernel: Implement selective syscall userspace redirection
entry: Support Syscall User Dispatch on common syscall entry
selftests: Add kselftest for syscall user dispatch
selftests: Add benchmark for syscall user dispatch
docs: Document Syscall User Dispatch
Quoted 3 lines
Aside from the one little nit this looks good to me.
Agreed, and thank you Gabriel for the SYSCALL_WORK series too. :) That's so nice to have!
Signature · 1 line
Kees Cook