Commit 25c619e5 authored by Brian Gerst's avatar Brian Gerst Committed by Thomas Gleixner
Browse files

x86/entry/32: Enable pt_regs based syscalls 



Enable pt_regs based syscalls for 32-bit.  This makes the 32-bit native
kernel consistent with the 64-bit kernel, and improves the syscall
interface by not needing to push all 6 potential arguments onto the stack.

Signed-off-by: default avatarBrian Gerst <brgerst@gmail.com>
Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
Reviewed-by: default avatarDominik Brodowski <linux@dominikbrodowski.net>
Link: https://lkml.kernel.org/r/20200313195144.164260-17-brgerst@gmail.com
parent 121b32a5

arch/x86/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ config X86_64 
	select MODULES_USE_ELF_RELA

	select NEED_DMA_MAP_STATE

	select SWIOTLB

	select ARCH_HAS_SYSCALL_WRAPPER



config FORCE_DYNAMIC_FTRACE

	def_bool y
@@ -80,6 +79,7 @@ config X86 
	select ARCH_HAS_STRICT_KERNEL_RWX

	select ARCH_HAS_STRICT_MODULE_RWX

	select ARCH_HAS_SYNC_CORE_BEFORE_USERMODE

	select ARCH_HAS_SYSCALL_WRAPPER

	select ARCH_HAS_UBSAN_SANITIZE_ALL

	select ARCH_HAVE_NMI_SAFE_CMPXCHG

	select ARCH_MIGHT_HAVE_ACPI_PDC		if ACPI

arch/x86/entry/common.c

+0 −15
Original line number Diff line number Diff line
@@ -333,20 +333,7 @@ static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs) 


	if (likely(nr < IA32_NR_syscalls)) {

		nr = array_index_nospec(nr, IA32_NR_syscalls);

#ifdef CONFIG_IA32_EMULATION

		regs->ax = ia32_sys_call_table[nr](regs);

#else

		/*

		 * It's possible that a 32-bit syscall implementation

		 * takes a 64-bit parameter but nonetheless assumes that

		 * the high bits are zero.  Make sure we zero-extend all

		 * of the args.

		 */

		regs->ax = ia32_sys_call_table[nr](

			(unsigned int)regs->bx, (unsigned int)regs->cx,

			(unsigned int)regs->dx, (unsigned int)regs->si,

			(unsigned int)regs->di, (unsigned int)regs->bp);

#endif /* CONFIG_IA32_EMULATION */

	}



	syscall_return_slowpath(regs);
@@ -439,9 +426,7 @@ __visible long do_fast_syscall_32(struct pt_regs *regs) 
}

#endif



#ifdef CONFIG_X86_64

SYSCALL_DEFINE0(ni_syscall)

{

	return -ENOSYS;

}
 
#endif

arch/x86/entry/syscall_32.c

+2 −13
Original line number Diff line number Diff line
@@ -4,33 +4,22 @@ 
#include <linux/linkage.h>

#include <linux/sys.h>

#include <linux/cache.h>

#include <linux/syscalls.h>

#include <asm/unistd.h>

#include <asm/syscall.h>



#ifdef CONFIG_IA32_EMULATION

/* On X86_64, we use struct pt_regs * to pass parameters to syscalls */

#define __SYSCALL_I386(nr, sym) extern asmlinkage long __ia32_##sym(const struct pt_regs *);

#define __sys_ni_syscall __ia32_sys_ni_syscall

#else /* CONFIG_IA32_EMULATION */

#define __SYSCALL_I386(nr, sym) extern asmlinkage long sym(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long);

extern asmlinkage long sys_ni_syscall(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long);

#define __sys_ni_syscall sys_ni_syscall

#endif /* CONFIG_IA32_EMULATION */



#include <asm/syscalls_32.h>

#undef __SYSCALL_I386



#ifdef CONFIG_IA32_EMULATION

#define __SYSCALL_I386(nr, sym) [nr] = __ia32_##sym,

#else /* CONFIG_IA32_EMULATION */

#define __SYSCALL_I386(nr, sym) [nr] = sym,

