Skip to contentSkip to conversation

Enable pt_regs based syscalls for x86-32 native

PATCH Superseded Brian Gerst 2 participants 14 messages Feb 24, 2020 – Feb 25, 2020

Subsystems (3)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover Enable pt_regs based syscalls for x86-32 native

This patch series cleans up the x86 syscall wrapper code and converts the 32-bit native kernel over to pt_regs based syscalls. This makes the 32-bit syscall interface consistent with 64-bit, and a bit more effecient by not blindly pushing all 6 potential arguments onto the stack.

Changes since v1:
- Split patch 1 into multiple patches
- Updated comments and patch notes to clarify changes

Brian Gerst (8):
x86, syscalls: Refactor SYSCALL_DEFINEx macros x86, syscalls: Refactor SYSCALL_DEFINE0 macros x86, syscalls: Refactor COND_SYSCALL macros x86, syscalls: Refactor SYS_NI macros
x86: Move 32-bit compat syscalls to common location
x86-32: Enable syscall wrappers
x86-64: Use syscall wrappers for x32_rt_sigreturn
x86: Drop asmlinkage from syscalls

 arch/x86/Kconfig                       |   2 +-
 arch/x86/entry/common.c                |  20 +-
 arch/x86/entry/syscall_32.c            |  13 +-
 arch/x86/entry/syscall_64.c            |   9 +-
 arch/x86/entry/syscalls/syscall_32.tbl | 818 ++++++++++++-------------
 arch/x86/entry/syscalls/syscall_64.tbl |   2 +-
 arch/x86/entry/syscalls/syscalltbl.sh  |  33 +-
 arch/x86/ia32/Makefile                 |   2 +-
 arch/x86/include/asm/sighandling.h     |   5 -
 arch/x86/include/asm/syscall.h         |   8 +-
 arch/x86/include/asm/syscall_wrapper.h | 317 +++++-----
 arch/x86/include/asm/syscalls.h        |  29 -
 arch/x86/kernel/Makefile               |   2 +
 arch/x86/kernel/signal.c               |   2 +-
 arch/x86/{ia32 => kernel}/sys_ia32.c   | 130 ++--
 arch/x86/um/sys_call_table_32.c        |  10 +
 16 files changed, 690 insertions(+), 712 deletions(-)
 rename arch/x86/{ia32 => kernel}/sys_ia32.c (83%)
Signature · 1 line
2.24.1
#1 lore raw

PATCH v2 1/8 x86, syscalls: Refactor SYSCALL_DEFINEx macros

Pull the common code out from the SYSCALL_DEFINEx macros into a new __SYS_STUBx macro. Also conditionalize the X64 version in preparation for enabling syscall wrappers on 32-bit native kernels.

---
 arch/x86/include/asm/syscall_wrapper.h | 86 ++++++++++++++------------
 1 file changed, 45 insertions(+), 41 deletions(-)
arch/x86/include/asm/syscall_wrapper.h +45 -41
index e2389ce9bf58..44ed358a2e3c 100644
@@ -21,6 +21,22 @@ struct pt_regs;
 	      ,,(unsigned int)regs->dx,,(unsigned int)regs->si		\
 	      ,,(unsigned int)regs->di,,(unsigned int)regs->bp)
 
+#define __SYS_STUBx(abi, name, ...)					\
+	asmlinkage long __##abi##_##name(const struct pt_regs *regs);	\
+	ALLOW_ERROR_INJECTION(__##abi##_##name, ERRNO);			\
+	asmlinkage long __##abi##_##name(const struct pt_regs *regs)	\
+	{								\
+		return __se_##name(__VA_ARGS__);			\
+	}
+
+#ifdef CONFIG_X86_64
+#define __X64_SYS_STUBx(x, sys_name, ...)				\
+	__SYS_STUBx(x64, sys_name,					\
+		    SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__))
+#else /* CONFIG_X86_64 */
+#define __X64_SYS_STUBx(x, sys_name, ...)
+#endif /* CONFIG_X86_64 */
+
 #ifdef CONFIG_IA32_EMULATION
 /*
  * For IA32 emulation, we need to handle "compat" syscalls *and* create
@@ -38,21 +54,13 @@ struct pt_regs;
 		return __se_compat_sys_##name();			\
 	}
 
-#define __IA32_COMPAT_SYS_STUBx(x, name, ...)				\
-	asmlinkage long __ia32_compat_sys##name(const struct pt_regs *regs);\
-	ALLOW_ERROR_INJECTION(__ia32_compat_sys##name, ERRNO);		\
-	asmlinkage long __ia32_compat_sys##name(const struct pt_regs *regs)\
-	{								\
-		return __se_compat_sys##name(SC_IA32_REGS_TO_ARGS(x,__VA_ARGS__));\
-	}
+#define __IA32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)		\
+	__SYS_STUBx(ia32, compat_sys_name,				\
+		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))
 
-#define __IA32_SYS_STUBx(x, name, ...)					\
-	asmlinkage long __ia32_sys##name(const struct pt_regs *regs);	\
-	ALLOW_ERROR_INJECTION(__ia32_sys##name, ERRNO);			\
-	asmlinkage long __ia32_sys##name(const struct pt_regs *regs)	\
-	{								\
-		return __se_sys##name(SC_IA32_REGS_TO_ARGS(x,__VA_ARGS__));\
-	}
+#define __IA32_SYS_STUBx(x, sys_name, ...)				\
+	__SYS_STUBx(ia32, sys_name,					\
+		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))
 
 /*
  * To keep the naming coherent, re-define SYSCALL_DEFINE0 to create an alias
@@ -81,8 +89,8 @@ struct pt_regs;
 	SYSCALL_ALIAS(__ia32_sys_##name, sys_ni_posix_timers)
 
 #else /* CONFIG_IA32_EMULATION */
-#define __IA32_COMPAT_SYS_STUBx(x, name, ...)
-#define __IA32_SYS_STUBx(x, fullname, name, ...)
+#define __IA32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)
+#define __IA32_SYS_STUBx(x, sys_name, ...)
 #endif /* CONFIG_IA32_EMULATION */
 
 
@@ -100,17 +108,13 @@ struct pt_regs;
 		return __se_compat_sys_##name();\
 	}
 
-#define __X32_COMPAT_SYS_STUBx(x, name, ...)				\
-	asmlinkage long __x32_compat_sys##name(const struct pt_regs *regs);\
-	ALLOW_ERROR_INJECTION(__x32_compat_sys##name, ERRNO);		\
-	asmlinkage long __x32_compat_sys##name(const struct pt_regs *regs)\
-	{								\
-		return __se_compat_sys##name(SC_X86_64_REGS_TO_ARGS(x,__VA_ARGS__));\
-	}
+#define __X32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)			\
+	__SYS_STUBx(x32, compat_sys_name,				\
+		    SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__))
 
 #else /* CONFIG_X86_X32 */
 #define __X32_COMPAT_SYS_STUB0(x, name)
