From: Mark Rutland <mark.rutland@arm.com> To: linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, will.deacon@arm.com Cc: dave.martin@arm.com, hch@infradead.org, james.morse@arm.com, linux@dominikbrodowski.net, linux-fsdevel@vger.kernel.org, marc.zyngier@arm.com, mark.rutland@arm.com, viro@zeniv.linux.org.uk Subject: [PATCHv3 19/19] arm64: implement syscall wrappers Date: Mon, 18 Jun 2018 13:03:10 +0100 [thread overview] Message-ID: <20180618120310.39527-20-mark.rutland@arm.com> (raw) In-Reply-To: <20180618120310.39527-1-mark.rutland@arm.com> To minimize the risk of userspace-controlled values being used under speculation, this patch adds pt_regs based syscall wrappers for arm64, which pass the minimum set of required userspace values to syscall implementations. For each syscall, a wrapper which takes a pt_regs argument is automatically generated, and this extracts the arguments before calling the "real" syscall implementation. Each syscall has three functions generated: * __do_<compat_>sys_<name> is the "real" syscall implementation, with the expected prototype. * __se_<compat_>sys_<name> is the sign-extension/narrowing wrapper, inherited from common code. This takes a series of long parameters, casting each to the requisite types required by the "real" syscall implementation in __do_<compat_>sys_<name>. This wrapper *may* not be necessary on arm64 given the AAPCS rules on unused register bits, but it seemed safer to keep the wrapper for now. * __arm64_<compat_>_sys_<name> takes a struct pt_regs pointer, and extracts *only* the relevant register values, passing these on to the __se_<compat_>sys_<name> wrapper. The syscall invocation code is updated to handle the calling convention required by __arm64_<compat_>_sys_<name>, and passes a single struct pt_regs pointer. The compiler can fold the syscall implementation and its wrappers, such that the overhead of this approach is minimized. Note that we play games with sys_ni_syscall(). It can't be defined with SYSCALL_DEFINE0() because we must avoid the possibility of error injection. Additionally, there are a couple of locations where we need to call it from C code, and we don't (currently) have a ksys_ni_syscall(). While it has no wrapper, passing in a redundant pt_regs pointer is benign per the AAPCS. When ARCH_HAS_SYSCALL_WRAPPER is selected, no prototype is defines for sys_ni_syscall(). Since we need to treat it differently for in-kernel calls and the syscall tables, the prototype is defined as-required. The wrappers are largely the same as their x86 counterparts, but simplified as we don't have a variety of compat calling conventions that require separate stubs. Unlike x86, we have some zero-argument compat syscalls, and must define COMPAT_SYSCALL_DEFINE0() to ensure that these are also given an __arm64_compat_sys_ prefix. Signed-off-by: Mark Rutland <mark.rutland@arm.com> Reviewed-by: Dominik Brodowski <linux@dominikbrodowski.net> Cc: Catalin Marinas <catalin.marinas@arm.com> Cc: Will Deacon <will.deacon@arm.com> --- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/syscall_wrapper.h | 80 ++++++++++++++++++++++++++++++++ arch/arm64/kernel/sys.c | 10 +++- arch/arm64/kernel/sys32.c | 9 +++- arch/arm64/kernel/syscall.c | 8 +--- arch/arm64/kernel/traps.c | 2 + 6 files changed, 101 insertions(+), 9 deletions(-) create mode 100644 arch/arm64/include/asm/syscall_wrapper.h diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig index 42c090cf0292..2089aa3f27bc 100644 --- a/arch/arm64/Kconfig +++ b/arch/arm64/Kconfig @@ -24,6 +24,7 @@ config ARM64 select ARCH_HAS_SG_CHAIN select ARCH_HAS_STRICT_KERNEL_RWX select ARCH_HAS_STRICT_MODULE_RWX + select ARCH_HAS_SYSCALL_WRAPPER select ARCH_HAS_TICK_BROADCAST if GENERIC_CLOCKEVENTS_BROADCAST select ARCH_HAVE_NMI_SAFE_CMPXCHG select ARCH_INLINE_READ_LOCK if !PREEMPT diff --git a/arch/arm64/include/asm/syscall_wrapper.h b/arch/arm64/include/asm/syscall_wrapper.h new file mode 100644 index 000000000000..a4477e515b79 --- /dev/null +++ b/arch/arm64/include/asm/syscall_wrapper.h @@ -0,0 +1,80 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * syscall_wrapper.h - arm64 specific wrappers to syscall definitions + * + * Based on arch/x86/include/asm_syscall_wrapper.h + */ + +#ifndef __ASM_SYSCALL_WRAPPER_H +#define __ASM_SYSCALL_WRAPPER_H + +#define SC_ARM64_REGS_TO_ARGS(x, ...) \ + __MAP(x,__SC_ARGS \ + ,,regs->regs[0],,regs->regs[1],,regs->regs[2] \ + ,,regs->regs[3],,regs->regs[4],,regs->regs[5]) + +#ifdef CONFIG_COMPAT + +#define COMPAT_SYSCALL_DEFINEx(x, name, ...) \ + asmlinkage long __arm64_compat_sys##name(const struct pt_regs *regs); \ + ALLOW_ERROR_INJECTION(__arm64_compat_sys##name, ERRNO); \ + static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \ + static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \ + asmlinkage long __arm64_compat_sys##name(const struct pt_regs *regs) \ + { \ + return __se_compat_sys##name(SC_ARM64_REGS_TO_ARGS(x,__VA_ARGS__)); \ + } \ + static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \ + { \ + return __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__)); \ + } \ + static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) + +#define COMPAT_SYSCALL_DEFINE0(sname) \ + asmlinkage long __arm64_compat_sys_##sname(void); \ + ALLOW_ERROR_INJECTION(__arm64_compat_sys_##sname, ERRNO); \ + asmlinkage long __arm64_compat_sys_##sname(void) + +#define COND_SYSCALL_COMPAT(name) \ + cond_syscall(__arm64_compat_sys_##name); + +#define COMPAT_SYS_NI(name) \ + SYSCALL_ALIAS(__arm64_compat_sys_##name, sys_ni_posix_timers); + +#endif /* CONFIG_COMPAT */ + +#define __SYSCALL_DEFINEx(x, name, ...) \ + asmlinkage long __arm64_sys##name(const struct pt_regs *regs); \ + ALLOW_ERROR_INJECTION(__arm64_sys##name, ERRNO); \ + static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \ + static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \ + asmlinkage long __arm64_sys##name(const struct pt_regs *regs) \ + { \ + return __se_sys##name(SC_ARM64_REGS_TO_ARGS(x,__VA_ARGS__)); \ + } \ + static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \ + { \ + long ret = __do_sys##name(__MAP(x,__SC_CAST,__VA_ARGS__)); \ + __MAP(x,__SC_TEST,__VA_ARGS__); \ + __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__)); \ + return ret; \ + } \ + static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) + +#ifndef SYSCALL_DEFINE0 +#define SYSCALL_DEFINE0(sname) \ + SYSCALL_METADATA(_##sname, 0); \ + asmlinkage long __arm64_sys_##sname(void); \ + ALLOW_ERROR_INJECTION(__arm64_sys_##sname, ERRNO); \ + asmlinkage long __arm64_sys_##sname(void) +#endif + +#ifndef COND_SYSCALL +#define COND_SYSCALL(name) cond_syscall(__arm64_sys_##name) +#endif + +#ifndef SYS_NI +#define SYS_NI(name) SYSCALL_ALIAS(__arm64_sys_##name, sys_ni_posix_timers); +#endif + +#endif /* __ASM_SYSCALL_WRAPPER_H */ diff --git a/arch/arm64/kernel/sys.c b/arch/arm64/kernel/sys.c index 2ad1497a184e..ee93bf789f0a 100644 --- a/arch/arm64/kernel/sys.c +++ b/arch/arm64/kernel/sys.c @@ -48,11 +48,17 @@ SYSCALL_DEFINE1(arm64_personality, unsigned int, personality) /* * Wrappers to pass the pt_regs argument. */ -asmlinkage long sys_rt_sigreturn(void); #define sys_personality sys_arm64_personality +asmlinkage long sys_ni_syscall(const struct pt_regs *); +#define __arm64_sys_ni_syscall sys_ni_syscall + +#undef __SYSCALL +#define __SYSCALL(nr, sym) asmlinkage long __arm64_##sym(const struct pt_regs *); +#include <asm/unistd.h> + #undef __SYSCALL -#define __SYSCALL(nr, sym) [nr] = sym, +#define __SYSCALL(nr, sym) [nr] = __arm64_##sym, /* * The sys_call_table array must be 4K aligned to be accessible from diff --git a/arch/arm64/kernel/sys32.c b/arch/arm64/kernel/sys32.c index 793bd0952ee0..533c97c5c232 100644 --- a/arch/arm64/kernel/sys32.c +++ b/arch/arm64/kernel/sys32.c @@ -131,8 +131,15 @@ COMPAT_SYSCALL_DEFINE6(aarch32_fallocate, int, fd, int, mode, return ksys_fallocate(fd, mode, arg_u64(offset), arg_u64(len)); } +asmlinkage long sys_ni_syscall(const struct pt_regs *); +#define __arm64_sys_ni_syscall sys_ni_syscall + +#undef __SYSCALL +#define __SYSCALL(nr, sym) asmlinkage long __arm64_##sym(const struct pt_regs *); +#include <asm/unistd32.h> + #undef __SYSCALL -#define __SYSCALL(nr, sym) [nr] = sym, +#define __SYSCALL(nr, sym) [nr] = __arm64_##sym, /* * The sys_call_table array must be 4K aligned to be accessible from diff --git a/arch/arm64/kernel/syscall.c b/arch/arm64/kernel/syscall.c index 6a31bb2a382b..e5985924f57e 100644 --- a/arch/arm64/kernel/syscall.c +++ b/arch/arm64/kernel/syscall.c @@ -12,15 +12,11 @@ long do_ni_syscall(struct pt_regs *regs); -typedef long (*syscall_fn_t)(unsigned long, unsigned long, - unsigned long, unsigned long, - unsigned long, unsigned long); +typedef long (*syscall_fn_t)(struct pt_regs *regs); static void __invoke_syscall(struct pt_regs *regs, syscall_fn_t syscall_fn) { - regs->regs[0] = syscall_fn(regs->regs[0], regs->regs[1], - regs->regs[2], regs->regs[3], - regs->regs[4], regs->regs[5]); + regs->regs[0] = syscall_fn(regs); } static void invoke_syscall(struct pt_regs *regs, unsigned int scno, diff --git a/arch/arm64/kernel/traps.c b/arch/arm64/kernel/traps.c index c27292703bd1..d941942043e5 100644 --- a/arch/arm64/kernel/traps.c +++ b/arch/arm64/kernel/traps.c @@ -549,6 +549,8 @@ asmlinkage void __exception do_sysinstr(unsigned int esr, struct pt_regs *regs) long compat_arm_syscall(struct pt_regs *regs); +long sys_ni_syscall(void); + asmlinkage long do_ni_syscall(struct pt_regs *regs) { #ifdef CONFIG_COMPAT -- 2.11.0
WARNING: multiple messages have this Message-ID (diff)
From: mark.rutland@arm.com (Mark Rutland) To: linux-arm-kernel@lists.infradead.org Subject: [PATCHv3 19/19] arm64: implement syscall wrappers Date: Mon, 18 Jun 2018 13:03:10 +0100 [thread overview] Message-ID: <20180618120310.39527-20-mark.rutland@arm.com> (raw) In-Reply-To: <20180618120310.39527-1-mark.rutland@arm.com> To minimize the risk of userspace-controlled values being used under speculation, this patch adds pt_regs based syscall wrappers for arm64, which pass the minimum set of required userspace values to syscall implementations. For each syscall, a wrapper which takes a pt_regs argument is automatically generated, and this extracts the arguments before calling the "real" syscall implementation. Each syscall has three functions generated: * __do_<compat_>sys_<name> is the "real" syscall implementation, with the expected prototype. * __se_<compat_>sys_<name> is the sign-extension/narrowing wrapper, inherited from common code. This takes a series of long parameters, casting each to the requisite types required by the "real" syscall implementation in __do_<compat_>sys_<name>. This wrapper *may* not be necessary on arm64 given the AAPCS rules on unused register bits, but it seemed safer to keep the wrapper for now. * __arm64_<compat_>_sys_<name> takes a struct pt_regs pointer, and extracts *only* the relevant register values, passing these on to the __se_<compat_>sys_<name> wrapper. The syscall invocation code is updated to handle the calling convention required by __arm64_<compat_>_sys_<name>, and passes a single struct pt_regs pointer. The compiler can fold the syscall implementation and its wrappers, such that the overhead of this approach is minimized. Note that we play games with sys_ni_syscall(). It can't be defined with SYSCALL_DEFINE0() because we must avoid the possibility of error injection. Additionally, there are a couple of locations where we need to call it from C code, and we don't (currently) have a ksys_ni_syscall(). While it has no wrapper, passing in a redundant pt_regs pointer is benign per the AAPCS. When ARCH_HAS_SYSCALL_WRAPPER is selected, no prototype is defines for sys_ni_syscall(). Since we need to treat it differently for in-kernel calls and the syscall tables, the prototype is defined as-required. The wrappers are largely the same as their x86 counterparts, but simplified as we don't have a variety of compat calling conventions that require separate stubs. Unlike x86, we have some zero-argument compat syscalls, and must define COMPAT_SYSCALL_DEFINE0() to ensure that these are also given an __arm64_compat_sys_ prefix. Signed-off-by: Mark Rutland <mark.rutland@arm.com> Reviewed-by: Dominik Brodowski <linux@dominikbrodowski.net> Cc: Catalin Marinas <catalin.marinas@arm.com> Cc: Will Deacon <will.deacon@arm.com> --- arch/arm64/Kconfig | 1 + arch/arm64/include/asm/syscall_wrapper.h | 80 ++++++++++++++++++++++++++++++++ arch/arm64/kernel/sys.c | 10 +++- arch/arm64/kernel/sys32.c | 9 +++- arch/arm64/kernel/syscall.c | 8 +--- arch/arm64/kernel/traps.c | 2 + 6 files changed, 101 insertions(+), 9 deletions(-) create mode 100644 arch/arm64/include/asm/syscall_wrapper.h diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig index 42c090cf0292..2089aa3f27bc 100644 --- a/arch/arm64/Kconfig +++ b/arch/arm64/Kconfig @@ -24,6 +24,7 @@ config ARM64 select ARCH_HAS_SG_CHAIN select ARCH_HAS_STRICT_KERNEL_RWX select ARCH_HAS_STRICT_MODULE_RWX + select ARCH_HAS_SYSCALL_WRAPPER select ARCH_HAS_TICK_BROADCAST if GENERIC_CLOCKEVENTS_BROADCAST select ARCH_HAVE_NMI_SAFE_CMPXCHG select ARCH_INLINE_READ_LOCK if !PREEMPT diff --git a/arch/arm64/include/asm/syscall_wrapper.h b/arch/arm64/include/asm/syscall_wrapper.h new file mode 100644 index 000000000000..a4477e515b79 --- /dev/null +++ b/arch/arm64/include/asm/syscall_wrapper.h @@ -0,0 +1,80 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * syscall_wrapper.h - arm64 specific wrappers to syscall definitions + * + * Based on arch/x86/include/asm_syscall_wrapper.h + */ + +#ifndef __ASM_SYSCALL_WRAPPER_H +#define __ASM_SYSCALL_WRAPPER_H + +#define SC_ARM64_REGS_TO_ARGS(x, ...) \ + __MAP(x,__SC_ARGS \ + ,,regs->regs[0],,regs->regs[1],,regs->regs[2] \ + ,,regs->regs[3],,regs->regs[4],,regs->regs[5]) + +#ifdef CONFIG_COMPAT + +#define COMPAT_SYSCALL_DEFINEx(x, name, ...) \ + asmlinkage long __arm64_compat_sys##name(const struct pt_regs *regs); \ + ALLOW_ERROR_INJECTION(__arm64_compat_sys##name, ERRNO); \ + static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \ + static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \ + asmlinkage long __arm64_compat_sys##name(const struct pt_regs *regs) \ + { \ + return __se_compat_sys##name(SC_ARM64_REGS_TO_ARGS(x,__VA_ARGS__)); \ + } \ + static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \ + { \ + return __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__)); \ + } \ + static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) + +#define COMPAT_SYSCALL_DEFINE0(sname) \ + asmlinkage long __arm64_compat_sys_##sname(void); \ + ALLOW_ERROR_INJECTION(__arm64_compat_sys_##sname, ERRNO); \ + asmlinkage long __arm64_compat_sys_##sname(void) + +#define COND_SYSCALL_COMPAT(name) \ + cond_syscall(__arm64_compat_sys_##name); + +#define COMPAT_SYS_NI(name) \ + SYSCALL_ALIAS(__arm64_compat_sys_##name, sys_ni_posix_timers); + +#endif /* CONFIG_COMPAT */ + +#define __SYSCALL_DEFINEx(x, name, ...) \ + asmlinkage long __arm64_sys##name(const struct pt_regs *regs); \ + ALLOW_ERROR_INJECTION(__arm64_sys##name, ERRNO); \ + static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \ + static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \ + asmlinkage long __arm64_sys##name(const struct pt_regs *regs) \ + { \ + return __se_sys##name(SC_ARM64_REGS_TO_ARGS(x,__VA_ARGS__)); \ + } \ + static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \ + { \ + long ret = __do_sys##name(__MAP(x,__SC_CAST,__VA_ARGS__)); \ + __MAP(x,__SC_TEST,__VA_ARGS__); \ + __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__)); \ + return ret; \ + } \ + static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) + +#ifndef SYSCALL_DEFINE0 +#define SYSCALL_DEFINE0(sname) \ + SYSCALL_METADATA(_##sname, 0); \ + asmlinkage long __arm64_sys_##sname(void); \ + ALLOW_ERROR_INJECTION(__arm64_sys_##sname, ERRNO); \ + asmlinkage long __arm64_sys_##sname(void) +#endif + +#ifndef COND_SYSCALL +#define COND_SYSCALL(name) cond_syscall(__arm64_sys_##name) +#endif + +#ifndef SYS_NI +#define SYS_NI(name) SYSCALL_ALIAS(__arm64_sys_##name, sys_ni_posix_timers); +#endif + +#endif /* __ASM_SYSCALL_WRAPPER_H */ diff --git a/arch/arm64/kernel/sys.c b/arch/arm64/kernel/sys.c index 2ad1497a184e..ee93bf789f0a 100644 --- a/arch/arm64/kernel/sys.c +++ b/arch/arm64/kernel/sys.c @@ -48,11 +48,17 @@ SYSCALL_DEFINE1(arm64_personality, unsigned int, personality) /* * Wrappers to pass the pt_regs argument. */ -asmlinkage long sys_rt_sigreturn(void); #define sys_personality sys_arm64_personality +asmlinkage long sys_ni_syscall(const struct pt_regs *); +#define __arm64_sys_ni_syscall sys_ni_syscall + +#undef __SYSCALL +#define __SYSCALL(nr, sym) asmlinkage long __arm64_##sym(const struct pt_regs *); +#include <asm/unistd.h> + #undef __SYSCALL -#define __SYSCALL(nr, sym) [nr] = sym, +#define __SYSCALL(nr, sym) [nr] = __arm64_##sym, /* * The sys_call_table array must be 4K aligned to be accessible from diff --git a/arch/arm64/kernel/sys32.c b/arch/arm64/kernel/sys32.c index 793bd0952ee0..533c97c5c232 100644 --- a/arch/arm64/kernel/sys32.c +++ b/arch/arm64/kernel/sys32.c @@ -131,8 +131,15 @@ COMPAT_SYSCALL_DEFINE6(aarch32_fallocate, int, fd, int, mode, return ksys_fallocate(fd, mode, arg_u64(offset), arg_u64(len)); } +asmlinkage long sys_ni_syscall(const struct pt_regs *); +#define __arm64_sys_ni_syscall sys_ni_syscall + +#undef __SYSCALL +#define __SYSCALL(nr, sym) asmlinkage long __arm64_##sym(const struct pt_regs *); +#include <asm/unistd32.h> + #undef __SYSCALL -#define __SYSCALL(nr, sym) [nr] = sym, +#define __SYSCALL(nr, sym) [nr] = __arm64_##sym, /* * The sys_call_table array must be 4K aligned to be accessible from diff --git a/arch/arm64/kernel/syscall.c b/arch/arm64/kernel/syscall.c index 6a31bb2a382b..e5985924f57e 100644 --- a/arch/arm64/kernel/syscall.c +++ b/arch/arm64/kernel/syscall.c @@ -12,15 +12,11 @@ long do_ni_syscall(struct pt_regs *regs); -typedef long (*syscall_fn_t)(unsigned long, unsigned long, - unsigned long, unsigned long, - unsigned long, unsigned long); +typedef long (*syscall_fn_t)(struct pt_regs *regs); static void __invoke_syscall(struct pt_regs *regs, syscall_fn_t syscall_fn) { - regs->regs[0] = syscall_fn(regs->regs[0], regs->regs[1], - regs->regs[2], regs->regs[3], - regs->regs[4], regs->regs[5]); + regs->regs[0] = syscall_fn(regs); } static void invoke_syscall(struct pt_regs *regs, unsigned int scno, diff --git a/arch/arm64/kernel/traps.c b/arch/arm64/kernel/traps.c index c27292703bd1..d941942043e5 100644 --- a/arch/arm64/kernel/traps.c +++ b/arch/arm64/kernel/traps.c @@ -549,6 +549,8 @@ asmlinkage void __exception do_sysinstr(unsigned int esr, struct pt_regs *regs) long compat_arm_syscall(struct pt_regs *regs); +long sys_ni_syscall(void); + asmlinkage long do_ni_syscall(struct pt_regs *regs) { #ifdef CONFIG_COMPAT -- 2.11.0
next prev parent reply other threads:[~2018-06-18 12:04 UTC|newest] Thread overview: 106+ messages / expand[flat|nested] mbox.gz Atom feed top 2018-06-18 12:02 [PATCHv3 00/19] arm64: invoke syscalls with pt_regs Mark Rutland 2018-06-18 12:02 ` Mark Rutland 2018-06-18 12:02 ` [PATCHv3 01/19] arm64: consistently use unsigned long for thread flags Mark Rutland 2018-06-18 12:02 ` Mark Rutland 2018-06-19 10:49 ` Catalin Marinas 2018-06-19 10:49 ` Catalin Marinas 2018-06-19 11:19 ` Mark Rutland 2018-06-19 11:19 ` Mark Rutland 2018-06-18 12:02 ` [PATCHv3 02/19] arm64: move SCTLR_EL{1,2} assertions to <asm/sysreg.h> Mark Rutland 2018-06-18 12:02 ` [PATCHv3 02/19] arm64: move SCTLR_EL{1, 2} " Mark Rutland 2018-06-19 11:02 ` Catalin Marinas 2018-06-19 11:02 ` Catalin Marinas 2018-06-19 11:48 ` [PATCHv3 02/19] arm64: move SCTLR_EL{1,2} " Mark Rutland 2018-06-19 11:48 ` Mark Rutland 2018-06-18 12:02 ` [PATCHv3 03/19] arm64: introduce sysreg_clear_set() Mark Rutland 2018-06-18 12:02 ` Mark Rutland 2018-06-19 11:44 ` Catalin Marinas 2018-06-19 11:44 ` Catalin Marinas 2018-06-19 11:47 ` Marc Zyngier 2018-06-19 11:47 ` Marc Zyngier 2018-06-18 12:02 ` [PATCHv3 04/19] arm64: kill config_sctlr_el1() Mark Rutland 2018-06-18 12:02 ` Mark Rutland 2018-06-19 11:44 ` Catalin Marinas 2018-06-19 11:44 ` Catalin Marinas 2018-06-18 12:02 ` [PATCHv3 05/19] arm64: kill change_cpacr() Mark Rutland 2018-06-18 12:02 ` Mark Rutland 2018-06-19 11:45 ` Catalin Marinas 2018-06-19 11:45 ` Catalin Marinas 2018-06-18 12:02 ` [PATCHv3 06/19] arm64: move sve_user_{enable,disable} to <asm/fpsimd.h> Mark Rutland 2018-06-18 12:02 ` [PATCHv3 06/19] arm64: move sve_user_{enable, disable} " Mark Rutland 2018-06-19 12:00 ` Catalin Marinas 2018-06-19 12:00 ` Catalin Marinas 2018-06-19 12:19 ` Dave Martin 2018-06-19 12:19 ` Dave Martin 2018-06-18 12:02 ` [PATCHv3 07/19] arm64: remove sigreturn wrappers Mark Rutland 2018-06-18 12:02 ` Mark Rutland 2018-06-19 12:47 ` Catalin Marinas 2018-06-19 12:47 ` Catalin Marinas 2018-06-18 12:02 ` [PATCHv3 08/19] arm64: convert raw syscall invocation to C Mark Rutland 2018-06-18 12:02 ` Mark Rutland 2018-06-19 13:33 ` Catalin Marinas 2018-06-19 13:33 ` Catalin Marinas 2018-06-19 14:21 ` Catalin Marinas 2018-06-19 14:21 ` Catalin Marinas 2018-06-19 14:48 ` Mark Rutland 2018-06-19 14:48 ` Mark Rutland 2018-06-19 14:55 ` Catalin Marinas 2018-06-19 14:55 ` Catalin Marinas 2018-06-19 14:58 ` Mark Rutland 2018-06-19 14:58 ` Mark Rutland 2018-06-18 12:03 ` [PATCHv3 09/19] arm64: convert syscall trace logic " Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 14:32 ` Catalin Marinas 2018-06-19 14:32 ` Catalin Marinas 2018-06-19 15:14 ` Mark Rutland 2018-06-19 15:14 ` Mark Rutland 2018-06-18 12:03 ` [PATCHv3 10/19] arm64: convert native/compat syscall entry " Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 12:18 ` Dave Martin 2018-06-19 12:18 ` Dave Martin 2018-06-19 13:15 ` Mark Rutland 2018-06-19 13:15 ` Mark Rutland 2018-06-20 9:21 ` Dave Martin 2018-06-20 9:21 ` Dave Martin 2018-06-19 15:20 ` Catalin Marinas 2018-06-19 15:20 ` Catalin Marinas 2018-06-18 12:03 ` [PATCHv3 11/19] arm64: don't reload GPRs after apply_ssbd Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 15:23 ` Catalin Marinas 2018-06-19 15:23 ` Catalin Marinas 2018-06-18 12:03 ` [PATCHv3 12/19] arm64: zero GPRs upon entry from EL0 Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 15:24 ` Catalin Marinas 2018-06-19 15:24 ` Catalin Marinas 2018-06-18 12:03 ` [PATCHv3 13/19] kernel: add ksys_personality() Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 15:45 ` Catalin Marinas 2018-06-19 15:45 ` Catalin Marinas 2018-06-19 15:53 ` Mark Rutland 2018-06-19 15:53 ` Mark Rutland 2018-06-18 12:03 ` [PATCHv3 14/19] kernel: add kcompat_sys_{f,}statfs64() Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-18 12:03 ` [PATCHv3 15/19] arm64: remove in-kernel call to sys_personality() Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 15:46 ` Catalin Marinas 2018-06-19 15:46 ` Catalin Marinas 2018-06-18 12:03 ` [PATCHv3 16/19] arm64: use {COMPAT,}SYSCALL_DEFINE0 for sigreturn Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 15:48 ` Catalin Marinas 2018-06-19 15:48 ` [PATCHv3 16/19] arm64: use {COMPAT, }SYSCALL_DEFINE0 " Catalin Marinas 2018-06-18 12:03 ` [PATCHv3 17/19] arm64: use SYSCALL_DEFINE6() for mmap Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 15:50 ` Catalin Marinas 2018-06-19 15:50 ` Catalin Marinas 2018-06-18 12:03 ` [PATCHv3 18/19] arm64: convert compat wrappers to C Mark Rutland 2018-06-18 12:03 ` Mark Rutland 2018-06-19 15:51 ` Catalin Marinas 2018-06-19 15:51 ` Catalin Marinas 2018-06-18 12:03 ` Mark Rutland [this message] 2018-06-18 12:03 ` [PATCHv3 19/19] arm64: implement syscall wrappers Mark Rutland 2018-06-19 16:13 ` Catalin Marinas 2018-06-19 16:13 ` Catalin Marinas 2018-06-19 15:38 ` [PATCHv3 00/19] arm64: invoke syscalls with pt_regs Mark Rutland 2018-06-19 15:38 ` Mark Rutland 2018-06-19 16:14 ` Catalin Marinas 2018-06-19 16:14 ` Catalin Marinas
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20180618120310.39527-20-mark.rutland@arm.com \ --to=mark.rutland@arm.com \ --cc=catalin.marinas@arm.com \ --cc=dave.martin@arm.com \ --cc=hch@infradead.org \ --cc=james.morse@arm.com \ --cc=linux-arm-kernel@lists.infradead.org \ --cc=linux-fsdevel@vger.kernel.org \ --cc=linux@dominikbrodowski.net \ --cc=marc.zyngier@arm.com \ --cc=viro@zeniv.linux.org.uk \ --cc=will.deacon@arm.com \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.