#endif /* CONFIG_IA32_EMULATION */



__visible const sys_call_ptr_t ia32_sys_call_table[__NR_ia32_syscall_max+1] = {

	/*

	 * Smells like a compiler bug -- it doesn't work

	 * when the & below is removed.

	 */

	[0 ... __NR_ia32_syscall_max] = &__sys_ni_syscall,

	[0 ... __NR_ia32_syscall_max] = &__ia32_sys_ni_syscall,

#include <asm/syscalls_32.h>

};

arch/x86/include/asm/syscall.h

+0 −6
Original line number Diff line number Diff line
@@ -16,13 +16,7 @@ 
#include <asm/thread_info.h>	/* for TS_COMPAT */

#include <asm/unistd.h>



#ifdef CONFIG_X86_64

typedef asmlinkage long (*sys_call_ptr_t)(const struct pt_regs *);

#else

typedef asmlinkage long (*sys_call_ptr_t)(unsigned long, unsigned long,

					  unsigned long, unsigned long,

					  unsigned long, unsigned long);

#endif /* CONFIG_X86_64 */

extern const sys_call_ptr_t sys_call_table[];



#if defined(CONFIG_X86_32)

arch/x86/include/asm/syscall_wrapper.h

+61 −50
Original line number Diff line number Diff line
@@ -11,6 +11,47 @@ struct pt_regs; 
extern asmlinkage long __x64_sys_ni_syscall(const struct pt_regs *regs);

extern asmlinkage long __ia32_sys_ni_syscall(const struct pt_regs *regs);



/*

 * Instead of the generic __SYSCALL_DEFINEx() definition, the x86 version takes

 * struct pt_regs *regs as the only argument of the syscall stub(s) named as:

 * __x64_sys_*()         - 64-bit native syscall

 * __ia32_sys_*()        - 32-bit native syscall or common compat syscall

 * __ia32_compat_sys_*() - 32-bit compat syscall

 * __x32_compat_sys_*()  - 64-bit X32 compat syscall

 *

 * The registers are decoded according to the ABI:

 * 64-bit: RDI, RSI, RDX, R10, R8, R9

 * 32-bit: EBX, ECX, EDX, ESI, EDI, EBP

 *

 * The stub then passes the decoded arguments to the __se_sys_*() wrapper to

 * perform sign-extension (omitted for zero-argument syscalls).  Finally the

 * arguments are passed to the __do_sys_*() function which is the actual

 * syscall.  These wrappers are marked as inline so the compiler can optimize

 * the functions where appropriate.

 *

 * Example assembly (slightly re-ordered for better readability):

 *

 * <__x64_sys_recv>:		<-- syscall with 4 parameters

 *	callq	<__fentry__>

 *

 *	mov	0x70(%rdi),%rdi	<-- decode regs->di

 *	mov	0x68(%rdi),%rsi	<-- decode regs->si

 *	mov	0x60(%rdi),%rdx	<-- decode regs->dx

 *	mov	0x38(%rdi),%rcx	<-- decode regs->r10

 *

 *	xor	%r9d,%r9d	<-- clear %r9

 *	xor	%r8d,%r8d	<-- clear %r8

 *

 *	callq	__sys_recvfrom	<-- do the actual work in __sys_recvfrom()

 *				    which takes 6 arguments

 *

 *	cltq			<-- extend return value to 64-bit

 *	retq			<-- return

 *

 * This approach avoids leaking random user-provided register content down

 * the call chain.

 */



/* Mapping of registers to parameters for syscalls on x86-64 and x32 */