-#define __X32_COMPAT_SYS_STUBx(x, name, ...)
+#define __X32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)
 #endif /* CONFIG_X86_X32 */
 
 
@@ -131,16 +135,21 @@ struct pt_regs;
 	}								\
 	static inline long __do_compat_sys_##name(void)
 
-#define COMPAT_SYSCALL_DEFINEx(x, name, ...)					\
-	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__));\
-	__IA32_COMPAT_SYS_STUBx(x, name, __VA_ARGS__)				\
-	__X32_COMPAT_SYS_STUBx(x, name, __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_DEFINEx(x, name, ...)				\
+	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__));	\
+	__IA32_COMPAT_SYS_STUBx(x, compat_sys##name, __VA_ARGS__)	\
+	__X32_COMPAT_SYS_STUBx(x, compat_sys##name, __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__))
 
 /*
  * As some compat syscalls may not be implemented, we need to expand
@@ -192,15 +201,10 @@ struct pt_regs;
  * to the i386 calling convention (bx, cx, dx, si, di, bp).
  */
 #define __SYSCALL_DEFINEx(x, name, ...)					\
-	asmlinkage long __x64_sys##name(const struct pt_regs *regs);	\
-	ALLOW_ERROR_INJECTION(__x64_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 __x64_sys##name(const struct pt_regs *regs)	\
-	{								\
-		return __se_sys##name(SC_X86_64_REGS_TO_ARGS(x,__VA_ARGS__));\
-	}								\
-	__IA32_SYS_STUBx(x, name, __VA_ARGS__)				\
+	__X64_SYS_STUBx(x, sys##name, __VA_ARGS__)			\
+	__IA32_SYS_STUBx(x, sys##name, __VA_ARGS__)			\
 	static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))	\
 	{								\
 		long ret = __do_sys##name(__MAP(x,__SC_CAST,__VA_ARGS__));\
Signature · 1 line
2.24.1
#2 lore raw

Re: [PATCH v2 1/8] x86, syscalls: Refactor SYSCALL_DEFINEx macros

Thanks for the updated series! Looks nicer to me now.

arch/x86/include/asm/syscall_wrapper.h struct pt_regs; · line 35

Quoted 4 lines
arch/x86/include/asm/syscall_wrapper.h +4 -0
+#ifdef CONFIG_X86_64
+#define __X64_SYS_STUBx(x, sys_name, ...)				\
+	__SYS_STUBx(x64, sys_name,					\
+		    SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__))

I'd say it's easier to read if "name" is passed to this macro, and it is expanded to sys_##name only within this macro...

arch/x86/include/asm/syscall_wrapper.h struct pt_regs; · line 59

Quoted 3 lines
arch/x86/include/asm/syscall_wrapper.h +3 -0
+#define __IA32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)		\
+	__SYS_STUBx(ia32, compat_sys_name,				\
+		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))

... and in particular here (with compat_sys)

arch/x86/include/asm/syscall_wrapper.h struct pt_regs; · line 63

Quoted 3 lines
arch/x86/include/asm/syscall_wrapper.h +3 -0
+#define __IA32_SYS_STUBx(x, sys_name, ...)				\
+	__SYS_STUBx(ia32, sys_name,					\
+		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))

... same here

arch/x86/include/asm/syscall_wrapper.h struct pt_regs; · line 113

Quoted 3 lines
arch/x86/include/asm/syscall_wrapper.h +3 -0
+#define __X32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)			\
+	__SYS_STUBx(x32, compat_sys_name,				\
+		    SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__))

... and here.

Otherwise, a nice cleanup!

Thanks,
Dominik

#3 lore raw

PATCH v2 2/8 x86, syscalls: Refactor SYSCALL_DEFINE0 macros

In reply to Brian Gerst

Pull the common code out from the SYSCALL_DEFINE0 macros into a new __SYS_STUB0 macro. Also conditionalize the X64 version in preparation for enabling syscall wrappers on 32-bit native kernels.

---
 arch/x86/include/asm/syscall_wrapper.h | 73 +++++++++++---------------
 1 file changed, 32 insertions(+), 41 deletions(-)
arch/x86/include/asm/syscall_wrapper.h +32 -41
index 44ed358a2e3c..c13be057865f 100644
@@ -21,6 +21,12 @@ struct pt_regs;
 	      ,,(unsigned int)regs->dx,,(unsigned int)regs->si		\
 	      ,,(unsigned int)regs->di,,(unsigned int)regs->bp)
 
+#define __SYS_STUB0(abi, name)						\
+	asmlinkage long __##abi##_##name(const struct pt_regs *regs);	\
+	ALLOW_ERROR_INJECTION(__##abi##_##name, ERRNO);			\
+	asmlinkage long __##abi##_##name(const struct pt_regs *regs)	\
+		__alias(__do_##name);
+
 #define __SYS_STUBx(abi, name, ...)					\
 	asmlinkage long __##abi##_##name(const struct pt_regs *regs);	\
 	ALLOW_ERROR_INJECTION(__##abi##_##name, ERRNO);			\
@@ -30,10 +36,14 @@ struct pt_regs;
 	}
 
 #ifdef CONFIG_X86_64
+#define __X64_SYS_STUB0(sys_name)					\
+	__SYS_STUB0(x64, sys_name)
+
 #define __X64_SYS_STUBx(x, sys_name, ...)				\
 	__SYS_STUBx(x64, sys_name,					\
 		    SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__))
 #else /* CONFIG_X86_64 */
+#define __X64_SYS_STUB0(sys_name)
 #define __X64_SYS_STUBx(x, sys_name, ...)
 #endif /* CONFIG_X86_64 */
 
@@ -46,34 +56,20 @@ struct pt_regs;
  * kernel/sys_ni.c and SYS_NI in kernel/time/posix-stubs.c to cover this
  * case as well.
  */
-#define __IA32_COMPAT_SYS_STUB0(x, name)				\
-	asmlinkage long __ia32_compat_sys_##name(const struct pt_regs *regs);\
-	ALLOW_ERROR_INJECTION(__ia32_compat_sys_##name, ERRNO);		\
-	asmlinkage long __ia32_compat_sys_##name(const struct pt_regs *regs)\
-	{								\
-		return __se_compat_sys_##name();			\
-	}
+#define __IA32_COMPAT_SYS_STUB0(compat_sys_name)			\
+	__SYS_STUB0(ia32, compat_sys_name)
 
 #define __IA32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)		\
 	__SYS_STUBx(ia32, compat_sys_name,				\
 		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))
 
+#define __IA32_SYS_STUB0(sys_name)					\
+	__SYS_STUB0(ia32, sys_name)
+
 #define __IA32_SYS_STUBx(x, sys_name, ...)				\
 	__SYS_STUBx(ia32, sys_name,					\
 		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))
 
