Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > linux.kernel > #1405743 > unrolled thread
| Started by | Yury Norov <ynorov@caviumnetworks.com> |
|---|---|
| First post | 2016-05-24 02:20 +0200 |
| Last post | 2016-05-25 22:30 +0200 |
| Articles | 20 on this page of 23 — 5 participants |
Back to article view | Back to linux.kernel
[PATCH v6 00/21] ILP32 for ARM64 Yury Norov <ynorov@caviumnetworks.com> - 2016-05-24 02:20 +0200
[PATCH 05/23] all: wrap needed syscalls in generic unistd Yury Norov <ynorov@caviumnetworks.com> - 2016-05-24 02:30 +0200
Re: [PATCH v6 00/21] ILP32 for ARM64 Yury Norov <ynorov@caviumnetworks.com> - 2016-05-25 18:50 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation David Miller <davem@davemloft.net> - 2016-05-25 21:40 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation David Miller <davem@davemloft.net> - 2016-05-25 22:30 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Arnd Bergmann <arnd@arndb.de> - 2016-05-25 22:50 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation David Miller <davem@davemloft.net> - 2016-05-25 23:00 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Arnd Bergmann <arnd@arndb.de> - 2016-05-25 23:10 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation David Miller <davem@davemloft.net> - 2016-05-25 23:30 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Catalin Marinas <catalin.marinas@arm.com> - 2016-05-26 16:30 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Catalin Marinas <catalin.marinas@arm.com> - 2016-05-26 17:20 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation David Miller <davem@davemloft.net> - 2016-05-26 21:50 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Catalin Marinas <catalin.marinas@arm.com> - 2016-05-27 12:20 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Catalin Marinas <catalin.marinas@arm.com> - 2016-05-27 00:40 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Heiko Carstens <heiko.carstens@de.ibm.com> - 2016-05-27 08:10 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Arnd Bergmann <arnd@arndb.de> - 2016-05-27 10:50 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Catalin Marinas <catalin.marinas@arm.com> - 2016-05-27 11:40 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Arnd Bergmann <arnd@arndb.de> - 2016-05-27 13:00 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Catalin Marinas <catalin.marinas@arm.com> - 2016-05-27 15:10 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Catalin Marinas <catalin.marinas@arm.com> - 2016-05-27 19:40 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Catalin Marinas <catalin.marinas@arm.com> - 2016-05-27 11:10 +0200
Re: [PATCH 01/23] all: syscall wrappers: add documentation Heiko Carstens <heiko.carstens@de.ibm.com> - 2016-05-27 08:00 +0200
Re: [PATCH 18/23] arm64: ilp32: add sys_ilp32.c and a separate table (in entry.S) to use it Arnd Bergmann <arnd@arndb.de> - 2016-05-25 22:30 +0200
Page 1 of 2 [1] 2 Next page →
| From | Yury Norov <ynorov@caviumnetworks.com> |
|---|---|
| Date | 2016-05-24 02:20 +0200 |
| Subject | [PATCH v6 00/21] ILP32 for ARM64 |
| Message-ID | <rC853-4h8-7@gated-at.bofh.it> |
This series enables aarch64 with ilp32 mode, and as supporting work,
introduces compat wrappers based on s390 solution, and also introduces
ARCH_32BIT_OFF_T configuration option that is enabled for existing
32-bit architectures but disabled for new arches (so 64-bit off_t is
is used by new userspace).
This version is based on kernel v4.6.
It works with glibc-2.23, and tested with LTP.
It was tested on QEMU and ThunderX machines. No major differences found.
This is not RFC anymore, because ILP32 is now tested in big-endian mode;
signals, vDSO and other subsystems are tested, and look working
v3: https://lkml.org/lkml/2014/9/3/704
v4: https://lkml.org/lkml/2015/4/13/691
v5: https://lkml.org/lkml/2015/9/29/911
v6: ABI reworked significantly;
- syscall input arguments are deloused with compat wrappers;
- vDSO is now working for both BE and LE;
- signal subsystem is reworked to handle signal context properly;
- binfmt_elf is reworked, and now most of places where execution mode
should be detected, are handled statically;
- many other less-important fixes.
ILP32 glibc branch is available here:
https://github.com/norov/glibc/tree/ilp32-2.23
It is tested with this series with no major downsides. I will send it to
glibc-alpha soon, after final revise. Please review and comment it as well.
Andrew Pinski (6):
arm64: ensure the kernel is compiled for LP64
arm64: rename COMPAT to AARCH32_EL0 in Kconfig
arm64:uapi: set __BITS_PER_LONG correctly for ILP32 and LP64
arm64: ilp32: add sys_ilp32.c and a separate table (in entry.S) to use
it
arm64: ilp32: introduce ilp32-specific handlers for sigframe and
ucontext
arm64:ilp32: add ARM64_ILP32 to Kconfig
Philipp Tomsich (1):
arm64:ilp32: add vdso-ilp32 and use for signal return
Yury Norov (15):
all: introduce COMPAT_WRAPPER option and enable it for s390
all: s390: move wrapper infrastructure to generic headers
all: s390: move compat_wrappers.c from arch/s390/kernel to kernel/
all: wrap needed syscalls in generic unistd
compat ABI: use non-compat openat and open_by_handle_at variants
32-bit ABI: introduce ARCH_32BIT_OFF_T config option
arm64: ilp32: add documentation on the ILP32 ABI for ARM64
thread: move thread bits accessors to separated file
arm64: introduce is_a32_task and is_a32_thread (for AArch32 compat)
arm64: ilp32: add is_ilp32_compat_{task,thread} and TIF_32BIT_AARCH64
arm64: introduce binfmt_elf32.c
arm64: ilp32: introduce binfmt_ilp32.c
arm64: ptrace: handle ptrace_request differently for aarch32 and ilp32
arm64: signal: share lp64 signal routines to ilp32
arm64: signal32: move ilp32 and aarch32 common code to separated file
Documentation/arm64/ilp32.txt | 25 +++
arch/Kconfig | 8 +
arch/arc/Kconfig | 1 +
arch/arm/Kconfig | 1 +
arch/arm64/Kconfig | 20 +-
arch/arm64/Makefile | 5 +
arch/arm64/include/asm/compat.h | 19 +-
arch/arm64/include/asm/elf.h | 35 +---
arch/arm64/include/asm/fpsimd.h | 2 +-
arch/arm64/include/asm/ftrace.h | 2 +-
arch/arm64/include/asm/hwcap.h | 6 +-
arch/arm64/include/asm/is_compat.h | 84 ++++++++
arch/arm64/include/asm/memory.h | 3 +-
arch/arm64/include/asm/processor.h | 11 +-
arch/arm64/include/asm/ptrace.h | 2 +-
arch/arm64/include/asm/signal32.h | 6 +-
arch/arm64/include/asm/signal32_common.h | 25 +++
arch/arm64/include/asm/signal_common.h | 33 +++
arch/arm64/include/asm/signal_ilp32.h | 34 ++++
arch/arm64/include/asm/syscall.h | 2 +-
arch/arm64/include/asm/thread_info.h | 4 +-
arch/arm64/include/asm/unistd.h | 11 +-
arch/arm64/include/asm/unistd32.h | 2 +-
arch/arm64/include/asm/vdso.h | 6 +
arch/arm64/include/uapi/asm/bitsperlong.h | 9 +-
arch/arm64/kernel/Makefile | 14 +-
arch/arm64/kernel/asm-offsets.c | 9 +-
arch/arm64/kernel/binfmt_elf32.c | 33 +++
arch/arm64/kernel/binfmt_ilp32.c | 91 +++++++++
arch/arm64/kernel/cpufeature.c | 8 +-
arch/arm64/kernel/cpuinfo.c | 4 +-
arch/arm64/kernel/entry.S | 16 +-
arch/arm64/kernel/entry_ilp32.S | 23 +++
arch/arm64/kernel/head.S | 2 +-
arch/arm64/kernel/hw_breakpoint.c | 10 +-
arch/arm64/kernel/perf_regs.c | 2 +-
arch/arm64/kernel/process.c | 7 +-
arch/arm64/kernel/ptrace.c | 67 ++++++-
arch/arm64/kernel/signal.c | 100 ++++++----
arch/arm64/kernel/signal32.c | 85 --------
arch/arm64/kernel/signal32_common.c | 115 +++++++++++
arch/arm64/kernel/signal_ilp32.c | 192 ++++++++++++++++++
arch/arm64/kernel/sys32.c | 1 +
arch/arm64/kernel/sys_ilp32.c | 86 ++++++++
arch/arm64/kernel/traps.c | 5 +-
arch/arm64/kernel/vdso-ilp32/.gitignore | 2 +
arch/arm64/kernel/vdso-ilp32/Makefile | 74 +++++++
arch/arm64/kernel/vdso-ilp32/vdso-ilp32.S | 33 +++
arch/arm64/kernel/vdso-ilp32/vdso-ilp32.lds.S | 95 +++++++++
arch/arm64/kernel/vdso.c | 65 ++++--
arch/arm64/kernel/vdso/gettimeofday.S | 20 +-
arch/blackfin/Kconfig | 1 +
arch/cris/Kconfig | 1 +
arch/frv/Kconfig | 1 +
arch/h8300/Kconfig | 1 +
arch/hexagon/Kconfig | 1 +
arch/m32r/Kconfig | 1 +
arch/m68k/Kconfig | 1 +
arch/metag/Kconfig | 1 +
arch/microblaze/Kconfig | 1 +
arch/mips/Kconfig | 1 +
arch/mn10300/Kconfig | 1 +
arch/nios2/Kconfig | 1 +
arch/openrisc/Kconfig | 1 +
arch/parisc/Kconfig | 1 +
arch/powerpc/Kconfig | 1 +
arch/s390/Kconfig | 1 +
arch/s390/include/asm/compat.h | 17 +-
arch/s390/kernel/Makefile | 2 +-
arch/s390/kernel/compat_linux.c | 4 +
arch/s390/kernel/compat_wrapper.c | 180 -----------------
arch/score/Kconfig | 1 +
arch/sh/Kconfig | 1 +
arch/sparc/Kconfig | 1 +
arch/tile/Kconfig | 1 +
arch/tile/kernel/compat.c | 3 +
arch/unicore32/Kconfig | 1 +
arch/x86/Kconfig | 1 +
arch/x86/um/Kconfig | 1 +
arch/xtensa/Kconfig | 1 +
drivers/clocksource/arm_arch_timer.c | 2 +-
include/linux/compat.h | 277 ++++++++++++++++++++++++++
include/linux/fcntl.h | 2 +-
include/linux/ptrace.h | 6 +
include/linux/syscalls.h | 57 +-----
include/linux/syscalls_structs.h | 60 ++++++
include/linux/thread_bits.h | 55 +++++
include/linux/thread_info.h | 44 +---
include/uapi/asm-generic/unistd.h | 231 ++++++++++-----------
kernel/Makefile | 1 +
kernel/compat_wrapper.c | 175 ++++++++++++++++
kernel/ptrace.c | 10 +-
92 files changed, 2024 insertions(+), 641 deletions(-)
create mode 100644 Documentation/arm64/ilp32.txt
create mode 100644 arch/arm64/include/asm/is_compat.h
create mode 100644 arch/arm64/include/asm/signal32_common.h
create mode 100644 arch/arm64/include/asm/signal_common.h
create mode 100644 arch/arm64/include/asm/signal_ilp32.h
create mode 100644 arch/arm64/kernel/binfmt_elf32.c
create mode 100644 arch/arm64/kernel/binfmt_ilp32.c
create mode 100644 arch/arm64/kernel/entry_ilp32.S
create mode 100644 arch/arm64/kernel/signal32_common.c
create mode 100644 arch/arm64/kernel/signal_ilp32.c
create mode 100644 arch/arm64/kernel/sys_ilp32.c
create mode 100644 arch/arm64/kernel/vdso-ilp32/.gitignore
create mode 100644 arch/arm64/kernel/vdso-ilp32/Makefile
create mode 100644 arch/arm64/kernel/vdso-ilp32/vdso-ilp32.S
create mode 100644 arch/arm64/kernel/vdso-ilp32/vdso-ilp32.lds.S
delete mode 100644 arch/s390/kernel/compat_wrapper.c
create mode 100644 include/linux/syscalls_structs.h
create mode 100644 include/linux/thread_bits.h
create mode 100644 kernel/compat_wrapper.c
--
2.5.0
[toc] | [next] | [standalone]
| From | Yury Norov <ynorov@caviumnetworks.com> |
|---|---|
| Date | 2016-05-24 02:30 +0200 |
| Subject | [PATCH 05/23] all: wrap needed syscalls in generic unistd |
| Message-ID | <rC8op-4no-13@gated-at.bofh.it> |
| In reply to | #1405743 |
As generic unistd syscall table is written in C, syscall
prototypes declaration is needed. It's added to compat header.
Signed-off-by: Yury Norov <ynorov@caviumnetworks.com>
---
include/linux/compat.h | 225 +++++++++++++++++++++++++++++++++++++
include/uapi/asm-generic/unistd.h | 227 +++++++++++++++++++-------------------
2 files changed, 338 insertions(+), 114 deletions(-)
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 4eba16e..248e015 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -789,6 +789,231 @@ asmlinkage long notrace compat_SyS##name(__MAP(x,__SC_COMPAT_TYPE,__VA_ARGS__))
}
#endif
+/* Compat wrappers */
+#include <linux/syscalls_structs.h>
+asmlinkage long compat_sys_creat(const char __user *pathname, umode_t mode);
+asmlinkage long compat_sys_link(const char __user *oldname,
+ const char __user *newname);
+asmlinkage long compat_sys_chdir(const char __user *filename);
+asmlinkage long compat_sys_mknod(const char __user *filename, umode_t mode,
+ unsigned dev);
+asmlinkage long compat_sys_chmod(const char __user *filename, umode_t mode);
+asmlinkage long compat_sys_oldumount(char __user *name);
+asmlinkage long compat_sys_access(const char __user *filename, int mode);
+asmlinkage long compat_sys_rename(const char __user *oldname,
+ const char __user *newname);
+asmlinkage long compat_sys_mkdir(const char __user *pathname, umode_t mode);
+asmlinkage long compat_sys_rmdir(const char __user *pathname);
+asmlinkage long compat_sys_pipe(int __user *fildes);
+asmlinkage long compat_sys_brk(unsigned long brk);
+asmlinkage long compat_sys_signal(int sig, __sighandler_t handler);
+asmlinkage long compat_sys_acct(const char __user *name);
+asmlinkage long compat_sys_umount(char __user *name, int flags);
+asmlinkage long compat_sys_chroot(const char __user *filename);
+
+#ifdef CONFIG_OLD_SIGSUSPEND
+asmlinkage long compat_sys_sigsuspend(old_sigset_t mask);
+#endif
+
+#ifdef CONFIG_OLD_SIGSUSPEND3
+asmlinkage long compat_sys_sigsuspend(int unused1, int unused2, old_sigset_t mask);
+#endif
+
+asmlinkage long compat_sys_sethostname(char __user *name, int len);
+asmlinkage long compat_sys_symlink(const char __user *old, const char __user *new);
+asmlinkage long compat_sys_readlink(const char __user *path,
+ char __user *buf, int bufsiz);
+asmlinkage long compat_sys_uselib(const char __user *library);
+asmlinkage long compat_sys_swapon(const char __user *specialfile, int swap_flags);
+asmlinkage long compat_sys_reboot(int magic1, int magic2, unsigned int cmd,
+ void __user *arg);
+asmlinkage long compat_sys_munmap(unsigned long addr, size_t len);
+asmlinkage long compat_sys_munmap(unsigned long addr, size_t len);
+asmlinkage long compat_sys_syslog(int type, char __user *buf, int len);
+asmlinkage long compat_sys_swapoff(const char __user *specialfile);
+asmlinkage long compat_sys_setdomainname(char __user *name, int len);
+asmlinkage long compat_sys_newuname(struct new_utsname __user *name);
+asmlinkage long compat_sys_mprotect(unsigned long start, size_t len,
+ unsigned long prot);
+asmlinkage long compat_sys_init_module(void __user *umod, unsigned long len,
+ const char __user *uargs);
+asmlinkage long compat_sys_delete_module(const char __user *name_user,
+ unsigned int flags);
+asmlinkage long compat_sys_quotactl(unsigned int cmd, const char __user *special,
+ qid_t id, void __user *addr);
+asmlinkage long compat_sys_bdflush(int func, long data);
+asmlinkage long compat_sys_sysfs(int option,
+ unsigned long arg1, unsigned long arg2);
+asmlinkage long compat_sys_llseek(unsigned int fd, unsigned long offset_high,
+ unsigned long offset_low, loff_t __user *result,
+ unsigned int whence);
+asmlinkage long compat_sys_msync(unsigned long start, size_t len, int flags);
+asmlinkage long compat_sys_mlock(unsigned long start, size_t len);
+asmlinkage long compat_sys_munlock(unsigned long start, size_t len);
+asmlinkage long compat_sys_sched_setparam(pid_t pid,
+ struct sched_param __user *param);
+asmlinkage long compat_sys_sched_getparam(pid_t pid,
+ struct sched_param __user *param);
+asmlinkage long compat_sys_sched_setscheduler(pid_t pid, int policy,
+ struct sched_param __user *param);
+asmlinkage long compat_sys_mremap(unsigned long addr,
+ unsigned long old_len, unsigned long new_len,
+ unsigned long flags, unsigned long new_addr);
+asmlinkage long compat_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
+ int timeout);
+asmlinkage long compat_sys_prctl(int option, unsigned long arg2, unsigned long arg3,
+ unsigned long arg4, unsigned long arg5);
+asmlinkage long compat_sys_getcwd(char __user *buf, unsigned long size);
+asmlinkage long compat_sys_capget(cap_user_header_t header,
+ cap_user_data_t dataptr);
+asmlinkage long compat_sys_capset(cap_user_header_t header,
+ const cap_user_data_t data);
+asmlinkage long compat_sys_lchown(const char __user *filename,
+ uid_t user, gid_t group);
+asmlinkage long compat_sys_getgroups(int gidsetsize, gid_t __user *grouplist);
+asmlinkage long compat_sys_setgroups(int gidsetsize, gid_t __user *grouplist);
+asmlinkage long compat_sys_getresuid(uid_t __user *ruid, uid_t __user *euid, uid_t __user *suid);
+asmlinkage long compat_sys_getresgid(gid_t __user *rgid, gid_t __user *egid, gid_t __user *sgid);
+asmlinkage long compat_sys_chown(const char __user *filename,
+ uid_t user, gid_t group);
+asmlinkage long compat_sys_pivot_root(const char __user *new_root,
+ const char __user *put_old);
+asmlinkage long compat_sys_mincore(unsigned long start, size_t len,
+ unsigned char __user * vec);
+asmlinkage long compat_sys_madvise(unsigned long start, size_t len, int behavior);
+asmlinkage long compat_sys_setxattr(const char __user *path, const char __user *name,
+ const void __user *value, size_t size, int flags);
+asmlinkage long compat_sys_lsetxattr(const char __user *path, const char __user *name,
+ const void __user *value, size_t size, int flags);
+asmlinkage long compat_sys_fsetxattr(int fd, const char __user *name,
+ const void __user *value, size_t size, int flags);
+asmlinkage long compat_sys_getdents64(unsigned int fd,
+ struct linux_dirent64 __user *dirent,
+ unsigned int count);
+asmlinkage long compat_sys_getxattr(const char __user *path, const char __user *name,
+ void __user *value, size_t size);
+asmlinkage long compat_sys_lgetxattr(const char __user *path, const char __user *name,
+ void __user *value, size_t size);
+asmlinkage long compat_sys_fgetxattr(int fd, const char __user *name,
+ void __user *value, size_t size);
+asmlinkage long compat_sys_listxattr(const char __user *path, char __user *list,
+ size_t size);
+asmlinkage long compat_sys_llistxattr(const char __user *path, char __user *list,
+ size_t size);
+asmlinkage long compat_sys_flistxattr(int fd, char __user *list, size_t size);
+asmlinkage long compat_sys_listxattr(const char __user *path, char __user *list,
+ size_t size);
+asmlinkage long compat_sys_llistxattr(const char __user *path, char __user *list,
+ size_t size);
+asmlinkage long compat_sys_flistxattr(int fd, char __user *list, size_t size);
+asmlinkage long compat_sys_removexattr(const char __user *path,
+ const char __user *name);
+asmlinkage long compat_sys_lremovexattr(const char __user *path,
+ const char __user *name);
+asmlinkage long compat_sys_fremovexattr(int fd, const char __user *name);
+asmlinkage long compat_sys_set_tid_address(int __user *tidptr);
+asmlinkage long compat_sys_epoll_ctl(int epfd, int op, int fd,
+ struct epoll_event __user *event);
+asmlinkage long compat_sys_epoll_wait(int epfd, struct epoll_event __user *events,
+ int maxevents, int timeout);
+asmlinkage long compat_sys_io_destroy(aio_context_t ctx);
+asmlinkage long compat_sys_io_cancel(aio_context_t ctx_id, struct iocb __user *iocb,
+ struct io_event __user *result);
+asmlinkage long compat_sys_mq_unlink(const char __user *name);
+asmlinkage long compat_sys_add_key(const char __user *_type,
+ const char __user *_description,
+ const void __user *_payload,
+ size_t plen,
+ key_serial_t destringid);
+asmlinkage long compat_sys_request_key(const char __user *_type,
+ const char __user *_description,
+ const char __user *_callout_info,
+ key_serial_t destringid);
+asmlinkage long compat_sys_remap_file_pages(unsigned long start, unsigned long size,
+ unsigned long prot, unsigned long pgoff,
+ unsigned long flags);
+asmlinkage long compat_sys_inotify_add_watch(int fd, const char __user *path,
+ u32 mask);
+asmlinkage long compat_sys_mknodat(int dfd, const char __user * filename, umode_t mode,
+ unsigned dev);
+asmlinkage long compat_sys_mkdirat(int dfd, const char __user * pathname, umode_t mode);
+asmlinkage long compat_sys_fchownat(int dfd, const char __user *filename, uid_t user,
+ gid_t group, int flag);
+asmlinkage long compat_sys_unlinkat(int dfd, const char __user * pathname, int flag);
+asmlinkage long compat_sys_renameat(int olddfd, const char __user * oldname,
+ int newdfd, const char __user * newname);
+asmlinkage long compat_sys_symlinkat(const char __user * oldname,
+ int newdfd, const char __user * newname);
+asmlinkage long compat_sys_linkat(int olddfd, const char __user *oldname,
+ int newdfd, const char __user *newname, int flags);
+asmlinkage long compat_sys_readlinkat(int dfd, const char __user *path, char __user *buf,
+ int bufsiz);
+asmlinkage long compat_sys_fchmodat(int dfd, const char __user * filename,
+ umode_t mode);
+asmlinkage long compat_sys_faccessat(int dfd, const char __user *filename, int mode);
+asmlinkage long compat_sys_unshare(unsigned long unshare_flags);
+asmlinkage long compat_sys_splice(int fd_in, loff_t __user *off_in,
+ int fd_out, loff_t __user *off_out,
+ size_t len, unsigned int flags);
+asmlinkage long compat_sys_tee(int fdin, int fdout, size_t len, unsigned int flags);
+asmlinkage long compat_sys_getcpu(unsigned __user *cpu, unsigned __user *node, struct getcpu_cache __user *cache);
+asmlinkage long compat_sys_pipe2(int __user *fildes, int flags);
+asmlinkage long compat_sys_perf_event_open(
+ struct perf_event_attr __user *attr_uptr,
+ pid_t pid, int cpu, int group_fd, unsigned long flags);
+
+#ifdef CONFIG_CLONE_BACKWARDS
+asmlinkage long compat_sys_clone(unsigned long, unsigned long, int __user *, unsigned long,
+ int __user *);
+#else
+#ifdef CONFIG_CLONE_BACKWARDS3
+asmlinkage long compat_sys_clone(unsigned long, unsigned long, int, int __user *,
+ int __user *, unsigned long);
+#else
+asmlinkage long compat_sys_clone(unsigned long, unsigned long, int __user *,
+ int __user *, unsigned long);
+#endif
+#endif
+
+asmlinkage long compat_sys_prlimit64(pid_t pid, unsigned int resource,
+ const struct rlimit64 __user *new_rlim,
+ struct rlimit64 __user *old_rlim);
+asmlinkage long compat_sys_name_to_handle_at(int dfd, const char __user *name,
+ struct file_handle __user *handle,
+ int __user *mnt_id, int flag);
+asmlinkage long compat_sys_kcmp(pid_t pid1, pid_t pid2, int type,
+ unsigned long idx1, unsigned long idx2);
+asmlinkage long compat_sys_finit_module(int fd, const char __user *uargs, int flags);
+asmlinkage long compat_sys_sched_setattr(pid_t pid,
+ struct sched_attr __user *attr,
+ unsigned int flags);
+asmlinkage long compat_sys_sched_getattr(pid_t pid,
+ struct sched_attr __user *attr,
+ unsigned int size,
+ unsigned int flags);
+asmlinkage long compat_sys_renameat2(int olddfd, const char __user *oldname,
+ int newdfd, const char __user *newname,
+ unsigned int flags);
+asmlinkage long compat_sys_seccomp(unsigned int op, unsigned int flags,
+ const char __user *uargs);
+asmlinkage long compat_sys_getrandom(char __user *buf, size_t count,
+ unsigned int flags);
+asmlinkage long compat_sys_memfd_create(const char __user *uname_ptr, unsigned int flags);
+asmlinkage long compat_sys_bpf(int cmd, union bpf_attr *attr, unsigned int size);
+asmlinkage long compat_sys_socketpair(int, int, int, int __user *);
+asmlinkage long compat_sys_bind(int, struct sockaddr __user *, int);
+asmlinkage long compat_sys_connect(int, struct sockaddr __user *, int);
+asmlinkage long compat_sys_accept4(int, struct sockaddr __user *, int __user *, int);
+asmlinkage long compat_sys_getsockname(int, struct sockaddr __user *, int __user *);
+asmlinkage long compat_sys_getpeername(int, struct sockaddr __user *, int __user *);
+asmlinkage long compat_sys_sendto(int, void __user *, size_t, unsigned,
+ struct sockaddr __user *, int);
+asmlinkage long compat_sys_mlock2(unsigned long start, size_t len, int flags);
+
+asmlinkage long compat_sys_copy_file_range(int fd_in, loff_t __user *off_in,
+ int fd_out, loff_t __user *off_out,
+ size_t len, unsigned int flags);
+
#endif /* CONFIG_COMPAT_WRAPPER */
#endif /* _LINUX_COMPAT_H */
diff --git a/include/uapi/asm-generic/unistd.h b/include/uapi/asm-generic/unistd.h
index 7e91d83..6ed4613 100644
--- a/include/uapi/asm-generic/unistd.h
+++ b/include/uapi/asm-generic/unistd.h
@@ -36,43 +36,43 @@
#define __NR_io_setup 0
__SC_COMP(__NR_io_setup, sys_io_setup, compat_sys_io_setup)
#define __NR_io_destroy 1
-__SYSCALL(__NR_io_destroy, sys_io_destroy)
+__SC_WRAP(__NR_io_destroy, sys_io_destroy)
#define __NR_io_submit 2
__SC_COMP(__NR_io_submit, sys_io_submit, compat_sys_io_submit)
#define __NR_io_cancel 3
-__SYSCALL(__NR_io_cancel, sys_io_cancel)
+__SC_WRAP(__NR_io_cancel, sys_io_cancel)
#define __NR_io_getevents 4
__SC_COMP(__NR_io_getevents, sys_io_getevents, compat_sys_io_getevents)
/* fs/xattr.c */
#define __NR_setxattr 5
-__SYSCALL(__NR_setxattr, sys_setxattr)
+__SC_WRAP(__NR_setxattr, sys_setxattr)
#define __NR_lsetxattr 6
-__SYSCALL(__NR_lsetxattr, sys_lsetxattr)
+__SC_WRAP(__NR_lsetxattr, sys_lsetxattr)
#define __NR_fsetxattr 7
-__SYSCALL(__NR_fsetxattr, sys_fsetxattr)
+__SC_WRAP(__NR_fsetxattr, sys_fsetxattr)
#define __NR_getxattr 8
-__SYSCALL(__NR_getxattr, sys_getxattr)
+__SC_WRAP(__NR_getxattr, sys_getxattr)
#define __NR_lgetxattr 9
-__SYSCALL(__NR_lgetxattr, sys_lgetxattr)
+__SC_WRAP(__NR_lgetxattr, sys_lgetxattr)
#define __NR_fgetxattr 10
-__SYSCALL(__NR_fgetxattr, sys_fgetxattr)
+__SC_WRAP(__NR_fgetxattr, sys_fgetxattr)
#define __NR_listxattr 11
-__SYSCALL(__NR_listxattr, sys_listxattr)
+__SC_WRAP(__NR_listxattr, sys_listxattr)
#define __NR_llistxattr 12
-__SYSCALL(__NR_llistxattr, sys_llistxattr)
+__SC_WRAP(__NR_llistxattr, sys_llistxattr)
#define __NR_flistxattr 13
-__SYSCALL(__NR_flistxattr, sys_flistxattr)
+__SC_WRAP(__NR_flistxattr, sys_flistxattr)
#define __NR_removexattr 14
-__SYSCALL(__NR_removexattr, sys_removexattr)
+__SC_WRAP(__NR_removexattr, sys_removexattr)
#define __NR_lremovexattr 15
-__SYSCALL(__NR_lremovexattr, sys_lremovexattr)
+__SC_WRAP(__NR_lremovexattr, sys_lremovexattr)
#define __NR_fremovexattr 16
-__SYSCALL(__NR_fremovexattr, sys_fremovexattr)
+__SC_WRAP(__NR_fremovexattr, sys_fremovexattr)
/* fs/dcache.c */
#define __NR_getcwd 17
-__SYSCALL(__NR_getcwd, sys_getcwd)
+__SC_WRAP(__NR_getcwd, sys_getcwd)
/* fs/cookies.c */
#define __NR_lookup_dcookie 18
@@ -86,7 +86,7 @@ __SYSCALL(__NR_eventfd2, sys_eventfd2)
#define __NR_epoll_create1 20
__SYSCALL(__NR_epoll_create1, sys_epoll_create1)
#define __NR_epoll_ctl 21
-__SYSCALL(__NR_epoll_ctl, sys_epoll_ctl)
+__SC_WRAP(__NR_epoll_ctl, sys_epoll_ctl)
#define __NR_epoll_pwait 22
__SC_COMP(__NR_epoll_pwait, sys_epoll_pwait, compat_sys_epoll_pwait)
@@ -102,7 +102,7 @@ __SC_COMP_3264(__NR3264_fcntl, sys_fcntl64, sys_fcntl, compat_sys_fcntl64)
#define __NR_inotify_init1 26
__SYSCALL(__NR_inotify_init1, sys_inotify_init1)
#define __NR_inotify_add_watch 27
-__SYSCALL(__NR_inotify_add_watch, sys_inotify_add_watch)
+__SC_WRAP(__NR_inotify_add_watch, sys_inotify_add_watch)
#define __NR_inotify_rm_watch 28
__SYSCALL(__NR_inotify_rm_watch, sys_inotify_rm_watch)
@@ -122,17 +122,17 @@ __SYSCALL(__NR_flock, sys_flock)
/* fs/namei.c */
#define __NR_mknodat 33
-__SYSCALL(__NR_mknodat, sys_mknodat)
+__SC_WRAP(__NR_mknodat, sys_mknodat)
#define __NR_mkdirat 34
-__SYSCALL(__NR_mkdirat, sys_mkdirat)
+__SC_WRAP(__NR_mkdirat, sys_mkdirat)
#define __NR_unlinkat 35
-__SYSCALL(__NR_unlinkat, sys_unlinkat)
+__SC_WRAP(__NR_unlinkat, sys_unlinkat)
#define __NR_symlinkat 36
-__SYSCALL(__NR_symlinkat, sys_symlinkat)
+__SC_WRAP(__NR_symlinkat, sys_symlinkat)
#define __NR_linkat 37
-__SYSCALL(__NR_linkat, sys_linkat)
+__SC_WRAP(__NR_linkat, sys_linkat)
#define __NR_renameat 38
-__SYSCALL(__NR_renameat, sys_renameat)
+__SC_WRAP(__NR_renameat, sys_renameat)
/* fs/namespace.c */
#define __NR_umount2 39
@@ -140,7 +140,7 @@ __SYSCALL(__NR_umount2, sys_umount)
#define __NR_mount 40
__SC_COMP(__NR_mount, sys_mount, compat_sys_mount)
#define __NR_pivot_root 41
-__SYSCALL(__NR_pivot_root, sys_pivot_root)
+__SC_WRAP(__NR_pivot_root, sys_pivot_root)
/* fs/nfsctl.c */
#define __NR_nfsservctl 42
@@ -163,23 +163,23 @@ __SC_COMP_3264(__NR3264_ftruncate, sys_ftruncate64, sys_ftruncate, \
#define __NR_fallocate 47
__SC_COMP(__NR_fallocate, sys_fallocate, compat_sys_fallocate)
#define __NR_faccessat 48
-__SYSCALL(__NR_faccessat, sys_faccessat)
+__SC_WRAP(__NR_faccessat, sys_faccessat)
#define __NR_chdir 49
-__SYSCALL(__NR_chdir, sys_chdir)
+__SC_WRAP(__NR_chdir, sys_chdir)
#define __NR_fchdir 50
__SYSCALL(__NR_fchdir, sys_fchdir)
#define __NR_chroot 51
-__SYSCALL(__NR_chroot, sys_chroot)
+__SC_WRAP(__NR_chroot, sys_chroot)
#define __NR_fchmod 52
__SYSCALL(__NR_fchmod, sys_fchmod)
#define __NR_fchmodat 53
-__SYSCALL(__NR_fchmodat, sys_fchmodat)
+__SC_WRAP(__NR_fchmodat, sys_fchmodat)
#define __NR_fchownat 54
-__SYSCALL(__NR_fchownat, sys_fchownat)
+__SC_WRAP(__NR_fchownat, sys_fchownat)
#define __NR_fchown 55
__SYSCALL(__NR_fchown, sys_fchown)
#define __NR_openat 56
-__SC_COMP(__NR_openat, sys_openat, compat_sys_openat)
+__SYSCALL(__NR_openat, sys_openat)
#define __NR_close 57
__SYSCALL(__NR_close, sys_close)
#define __NR_vhangup 58
@@ -187,11 +187,11 @@ __SYSCALL(__NR_vhangup, sys_vhangup)
/* fs/pipe.c */
#define __NR_pipe2 59
-__SYSCALL(__NR_pipe2, sys_pipe2)
+__SC_WRAP(__NR_pipe2, sys_pipe2)
/* fs/quota.c */
#define __NR_quotactl 60
-__SYSCALL(__NR_quotactl, sys_quotactl)
+__SC_WRAP(__NR_quotactl, sys_quotactl)
/* fs/readdir.c */
#define __NR_getdents64 61
@@ -236,13 +236,13 @@ __SC_COMP(__NR_signalfd4, sys_signalfd4, compat_sys_signalfd4)
#define __NR_vmsplice 75
__SC_COMP(__NR_vmsplice, sys_vmsplice, compat_sys_vmsplice)
#define __NR_splice 76
-__SYSCALL(__NR_splice, sys_splice)
+__SC_WRAP(__NR_splice, sys_splice)
#define __NR_tee 77
-__SYSCALL(__NR_tee, sys_tee)
+__SC_WRAP(__NR_tee, sys_tee)
/* fs/stat.c */
#define __NR_readlinkat 78
-__SYSCALL(__NR_readlinkat, sys_readlinkat)
+__SC_WRAP(__NR_readlinkat, sys_readlinkat)
#define __NR3264_fstatat 79
__SC_3264(__NR3264_fstatat, sys_fstatat64, sys_newfstatat)
#define __NR3264_fstat 80
@@ -281,13 +281,13 @@ __SC_COMP(__NR_utimensat, sys_utimensat, compat_sys_utimensat)
/* kernel/acct.c */
#define __NR_acct 89
-__SYSCALL(__NR_acct, sys_acct)
+__SC_WRAP(__NR_acct, sys_acct)
/* kernel/capability.c */
#define __NR_capget 90
-__SYSCALL(__NR_capget, sys_capget)
+__SC_WRAP(__NR_capget, sys_capget)
#define __NR_capset 91
-__SYSCALL(__NR_capset, sys_capset)
+__SC_WRAP(__NR_capset, sys_capset)
/* kernel/exec_domain.c */
#define __NR_personality 92
@@ -303,9 +303,9 @@ __SC_COMP(__NR_waitid, sys_waitid, compat_sys_waitid)
/* kernel/fork.c */
#define __NR_set_tid_address 96
-__SYSCALL(__NR_set_tid_address, sys_set_tid_address)
+__SC_WRAP(__NR_set_tid_address, sys_set_tid_address)
#define __NR_unshare 97
-__SYSCALL(__NR_unshare, sys_unshare)
+__SC_WRAP(__NR_unshare, sys_unshare)
/* kernel/futex.c */
#define __NR_futex 98
@@ -333,9 +333,9 @@ __SC_COMP(__NR_kexec_load, sys_kexec_load, compat_sys_kexec_load)
/* kernel/module.c */
#define __NR_init_module 105
-__SYSCALL(__NR_init_module, sys_init_module)
+__SC_WRAP(__NR_init_module, sys_init_module)
#define __NR_delete_module 106
-__SYSCALL(__NR_delete_module, sys_delete_module)
+__SC_WRAP(__NR_delete_module, sys_delete_module)
/* kernel/posix-timers.c */
#define __NR_timer_create 107
@@ -360,7 +360,7 @@ __SC_COMP(__NR_clock_nanosleep, sys_clock_nanosleep, \
/* kernel/printk.c */
#define __NR_syslog 116
-__SYSCALL(__NR_syslog, sys_syslog)
+__SC_WRAP(__NR_syslog, sys_syslog)
/* kernel/ptrace.c */
#define __NR_ptrace 117
@@ -368,13 +368,13 @@ __SYSCALL(__NR_ptrace, sys_ptrace)
/* kernel/sched/core.c */
#define __NR_sched_setparam 118
-__SYSCALL(__NR_sched_setparam, sys_sched_setparam)
+__SC_WRAP(__NR_sched_setparam, sys_sched_setparam)
#define __NR_sched_setscheduler 119
-__SYSCALL(__NR_sched_setscheduler, sys_sched_setscheduler)
+__SC_WRAP(__NR_sched_setscheduler, sys_sched_setscheduler)
#define __NR_sched_getscheduler 120
__SYSCALL(__NR_sched_getscheduler, sys_sched_getscheduler)
#define __NR_sched_getparam 121
-__SYSCALL(__NR_sched_getparam, sys_sched_getparam)
+__SC_WRAP(__NR_sched_getparam, sys_sched_getparam)
#define __NR_sched_setaffinity 122
__SC_COMP(__NR_sched_setaffinity, sys_sched_setaffinity, \
compat_sys_sched_setaffinity)
@@ -425,7 +425,7 @@ __SYSCALL(__NR_setpriority, sys_setpriority)
#define __NR_getpriority 141
__SYSCALL(__NR_getpriority, sys_getpriority)
#define __NR_reboot 142
-__SYSCALL(__NR_reboot, sys_reboot)
+__SC_WRAP(__NR_reboot, sys_reboot)
#define __NR_setregid 143
__SYSCALL(__NR_setregid, sys_setregid)
#define __NR_setgid 144
@@ -437,11 +437,11 @@ __SYSCALL(__NR_setuid, sys_setuid)
#define __NR_setresuid 147
__SYSCALL(__NR_setresuid, sys_setresuid)
#define __NR_getresuid 148
-__SYSCALL(__NR_getresuid, sys_getresuid)
+__SC_WRAP(__NR_getresuid, sys_getresuid)
#define __NR_setresgid 149
__SYSCALL(__NR_setresgid, sys_setresgid)
#define __NR_getresgid 150
-__SYSCALL(__NR_getresgid, sys_getresgid)
+__SC_WRAP(__NR_getresgid, sys_getresgid)
#define __NR_setfsuid 151
__SYSCALL(__NR_setfsuid, sys_setfsuid)
#define __NR_setfsgid 152
@@ -457,15 +457,15 @@ __SYSCALL(__NR_getsid, sys_getsid)
#define __NR_setsid 157
__SYSCALL(__NR_setsid, sys_setsid)
#define __NR_getgroups 158
-__SYSCALL(__NR_getgroups, sys_getgroups)
+__SC_WRAP(__NR_getgroups, sys_getgroups)
#define __NR_setgroups 159
-__SYSCALL(__NR_setgroups, sys_setgroups)
+__SC_WRAP(__NR_setgroups, sys_setgroups)
#define __NR_uname 160
-__SYSCALL(__NR_uname, sys_newuname)
+__SC_WRAP(__NR_uname, sys_newuname)
#define __NR_sethostname 161
-__SYSCALL(__NR_sethostname, sys_sethostname)
+__SC_WRAP(__NR_sethostname, sys_sethostname)
#define __NR_setdomainname 162
-__SYSCALL(__NR_setdomainname, sys_setdomainname)
+__SC_WRAP(__NR_setdomainname, sys_setdomainname)
#define __NR_getrlimit 163
__SC_COMP(__NR_getrlimit, sys_getrlimit, compat_sys_getrlimit)
#define __NR_setrlimit 164
@@ -475,9 +475,9 @@ __SC_COMP(__NR_getrusage, sys_getrusage, compat_sys_getrusage)
#define __NR_umask 166
__SYSCALL(__NR_umask, sys_umask)
#define __NR_prctl 167
-__SYSCALL(__NR_prctl, sys_prctl)
+__SC_WRAP(__NR_prctl, sys_prctl)
#define __NR_getcpu 168
-__SYSCALL(__NR_getcpu, sys_getcpu)
+__SC_WRAP(__NR_getcpu, sys_getcpu)
/* kernel/time.c */
#define __NR_gettimeofday 169
@@ -509,7 +509,7 @@ __SC_COMP(__NR_sysinfo, sys_sysinfo, compat_sys_sysinfo)
#define __NR_mq_open 180
__SC_COMP(__NR_mq_open, sys_mq_open, compat_sys_mq_open)
#define __NR_mq_unlink 181
-__SYSCALL(__NR_mq_unlink, sys_mq_unlink)
+__SC_WRAP(__NR_mq_unlink, sys_mq_unlink)
#define __NR_mq_timedsend 182
__SC_COMP(__NR_mq_timedsend, sys_mq_timedsend, compat_sys_mq_timedsend)
#define __NR_mq_timedreceive 183
@@ -554,21 +554,21 @@ __SYSCALL(__NR_shmdt, sys_shmdt)
#define __NR_socket 198
__SYSCALL(__NR_socket, sys_socket)
#define __NR_socketpair 199
-__SYSCALL(__NR_socketpair, sys_socketpair)
+__SC_WRAP(__NR_socketpair, sys_socketpair)
#define __NR_bind 200
-__SYSCALL(__NR_bind, sys_bind)
+__SC_WRAP(__NR_bind, sys_bind)
#define __NR_listen 201
__SYSCALL(__NR_listen, sys_listen)
#define __NR_accept 202
__SYSCALL(__NR_accept, sys_accept)
#define __NR_connect 203
-__SYSCALL(__NR_connect, sys_connect)
+__SC_WRAP(__NR_connect, sys_connect)
#define __NR_getsockname 204
-__SYSCALL(__NR_getsockname, sys_getsockname)
+__SC_WRAP(__NR_getsockname, sys_getsockname)
#define __NR_getpeername 205
-__SYSCALL(__NR_getpeername, sys_getpeername)
+__SC_WRAP(__NR_getpeername, sys_getpeername)
#define __NR_sendto 206
-__SYSCALL(__NR_sendto, sys_sendto)
+__SC_WRAP(__NR_sendto, sys_sendto)
#define __NR_recvfrom 207
__SC_COMP(__NR_recvfrom, sys_recvfrom, compat_sys_recvfrom)
#define __NR_setsockopt 208
@@ -588,23 +588,23 @@ __SC_COMP(__NR_readahead, sys_readahead, compat_sys_readahead)
/* mm/nommu.c, also with MMU */
#define __NR_brk 214
-__SYSCALL(__NR_brk, sys_brk)
+__SC_WRAP(__NR_brk, sys_brk)
#define __NR_munmap 215
-__SYSCALL(__NR_munmap, sys_munmap)
+__SC_WRAP(__NR_munmap, sys_munmap)
#define __NR_mremap 216
-__SYSCALL(__NR_mremap, sys_mremap)
+__SC_WRAP(__NR_mremap, sys_mremap)
/* security/keys/keyctl.c */
#define __NR_add_key 217
-__SYSCALL(__NR_add_key, sys_add_key)
+__SC_WRAP(__NR_add_key, sys_add_key)
#define __NR_request_key 218
-__SYSCALL(__NR_request_key, sys_request_key)
+__SC_WRAP(__NR_request_key, sys_request_key)
#define __NR_keyctl 219
__SC_COMP(__NR_keyctl, sys_keyctl, compat_sys_keyctl)
/* arch/example/kernel/sys_example.c */
#define __NR_clone 220
-__SYSCALL(__NR_clone, sys_clone)
+__SC_WRAP(__NR_clone, sys_clone)
#define __NR_execve 221
__SC_COMP(__NR_execve, sys_execve, compat_sys_execve)
@@ -617,27 +617,27 @@ __SC_COMP(__NR3264_fadvise64, sys_fadvise64_64, compat_sys_fadvise64_64)
/* mm/, CONFIG_MMU only */
#ifndef __ARCH_NOMMU
#define __NR_swapon 224
-__SYSCALL(__NR_swapon, sys_swapon)
+__SC_WRAP(__NR_swapon, sys_swapon)
#define __NR_swapoff 225
-__SYSCALL(__NR_swapoff, sys_swapoff)
+__SC_WRAP(__NR_swapoff, sys_swapoff)
#define __NR_mprotect 226
-__SYSCALL(__NR_mprotect, sys_mprotect)
+__SC_WRAP(__NR_mprotect, sys_mprotect)
#define __NR_msync 227
-__SYSCALL(__NR_msync, sys_msync)
+__SC_WRAP(__NR_msync, sys_msync)
#define __NR_mlock 228
-__SYSCALL(__NR_mlock, sys_mlock)
+__SC_WRAP(__NR_mlock, sys_mlock)
#define __NR_munlock 229
-__SYSCALL(__NR_munlock, sys_munlock)
+__SC_WRAP(__NR_munlock, sys_munlock)
#define __NR_mlockall 230
__SYSCALL(__NR_mlockall, sys_mlockall)
#define __NR_munlockall 231
__SYSCALL(__NR_munlockall, sys_munlockall)
#define __NR_mincore 232
-__SYSCALL(__NR_mincore, sys_mincore)
+__SC_WRAP(__NR_mincore, sys_mincore)
#define __NR_madvise 233
-__SYSCALL(__NR_madvise, sys_madvise)
+__SC_WRAP(__NR_madvise, sys_madvise)
#define __NR_remap_file_pages 234
-__SYSCALL(__NR_remap_file_pages, sys_remap_file_pages)
+__SC_WRAP(__NR_remap_file_pages, sys_remap_file_pages)
#define __NR_mbind 235
__SC_COMP(__NR_mbind, sys_mbind, compat_sys_mbind)
#define __NR_get_mempolicy 236
@@ -654,9 +654,9 @@ __SC_COMP(__NR_move_pages, sys_move_pages, compat_sys_move_pages)
__SC_COMP(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo, \
compat_sys_rt_tgsigqueueinfo)
#define __NR_perf_event_open 241
-__SYSCALL(__NR_perf_event_open, sys_perf_event_open)
+__SC_WRAP(__NR_perf_event_open, sys_perf_event_open)
#define __NR_accept4 242
-__SYSCALL(__NR_accept4, sys_accept4)
+__SC_WRAP(__NR_accept4, sys_accept4)
#define __NR_recvmmsg 243
__SC_COMP(__NR_recvmmsg, sys_recvmmsg, compat_sys_recvmmsg)
@@ -669,16 +669,15 @@ __SC_COMP(__NR_recvmmsg, sys_recvmmsg, compat_sys_recvmmsg)
#define __NR_wait4 260
__SC_COMP(__NR_wait4, sys_wait4, compat_sys_wait4)
#define __NR_prlimit64 261
-__SYSCALL(__NR_prlimit64, sys_prlimit64)
+__SC_WRAP(__NR_prlimit64, sys_prlimit64)
#define __NR_fanotify_init 262
__SYSCALL(__NR_fanotify_init, sys_fanotify_init)
#define __NR_fanotify_mark 263
__SYSCALL(__NR_fanotify_mark, sys_fanotify_mark)
#define __NR_name_to_handle_at 264
-__SYSCALL(__NR_name_to_handle_at, sys_name_to_handle_at)
+__SC_WRAP(__NR_name_to_handle_at, sys_name_to_handle_at)
#define __NR_open_by_handle_at 265
-__SC_COMP(__NR_open_by_handle_at, sys_open_by_handle_at, \
- compat_sys_open_by_handle_at)
+__SYSCALL(__NR_open_by_handle_at, sys_open_by_handle_at)
#define __NR_clock_adjtime 266
__SC_COMP(__NR_clock_adjtime, sys_clock_adjtime, compat_sys_clock_adjtime)
#define __NR_syncfs 267
@@ -694,23 +693,23 @@ __SC_COMP(__NR_process_vm_readv, sys_process_vm_readv, \
__SC_COMP(__NR_process_vm_writev, sys_process_vm_writev, \
compat_sys_process_vm_writev)
#define __NR_kcmp 272
-__SYSCALL(__NR_kcmp, sys_kcmp)
+__SC_WRAP(__NR_kcmp, sys_kcmp)
#define __NR_finit_module 273
-__SYSCALL(__NR_finit_module, sys_finit_module)
+__SC_WRAP(__NR_finit_module, sys_finit_module)
#define __NR_sched_setattr 274
-__SYSCALL(__NR_sched_setattr, sys_sched_setattr)
+__SC_WRAP(__NR_sched_setattr, sys_sched_setattr)
#define __NR_sched_getattr 275
-__SYSCALL(__NR_sched_getattr, sys_sched_getattr)
+__SC_WRAP(__NR_sched_getattr, sys_sched_getattr)
#define __NR_renameat2 276
-__SYSCALL(__NR_renameat2, sys_renameat2)
+__SC_WRAP(__NR_renameat2, sys_renameat2)
#define __NR_seccomp 277
-__SYSCALL(__NR_seccomp, sys_seccomp)
+__SC_WRAP(__NR_seccomp, sys_seccomp)
#define __NR_getrandom 278
-__SYSCALL(__NR_getrandom, sys_getrandom)
+__SC_WRAP(__NR_getrandom, sys_getrandom)
#define __NR_memfd_create 279
-__SYSCALL(__NR_memfd_create, sys_memfd_create)
+__SC_WRAP(__NR_memfd_create, sys_memfd_create)
#define __NR_bpf 280
-__SYSCALL(__NR_bpf, sys_bpf)
+__SC_WRAP(__NR_bpf, sys_bpf)
#define __NR_execveat 281
__SC_COMP(__NR_execveat, sys_execveat, compat_sys_execveat)
#define __NR_userfaultfd 282
@@ -718,9 +717,9 @@ __SYSCALL(__NR_userfaultfd, sys_userfaultfd)
#define __NR_membarrier 283
__SYSCALL(__NR_membarrier, sys_membarrier)
#define __NR_mlock2 284
-__SYSCALL(__NR_mlock2, sys_mlock2)
+__SC_WRAP(__NR_mlock2, sys_mlock2)
#define __NR_copy_file_range 285
-__SYSCALL(__NR_copy_file_range, sys_copy_file_range)
+__SC_WRAP(__NR_copy_file_range, sys_copy_file_range)
#define __NR_preadv2 286
__SC_COMP(__NR_preadv2, sys_preadv2, compat_sys_preadv2)
#define __NR_pwritev2 287
@@ -741,29 +740,29 @@ __SC_COMP(__NR_pwritev2, sys_pwritev2, compat_sys_pwritev2)
#define __NR_open 1024
__SYSCALL(__NR_open, sys_open)
#define __NR_link 1025
-__SYSCALL(__NR_link, sys_link)
+__SC_WRAP(__NR_link, sys_link)
#define __NR_unlink 1026
-__SYSCALL(__NR_unlink, sys_unlink)
+__SC_WRAP(__NR_unlink, sys_unlink)
#define __NR_mknod 1027
-__SYSCALL(__NR_mknod, sys_mknod)
+__SC_WRAP(__NR_mknod, sys_mknod)
#define __NR_chmod 1028
-__SYSCALL(__NR_chmod, sys_chmod)
+__SC_WRAP(__NR_chmod, sys_chmod)
#define __NR_chown 1029
-__SYSCALL(__NR_chown, sys_chown)
+__SC_WRAP(__NR_chown, sys_chown)
#define __NR_mkdir 1030
-__SYSCALL(__NR_mkdir, sys_mkdir)
+__SC_WRAP(__NR_mkdir, sys_mkdir)
#define __NR_rmdir 1031
-__SYSCALL(__NR_rmdir, sys_rmdir)
+__SC_WRAP(__NR_rmdir, sys_rmdir)
#define __NR_lchown 1032
-__SYSCALL(__NR_lchown, sys_lchown)
+__SC_WRAP(__NR_lchown, sys_lchown)
#define __NR_access 1033
-__SYSCALL(__NR_access, sys_access)
+__SC_WRAP(__NR_access, sys_access)
#define __NR_rename 1034
-__SYSCALL(__NR_rename, sys_rename)
+__SC_WRAP(__NR_rename, sys_rename)
#define __NR_readlink 1035
-__SYSCALL(__NR_readlink, sys_readlink)
+__SC_WRAP(__NR_readlink, sys_readlink)
#define __NR_symlink 1036
-__SYSCALL(__NR_symlink, sys_symlink)
+__SC_WRAP(__NR_symlink, sys_symlink)
#define __NR_utimes 1037
__SYSCALL(__NR_utimes, sys_utimes)
#define __NR3264_stat 1038
@@ -777,7 +776,7 @@ __SC_3264(__NR3264_lstat, sys_lstat64, sys_newlstat)
#ifdef __ARCH_WANT_SYSCALL_NO_FLAGS
#define __NR_pipe 1040
-__SYSCALL(__NR_pipe, sys_pipe)
+__SC_WRAP(__NR_pipe, sys_pipe)
#define __NR_dup2 1041
__SYSCALL(__NR_dup2, sys_dup2)
#define __NR_epoll_create 1042
@@ -847,7 +846,7 @@ __SYSCALL(__NR_time, sys_time)
__SYSCALL(__NR_utime, sys_utime)
#define __NR_creat 1064
-__SYSCALL(__NR_creat, sys_creat)
+__SC_WRAP(__NR_creat, sys_creat)
#define __NR_getdents 1065
#define __ARCH_WANT_SYS_GETDENTS
__SYSCALL(__NR_getdents, sys_getdents)
@@ -857,9 +856,9 @@ __SYSCALL(__NR_futimesat, sys_futimesat)
#define __ARCH_WANT_SYS_SELECT
__SYSCALL(__NR_select, sys_select)
#define __NR_poll 1068
-__SYSCALL(__NR_poll, sys_poll)
+__SC_WRAP(__NR_poll, sys_poll)
#define __NR_epoll_wait 1069
-__SYSCALL(__NR_epoll_wait, sys_epoll_wait)
+__SC_WRAP(__NR_epoll_wait, sys_epoll_wait)
#define __NR_ustat 1070
__SYSCALL(__NR_ustat, sys_ustat)
#define __NR_vfork 1071
@@ -871,12 +870,12 @@ __SYSCALL(__NR_recv, sys_recv)
#define __NR_send 1074
__SYSCALL(__NR_send, sys_send)
#define __NR_bdflush 1075
-__SYSCALL(__NR_bdflush, sys_bdflush)
+__SC_WRAP(__NR_bdflush, sys_bdflush)
#define __NR_umount 1076
-__SYSCALL(__NR_umount, sys_oldumount)
+__SC_WRAP(__NR_umount, sys_oldumount)
#define __ARCH_WANT_SYS_OLDUMOUNT
#define __NR_uselib 1077
-__SYSCALL(__NR_uselib, sys_uselib)
+__SC_WRAP(__NR_uselib, sys_uselib)
#define __NR__sysctl 1078
__SYSCALL(__NR__sysctl, sys_sysctl)
--
2.5.0
[toc] | [prev] | [next] | [standalone]
| From | Yury Norov <ynorov@caviumnetworks.com> |
|---|---|
| Date | 2016-05-25 18:50 +0200 |
| Message-ID | <rCKal-3fR-1@gated-at.bofh.it> |
| In reply to | #1405743 |
On Wed, May 25, 2016 at 11:42:04AM +0100, Szabolcs Nagy wrote: > On 24/05/16 01:04, Yury Norov wrote: > > This version is based on kernel v4.6. > > It works with glibc-2.23, and tested with LTP. > > > ... > > ILP32 glibc branch is available here: > > https://github.com/norov/glibc/tree/ilp32-2.23 > > > > It is tested with this series with no major downsides. I will send it to > > glibc-alpha soon, after final revise. Please review and comment it as well. > > i spotted one __ilp32__ vs __ILP32__ typo in the glibc code, Yes, I also found it. Thank you. > i can review it in detail when there is a cleaned up patch set. > > in general the approach seems ok, the ugly part is when lp64 > and ilp32 share code, but ilp32 needs some tweaks compared to > the current code (e.g. x vs w regs in asm, long changed to > long long in syscalls, different relocations etc) those will > be hard to review. the naming is sometimes _be_ilp32 sometimes > ilp32_be, but let's hope there will be no new abi variant to > confuse this further. I think I shared the link too soon, and patches should be revised again. So I continue the work on it. If you curious, find it here. https://github.com/norov/glibc/tree/ilp32-dev (I don't promise I'll keep it stable, or will avoid using things like fast-forward. It's just a branch for my experiments.) For now, it has fixed: - __ilp32__ mess (by introducing DELOUSE() macro); - few unneeded patches dropped; - 32-bit off_t turned to 64-bit. With all changes, LPT fail list grows: peio_3 FAIL 5 pipeio_6 FAIL 1 abort01 FAIL 2 clone02 FAIL 4 fcntl11 FAIL 1 fcntl14 FAIL 1 fcntl17 FAIL 1 fcntl19 FAIL 1 fcntl20 FAIL 1 fcntl21 FAIL 1 fpathconf01 FAIL 1 ftruncate04 FAIL 1 kill11 FAIL 2 mmap16 FAIL 6 open12 FAIL 2 pread01 FAIL 2 pread02 FAIL 2 pread03 FAIL 2 preadv01 FAIL 6 preadv02 FAIL 6 pwrite01 FAIL 2 pwrite02 FAIL 2 pwrite04 FAIL 6 pwrite02_64 FAIL 1 pwritev01 FAIL 2 pwritev02 FAIL 2 rename11 FAIL 2 rmdir02 FAIL 2 umount2_01 FAIL 2 umount2_02 FAIL 2 umount2_03 FAIL 2 utime06 FAIL 2 mtest01 FAIL 1 mtest01w FAIL 1 mtest06 FAIL 11 gf01 FAIL 1 gf02 FAIL 1 gf07 FAIL 1 gf10 FAIL 1 gf11 FAIL 1 gf15 FAIL 1 gf18 FAIL 1 gf19 FAIL 1 Yury
[toc] | [prev] | [next] | [standalone]
| From | David Miller <davem@davemloft.net> |
|---|---|
| Date | 2016-05-25 21:40 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rCMOS-4RW-7@gated-at.bofh.it> |
| In reply to | #1405743 |
From: Yury Norov <ynorov@caviumnetworks.com> Date: Tue, 24 May 2016 03:04:30 +0300 > +To clear that top halves, automatic wrappers are introduced. They clear all > +required registers before passing control to regular syscall handler. Why have one of these for every single compat system call, rather than simply clearing the top half of all of these registers unconditionally in the 32-bit system call trap before the system call is invoked? That's what we do on sparc64. And with that, you only need wrappers for the case where there needs to be proper sign extention of a 32-bit signed argument.
[toc] | [prev] | [next] | [standalone]
| From | David Miller <davem@davemloft.net> |
|---|---|
| Date | 2016-05-25 22:30 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rCNBf-5mV-3@gated-at.bofh.it> |
| In reply to | #1407178 |
From: Yury Norov <ynorov@caviumnetworks.com> Date: Wed, 25 May 2016 23:03:27 +0300 > On Wed, May 25, 2016 at 12:30:17PM -0700, David Miller wrote: >> From: Yury Norov <ynorov@caviumnetworks.com> >> Date: Tue, 24 May 2016 03:04:30 +0300 >> >> > +To clear that top halves, automatic wrappers are introduced. They clear all >> > +required registers before passing control to regular syscall handler. >> >> Why have one of these for every single compat system call, rather than >> simply clearing the top half of all of these registers unconditionally >> in the 32-bit system call trap before the system call is invoked? >> >> That's what we do on sparc64. >> >> And with that, you only need wrappers for the case where there needs >> to be proper sign extention of a 32-bit signed argument. > > It was discussed as one of possible solutions. The downside of it is > that we cannot pass 64-bit types (like off_t) in single register. Wrappers can be added for the cases where you'd like to do that. > The other downside is that we clear top halves for every single > syscall, and it looks excessive. So, from spark64 and s390 approaches > we choosed second. It's like 4 cpu cycles even on crappy sparc64 cpus which only dual issue. :) And that's a pretty low cost for the benefits if you ask me.
[toc] | [prev] | [next] | [standalone]
| From | Arnd Bergmann <arnd@arndb.de> |
|---|---|
| Date | 2016-05-25 22:50 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rCNUB-5tm-3@gated-at.bofh.it> |
| In reply to | #1407194 |
On Wednesday, May 25, 2016 1:21:45 PM CEST David Miller wrote:
> From: Yury Norov <ynorov@caviumnetworks.com>
> Date: Wed, 25 May 2016 23:03:27 +0300
>
> > On Wed, May 25, 2016 at 12:30:17PM -0700, David Miller wrote:
> >> From: Yury Norov <ynorov@caviumnetworks.com>
> >> Date: Tue, 24 May 2016 03:04:30 +0300
> >>
> >> > +To clear that top halves, automatic wrappers are introduced. They clear all
> >> > +required registers before passing control to regular syscall handler.
> >>
> >> Why have one of these for every single compat system call, rather than
> >> simply clearing the top half of all of these registers unconditionally
> >> in the 32-bit system call trap before the system call is invoked?
> >>
> >> That's what we do on sparc64.
> >>
> >> And with that, you only need wrappers for the case where there needs
> >> to be proper sign extention of a 32-bit signed argument.
> >
> > It was discussed as one of possible solutions. The downside of it is
> > that we cannot pass 64-bit types (like off_t) in single register.
>
> Wrappers can be added for the cases where you'd like to do that.
If we clear the upper halves on the initial entry, we can't use a wrapper
to restore them, so would have to instead pass them as register
pairs as we do on the other 32-bit architectures.
> > The other downside is that we clear top halves for every single
> > syscall, and it looks excessive. So, from spark64 and s390 approaches
> > we choosed second.
>
> It's like 4 cpu cycles even on crappy sparc64 cpus which only dual
> issue. :)
>
> And that's a pretty low cost for the benefits if you ask me.
To clarify what we are talking about: These syscalls that normally
pass 64-bit arguments as register pairs are intentionally overridden
to make them faster on ilp32 mode compare to other compat modes:
+#define compat_sys_fadvise64_64 sys_fadvise64_64
+#define compat_sys_fallocate sys_fallocate
+#define compat_sys_ftruncate64 sys_ftruncate
+#define compat_sys_lookup_dcookie sys_lookup_dcookie
+#define compat_sys_readahead sys_readahead
+#define compat_sys_sync_file_range sys_sync_file_range
+#define compat_sys_truncate64 sys_truncate
+#define sys_llseek sys_lseek
+static unsigned long compat_sys_pread64(unsigned int fd,
+ compat_uptr_t __user *ubuf, compat_size_t count, off_t offset)
+{
+ return sys_pread64(fd, (char *) ubuf, count, offset);
+}
+
+static unsigned long compat_sys_pwrite64(unsigned int fd,
+ compat_uptr_t __user *ubuf, compat_size_t count, off_t offset)
+{
+ return sys_pwrite64(fd, (char *) ubuf, count, offset);
+}
If we use the normal calling conventions, we could remove these overrides
along with the respective special-case handling in glibc. None of them
look particularly performance-sensitive, but I could be wrong there.
Arnd
[toc] | [prev] | [next] | [standalone]
| From | David Miller <davem@davemloft.net> |
|---|---|
| Date | 2016-05-25 23:00 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rCO4h-5ww-1@gated-at.bofh.it> |
| In reply to | #1407199 |
From: Arnd Bergmann <arnd@arndb.de> Date: Wed, 25 May 2016 22:47:33 +0200 > If we use the normal calling conventions, we could remove these overrides > along with the respective special-case handling in glibc. None of them > look particularly performance-sensitive, but I could be wrong there. You could set the lowest bit in the system call entry pointer to indicate the upper-half clears should be elided.
[toc] | [prev] | [next] | [standalone]
| From | Arnd Bergmann <arnd@arndb.de> |
|---|---|
| Date | 2016-05-25 23:10 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rCOdZ-5Pr-67@gated-at.bofh.it> |
| In reply to | #1407205 |
On Wednesday, May 25, 2016 1:50:39 PM CEST David Miller wrote: > From: Arnd Bergmann <arnd@arndb.de> > Date: Wed, 25 May 2016 22:47:33 +0200 > > > If we use the normal calling conventions, we could remove these overrides > > along with the respective special-case handling in glibc. None of them > > look particularly performance-sensitive, but I could be wrong there. > > You could set the lowest bit in the system call entry pointer to indicate > the upper-half clears should be elided. Right, but that would introduce an extra conditional branch in the syscall hotpath, and likely eliminate the gains from passing the loff_t arguments in a single register instead of a pair. Arnd
[toc] | [prev] | [next] | [standalone]
| From | David Miller <davem@davemloft.net> |
|---|---|
| Date | 2016-05-25 23:30 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rCOxj-5WN-15@gated-at.bofh.it> |
| In reply to | #1407215 |
From: Arnd Bergmann <arnd@arndb.de> Date: Wed, 25 May 2016 23:01:06 +0200 > On Wednesday, May 25, 2016 1:50:39 PM CEST David Miller wrote: >> From: Arnd Bergmann <arnd@arndb.de> >> Date: Wed, 25 May 2016 22:47:33 +0200 >> >> > If we use the normal calling conventions, we could remove these overrides >> > along with the respective special-case handling in glibc. None of them >> > look particularly performance-sensitive, but I could be wrong there. >> >> You could set the lowest bit in the system call entry pointer to indicate >> the upper-half clears should be elided. > > Right, but that would introduce an extra conditional branch in the syscall > hotpath, and likely eliminate the gains from passing the loff_t arguments > in a single register instead of a pair. Ok, then, how much are you really gaining from avoiding a 'shift' and an 'or' to build the full 64-bit value? 3 cycles? Maybe 4? And the executing the wrappers, those have a non-trivial cost too. Cost wise, this seems like it all cancels out in the end, but what do I know?
[toc] | [prev] | [next] | [standalone]
| From | Catalin Marinas <catalin.marinas@arm.com> |
|---|---|
| Date | 2016-05-26 16:30 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rD4sq-7xk-27@gated-at.bofh.it> |
| In reply to | #1407219 |
On Wed, May 25, 2016 at 02:28:21PM -0700, David Miller wrote: > From: Arnd Bergmann <arnd@arndb.de> > Date: Wed, 25 May 2016 23:01:06 +0200 > > > On Wednesday, May 25, 2016 1:50:39 PM CEST David Miller wrote: > >> From: Arnd Bergmann <arnd@arndb.de> > >> Date: Wed, 25 May 2016 22:47:33 +0200 > >> > >> > If we use the normal calling conventions, we could remove these overrides > >> > along with the respective special-case handling in glibc. None of them > >> > look particularly performance-sensitive, but I could be wrong there. > >> > >> You could set the lowest bit in the system call entry pointer to indicate > >> the upper-half clears should be elided. > > > > Right, but that would introduce an extra conditional branch in the syscall > > hotpath, and likely eliminate the gains from passing the loff_t arguments > > in a single register instead of a pair. > > Ok, then, how much are you really gaining from avoiding a 'shift' and > an 'or' to build the full 64-bit value? 3 cycles? Maybe 4? It's possible a few more cycles overall. Whether this is noticeable, I can't really tell without some benchmarks (e.g. a getpid wrapper zeroing top 32-bit of all possible 6 arguments, called in a loop). On arm64 with ILP32 we have three types of syscalls w.r.t. parameter width (I guess that's true for all other compat implementations): 1. User syscall definition with 32-bit arguments, kernel handling 32-bit arguments 2. User 32-bit arguments, kernel 64-bit arguments 3. User 64-bit arguments, kernel 64-bit arguments For (1), the AArch64 ABI (AAPCS) allows us to ignore the garbage in the top 32-bit of a 64-bit register as long as the callee has 32-bit arguments (IOW, the generated code will use 32-git Wn instead of 64-bit Xn registers). In this case, zeroing the top 32-bit of all 6 arguments is unnecessary. In the 2nd case, we need sign or zero extension of 32-bit arguments. For sign extension we would still need a wrapper as the generic one can only zero-extend without knowing the underlying type. How many cases do we have where sign extension is required (off_t is a signed type but does it actually make sense as a negative value)? The __SC_WRAP and COMPAT_SYSCALL_WRAP macros introduced by patches 3-5 in this series handle such conversion for both sign and unsigned arguments. We don't have such problem with AArch32 tasks since the architecture guarantees zeroing or preserving the top half of all registers. For (3), with the current ILP32 approach we wouldn't need any wrapper. If we are to pass the argument as two 32-bit values, we would need both the user (glibc) to split the argument and the kernel to re-construct it. This would be in addition to any default top 32-bit zeroing on kernel entry. The overhead may be lost in the noise (we need some data) but IIRC our decision was mostly based on a cleaner user implementation for point (3) above. Since an AArch64/ILP32 process can freely use 64-bit registers, we found it nicer to be able to pass such value directly to the kernel. Reusing the s390 macros should reduce the amount of new code added to the kernel. While writing the above, I realised the current ILP32 patches still miss on converting pointers passed from user space (unless I got myself confused in macros). The new __SC_WRAP() and COMPAT_SYSCALL_WRAPx() macros take care of zero or sign extension via __SC_COMPAT_CAST(). However, we have two more existing cases which I don't see covered: a) Native syscalls taking a pointer argument and invoked directly from ILP32. For example, sys_read() takes a pointer but I don't see any __SC_WRAP added by patch 5 b) Current compat syscalls taking a pointer argument. For example, compat_sys_vmsplice() gets the iov32 pointer and the compiler assumes it is a 64-bit variable. I don't see where the upper half is zeroed We can solve (a) by adding more __SC_WRAP annotations in the generic unistd.h. For (b), we would need an __SC_DELOUSE with a bit of penalty on AArch32/compat support where it isn't needed. So maybe davem has a point on the overall impact of always zeroing the upper half of the arguments ;) (both from a performance and maintainability perspective). I guess this part of the ABI is still up for discussion. -- Catalin
[toc] | [prev] | [next] | [standalone]
| From | Catalin Marinas <catalin.marinas@arm.com> |
|---|---|
| Date | 2016-05-26 17:20 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rD5eN-82B-1@gated-at.bofh.it> |
| In reply to | #1407582 |
On Thu, May 26, 2016 at 03:50:01PM +0100, Szabolcs Nagy wrote: > On 26/05/16 15:20, Catalin Marinas wrote: > > While writing the above, I realised the current ILP32 patches still miss > > on converting pointers passed from user space (unless I got myself > > confused in macros). The new __SC_WRAP() and COMPAT_SYSCALL_WRAPx() > > macros take care of zero or sign extension via __SC_COMPAT_CAST(). > > However, we have two more existing cases which I don't see covered: > > > > a) Native syscalls taking a pointer argument and invoked directly from > > ILP32. For example, sys_read() takes a pointer but I don't see any > > __SC_WRAP added by patch 5 > > > > b) Current compat syscalls taking a pointer argument. For example, > > compat_sys_vmsplice() gets the iov32 pointer and the compiler assumes > > it is a 64-bit variable. I don't see where the upper half is zeroed > > on x32 sign/zero extension is currently left to userspace, > which is difficult to deal with, (long long)arg does the > wrong thing for pointer args. I agree, I don't think we should leave sign/zero extension to user. We should do it in the kernel either in a way similar to s390 (specific __SC_COMPAT_CAST, __SC_DELOUSE) or by always zeroing the arguments upper half on kernel entry with a few additional wrappers (where we have 64-bit arguments or they require sign extension). The latter has the disadvantage of having to split 64-bit arguments in user space while the former adds more maintenance burden to the kernel. I can't comment on performance aspects without some real numbers. -- Catalin
[toc] | [prev] | [next] | [standalone]
| From | David Miller <davem@davemloft.net> |
|---|---|
| Date | 2016-05-26 21:50 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rD9s5-23a-3@gated-at.bofh.it> |
| In reply to | #1407582 |
From: Catalin Marinas <catalin.marinas@arm.com> Date: Thu, 26 May 2016 15:20:58 +0100 > We can solve (a) by adding more __SC_WRAP annotations in the generic > unistd.h. ... I really think it's much more robust to clear the tops of the registers by default. Then you won't be auditing constantly and adding more and more wrappers. You can't even quantify the performance gains for me in any precise way. Whatever you gain by avoiding the 64-bit decompostion/reconstitution for those few system calls with 64-bit registers, you are losing by calling the wrappers for more common system calls, more often. "it's more natural to pass 64-bit values in a register" is not a clear justification for this change. This looks way over engineered to me.
[toc] | [prev] | [next] | [standalone]
| From | Catalin Marinas <catalin.marinas@arm.com> |
|---|---|
| Date | 2016-05-27 12:20 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rDn21-28H-7@gated-at.bofh.it> |
| In reply to | #1407694 |
On Thu, May 26, 2016 at 12:43:44PM -0700, David Miller wrote: > From: Catalin Marinas <catalin.marinas@arm.com> > Date: Thu, 26 May 2016 15:20:58 +0100 > > > We can solve (a) by adding more __SC_WRAP annotations in the generic > > unistd.h. > ... > > I really think it's much more robust to clear the tops of the registers > by default. Then you won't be auditing constantly and adding more and > more wrappers. I think we could avoid adding a new __SC_WRAP by redefining __SYSCALL for ILP32 to always invoke a wrapper. But given the wrapper overhead, cache locality, I don't think we would notice any performance difference in either case. > You can't even quantify the performance gains for me in any precise > way. Whatever you gain by avoiding the 64-bit > decompostion/reconstitution for those few system calls with 64-bit > registers, you are losing by calling the wrappers for more common > system calls, more often. I hope Yury can provide some numbers. All being equal, I would go for the lowest code maintenance cost (which is probably less annotations and wrappers). > "it's more natural to pass 64-bit values in a register" is not a clear > justification for this change. It's more related to how we went about the ILP32 ABI. We initially asked for a 64-bit native ABI similar to x32 until the libc-alpha community raised some POSIX compliance issues on time structures. So we decided to go for a 32-bit-like ABI while keeping the syscall interface close to the AArch64/ILP32 procedure calling standard (64-bit values passed in a single register). And now we have this discussion, revisiting this decision again (which is perfectly fine, we better get it right before any merging plans; thanks for your input). -- Catalin
[toc] | [prev] | [next] | [standalone]
| From | Catalin Marinas <catalin.marinas@arm.com> |
|---|---|
| Date | 2016-05-27 00:40 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rDc6B-3F0-3@gated-at.bofh.it> |
| In reply to | #1407219 |
On Thu, May 26, 2016 at 11:48:19PM +0300, Yury Norov wrote: > On Wed, May 25, 2016 at 02:28:21PM -0700, David Miller wrote: > > From: Arnd Bergmann <arnd@arndb.de> > > Date: Wed, 25 May 2016 23:01:06 +0200 > > > > > On Wednesday, May 25, 2016 1:50:39 PM CEST David Miller wrote: > > >> From: Arnd Bergmann <arnd@arndb.de> > > >> Date: Wed, 25 May 2016 22:47:33 +0200 > > >> > > >> > If we use the normal calling conventions, we could remove these overrides > > >> > along with the respective special-case handling in glibc. None of them > > >> > look particularly performance-sensitive, but I could be wrong there. > > >> > > >> You could set the lowest bit in the system call entry pointer to indicate > > >> the upper-half clears should be elided. > > > > > > Right, but that would introduce an extra conditional branch in the syscall > > > hotpath, and likely eliminate the gains from passing the loff_t arguments > > > in a single register instead of a pair. > > > > Ok, then, how much are you really gaining from avoiding a 'shift' and > > an 'or' to build the full 64-bit value? 3 cycles? Maybe 4? > > 4 cycles in kernel and ~same cost in glibc to create a pair. It would take a single instruction per argument in the kernel to do shift+or and maybe 1-2 more instructions to move the remaining arguments in place (we do this for a few wrappers in arch/arm64/kernel/entry32.S). And the glibc counterpart. > And 8 'mov's that exist for every syscall, even yield(). > > > And the executing the wrappers, those have a non-trivial cost too. > > The cost is pretty trivial though. See kernel/compat_wrapper.o: > COMPAT_SYSCALL_WRAP2(creat, const char __user *, pathname, umode_t, mode); > 0: a9bf7bfd stp x29, x30, [sp,#-16]! > 4: 910003fd mov x29, sp > 8: 2a0003e0 mov w0, w0 > c: 94000000 bl 0 <sys_creat> > 10: a8c17bfd ldp x29, x30, [sp],#16 > 14: d65f03c0 ret I would say the above could be more expensive than 8 movs (16 bytes to write, read, a branch and a ret). You can also add the I-cache locality, having wrappers for each syscalls instead of a single place for zeroing the upper half (where no other wrapper is necessary). Can we trick the compiler into doing a tail call optimisation. This could have simply been: COMPAT_SYSCALL_WRAP2(creat, ...): mov w0, w0 b <sys_creat> > > Cost wise, this seems like it all cancels out in the end, but what > > do I know? > > I think you know something, and I also think Heiko and other s390 guys > know something as well. So I'd like to listen their arguments here. > > For me spark64 way is looking reasonable only because it's really simple > and takes less coding. I'll try it on some branch and share here what happened. The kernel code will definitely look simpler ;). It would be good to see if there actually is any performance impact. Even with 16 more cycles on syscall entry, would they be lost in the noise? You don't need a full implementation, just some dummy mov x0, x0 on the entry path. -- Catalin
[toc] | [prev] | [next] | [standalone]
| From | Heiko Carstens <heiko.carstens@de.ibm.com> |
|---|---|
| Date | 2016-05-27 08:10 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rDj86-8cF-21@gated-at.bofh.it> |
| In reply to | #1407740 |
> > > The cost is pretty trivial though. See kernel/compat_wrapper.o: > > > COMPAT_SYSCALL_WRAP2(creat, const char __user *, pathname, umode_t, mode); > > > 0: a9bf7bfd stp x29, x30, [sp,#-16]! > > > 4: 910003fd mov x29, sp > > > 8: 2a0003e0 mov w0, w0 > > > c: 94000000 bl 0 <sys_creat> > > > 10: a8c17bfd ldp x29, x30, [sp],#16 > > > 14: d65f03c0 ret > > > > I would say the above could be more expensive than 8 movs (16 bytes to > > write, read, a branch and a ret). You can also add the I-cache locality, > > having wrappers for each syscalls instead of a single place for zeroing > > the upper half (where no other wrapper is necessary). > > > > Can we trick the compiler into doing a tail call optimisation. This > > could have simply been: > > > > COMPAT_SYSCALL_WRAP2(creat, ...): > > mov w0, w0 > > b <sys_creat> > > What you talk about was in my initial version. But Heiko insisted on having all > wrappers together. > http://www.spinics.net/lists/linux-s390/msg11593.html > > Grep your email for discussion. I think Catalin's question was more about why there is even a stack frame generated. It looks like it is not necessary. I did ask this too a couple of months ago, when we discussed this. > > > > Cost wise, this seems like it all cancels out in the end, but what > > > > do I know? > > > > > > I think you know something, and I also think Heiko and other s390 guys > > > know something as well. So I'd like to listen their arguments here. If it comes to 64 bit arguments for compat system calls: s390 also has an x32-like ABI extension which allows user space to use full 64 bit registers. As far as I know hardly anybody ever made use of that. However even if that would be widely used, to me it wouldn't make sense to add new compat system calls which allow 64 bit arguments, simply because something like c = (u32)a | (u64)b << 32; can be done with a single 1-cycle instruction. It's just not worth the extra effort to maintain additional system call variants.
[toc] | [prev] | [next] | [standalone]
| From | Arnd Bergmann <arnd@arndb.de> |
|---|---|
| Date | 2016-05-27 10:50 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rDlCV-18r-5@gated-at.bofh.it> |
| In reply to | #1407834 |
On Friday, May 27, 2016 8:03:57 AM CEST Heiko Carstens wrote: > > > > > Cost wise, this seems like it all cancels out in the end, but what > > > > > do I know? > > > > > > > > I think you know something, and I also think Heiko and other s390 guys > > > > know something as well. So I'd like to listen their arguments here. > > If it comes to 64 bit arguments for compat system calls: s390 also has an > x32-like ABI extension which allows user space to use full 64 bit > registers. As far as I know hardly anybody ever made use of that. > > However even if that would be widely used, to me it wouldn't make sense to > add new compat system calls which allow 64 bit arguments, simply because > something like > > c = (u32)a | (u64)b << 32; > > can be done with a single 1-cycle instruction. It's just not worth the > extra effort to maintain additional system call variants. For reference, both tile and mips also have separate 32-bit ABIs that are only used on 64-bit kernels (aside from the normal 32-bit ABI). Tile does it like s390 and passes 64-bit arguments as pairs, while MIPS and x86 and pass them as single registers. Tile is very similar to arm64 because it also uses the generic system call table, which I think is a good argument to keep them in sync. Arnd
[toc] | [prev] | [next] | [standalone]
| From | Catalin Marinas <catalin.marinas@arm.com> |
|---|---|
| Date | 2016-05-27 11:40 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rDmpk-1Gr-25@gated-at.bofh.it> |
| In reply to | #1407928 |
On Fri, May 27, 2016 at 10:42:59AM +0200, Arnd Bergmann wrote: > On Friday, May 27, 2016 8:03:57 AM CEST Heiko Carstens wrote: > > > > > > Cost wise, this seems like it all cancels out in the end, but what > > > > > > do I know? > > > > > > > > > > I think you know something, and I also think Heiko and other s390 guys > > > > > know something as well. So I'd like to listen their arguments here. > > > > If it comes to 64 bit arguments for compat system calls: s390 also has an > > x32-like ABI extension which allows user space to use full 64 bit > > registers. As far as I know hardly anybody ever made use of that. > > > > However even if that would be widely used, to me it wouldn't make sense to > > add new compat system calls which allow 64 bit arguments, simply because > > something like > > > > c = (u32)a | (u64)b << 32; > > > > can be done with a single 1-cycle instruction. It's just not worth the > > extra effort to maintain additional system call variants. > > For reference, both tile and mips also have separate 32-bit ABIs that are > only used on 64-bit kernels (aside from the normal 32-bit ABI). Tile > does it like s390 and passes 64-bit arguments as pairs, while MIPS > and x86 and pass them as single registers. AFAIK, x32 also requires that the upper half of a 64-bit reg is zeroed by the user when a 32-bit value is passed. We could require the same on AArch64/ILP32 but I'm a bit uneasy on trusting a multitude of C libraries on this. -- Catalin
[toc] | [prev] | [next] | [standalone]
| From | Arnd Bergmann <arnd@arndb.de> |
|---|---|
| Date | 2016-05-27 13:00 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rDnEJ-2mG-5@gated-at.bofh.it> |
| In reply to | #1407963 |
On Friday, May 27, 2016 10:30:52 AM CEST Catalin Marinas wrote: > On Fri, May 27, 2016 at 10:42:59AM +0200, Arnd Bergmann wrote: > > On Friday, May 27, 2016 8:03:57 AM CEST Heiko Carstens wrote: > > > > > > > Cost wise, this seems like it all cancels out in the end, but what > > > > > > > do I know? > > > > > > > > > > > > I think you know something, and I also think Heiko and other s390 guys > > > > > > know something as well. So I'd like to listen their arguments here. > > > > > > If it comes to 64 bit arguments for compat system calls: s390 also has an > > > x32-like ABI extension which allows user space to use full 64 bit > > > registers. As far as I know hardly anybody ever made use of that. > > > > > > However even if that would be widely used, to me it wouldn't make sense to > > > add new compat system calls which allow 64 bit arguments, simply because > > > something like > > > > > > c = (u32)a | (u64)b << 32; > > > > > > can be done with a single 1-cycle instruction. It's just not worth the > > > extra effort to maintain additional system call variants. > > > > For reference, both tile and mips also have separate 32-bit ABIs that are > > only used on 64-bit kernels (aside from the normal 32-bit ABI). Tile > > does it like s390 and passes 64-bit arguments as pairs, while MIPS > > and x86 and pass them as single registers. > > AFAIK, x32 also requires that the upper half of a 64-bit reg is zeroed > by the user when a 32-bit value is passed. We could require the same on > AArch64/ILP32 but I'm a bit uneasy on trusting a multitude of C > libraries on this. It's not about trusting a C library, it's about ensuring malicious code cannot pass argumentst that the kernel code assumes will never happen. Arnd
[toc] | [prev] | [next] | [standalone]
| From | Catalin Marinas <catalin.marinas@arm.com> |
|---|---|
| Date | 2016-05-27 15:10 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rDpGy-3QJ-21@gated-at.bofh.it> |
| In reply to | #1407999 |
On Fri, May 27, 2016 at 12:49:11PM +0200, Arnd Bergmann wrote: > On Friday, May 27, 2016 10:30:52 AM CEST Catalin Marinas wrote: > > On Fri, May 27, 2016 at 10:42:59AM +0200, Arnd Bergmann wrote: > > > On Friday, May 27, 2016 8:03:57 AM CEST Heiko Carstens wrote: > > > > > > > > Cost wise, this seems like it all cancels out in the end, but what > > > > > > > > do I know? > > > > > > > > > > > > > > I think you know something, and I also think Heiko and other s390 guys > > > > > > > know something as well. So I'd like to listen their arguments here. > > > > > > > > If it comes to 64 bit arguments for compat system calls: s390 also has an > > > > x32-like ABI extension which allows user space to use full 64 bit > > > > registers. As far as I know hardly anybody ever made use of that. > > > > > > > > However even if that would be widely used, to me it wouldn't make sense to > > > > add new compat system calls which allow 64 bit arguments, simply because > > > > something like > > > > > > > > c = (u32)a | (u64)b << 32; > > > > > > > > can be done with a single 1-cycle instruction. It's just not worth the > > > > extra effort to maintain additional system call variants. > > > > > > For reference, both tile and mips also have separate 32-bit ABIs that are > > > only used on 64-bit kernels (aside from the normal 32-bit ABI). Tile > > > does it like s390 and passes 64-bit arguments as pairs, while MIPS > > > and x86 and pass them as single registers. > > > > AFAIK, x32 also requires that the upper half of a 64-bit reg is zeroed > > by the user when a 32-bit value is passed. We could require the same on > > AArch64/ILP32 but I'm a bit uneasy on trusting a multitude of C > > libraries on this. > > It's not about trusting a C library, it's about ensuring malicious code > cannot pass argumentst that the kernel code assumes will never happen. At least for pointers and sizes, we have additional checks in place already, like __access_ok(). Most of the syscalls should be safe since they either go through some compat functions taking 32-bit arguments or are routed to native functions which already need to cope with a full random 64-bit value. On arm64, I think the only risk comes from syscall handlers expecting 32-bit arguments but using 64-bit types. Apart from pointer types, I don't expect this to happen but we could enforce it via a BUILD_BUG_ON(sizeof(t) > 4 && !__TYPE_IS_PTR(t)) in __SC_DELOUSE as per the s390 implementation. With ILP32 if we go for 64-bit off_t, those syscalls would be routed directly to the native layer. -- Catalin
[toc] | [prev] | [next] | [standalone]
| From | Catalin Marinas <catalin.marinas@arm.com> |
|---|---|
| Date | 2016-05-27 19:40 +0200 |
| Subject | Re: [PATCH 01/23] all: syscall wrappers: add documentation |
| Message-ID | <rDtTQ-6nl-23@gated-at.bofh.it> |
| In reply to | #1408066 |
On Fri, May 27, 2016 at 07:58:06PM +0300, Yury Norov wrote: > So, we have 3 options for now: > 1. Clear top halves in entry.S which means we pass off_t as a pair. > The cost is performance (didn't measure it yet and doubt about it > makes serious impact). The advantage is simplicity and unification with > aarch32, as I mentioned above. And David likes it. And it mininizes > the amount of changes on glibc side. > 2. Clear top halves in in separated file hosted wrappers. > 3. Clear top halves in I-cache and tail optimization friendly in-site wrappers. > > 2 and 3 are the same from ABI point of view. > > 2 is the worst for me as it is the most complex in implementation and > I-cache and tail optimization non-friendly. But Heiko likes it. > > 3 is what Catalin is talking about, and it was my initial approach. > Though I didn't made compiler to do tail optimization, I think we can > do it. I don't fully understand the difference between 2 and 3. My comment was more around annotating the wrappers in (2) with __naked to no longer generate function prologue/epilogue. They would still be in a separate kernel/compat_wrapper.c file. I can't figure out how you would have in-place wrappers for all syscalls. You can indeed handle the current COMPAT_SYSCALL_DEFINE via __SC_DELOUSE (and penalising the AArch32/compat support slightly) but there is no solution for native SYSCALL_DEFINE functions to do it in-place. > But 2 is what we have now. And I'd choose it. We'll never get ilp32 done > if will roll back previously agreed decisions again and again. I would rather roll back a decision than going ahead with a wrong one. Note that this is *ABI*, not a driver that you can fix upstream later. Since yesterday, I realised that (2) requires further annotations and wrapping for the native and compat syscalls used by ILP32 just to cope with pointers. Also given davem's comments, (1) starts to look a bit more appealing (I don't like reverting such decisions either, I'd have to review the code again and again). -- Catalin
[toc] | [prev] | [next] | [standalone]
Page 1 of 2 [1] 2 Next page →
Back to top | Article view | linux.kernel
csiph-web