#define SC_X86_64_REGS_TO_ARGS(x, ...)					\

	__MAP(x,__SC_ARGS						\
@@ -68,6 +109,26 @@ extern asmlinkage long __ia32_sys_ni_syscall(const struct pt_regs *regs); 
#define __X64_SYS_NI(name)

#endif /* CONFIG_X86_64 */



#if defined(CONFIG_X86_32) || defined(CONFIG_IA32_EMULATION)

#define __IA32_SYS_STUB0(name)						\

	__SYS_STUB0(ia32, sys_##name)



#define __IA32_SYS_STUBx(x, name, ...)					\

	__SYS_STUBx(ia32, sys##name,					\

		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))



#define __IA32_COND_SYSCALL(name)					\

	__COND_SYSCALL(ia32, sys_##name)



#define __IA32_SYS_NI(name)						\

	__SYS_NI(ia32, sys_##name)

#else /* CONFIG_X86_32 || CONFIG_IA32_EMULATION */

#define __IA32_SYS_STUB0(name)

#define __IA32_SYS_STUBx(x, name, ...)

#define __IA32_COND_SYSCALL(name)

#define __IA32_SYS_NI(name)

#endif /* CONFIG_X86_32 || CONFIG_IA32_EMULATION */



#ifdef CONFIG_IA32_EMULATION

/*

 * For IA32 emulation, we need to handle "compat" syscalls *and* create
@@ -90,27 +151,11 @@ extern asmlinkage long __ia32_sys_ni_syscall(const struct pt_regs *regs); 
#define __IA32_COMPAT_SYS_NI(name)					\

	__SYS_NI(ia32, compat_sys_##name)



#define __IA32_SYS_STUB0(name)						\

	__SYS_STUB0(ia32, sys_##name)



#define __IA32_SYS_STUBx(x, name, ...)					\

	__SYS_STUBx(ia32, sys##name,					\

		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))



#define __IA32_COND_SYSCALL(name)					\

	__COND_SYSCALL(ia32, sys_##name)



#define __IA32_SYS_NI(name)						\

	__SYS_NI(ia32, sys_##name)

#else /* CONFIG_IA32_EMULATION */

#define __IA32_COMPAT_SYS_STUB0(name)

#define __IA32_COMPAT_SYS_STUBx(x, name, ...)

#define __IA32_COMPAT_COND_SYSCALL(name)

#define __IA32_COMPAT_SYS_NI(name)

#define __IA32_SYS_STUB0(name)

#define __IA32_SYS_STUBx(x, name, ...)

#define __IA32_COND_SYSCALL(name)

#define __IA32_SYS_NI(name)

#endif /* CONFIG_IA32_EMULATION */
@@ -180,40 +225,6 @@ extern asmlinkage long __ia32_sys_ni_syscall(const struct pt_regs *regs); 


#endif /* CONFIG_COMPAT */





/*

 * Instead of the generic __SYSCALL_DEFINEx() definition, this macro takes

 * struct pt_regs *regs as the only argument of the syscall stub named

 * __x64_sys_*(). It decodes just the registers it needs and passes them on to

 * the __se_sys_*() wrapper performing sign extension and then to the

 * __do_sys_*() function doing the actual job. These wrappers and functions

 * are inlined (at least in very most cases), meaning that the assembly looks

 * as follows (slightly re-ordered for better readability):

 *

 * <__x64_sys_recv>:		<-- syscall with 4 parameters

 *	callq	<__fentry__>

 *

 *	mov	0x70(%rdi),%rdi	<-- decode regs->di

 *	mov	0x68(%rdi),%rsi	<-- decode regs->si

 *	mov	0x60(%rdi),%rdx	<-- decode regs->dx

 *	mov	0x38(%rdi),%rcx	<-- decode regs->r10

 *

 *	xor	%r9d,%r9d	<-- clear %r9

 *	xor	%r8d,%r8d	<-- clear %r8

 *

 *	callq	__sys_recvfrom	<-- do the actual work in __sys_recvfrom()

 *				    which takes 6 arguments

 *

 *	cltq			<-- extend return value to 64-bit

 *	retq			<-- return

 *

 * This approach avoids leaking random user-provided register content down

 * the call chain.

 *

 * If IA32_EMULATION is enabled, this macro generates an additional wrapper

 * named __ia32_sys_*() which decodes the struct pt_regs *regs according

 * to the i386 calling convention (bx, cx, dx, si, di, bp).

 */

#define __SYSCALL_DEFINEx(x, name, ...)					\

	static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__));	\

	static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));\

CRA Git | Maintained and supported by SUSTech CRA and CCSE