x32 and compat syscall improvements
Subsystems (3)
Andy Lutomirski
maintainercover x32 and compat syscall improvements
This series contains a couple of minor cleanups and a major change to the way that x32 syscalls work. We currently have a range of syscall numbers starting at 512 that are rather annoying -- they've been known to cause security problems for seccomp filter authors who don't know about them, and they cause people to think that x86_64 will run out of syscall numbers after 511 due to a conflict with x32.
With this series applied, 512-547 can be just a silly legacy oddity just like all the other silly legacy oddities we have, and we can go on with our lives without kludges starting at 548 :)
Andy Lutomirski (4):
x86/syscalls: Use the compat versions of rt_sigsuspend() and
rt_sigprocmask()
x86/syscalls: Disallow compat entries for all types of 64-bit syscalls x86/syscalls: Split the x32 syscalls into their own table x86/syscalls: Make __X32_SYSCALL_BIT be unsigned long
arch/x86/entry/common.c | 13 +-- arch/x86/entry/syscall_64.c | 25 ++++++ arch/x86/entry/syscalls/syscall_32.tbl | 4 +- arch/x86/entry/syscalls/syscalltbl.sh | 35 ++++---- arch/x86/include/asm/syscall.h | 4 + arch/x86/include/asm/unistd.h | 6 -- arch/x86/include/uapi/asm/unistd.h | 2 +- arch/x86/kernel/asm-offsets_64.c | 20 +++++ tools/testing/selftests/x86/Makefile | 2 +- .../testing/selftests/x86/syscall_numbering.c | 89 +++++++++++++++++++ 10 files changed, 168 insertions(+), 32 deletions(-) create mode 100644 tools/testing/selftests/x86/syscall_numbering.c
Signature · 1 line
2.21.0
Andy Lutomirski
maintainerPATCH 1/4 x86/syscalls: Use the compat versions of rt_sigsuspend() and rt_sigprocmask()
I'm working on some code that detects at build time if there's a COMPAT_SYSCALL_DEFINE() that is not referenced in the x86 syscall tables. It catches three offenders: rt_sigsuspend(), rt_sigprocmask(), and sendfile64().
For rt_sigsuspend() and rt_sigprocmask(), the only potential difference between the native and compat versions is that the compat version converts the sigset_t, but, on little endian architectures, the conversion is a no-op. This is why they both currently work on x86.
To make the code more consistent, and to make my upcoming patches work, this patch rewires x86 to use the compat vesions.
sendfile64() is more complicated, and I'll address it separately.
--- arch/x86/entry/syscalls/syscall_32.tbl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/entry/syscalls/syscall_32.tbl +2 -2
@@ -186,11 +186,11 @@ 172 i386 prctl sys_prctl __ia32_sys_prctl 173 i386 rt_sigreturn sys_rt_sigreturn sys32_rt_sigreturn 174 i386 rt_sigaction sys_rt_sigaction __ia32_compat_sys_rt_sigaction -175 i386 rt_sigprocmask sys_rt_sigprocmask __ia32_sys_rt_sigprocmask +175 i386 rt_sigprocmask sys_rt_sigprocmask __ia32_compat_sys_rt_sigprocmask 176 i386 rt_sigpending sys_rt_sigpending __ia32_compat_sys_rt_sigpending 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_sys_rt_sigsuspend +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 182 i386 chown sys_chown16 __ia32_sys_chown16
Signature · 1 line
2.21.0
tip-bot for Andy Lutomirski
merge bot[tip:x86/entry] x86/syscalls: Use the compat versions of rt_sigsuspend() and rt_sigprocmask()
x86/syscalls: Use the compat versions of rt_sigsuspend() and rt_sigprocmask()
Commit-ID: a8d03c3f300eefff3b5c14798409e4b43e37dd9b Gitweb: https://git.kernel.org/tip/a8d03c3f300eefff3b5c14798409e4b43e37dd9b Author: Andy Lutomirski <[email protected]> AuthorDate: Wed, 3 Jul 2019 13:34:02 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 22 Jul 2019 10:31:22 +0200
x86/syscalls: Use the compat versions of rt_sigsuspend() and rt_sigprocmask()
I'm working on some code that detects at build time if there's a COMPAT_SYSCALL_DEFINE() that is not referenced in the x86 syscall tables. It catches three offenders: rt_sigsuspend(), rt_sigprocmask(), and sendfile64().
For rt_sigsuspend() and rt_sigprocmask(), the only potential difference between the native and compat versions is that the compat version converts the sigset_t, but, on little endian architectures, the conversion is a no-op. This is why they both currently work on x86.
To make the code more consistent, and to make the upcoming patches work, rewire x86 to use the compat vesions.
sendfile64() is more complicated, and will be addressed separately.
--- arch/x86/entry/syscalls/syscall_32.tbl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/entry/syscalls/syscall_32.tbl +2 -2
@@ -186,11 +186,11 @@ 172 i386 prctl sys_prctl __ia32_sys_prctl 173 i386 rt_sigreturn sys_rt_sigreturn sys32_rt_sigreturn 174 i386 rt_sigaction sys_rt_sigaction __ia32_compat_sys_rt_sigaction -175 i386 rt_sigprocmask sys_rt_sigprocmask __ia32_sys_rt_sigprocmask +175 i386 rt_sigprocmask sys_rt_sigprocmask __ia32_compat_sys_rt_sigprocmask 176 i386 rt_sigpending sys_rt_sigpending __ia32_compat_sys_rt_sigpending 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_sys_rt_sigsuspend +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 182 i386 chown sys_chown16 __ia32_sys_chown16
Andy Lutomirski
maintainerPATCH 2/4 x86/syscalls: Disallow compat entries for all types of 64-bit syscalls
In reply to Andy LutomirskiA "compat" entry in the syscall tables means to use a different entry on 32-bit and 64-bit builds. This only makes sense for syscalls that exist in the first place in 32-bit builds, so disallow it for anything other than i386.
--- arch/x86/entry/syscalls/syscalltbl.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/entry/syscalls/syscalltbl.sh +2 -2
@@ -27,8 +27,8 @@ emit() { compat="$4" umlentry="" - if [ "$abi" = "64" -a -n "$compat" ]; then - echo "a compat entry for a 64-bit syscall makes no sense" >&2 + if [ "$abi" != "I386" -a -n "$compat" ]; then + echo "a compat entry ($abi: $compat) for a 64-bit syscall makes no sense" >&2 exit 1 fi
Signature · 1 line
2.21.0
tip-bot for Andy Lutomirski
merge bot[tip:x86/entry] x86/syscalls: Disallow compat entries for all types of 64-bit syscalls
x86/syscalls: Disallow compat entries for all types of 64-bit syscalls
Commit-ID: f85a8573ceb225e606fcf38a9320782316f47c71 Gitweb: https://git.kernel.org/tip/f85a8573ceb225e606fcf38a9320782316f47c71 Author: Andy Lutomirski <[email protected]> AuthorDate: Wed, 3 Jul 2019 13:34:03 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 22 Jul 2019 10:31:22 +0200
x86/syscalls: Disallow compat entries for all types of 64-bit syscalls
A "compat" entry in the syscall tables means to use a different entry on 32-bit and 64-bit builds.
This only makes sense for syscalls that exist in the first place in 32-bit builds, so disallow it for anything other than i386.
--- arch/x86/entry/syscalls/syscalltbl.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/entry/syscalls/syscalltbl.sh +2 -2
@@ -27,8 +27,8 @@ emit() { compat="$4" umlentry="" - if [ "$abi" = "64" -a -n "$compat" ]; then - echo "a compat entry for a 64-bit syscall makes no sense" >&2 + if [ "$abi" != "I386" -a -n "$compat" ]; then + echo "a compat entry ($abi: $compat) for a 64-bit syscall makes no sense" >&2 exit 1 fi
Andy Lutomirski
maintainerPATCH 3/4 x86/syscalls: Split the x32 syscalls into their own table
In reply to Andy LutomirskiFor unfortunate historical reasons, the x32 syscalls and the x86_64 syscalls are not all numbered the same. As an example, ioctl() is nr 16 on x86_64 but 514 on x32.
This has potentially nasty consequences, since it means that there are two valid RAX values to do ioctl(2) and two invalid RAX values. The valid values are 16 (i.e. ioctl(2) using the x86_64 ABI) and (514 | 0x40000000) (i.e. ioctl(2) using the x32 ABI). The invalid values are 514 and (16 | 0x40000000). 514 will enter the "COMPAT_SYSCALL_DEFINE3(ioctl, ...)" entry point with in_compat_syscall() and in_x32_syscall() returning false, whereas (16 | 0x40000000) will enter the native entry point with in_compat_syscall() and in_x32_syscall() returning true. Both are bogus, and both will exercise code paths in the kernel and in any running seccomp filters that really ought to be unreachable.
By splitting out the x32 syscalls into their own tables, we can make both bogus invocations return -ENOSYS. I've checked glibc, musl, and Bionic, and all of them appear to call syscalls with their correct numbers, so this patch should have no effect on them.
This patch has an added benefit going forward: new syscalls that need special handling on x32 can share the same number on x32 and x86_64. This means that the special syscall range 512-547 can be treated as a legacy wart instead of something that may need to be extended in the future.
This patch also adds a selftest to verify the new behavior.
--- arch/x86/entry/common.c | 13 +-- arch/x86/entry/syscall_64.c | 25 ++++++ arch/x86/entry/syscalls/syscalltbl.sh | 31 ++++--- arch/x86/include/asm/syscall.h | 4 + arch/x86/include/asm/unistd.h | 6 -- arch/x86/kernel/asm-offsets_64.c | 20 +++++ tools/testing/selftests/x86/Makefile | 2 +- .../testing/selftests/x86/syscall_numbering.c | 89 +++++++++++++++++++ 8 files changed, 163 insertions(+), 27 deletions(-) create mode 100644 tools/testing/selftests/x86/syscall_numbering.c
arch/x86/entry/common.c +7 -6
@@ -290,15 +290,16 @@ __visible void do_syscall_64(unsigned long nr, struct pt_regs *regs)if (READ_ONCE (ti->flags) & _TIF_WORK_SYSCALL_ENTRY) nr =syscall_trace_enter (regs); -/* -* NB: Native and x32 syscalls are dispatched from the same -* table. The only functional difference is the x32 bit in -* regs->orig_ax, which changes the behavior of some syscalls. -*/ - nr &= __SYSCALL_MASK;if (likely (nr < NR_syscalls)) { nr =array_index_nospec (nr, NR_syscalls); regs->ax = sys_call_table[nr](regs); +#ifdef CONFIG_X86_X32_ABI + }else if (likely ((nr & __X32_SYSCALL_BIT) && + (nr & ~__X32_SYSCALL_BIT) < X32_NR_syscalls)) { + nr =array_index_nospec (nr & ~__X32_SYSCALL_BIT, + X32_NR_syscalls); + regs->ax = x32_sys_call_table[nr](regs); +#endif }syscall_return_slowpath (regs);
arch/x86/entry/syscall_64.c +25 -0
@@ -10,10 +10,13 @@/* this is a lie, but it does not hurt as sys_ni_syscall just returns -EINVAL */ extern asmlinkage long sys_ni_syscall (const struct pt_regs *);#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> #undef __SYSCALL_64 +#undef __SYSCALL_X32#define __SYSCALL_64 (nr, sym, qual) [nr] = sym, +#define __SYSCALL_X32 (nr, sym, qual) asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = {/*
@@ -23,3 +26,25 @@ asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = { [0 ... __NR_syscall_max] = &sys_ni_syscall,#include <asm/syscalls_64.h> }; + +#undef __SYSCALL_64 +#undef __SYSCALL_X32 + +#ifdef CONFIG_X86_X32_ABI + +#define __SYSCALL_64 (nr, sym, qual) +#define __SYSCALL_X32 (nr, sym, qual) [nr] = sym, + +asmlinkage const sys_call_ptr_t x32_sys_call_table[__NR_syscall_x32_max+1] = { +/* +* Smells like a compiler bug -- it doesn't work +* when the & below is removed. +*/ + [0 ... __NR_syscall_x32_max] = &sys_ni_syscall, +#include <asm/syscalls_64.h> +}; + +#undef __SYSCALL_64 +#undef __SYSCALL_X32 + +#endif
arch/x86/entry/syscalls/syscalltbl.sh +17 -14
@@ -1,13 +1,13 @@ -#!/bin/sh +#!/bin/bash # SPDX-License-Identifier: GPL-2.0 in="$1" out="$2" syscall_macro() { - abi="$1" - nr="$2" - entry="$3" + local abi="$1" + local nr="$2" + local entry="$3" # Entry can be either just a function name or "function/qualifier" real_entry="${entry%%/*}"
@@ -21,11 +21,11 @@ syscall_macro() { } emit() { - abi="$1" - nr="$2" - entry="$3" - compat="$4" - umlentry="" + local abi="$1" + local nr="$2" + local entry="$3" + local compat="$4" + local umlentry="" if [ "$abi" != "I386" -a -n "$compat" ]; then echo "a compat entry ($abi: $compat) for a 64-bit syscall makes no sense" >&2
@@ -62,14 +62,17 @@ grep '^[0-9]' "$in" | sort -n | ( while read nr abi name entry compat; do abi=`echo "$abi" | tr '[a-z]' '[A-Z]'` if [ "$abi" = "COMMON" -o "$abi" = "64" ]; then - # COMMON is the same as 64, except that we don't expect X32 - # programs to use it. Our expectation has nothing to do with - # any generated code, so treat them the same. emit 64 "$nr" "$entry" "$compat" + if [ "$abi" = "COMMON" ]; then + # COMMON means that this syscall exists in the same form for + # 64-bit and X32. + echo "#ifdef CONFIG_X86_X32_ABI" + emit X32 "$nr" "$entry" "$compat" + echo "#endif" + fi elif [ "$abi" = "X32" ]; then - # X32 is equivalent to 64 on an X32-compatible kernel. echo "#ifdef CONFIG_X86_X32_ABI" - emit 64 "$nr" "$entry" "$compat" + emit X32 "$nr" "$entry" "$compat" echo "#endif" elif [ "$abi" = "I386" ]; then emit "$abi" "$nr" "$entry" "$compat"
arch/x86/include/asm/syscall.h +4 -0
@@ -36,6 +36,10 @@ extern const sys_call_ptr_t sys_call_table[];extern const sys_call_ptr_t ia32_sys_call_table[];#endif +#ifdef CONFIG_X86_X32_ABI +extern const sys_call_ptr_t x32_sys_call_table[]; +#endif +/* * Only the low 32 bits of orig_ax are meaningful, so we return int. * This importantly ignores the high bits on 64-bit, so comparisons
arch/x86/include/asm/unistd.h +0 -6
@@ -5,12 +5,6 @@#include <uapi/asm/unistd.h> -# ifdef CONFIG_X86_X32_ABI -# define __SYSCALL_MASK (~(__X32_SYSCALL_BIT)) -# else -# define __SYSCALL_MASK (~0) -# endif -# ifdef CONFIG_X86_32 # include <asm/unistd_32.h>
arch/x86/kernel/asm-offsets_64.c +20 -0
@@ -6,13 +6,28 @@#include <asm/ia32.h> #define __SYSCALL_64 (nr, sym, qual) [nr] = 1, +#define __SYSCALL_X32 (nr, sym, qual) static char syscalls_64[] = {#include <asm/syscalls_64.h> }; +#undef __SYSCALL_64 +#undef __SYSCALL_X32 + +#ifdef CONFIG_X86_X32_ABI +#define __SYSCALL_64 (nr, sym, qual) +#define __SYSCALL_X32 (nr, sym, qual) [nr] = 1, +static char syscalls_x32[] = { +#include <asm/syscalls_64.h> +}; +#undef __SYSCALL_64 +#undef __SYSCALL_X32 +#endif +#define __SYSCALL_I386 (nr, sym, qual) [nr] = 1, static char syscalls_ia32[] = {#include <asm/syscalls_32.h> }; +#undef __SYSCALL_I386#if defined(CONFIG_KVM_GUEST ) && defined(CONFIG_PARAVIRT_SPINLOCKS )#include <asm/kvm_para.h>
@@ -80,6 +95,11 @@ int main(void)DEFINE (__NR_syscall_max,sizeof (syscalls_64) -1 );DEFINE (NR_syscalls,sizeof (syscalls_64)); +#ifdef CONFIG_X86_X32_ABI +DEFINE (__NR_syscall_x32_max,sizeof (syscalls_x32) -1 ); +DEFINE (X32_NR_syscalls,sizeof (syscalls_x32)); +#endif +DEFINE (__NR_syscall_compat_max,sizeof (syscalls_ia32) -1 );DEFINE (IA32_NR_syscalls,sizeof (syscalls_ia32));
tools/testing/selftests/x86/Makefile +1 -1
@@ -16,7 +16,7 @@ TARGETS_C_BOTHBITS := single_step_syscall sysret_ss_attrs syscall_nt test_mremap TARGETS_C_32BIT_ONLY := entry_from_vm86 syscall_arg_fault test_syscall_vdso unwind_vdso \ test_FCMOV test_FCOMI test_FISTTP \ vdso_restorer -TARGETS_C_64BIT_ONLY := fsgsbase sysret_rip +TARGETS_C_64BIT_ONLY := fsgsbase sysret_rip syscall_numbering # Some selftests require 32bit support enabled also on 64bit systems TARGETS_C_32BIT_NEEDED := ldt_gdt ptrace_syscall
tools/testing/selftests/x86/syscall_numbering.c new file +89 -0
89 lines not on this page · raw message
Signature · 1 line
2.21.0
tip-bot for Andy Lutomirski
merge bot[tip:x86/entry] x86/syscalls: Split the x32 syscalls into their own table
x86/syscalls: Split the x32 syscalls into their own table
Commit-ID: 6365b842aae4490ebfafadfc6bb27a6d3cc54757 Gitweb: https://git.kernel.org/tip/6365b842aae4490ebfafadfc6bb27a6d3cc54757 Author: Andy Lutomirski <[email protected]> AuthorDate: Wed, 3 Jul 2019 13:34:04 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 22 Jul 2019 10:31:23 +0200
x86/syscalls: Split the x32 syscalls into their own table
For unfortunate historical reasons, the x32 syscalls and the x86_64 syscalls are not all numbered the same. As an example, ioctl() is nr 16 on x86_64 but 514 on x32.
This has potentially nasty consequences, since it means that there are two valid RAX values to do ioctl(2) and two invalid RAX values. The valid values are 16 (i.e. ioctl(2) using the x86_64 ABI) and (514 | 0x40000000) (i.e. ioctl(2) using the x32 ABI).
The invalid values are 514 and (16 | 0x40000000). 514 will enter the "COMPAT_SYSCALL_DEFINE3(ioctl, ...)" entry point with in_compat_syscall() and in_x32_syscall() returning false, whereas (16 | 0x40000000) will enter the native entry point with in_compat_syscall() and in_x32_syscall() returning true. Both are bogus, and both will exercise code paths in the kernel and in any running seccomp filters that really ought to be unreachable.
Splitting out the x32 syscalls into their own tables, allows both bogus invocations to return -ENOSYS. I've checked glibc, musl, and Bionic, and all of them appear to call syscalls with their correct numbers, so this change should have no effect on them.
There is an added benefit going forward: new syscalls that need special handling on x32 can share the same number on x32 and x86_64. This means that the special syscall range 512-547 can be treated as a legacy wart instead of something that may need to be extended in the future.
Also add a selftest to verify the new behavior.
--- arch/x86/entry/common.c | 13 ++-- arch/x86/entry/syscall_64.c | 25 +++++++ arch/x86/entry/syscalls/syscalltbl.sh | 31 +++++---- arch/x86/include/asm/syscall.h | 4 ++ arch/x86/include/asm/unistd.h | 6 -- arch/x86/kernel/asm-offsets_64.c | 20 ++++++ tools/testing/selftests/x86/Makefile | 2 +- tools/testing/selftests/x86/syscall_numbering.c | 89 +++++++++++++++++++++++++ 8 files changed, 163 insertions(+), 27 deletions(-)
arch/x86/entry/common.c +7 -6
@@ -285,15 +285,16 @@ __visible void do_syscall_64(unsigned long nr, struct pt_regs *regs)if (READ_ONCE (ti->flags) & _TIF_WORK_SYSCALL_ENTRY) nr =syscall_trace_enter (regs); -/* -* NB: Native and x32 syscalls are dispatched from the same -* table. The only functional difference is the x32 bit in -* regs->orig_ax, which changes the behavior of some syscalls. -*/ - nr &= __SYSCALL_MASK;if (likely (nr < NR_syscalls)) { nr =array_index_nospec (nr, NR_syscalls); regs->ax = sys_call_table[nr](regs); +#ifdef CONFIG_X86_X32_ABI + }else if (likely ((nr & __X32_SYSCALL_BIT) && + (nr & ~__X32_SYSCALL_BIT) < X32_NR_syscalls)) { + nr =array_index_nospec (nr & ~__X32_SYSCALL_BIT, + X32_NR_syscalls); + regs->ax = x32_sys_call_table[nr](regs); +#endif }syscall_return_slowpath (regs);
arch/x86/entry/syscall_64.c +25 -0
@@ -10,10 +10,13 @@/* this is a lie, but it does not hurt as sys_ni_syscall just returns -EINVAL */ extern asmlinkage long sys_ni_syscall (const struct pt_regs *);#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> #undef __SYSCALL_64 +#undef __SYSCALL_X32#define __SYSCALL_64 (nr, sym, qual) [nr] = sym, +#define __SYSCALL_X32 (nr, sym, qual) asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = {/*
@@ -23,3 +26,25 @@ asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = { [0 ... __NR_syscall_max] = &sys_ni_syscall,#include <asm/syscalls_64.h> }; + +#undef __SYSCALL_64 +#undef __SYSCALL_X32 + +#ifdef CONFIG_X86_X32_ABI + +#define __SYSCALL_64 (nr, sym, qual) +#define __SYSCALL_X32 (nr, sym, qual) [nr] = sym, + +asmlinkage const sys_call_ptr_t x32_sys_call_table[__NR_syscall_x32_max+1] = { +/* +* Smells like a compiler bug -- it doesn't work +* when the & below is removed. +*/ + [0 ... __NR_syscall_x32_max] = &sys_ni_syscall, +#include <asm/syscalls_64.h> +}; + +#undef __SYSCALL_64 +#undef __SYSCALL_X32 + +#endif
arch/x86/entry/syscalls/syscalltbl.sh +17 -14
@@ -1,13 +1,13 @@ -#!/bin/sh +#!/bin/bash # SPDX-License-Identifier: GPL-2.0 in="$1" out="$2" syscall_macro() { - abi="$1" - nr="$2" - entry="$3" + local abi="$1" + local nr="$2" + local entry="$3" # Entry can be either just a function name or "function/qualifier" real_entry="${entry%%/*}"
@@ -21,11 +21,11 @@ syscall_macro() { } emit() { - abi="$1" - nr="$2" - entry="$3" - compat="$4" - umlentry="" + local abi="$1" + local nr="$2" + local entry="$3" + local compat="$4" + local umlentry="" if [ "$abi" != "I386" -a -n "$compat" ]; then echo "a compat entry ($abi: $compat) for a 64-bit syscall makes no sense" >&2
@@ -62,14 +62,17 @@ grep '^[0-9]' "$in" | sort -n | ( while read nr abi name entry compat; do abi=`echo "$abi" | tr '[a-z]' '[A-Z]'` if [ "$abi" = "COMMON" -o "$abi" = "64" ]; then - # COMMON is the same as 64, except that we don't expect X32 - # programs to use it. Our expectation has nothing to do with - # any generated code, so treat them the same. emit 64 "$nr" "$entry" "$compat" + if [ "$abi" = "COMMON" ]; then + # COMMON means that this syscall exists in the same form for + # 64-bit and X32. + echo "#ifdef CONFIG_X86_X32_ABI" + emit X32 "$nr" "$entry" "$compat" + echo "#endif" + fi elif [ "$abi" = "X32" ]; then - # X32 is equivalent to 64 on an X32-compatible kernel. echo "#ifdef CONFIG_X86_X32_ABI" - emit 64 "$nr" "$entry" "$compat" + emit X32 "$nr" "$entry" "$compat" echo "#endif" elif [ "$abi" = "I386" ]; then emit "$abi" "$nr" "$entry" "$compat"
arch/x86/include/asm/syscall.h +4 -0
@@ -36,6 +36,10 @@ extern const sys_call_ptr_t sys_call_table[];extern const sys_call_ptr_t ia32_sys_call_table[];#endif +#ifdef CONFIG_X86_X32_ABI +extern const sys_call_ptr_t x32_sys_call_table[]; +#endif +/* * Only the low 32 bits of orig_ax are meaningful, so we return int. * This importantly ignores the high bits on 64-bit, so comparisons
arch/x86/include/asm/unistd.h +0 -6
@@ -5,12 +5,6 @@#include <uapi/asm/unistd.h> -# ifdef CONFIG_X86_X32_ABI -# define __SYSCALL_MASK (~(__X32_SYSCALL_BIT)) -# else -# define __SYSCALL_MASK (~0) -# endif -# ifdef CONFIG_X86_32 # include <asm/unistd_32.h>
arch/x86/kernel/asm-offsets_64.c +20 -0
@@ -6,13 +6,28 @@#include <asm/ia32.h> #define __SYSCALL_64 (nr, sym, qual) [nr] = 1, +#define __SYSCALL_X32 (nr, sym, qual) static char syscalls_64[] = {#include <asm/syscalls_64.h> }; +#undef __SYSCALL_64 +#undef __SYSCALL_X32 + +#ifdef CONFIG_X86_X32_ABI +#define __SYSCALL_64 (nr, sym, qual) +#define __SYSCALL_X32 (nr, sym, qual) [nr] = 1, +static char syscalls_x32[] = { +#include <asm/syscalls_64.h> +}; +#undef __SYSCALL_64 +#undef __SYSCALL_X32 +#endif +#define __SYSCALL_I386 (nr, sym, qual) [nr] = 1, static char syscalls_ia32[] = {#include <asm/syscalls_32.h> }; +#undef __SYSCALL_I386#if defined(CONFIG_KVM_GUEST ) && defined(CONFIG_PARAVIRT_SPINLOCKS )#include <asm/kvm_para.h>
@@ -80,6 +95,11 @@ int main(void)DEFINE (__NR_syscall_max,sizeof (syscalls_64) -1 );DEFINE (NR_syscalls,sizeof (syscalls_64)); +#ifdef CONFIG_X86_X32_ABI +DEFINE (__NR_syscall_x32_max,sizeof (syscalls_x32) -1 ); +DEFINE (X32_NR_syscalls,sizeof (syscalls_x32)); +#endif +DEFINE (__NR_syscall_compat_max,sizeof (syscalls_ia32) -1 );DEFINE (IA32_NR_syscalls,sizeof (syscalls_ia32));
tools/testing/selftests/x86/Makefile +1 -1
@@ -17,7 +17,7 @@ TARGETS_C_BOTHBITS := single_step_syscall sysret_ss_attrs syscall_nt test_mremap TARGETS_C_32BIT_ONLY := entry_from_vm86 test_syscall_vdso unwind_vdso \ test_FCMOV test_FCOMI test_FISTTP \ vdso_restorer -TARGETS_C_64BIT_ONLY := fsgsbase sysret_rip +TARGETS_C_64BIT_ONLY := fsgsbase sysret_rip syscall_numbering # Some selftests require 32bit support enabled also on 64bit systems TARGETS_C_32BIT_NEEDED := ldt_gdt ptrace_syscall
tools/testing/selftests/x86/syscall_numbering.c new file +89 -0
89 lines not on this page · raw message
Andy Lutomirski
maintainerPATCH 4/4 x86/syscalls: Make __X32_SYSCALL_BIT be unsigned long
In reply to Andy LutomirskiCurrently, it's an int. This is bizarre. Fortunately, the code using it still works: ~__X32_SYSCALL_BIT is also int, so, if nr is unsigned long, then C kindly sign-extends the ~__X32_SYSCALL_BIT part, and we actually get the desired value.
This is far more subtle than it deserves to be. Syscall numbers are, for all practical purposes, unsigned long, so make __X32_SYSCALL_BIT be unsigned long.
--- arch/x86/include/uapi/asm/unistd.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/include/uapi/asm/unistd.h +1 -1
@@ -3,7 +3,7 @@#define _UAPI_ASM_X86_UNISTD_H/* x32 syscall flag bit */ -#define __X32_SYSCALL_BIT 0x40000000 +#define __X32_SYSCALL_BIT 0x40000000UL#ifndef __KERNEL__# ifdef __i386__
Signature · 1 line
2.21.0
tip-bot for Andy Lutomirski
merge bot[tip:x86/entry] x86/syscalls: Make __X32_SYSCALL_BIT be unsigned long
x86/syscalls: Make __X32_SYSCALL_BIT be unsigned long
Commit-ID: 45e29d119e9923ff14dfb840e3482bef1667bbfb Gitweb: https://git.kernel.org/tip/45e29d119e9923ff14dfb840e3482bef1667bbfb Author: Andy Lutomirski <[email protected]> AuthorDate: Wed, 3 Jul 2019 13:34:05 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 22 Jul 2019 10:31:22 +0200
x86/syscalls: Make __X32_SYSCALL_BIT be unsigned long
Currently, it's an int. This is bizarre. Fortunately, the code using it still works: ~__X32_SYSCALL_BIT is also int, so, if nr is unsigned long, then C kindly sign-extends the ~__X32_SYSCALL_BIT part, and it actually results in the desired value.
This is far more subtle than it deserves to be. Syscall numbers are, for all practical purposes, unsigned long, so make __X32_SYSCALL_BIT be unsigned long.
--- arch/x86/include/uapi/asm/unistd.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/include/uapi/asm/unistd.h +1 -1
@@ -3,7 +3,7 @@#define _UAPI_ASM_X86_UNISTD_H/* x32 syscall flag bit */ -#define __X32_SYSCALL_BIT 0x40000000 +#define __X32_SYSCALL_BIT 0x40000000UL#ifndef __KERNEL__# ifdef __i386__