-/*
- * To keep the naming coherent, re-define SYSCALL_DEFINE0 to create an alias
- * named __ia32_sys_*()
- */
-
-#define SYSCALL_DEFINE0(sname)						\
-	SYSCALL_METADATA(_##sname, 0);					\
-	asmlinkage long __x64_sys_##sname(const struct pt_regs *__unused);\
-	ALLOW_ERROR_INJECTION(__x64_sys_##sname, ERRNO);		\
-	SYSCALL_ALIAS(__ia32_sys_##sname, __x64_sys_##sname);		\
-	asmlinkage long __x64_sys_##sname(const struct pt_regs *__unused)
-
 #define COND_SYSCALL(name)							\
 	asmlinkage __weak long __x64_sys_##name(const struct pt_regs *__unused)	\
 	{									\
@@ -89,7 +85,9 @@ struct pt_regs;
 	SYSCALL_ALIAS(__ia32_sys_##name, sys_ni_posix_timers)
 
 #else /* CONFIG_IA32_EMULATION */
+#define __IA32_COMPAT_SYS_STUB0(compat_sys_name)
 #define __IA32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)
+#define __IA32_SYS_STUB0(sys_name)
 #define __IA32_SYS_STUBx(x, sys_name, ...)
 #endif /* CONFIG_IA32_EMULATION */
 
@@ -100,20 +98,15 @@ struct pt_regs;
  * of the x86-64-style parameter ordering of x32 syscalls. The syscalls common
  * with x86_64 obviously do not need such care.
  */
-#define __X32_COMPAT_SYS_STUB0(x, name, ...)				\
-	asmlinkage long __x32_compat_sys_##name(const struct pt_regs *regs);\
-	ALLOW_ERROR_INJECTION(__x32_compat_sys_##name, ERRNO);		\
-	asmlinkage long __x32_compat_sys_##name(const struct pt_regs *regs)\
-	{								\
-		return __se_compat_sys_##name();\
-	}
+#define __X32_COMPAT_SYS_STUB0(compat_sys_name)				\
+	__SYS_STUB0(x32, compat_sys_name)
 
 #define __X32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)			\
 	__SYS_STUBx(x32, compat_sys_name,				\
 		    SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__))
 
 #else /* CONFIG_X86_X32 */
-#define __X32_COMPAT_SYS_STUB0(x, name)
+#define __X32_COMPAT_SYS_STUB0(compat_sys_name)
 #define __X32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)
 #endif /* CONFIG_X86_X32 */
 
@@ -125,15 +118,12 @@ struct pt_regs;
  * of them.
  */
 #define COMPAT_SYSCALL_DEFINE0(name)					\
-	static long __se_compat_sys_##name(void);			\
-	static inline long __do_compat_sys_##name(void);		\
-	__IA32_COMPAT_SYS_STUB0(x, name)				\
-	__X32_COMPAT_SYS_STUB0(x, name)					\
-	static long __se_compat_sys_##name(void)			\
-	{								\
-		return __do_compat_sys_##name();			\
-	}								\
-	static inline long __do_compat_sys_##name(void)
+	static asmlinkage long						\
+	__do_compat_sys_##name(const struct pt_regs *__unused);		\
+	__IA32_COMPAT_SYS_STUB0(compat_sys_##name)			\
+	__X32_COMPAT_SYS_STUB0(compat_sys_##name)			\
+	static asmlinkage long						\
+	__do_compat_sys_##name(const struct pt_regs *__unused)
 
 #define COMPAT_SYSCALL_DEFINEx(x, name, ...)				\
 	static long							\
@@ -221,13 +211,14 @@ struct pt_regs;
  * SYSCALL_DEFINEx() -- which is essential for the COND_SYSCALL() and SYS_NI()
  * macros to work correctly.
  */
-#ifndef SYSCALL_DEFINE0
 #define SYSCALL_DEFINE0(sname)						\
 	SYSCALL_METADATA(_##sname, 0);					\
-	asmlinkage long __x64_sys_##sname(const struct pt_regs *__unused);\
-	ALLOW_ERROR_INJECTION(__x64_sys_##sname, ERRNO);		\
-	asmlinkage long __x64_sys_##sname(const struct pt_regs *__unused)
-#endif
+	static asmlinkage long						\
+	__do_sys_##sname(const struct pt_regs *__unused);		\
+	__X64_SYS_STUB0(sys_##sname)					\
+	__IA32_SYS_STUB0(sys_##sname)					\
+	static asmlinkage long						\
+	__do_sys_##sname(const struct pt_regs *__unused)
 
 #ifndef COND_SYSCALL
 #define COND_SYSCALL(name) 							\
Signature · 1 line
2.24.1
#4 lore raw

Re: [PATCH v2 2/8] x86, syscalls: Refactor SYSCALL_DEFINE0 macros

This patch is also a nice cleanup, though the naming of the parameters (and where the "name" to "comapt_sys_##name" conversion is done) may need a bit more thought.

Thanks,
Dominik

#5 lore raw

PATCH v2 3/8 x86, syscalls: Refactor COND_SYSCALL macros

In reply to Brian Gerst

Pull the common code out from the COND_SYSCALL macros into a new __COND_SYSCALL macro. Also conditionalize the X64 version in preparation for enabling syscall wrappers on 32-bit native kernels.

---
 arch/x86/include/asm/syscall_wrapper.h | 44 +++++++++++++++-----------
 1 file changed, 26 insertions(+), 18 deletions(-)
arch/x86/include/asm/syscall_wrapper.h +26 -18
index c13be057865f..781adf7f611f 100644
@@ -35,6 +35,13 @@ struct pt_regs;
 		return __se_##name(__VA_ARGS__);			\
 	}
 
+#define __COND_SYSCALL(abi, name)					\
+	asmlinkage __weak long						\
+	__##abi##_##name(const struct pt_regs *__unused)		\
+	{								\
+		return sys_ni_syscall();				\
+	}
+
 #ifdef CONFIG_X86_64
 #define __X64_SYS_STUB0(sys_name)					\
 	__SYS_STUB0(x64, sys_name)
@@ -42,9 +49,13 @@ struct pt_regs;
 #define __X64_SYS_STUBx(x, sys_name, ...)				\
 	__SYS_STUBx(x64, sys_name,					\
 		    SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__))
+
+#define __X64_COND_SYSCALL(sys_name)					\
+	__COND_SYSCALL(x64, sys_name)
 #else /* CONFIG_X86_64 */
 #define __X64_SYS_STUB0(sys_name)
 #define __X64_SYS_STUBx(x, sys_name, ...)
+#define __X64_COND_SYSCALL(sys_name)
 #endif /* CONFIG_X86_64 */
 
 #ifdef CONFIG_IA32_EMULATION
@@ -63,6 +74,9 @@ struct pt_regs;
 	__SYS_STUBx(ia32, compat_sys_name,				\
 		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))
 
+#define __IA32_COMPAT_COND_SYSCALL(compat_sys_name)			\
+	__COND_SYSCALL(ia32, compat_sys_name)
+
 #define __IA32_SYS_STUB0(sys_name)					\
 	__SYS_STUB0(ia32, sys_name)
 
@@ -70,15 +84,8 @@ struct pt_regs;
 	__SYS_STUBx(ia32, sys_name,					\
 		    SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__))
 
-#define COND_SYSCALL(name)							\
-	asmlinkage __weak long __x64_sys_##name(const struct pt_regs *__unused)	\
-	{									\
-		return sys_ni_syscall();					\
-	}									\
-	asmlinkage __weak long __ia32_sys_##name(const struct pt_regs *__unused)\
-	{									\
-		return sys_ni_syscall();					\
-	}
+#define __IA32_COND_SYSCALL(sys_name)					\
+	__COND_SYSCALL(ia32, sys_name)
 
 #define SYS_NI(name)							\
 	SYSCALL_ALIAS(__x64_sys_##name, sys_ni_posix_timers);		\
@@ -87,8 +94,10 @@ struct pt_regs;
 #else /* CONFIG_IA32_EMULATION */
 #define __IA32_COMPAT_SYS_STUB0(compat_sys_name)
 #define __IA32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)
+#define __IA32_COMPAT_COND_SYSCALL(compat_sys_name)
 #define __IA32_SYS_STUB0(sys_name)
 #define __IA32_SYS_STUBx(x, sys_name, ...)
+#define __IA32_COND_SYSCALL(sys_name)
 #endif /* CONFIG_IA32_EMULATION */
 
 
@@ -105,9 +114,12 @@ struct pt_regs;
 	__SYS_STUBx(x32, compat_sys_name,				\
 		    SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__))
 
+#define __X32_COMPAT_COND_SYSCALL(compat_sys_name)			\
+	__COND_SYSCALL(x32, compat_sys_name)
 #else /* CONFIG_X86_X32 */
 #define __X32_COMPAT_SYS_STUB0(compat_sys_name)
 #define __X32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)
+#define __X32_COMPAT_COND_SYSCALL(compat_sys_name)
 #endif /* CONFIG_X86_X32 */
 
 
@@ -147,8 +159,8 @@ struct pt_regs;
  * kernel/time/posix-stubs.c to cover this case as well.
  */
 #define COND_SYSCALL_COMPAT(name) 					\
-	cond_syscall(__ia32_compat_sys_##name);				\
-	cond_syscall(__x32_compat_sys_##name)
+	__IA32_COMPAT_COND_SYSCALL(compat_sys_##name)			\
+	__X32_COMPAT_COND_SYSCALL(compat_sys_##name)
 
 #define COMPAT_SYS_NI(name)						\
 	SYSCALL_ALIAS(__ia32_compat_sys_##name, sys_ni_posix_timers);	\
@@ -220,13 +232,9 @@ struct pt_regs;
 	static asmlinkage long						\
 	__do_sys_##sname(const struct pt_regs *__unused)
 
-#ifndef COND_SYSCALL
-#define COND_SYSCALL(name) 							\
-	asmlinkage __weak long __x64_sys_##name(const struct pt_regs *__unused)	\
-	{									\
-		return sys_ni_syscall();					\
-	}
-#endif
+#define COND_SYSCALL(name)						\
+	__X64_COND_SYSCALL(sys_##name)					\
+	__IA32_COND_SYSCALL(sys_##name)
 
 #ifndef SYS_NI
 #define SYS_NI(name) SYSCALL_ALIAS(__x64_sys_##name, sys_ni_posix_timers);
Signature · 1 line
2.24.1
#6 lore raw

Re: [PATCH v2 3/8] x86, syscalls: Refactor COND_SYSCALL macros

Quoted 3 lines · Brian Gerst

Pull the common code out from the COND_SYSCALL macros into a new __COND_SYSCALL macro. Also conditionalize the X64 version in preparation for enabling syscall wrappers on 32-bit native kernels.

With the same caveat as the last patch: Nice work!

Thanks,
Dominik

#7 lore raw

PATCH v2 4/8 x86, syscalls: Refactor SYS_NI macros

In reply to Brian Gerst

Pull the common code out from the SYS_NI macros into a new __SYS_NI macro. Also conditionalize the X64 version in preparation for enabling syscall wrappers on 32-bit native kernels.

---
 arch/x86/include/asm/syscall_wrapper.h | 32 ++++++++++++++++++--------
 1 file changed, 23 insertions(+), 9 deletions(-)
arch/x86/include/asm/syscall_wrapper.h +23 -9
index 781adf7f611f..1166635cd841 100644
@@ -42,6 +42,9 @@ struct pt_regs;
 		return sys_ni_syscall();				\
 	}
 
+#define __SYS_NI(abi, name)						\
+	SYSCALL_ALIAS(__##abi##_##name, sys_ni_posix_timers)
+
 #ifdef CONFIG_X86_64
 #define __X64_SYS_STUB0(sys_name)					\
 	__SYS_STUB0(x64, sys_name)
@@ -52,10 +55,14 @@ struct pt_regs;
 
 #define __X64_COND_SYSCALL(sys_name)					\
 	__COND_SYSCALL(x64, sys_name)
+
+#define __X64_SYS_NI(sys_name)						\
+	__SYS_NI(x64, sys_name)
 #else /* CONFIG_X86_64 */
 #define __X64_SYS_STUB0(sys_name)
 #define __X64_SYS_STUBx(x, sys_name, ...)
 #define __X64_COND_SYSCALL(sys_name)
+#define __X64_SYS_NI(sys_name)
 #endif /* CONFIG_X86_64 */
 
 #ifdef CONFIG_IA32_EMULATION
@@ -77,6 +84,9 @@ struct pt_regs;
 #define __IA32_COMPAT_COND_SYSCALL(compat_sys_name)			\
 	__COND_SYSCALL(ia32, compat_sys_name)
 
+#define __IA32_COMPAT_SYS_NI(compat_sys_name)				\
+	__SYS_NI(ia32, compat_sys_name)
+
 #define __IA32_SYS_STUB0(sys_name)					\
 	__SYS_STUB0(ia32, sys_name)
 
@@ -87,17 +97,17 @@ struct pt_regs;
 #define __IA32_COND_SYSCALL(sys_name)					\
 	__COND_SYSCALL(ia32, sys_name)
 
-#define SYS_NI(name)							\
-	SYSCALL_ALIAS(__x64_sys_##name, sys_ni_posix_timers);		\
-	SYSCALL_ALIAS(__ia32_sys_##name, sys_ni_posix_timers)
-
+#define __IA32_SYS_NI(sys_name)						\
+	__SYS_NI(ia32, sys_name)
 #else /* CONFIG_IA32_EMULATION */
 #define __IA32_COMPAT_SYS_STUB0(compat_sys_name)
 #define __IA32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)
 #define __IA32_COMPAT_COND_SYSCALL(compat_sys_name)
+#define __IA32_COMPAT_SYS_NI(compat_sys_name)
 #define __IA32_SYS_STUB0(sys_name)
 #define __IA32_SYS_STUBx(x, sys_name, ...)
 #define __IA32_COND_SYSCALL(sys_name)
+#define __IA32_SYS_NI(sys_name)
 #endif /* CONFIG_IA32_EMULATION */
 
 
@@ -116,10 +126,14 @@ struct pt_regs;
 
 #define __X32_COMPAT_COND_SYSCALL(compat_sys_name)			\
 	__COND_SYSCALL(x32, compat_sys_name)
+
+#define __X32_COMPAT_SYS_NI(compat_sys_name)				\
+	__SYS_NI(x32, compat_sys_name)
 #else /* CONFIG_X86_X32 */
 #define __X32_COMPAT_SYS_STUB0(compat_sys_name)
 #define __X32_COMPAT_SYS_STUBx(x, compat_sys_name, ...)
 #define __X32_COMPAT_COND_SYSCALL(compat_sys_name)
+#define __X32_COMPAT_SYS_NI(compat_sys_name)
 #endif /* CONFIG_X86_X32 */
 
 
@@ -163,8 +177,8 @@ struct pt_regs;
 	__X32_COMPAT_COND_SYSCALL(compat_sys_##name)
 
 #define COMPAT_SYS_NI(name)						\
-	SYSCALL_ALIAS(__ia32_compat_sys_##name, sys_ni_posix_timers);	\
-	SYSCALL_ALIAS(__x32_compat_sys_##name, sys_ni_posix_timers)
+	__IA32_COMPAT_SYS_NI(compat_sys_##name)				\
+	__X32_COMPAT_SYS_NI(compat_sys_##name)
 
 #endif /* CONFIG_COMPAT */
 
@@ -236,9 +250,9 @@ struct pt_regs;
 	__X64_COND_SYSCALL(sys_##name)					\
 	__IA32_COND_SYSCALL(sys_##name)
 
-#ifndef SYS_NI
-#define SYS_NI(name) SYSCALL_ALIAS(__x64_sys_##name, sys_ni_posix_timers);
-#endif
+#define SYS_NI(name)							\
+	__X64_SYS_NI(sys_##name)					\
+	__IA32_SYS_NI(sys_##name)
 
 
 /*
Signature · 1 line
2.24.1
#8 lore raw

Re: [PATCH v2 4/8] x86, syscalls: Refactor SYS_NI macros

Quoted 3 lines · Brian Gerst

Pull the common code out from the SYS_NI macros into a new __SYS_NI macro. Also conditionalize the X64 version in preparation for enabling syscall wrappers on 32-bit native kernels.

Same comment about naming; looks good otherwise.

Thanks,
Dominik

#9 lore raw

PATCH v2 5/8 x86: Move 32-bit compat syscalls to common location

In reply to Brian Gerst

Move the 32-bit wrappers for syscalls that take 64-bit arguments (loff_t) to a common location so that native 32-bit can use them in preparation for enabling pt_regs-based syscalls.

---
 arch/x86/entry/syscalls/syscall_32.tbl |  18 ++--
 arch/x86/ia32/Makefile                 |   2 +-
 arch/x86/kernel/Makefile               |   2 +
 arch/x86/{ia32 => kernel}/sys_ia32.c   | 130 ++++++++++++-------------
 arch/x86/um/sys_call_table_32.c        |  10 ++
 5 files changed, 87 insertions(+), 75 deletions(-)
 rename arch/x86/{ia32 => kernel}/sys_ia32.c (83%)
arch/x86/entry/syscalls/syscall_32.tbl +9 -9
index c17cb77eb150..f06f0d1b1282 100644
@@ -191,8 +191,8 @@
 177	i386	rt_sigtimedwait		sys_rt_sigtimedwait_time32	__ia32_compat_sys_rt_sigtimedwait_time32
 178	i386	rt_sigqueueinfo		sys_rt_sigqueueinfo		__ia32_compat_sys_rt_sigqueueinfo
 179	i386	rt_sigsuspend		sys_rt_sigsuspend		__ia32_compat_sys_rt_sigsuspend
-180	i386	pread64			sys_pread64			__ia32_compat_sys_x86_pread
-181	i386	pwrite64		sys_pwrite64			__ia32_compat_sys_x86_pwrite
+180	i386	pread64			sys_x86_pread			__ia32_sys_x86_pread
+181	i386	pwrite64		sys_x86_pwrite			__ia32_sys_x86_pwrite
 182	i386	chown			sys_chown16			__ia32_sys_chown16
 183	i386	getcwd			sys_getcwd			__ia32_sys_getcwd
 184	i386	capget			sys_capget			__ia32_sys_capget
@@ -204,8 +204,8 @@
 190	i386	vfork			sys_vfork			__ia32_sys_vfork
 191	i386	ugetrlimit		sys_getrlimit			__ia32_compat_sys_getrlimit
 192	i386	mmap2			sys_mmap_pgoff			__ia32_sys_mmap_pgoff
-193	i386	truncate64		sys_truncate64			__ia32_compat_sys_x86_truncate64
-194	i386	ftruncate64		sys_ftruncate64			__ia32_compat_sys_x86_ftruncate64
+193	i386	truncate64		sys_x86_truncate64		__ia32_sys_x86_truncate64
+194	i386	ftruncate64		sys_x86_ftruncate64		__ia32_sys_x86_ftruncate64
 195	i386	stat64			sys_stat64			__ia32_compat_sys_x86_stat64
 196	i386	lstat64			sys_lstat64			__ia32_compat_sys_x86_lstat64
 197	i386	fstat64			sys_fstat64			__ia32_compat_sys_x86_fstat64
@@ -236,7 +236,7 @@
 # 222 is unused
 # 223 is unused
 224	i386	gettid			sys_gettid			__ia32_sys_gettid
-225	i386	readahead		sys_readahead			__ia32_compat_sys_x86_readahead
+225	i386	readahead		sys_x86_readahead		__ia32_sys_x86_readahead
 226	i386	setxattr		sys_setxattr			__ia32_sys_setxattr
 227	i386	lsetxattr		sys_lsetxattr			__ia32_sys_lsetxattr
 228	i386	fsetxattr		sys_fsetxattr			__ia32_sys_fsetxattr
@@ -261,7 +261,7 @@
 247	i386	io_getevents		sys_io_getevents_time32		__ia32_sys_io_getevents_time32
 248	i386	io_submit		sys_io_submit			__ia32_compat_sys_io_submit
 249	i386	io_cancel		sys_io_cancel			__ia32_sys_io_cancel
-250	i386	fadvise64		sys_fadvise64			__ia32_compat_sys_x86_fadvise64
+250	i386	fadvise64		sys_x86_fadvise64		__ia32_sys_x86_fadvise64
 # 251 is available for reuse (was briefly sys_set_zone_reclaim)
 252	i386	exit_group		sys_exit_group			__ia32_sys_exit_group
 253	i386	lookup_dcookie		sys_lookup_dcookie		__ia32_compat_sys_lookup_dcookie
@@ -283,7 +283,7 @@
 269	i386	fstatfs64		sys_fstatfs64			__ia32_compat_sys_fstatfs64
 270	i386	tgkill			sys_tgkill			__ia32_sys_tgkill
 271	i386	utimes			sys_utimes_time32		__ia32_sys_utimes_time32
-272	i386	fadvise64_64		sys_fadvise64_64		__ia32_compat_sys_x86_fadvise64_64
+272	i386	fadvise64_64		sys_x86_fadvise64_64		__ia32_sys_x86_fadvise64_64
 273	i386	vserver
 274	i386	mbind			sys_mbind			__ia32_sys_mbind
 275	i386	get_mempolicy		sys_get_mempolicy		__ia32_compat_sys_get_mempolicy
@@ -325,7 +325,7 @@
 311	i386	set_robust_list		sys_set_robust_list		__ia32_compat_sys_set_robust_list
 312	i386	get_robust_list		sys_get_robust_list		__ia32_compat_sys_get_robust_list
 313	i386	splice			sys_splice			__ia32_sys_splice
-314	i386	sync_file_range		sys_sync_file_range		__ia32_compat_sys_x86_sync_file_range
+314	i386	sync_file_range		sys_x86_sync_file_range		__ia32_sys_x86_sync_file_range
 315	i386	tee			sys_tee				__ia32_sys_tee
 316	i386	vmsplice		sys_vmsplice			__ia32_compat_sys_vmsplice
 317	i386	move_pages		sys_move_pages			__ia32_compat_sys_move_pages
@@ -335,7 +335,7 @@
 321	i386	signalfd		sys_signalfd			__ia32_compat_sys_signalfd
 322	i386	timerfd_create		sys_timerfd_create		__ia32_sys_timerfd_create
 323	i386	eventfd			sys_eventfd			__ia32_sys_eventfd
-324	i386	fallocate		sys_fallocate			__ia32_compat_sys_x86_fallocate
+324	i386	fallocate		sys_x86_fallocate		__ia32_sys_x86_fallocate
 325	i386	timerfd_settime		sys_timerfd_settime32		__ia32_sys_timerfd_settime32
 326	i386	timerfd_gettime		sys_timerfd_gettime32		__ia32_sys_timerfd_gettime32
 327	i386	signalfd4		sys_signalfd4			__ia32_compat_sys_signalfd4
arch/x86/ia32/Makefile +1 -1
index d13b352b2aa7..8e4d0391ff6c 100644
@@ -3,7 +3,7 @@
 # Makefile for the ia32 kernel emulation subsystem.
 #
 
-obj-$(CONFIG_IA32_EMULATION) := sys_ia32.o ia32_signal.o
+obj-$(CONFIG_IA32_EMULATION) := ia32_signal.o
 
 obj-$(CONFIG_IA32_AOUT) += ia32_aout.o
 
arch/x86/kernel/Makefile +2 -0
index 70615591a265..3f6d611fce08 100644
@@ -57,6 +57,8 @@ obj-y			+= setup.o x86_init.o i8259.o irqinit.o
 obj-$(CONFIG_JUMP_LABEL)	+= jump_label.o
 obj-$(CONFIG_IRQ_WORK)  += irq_work.o
 obj-y			+= probe_roms.o
+obj-$(CONFIG_X86_32)	+= sys_ia32.o
+obj-$(CONFIG_IA32_EMULATION)	+= sys_ia32.o
 obj-$(CONFIG_X86_64)	+= sys_x86_64.o
 obj-$(CONFIG_X86_ESPFIX64)	+= espfix_64.o
 obj-$(CONFIG_SYSFS)	+= ksysfs.o
arch/x86/kernel/sys_ia32.c renamed from arch/x86/ia32/sys_ia32.c +65 -65

154 lines not on this page · raw message

arch/x86/um/sys_call_table_32.c +10 -0
index 9649b5ad2ca2..d5520e92f89d 100644
@@ -26,6 +26,16 @@
 
 #define old_mmap sys_old_mmap
 
+#define sys_x86_pread sys_pread64
+#define sys_x86_pwrite sys_pwrite64
+#define sys_x86_truncate64 sys_truncate64
+#define sys_x86_ftruncate64 sys_ftruncate64
+#define sys_x86_readahead sys_readahead
+#define sys_x86_fadvise64 sys_fadvise64
+#define sys_x86_fadvise64_64 sys_fadvise64_64
+#define sys_x86_sync_file_range sys_sync_file_range
+#define sys_x86_fallocate sys_fallocate
+
 #define __SYSCALL_I386(nr, sym, qual) extern asmlinkage long sym(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) ;
 #include <asm/syscalls_32.h>
 
Signature · 1 line
2.24.1
#11 lore raw

PATCH v2 6/8 x86-32: Enable syscall wrappers

In reply to Brian Gerst

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.

---
 arch/x86/Kconfig                       |   2 +-
 arch/x86/entry/common.c                |  20 +-
 arch/x86/entry/syscall_32.c            |  11 +-
 arch/x86/entry/syscall_64.c            |   7 -
 arch/x86/entry/syscalls/syscall_32.tbl | 818 ++++++++++++-------------
 arch/x86/entry/syscalls/syscalltbl.sh  |  33 +-
 arch/x86/include/asm/syscall.h         |   6 -
 arch/x86/include/asm/syscall_wrapper.h | 123 ++--
 arch/x86/include/asm/syscalls.h        |  29 -
 9 files changed, 503 insertions(+), 546 deletions(-)
arch/x86/Kconfig +1 -1
index 7f65ee880463..d1c1920f2a55 100644
@@ -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
@@ -79,6 +78,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 +7 -13
index ec167d8c41cb..91689fd7a5e8 100644
@@ -334,20 +334,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,3 +426,10 @@ __visible long do_fast_syscall_32(struct pt_regs *regs)
 #endif
 }
 #endif
+
+extern asmlinkage long sys_ni_syscall(void);
+
+SYSCALL_DEFINE0(ni_syscall)
+{
+	return sys_ni_syscall();
+}
arch/x86/entry/syscall_32.c +2 -9
index 7d17b3addbbb..7af944b686ef 100644
@@ -4,18 +4,11 @@
 #include <linux/linkage.h>
 #include <linux/sys.h>
 #include <linux/cache.h>
+#include <linux/syscalls.h>
 #include <asm/asm-offsets.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, qual) extern asmlinkage long sym(const struct pt_regs *);
-#define __sys_ni_syscall __ia32_sys_ni_syscall
-#else /* CONFIG_IA32_EMULATION */
-#define __SYSCALL_I386(nr, sym, qual) 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
@@ -27,6 +20,6 @@ __visible const sys_call_ptr_t ia32_sys_call_table[__NR_syscall_compat_max+1] =
 	 * Smells like a compiler bug -- it doesn't work
 	 * when the & below is removed.
 	 */
-	[0 ... __NR_syscall_compat_max] = &__sys_ni_syscall,
+	[0 ... __NR_syscall_compat_max] = &__ia32_sys_ni_syscall,
 #include <asm/syscalls_32.h>
 };
arch/x86/entry/syscall_64.c +0 -7
index adf619a856e8..058dc1b73e96 100644
@@ -8,13 +8,6 @@
 #include <asm/asm-offsets.h>
 #include <asm/syscall.h>
 
-extern asmlinkage long sys_ni_syscall(void);
-
-SYSCALL_DEFINE0(ni_syscall)
-{
-	return sys_ni_syscall();
-}
-
 #define __SYSCALL_64(nr, sym, qual) extern asmlinkage long sym(const struct pt_regs *);
 #define __SYSCALL_X32(nr, sym, qual) __SYSCALL_64(nr, sym, qual)
 #include <asm/syscalls_64.h>
arch/x86/entry/syscalls/syscall_32.tbl +409 -409

843 lines not on this page · raw message

arch/x86/entry/syscalls/syscalltbl.sh +20 -13
index 1af2be39e7d9..e776a68bbe42 100644
@@ -36,25 +36,32 @@ emit() {
     if [ "$abi" = "64" -a "${entry}" != "${entry#__x64_sys}" ]; then
 	    umlentry="sys${entry#__x64_sys}"
     fi
+    if [ "$abi" = "I386" -a "${entry}" != "${entry#__ia32_sys}" ]; then
+	    umlentry="sys${entry#__ia32_sys}"
+    fi
 
-    if [ -z "$compat" ]; then
-	if [ -n "$entry" -a -z "$umlentry" ]; then
-	    syscall_macro "$abi" "$nr" "$entry"
-	elif [ -n "$umlentry" ]; then # implies -n "$entry"
+    if [ -n "$entry" ]; then
+	if [ -n "$umlentry" ]; then
 	    echo "#ifdef CONFIG_X86"
-	    syscall_macro "$abi" "$nr" "$entry"
+	fi
+
+	if [ -n "$compat" ]; then
+	    echo "#ifdef CONFIG_X86_32"
+	fi
+
+	syscall_macro "$abi" "$nr" "$entry"
+
+	if [ -n "$compat" ]; then
+	    echo "#else /* CONFIG_X86_32 */"
+	    syscall_macro "$abi" "$nr" "$compat"
+	    echo "#endif"
+	fi
+
+	if [ -n "$umlentry" ]; then
 	    echo "#else /* CONFIG_UML */"
 	    syscall_macro "$abi" "$nr" "$umlentry"
 	    echo "#endif"
 	fi
-    else
-	echo "#ifdef CONFIG_X86_32"
-	if [ -n "$entry" ]; then
-	    syscall_macro "$abi" "$nr" "$entry"
-	fi
-	echo "#else"
-	syscall_macro "$abi" "$nr" "$compat"
-	echo "#endif"
     fi
 }
 
arch/x86/include/asm/syscall.h +0 -6
index d20ffc518cf4..576178aefa01 100644
@@ -17,13 +17,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 +64 -59

153 lines not on this page · raw message

arch/x86/include/asm/syscalls.h +0 -29
index 91b7b6e1a115..06cbdca634d6 100644
@@ -17,33 +17,4 @@
 /* kernel/ioport.c */
 long ksys_ioperm(unsigned long from, unsigned long num, int turn_on);
 
-#ifdef CONFIG_X86_32
-/*
- * These definitions are only valid on pure 32-bit systems; x86-64 uses a
- * different syscall calling convention
- */
-asmlinkage long sys_ioperm(unsigned long, unsigned long, int);
-asmlinkage long sys_iopl(unsigned int);
-
-/* kernel/ldt.c */
-asmlinkage long sys_modify_ldt(int, void __user *, unsigned long);
-
-/* kernel/signal.c */
-asmlinkage long sys_rt_sigreturn(void);
-
-/* kernel/tls.c */
-asmlinkage long sys_set_thread_area(struct user_desc __user *);
-asmlinkage long sys_get_thread_area(struct user_desc __user *);
-
-/* X86_32 only */
-
-/* kernel/signal.c */
-asmlinkage long sys_sigreturn(void);
-
-/* kernel/vm86_32.c */
-struct vm86_struct;
-asmlinkage long sys_vm86old(struct vm86_struct __user *);
-asmlinkage long sys_vm86(unsigned long, unsigned long);
-
-#endif /* CONFIG_X86_32 */
 #endif /* _ASM_X86_SYSCALLS_H */
Signature · 1 line
2.24.1
#12 lore raw

PATCH v2 7/8 x86-64: Use syscall wrappers for x32_rt_sigreturn

In reply to Brian Gerst

Add missing syscall wrapper for x32_rt_sigreturn().

---
 arch/x86/entry/syscalls/syscall_64.tbl | 2 +-
 arch/x86/include/asm/sighandling.h     | 5 -----
 arch/x86/kernel/signal.c               | 2 +-
 3 files changed, 2 insertions(+), 7 deletions(-)
arch/x86/entry/syscalls/syscall_64.tbl +1 -1
index 44d510bc9b78..0b5a25bc9998 100644
@@ -367,7 +367,7 @@
 # is defined.
 #
 512	x32	rt_sigaction		__x32_compat_sys_rt_sigaction
-513	x32	rt_sigreturn		sys32_x32_rt_sigreturn
+513	x32	rt_sigreturn		__x32_compat_sys_x32_rt_sigreturn
 514	x32	ioctl			__x32_compat_sys_ioctl
 515	x32	readv			__x32_compat_sys_readv
 516	x32	writev			__x32_compat_sys_writev
arch/x86/include/asm/sighandling.h +0 -5
index 2fcbd6f33ef7..bd26834724e5 100644
@@ -17,9 +17,4 @@ void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
 int setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate,
 		     struct pt_regs *regs, unsigned long mask);
 
-
-#ifdef CONFIG_X86_X32_ABI
-asmlinkage long sys32_x32_rt_sigreturn(void);
-#endif
-
 #endif /* _ASM_X86_SIGHANDLING_H */
arch/x86/kernel/signal.c +1 -1
index 8a29573851a3..860904990b26 100644
@@ -859,7 +859,7 @@ void signal_fault(struct pt_regs *regs, void __user *frame, char *where)
 }
 
 #ifdef CONFIG_X86_X32_ABI
-asmlinkage long sys32_x32_rt_sigreturn(void)
+COMPAT_SYSCALL_DEFINE0(x32_rt_sigreturn)
 {
 	struct pt_regs *regs = current_pt_regs();
 	struct rt_sigframe_x32 __user *frame;
Signature · 1 line
2.24.1
#13 lore raw

PATCH v2 8/8 x86: Drop asmlinkage from syscalls

In reply to Brian Gerst

asmlinkage is no longer required since the syscall ABI is now fully under x86 architecture control. This makes the 32-bit native syscalls a bit more effecient by passing in regs via EAX instead of on the stack.

---
 arch/x86/entry/syscall_32.c            |  2 +-
 arch/x86/entry/syscall_64.c            |  2 +-
 arch/x86/include/asm/syscall.h         |  2 +-
 arch/x86/include/asm/syscall_wrapper.h | 31 ++++++++++++--------------
 4 files changed, 17 insertions(+), 20 deletions(-)
arch/x86/entry/syscall_32.c +1 -1
index 7af944b686ef..4e0113f3d4e8 100644
@@ -8,7 +8,7 @@
 #include <asm/asm-offsets.h>
 #include <asm/syscall.h>
 
-#define __SYSCALL_I386(nr, sym, qual) extern asmlinkage long sym(const struct pt_regs *);
+#define __SYSCALL_I386(nr, sym, qual) extern long sym(const struct pt_regs *);
 
 #include <asm/syscalls_32.h>
 #undef __SYSCALL_I386
arch/x86/entry/syscall_64.c +1 -1
index 058dc1b73e96..3331a71eec77 100644
@@ -8,7 +8,7 @@
 #include <asm/asm-offsets.h>
 #include <asm/syscall.h>
 
-#define __SYSCALL_64(nr, sym, qual) extern asmlinkage long sym(const struct pt_regs *);
+#define __SYSCALL_64(nr, sym, qual) extern long sym(const struct pt_regs *);
 #define __SYSCALL_X32(nr, sym, qual) __SYSCALL_64(nr, sym, qual)
 #include <asm/syscalls_64.h>
 #undef __SYSCALL_64
arch/x86/include/asm/syscall.h +1 -1
index 576178aefa01..a0b189714bac 100644
@@ -17,7 +17,7 @@
 #include <asm/thread_info.h>	/* for TS_COMPAT */
 #include <asm/unistd.h>
 
-typedef asmlinkage long (*sys_call_ptr_t)(const struct pt_regs *);
+typedef long (*sys_call_ptr_t)(const struct pt_regs *);
 extern const sys_call_ptr_t sys_call_table[];
 
 #if defined(CONFIG_X86_32)
arch/x86/include/asm/syscall_wrapper.h +14 -17
index f793f3b990a8..9b399f073642 100644
@@ -8,8 +8,8 @@
 
 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);
+extern long __x64_sys_ni_syscall(const struct pt_regs *regs);
+extern long __ia32_sys_ni_syscall(const struct pt_regs *regs);
 
 /*
  * Instead of the generic __SYSCALL_DEFINEx() definition, the x86 version takes
@@ -66,22 +66,21 @@ extern asmlinkage long __ia32_sys_ni_syscall(const struct pt_regs *regs);
 	      ,,(unsigned int)regs->di,,(unsigned int)regs->bp)
 
 #define __SYS_STUB0(abi, name)						\
-	asmlinkage long __##abi##_##name(const struct pt_regs *regs);	\
+	long __##abi##_##name(const struct pt_regs *regs);		\
 	ALLOW_ERROR_INJECTION(__##abi##_##name, ERRNO);			\
-	asmlinkage long __##abi##_##name(const struct pt_regs *regs)	\
+	long __##abi##_##name(const struct pt_regs *regs)		\
 		__alias(__do_##name);
 
 #define __SYS_STUBx(abi, name, ...)					\
-	asmlinkage long __##abi##_##name(const struct pt_regs *regs);	\
+	long __##abi##_##name(const struct pt_regs *regs);		\
 	ALLOW_ERROR_INJECTION(__##abi##_##name, ERRNO);			\
-	asmlinkage long __##abi##_##name(const struct pt_regs *regs)	\
+	long __##abi##_##name(const struct pt_regs *regs)		\
 	{								\
 		return __se_##name(__VA_ARGS__);			\
 	}
 
 #define __COND_SYSCALL(abi, name)					\
-	asmlinkage __weak long						\
-	__##abi##_##name(const struct pt_regs *__unused)		\
+	__weak long __##abi##_##name(const struct pt_regs *__unused)	\
 	{								\
 		return sys_ni_syscall();				\
 	}
@@ -183,11 +182,11 @@ extern asmlinkage long __ia32_sys_ni_syscall(const struct pt_regs *regs);
  * of them.
  */
 #define COMPAT_SYSCALL_DEFINE0(name)					\
-	static asmlinkage long						\
+	static long							\
 	__do_compat_sys_##name(const struct pt_regs *__unused);		\
 	__IA32_COMPAT_SYS_STUB0(compat_sys_##name)			\
 	__X32_COMPAT_SYS_STUB0(compat_sys_##name)			\
-	static asmlinkage long						\
+	static long							\
 	__do_compat_sys_##name(const struct pt_regs *__unused)
 
 #define COMPAT_SYSCALL_DEFINEx(x, name, ...)				\
@@ -244,12 +243,10 @@ extern asmlinkage long __ia32_sys_ni_syscall(const struct pt_regs *regs);
  */
 #define SYSCALL_DEFINE0(sname)						\
 	SYSCALL_METADATA(_##sname, 0);					\
-	static asmlinkage long						\
-	__do_sys_##sname(const struct pt_regs *__unused);		\
+	static long __do_sys_##sname(const struct pt_regs *__unused);	\
 	__X64_SYS_STUB0(sys_##sname)					\
 	__IA32_SYS_STUB0(sys_##sname)					\
-	static asmlinkage long						\
-	__do_sys_##sname(const struct pt_regs *__unused)
+	static long __do_sys_##sname(const struct pt_regs *__unused)
 
 #define COND_SYSCALL(name)						\
 	__X64_COND_SYSCALL(sys_##name)					\
@@ -264,8 +261,8 @@ extern asmlinkage long __ia32_sys_ni_syscall(const struct pt_regs *regs);
  * For VSYSCALLS, we need to declare these three syscalls with the new
  * pt_regs-based calling convention for in-kernel use.
  */
-asmlinkage long __x64_sys_getcpu(const struct pt_regs *regs);
-asmlinkage long __x64_sys_gettimeofday(const struct pt_regs *regs);
-asmlinkage long __x64_sys_time(const struct pt_regs *regs);
+long __x64_sys_getcpu(const struct pt_regs *regs);
+long __x64_sys_gettimeofday(const struct pt_regs *regs);
+long __x64_sys_time(const struct pt_regs *regs);
 
 #endif /* _ASM_X86_SYSCALL_WRAPPER_H */
Signature · 1 line
2.24.1