Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 642e7fd2 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'syscalls-next' of git://git.kernel.org/pub/scm/linux/kernel/git/brodo/linux 

Pull removal of in-kernel calls to syscalls from Dominik Brodowski:
 "System calls are interaction points between userspace and the kernel.
  Therefore, system call functions such as sys_xyzzy() or
  compat_sys_xyzzy() should only be called from userspace via the
  syscall table, but not from elsewhere in the kernel.

  At least on 64-bit x86, it will likely be a hard requirement from
  v4.17 onwards to not call system call functions in the kernel: It is
  better to use use a different calling convention for system calls
  there, where struct pt_regs is decoded on-the-fly in a syscall wrapper
  which then hands processing over to the actual syscall function. This
  means that only those parameters which are actually needed for a
  specific syscall are passed on during syscall entry, instead of
  filling in six CPU registers with random user space content all the
  time (which may cause serious trouble down the call chain). Those
  x86-specific patches will be pushed through the x86 tree in the near
  future.

  Moreover, rules on how data may be accessed may differ between kernel
  data and user data. This is another reason why calling sys_xyzzy() is
  generally a bad idea, and -- at most -- acceptable in arch-specific
  code.

  This patchset removes all in-kernel calls to syscall functions in the
  kernel with the exception of arch/. On top of this, it cleans up the
  three places where many syscalls are referenced or prototyped, namely
  kernel/sys_ni.c, include/linux/syscalls.h and include/linux/compat.h"

* 'syscalls-next' of git://git.kernel.org/pub/scm/linux/kernel/git/brodo/linux: (109 commits)
  bpf: whitelist all syscalls for error injection
  kernel/sys_ni: remove {sys_,sys_compat} from cond_syscall definitions
  kernel/sys_ni: sort cond_syscall() entries
  syscalls/x86: auto-create compat_sys_*() prototypes
  syscalls: sort syscall prototypes in include/linux/compat.h
  net: remove compat_sys_*() prototypes from net/compat.h
  syscalls: sort syscall prototypes in include/linux/syscalls.h
  kexec: move sys_kexec_load() prototype to syscalls.h
  x86/sigreturn: use SYSCALL_DEFINE0
  x86: fix sys_sigreturn() return type to be long, not unsigned long
  x86/ioport: add ksys_ioperm() helper; remove in-kernel calls to sys_ioperm()
  mm: add ksys_readahead() helper; remove in-kernel calls to sys_readahead()
  mm: add ksys_mmap_pgoff() helper; remove in-kernel calls to sys_mmap_pgoff()
  mm: add ksys_fadvise64_64() helper; remove in-kernel call to sys_fadvise64_64()
  fs: add ksys_fallocate() wrapper; remove in-kernel calls to sys_fallocate()
  fs: add ksys_p{read,write}64() helpers; remove in-kernel calls to syscalls
  fs: add ksys_truncate() wrapper; remove in-kernel calls to sys_truncate()
  fs: add ksys_sync_file_range helper(); remove in-kernel calls to syscall
  kernel: add ksys_setsid() helper; remove in-kernel call to sys_setsid()
  kernel: add ksys_unshare() helper; remove in-kernel calls to sys_unshare()
  ...
parents 21035965 c9a21195

Documentation/process/adding-syscalls.rst

+33 −1
Original line number Diff line number Diff line
@@ -222,7 +222,7 @@ your new syscall number may get adjusted to resolve conflicts. 
The file ``kernel/sys_ni.c`` provides a fallback stub implementation of each

system call, returning ``-ENOSYS``.  Add your new system call here too::



    cond_syscall(sys_xyzzy);

    COND_SYSCALL(xyzzy);



Your new kernel functionality, and the system call that controls it, should

normally be optional, so add a ``CONFIG`` option (typically to
@@ -487,6 +487,38 @@ patchset, for the convenience of reviewers. 
The man page should be cc'ed to linux-man@vger.kernel.org

For more details, see https://www.kernel.org/doc/man-pages/patches.html





Do not call System Calls in the Kernel

--------------------------------------



System calls are, as stated above, interaction points between userspace and

the kernel.  Therefore, system call functions such as ``sys_xyzzy()`` or

``compat_sys_xyzzy()`` should only be called from userspace via the syscall

table, but not from elsewhere in the kernel.  If the syscall functionality is

useful to be used within the kernel, needs to be shared between an old and a

new syscall, or needs to be shared between a syscall and its compatibility

variant, it should be implemented by means of a "helper" function (such as

``kern_xyzzy()``).  This kernel function may then be called within the

syscall stub (``sys_xyzzy()``), the compatibility syscall stub

(``compat_sys_xyzzy()``), and/or other kernel code.



At least on 64-bit x86, it will be a hard requirement from v4.17 onwards to not

call system call functions in the kernel.  It uses a different calling

convention for system calls where ``struct pt_regs`` is decoded on-the-fly in a

syscall wrapper which then hands processing over to the actual syscall function.

This means that only those parameters which are actually needed for a specific

syscall are passed on during syscall entry, instead of filling in six CPU

registers with random user space content all the time (which may cause serious

trouble down the call chain).



Moreover, rules on how data may be accessed may differ between kernel data and

user data.  This is another reason why calling ``sys_xyzzy()`` is generally a

bad idea.



Exceptions to this rule are only allowed in architecture-specific overrides,

architecture-specific compatibility wrappers, or other code in arch/.





References and Sources

----------------------

arch/alpha/kernel/osf_sys.c

+1 −1
Original line number Diff line number Diff line
@@ -189,7 +189,7 @@ SYSCALL_DEFINE6(osf_mmap, unsigned long, addr, unsigned long, len, 
		goto out;

	if (off & ~PAGE_MASK)

		goto out;

	ret = sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);

	ret = ksys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);

 out:

	return ret;

}

arch/arm/kernel/sys_arm.c

+1 −1
Original line number Diff line number Diff line
@@ -35,5 +35,5 @@ 
asmlinkage long sys_arm_fadvise64_64(int fd, int advice,

				     loff_t offset, loff_t len)

{

	return sys_fadvise64_64(fd, offset, len, advice);

	return ksys_fadvise64_64(fd, offset, len, advice);

}

arch/arm64/kernel/sys.c

+1 −1
Original line number Diff line number Diff line
@@ -34,7 +34,7 @@ asmlinkage long sys_mmap(unsigned long addr, unsigned long len, 
	if (offset_in_page(off) != 0)

		return -EINVAL;



	return sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);

	return ksys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);

}



SYSCALL_DEFINE1(arm64_personality, unsigned int, personality)

arch/ia64/kernel/sys_ia64.c

+2 −2
Original line number Diff line number Diff line
@@ -139,7 +139,7 @@ int ia64_mmap_check(unsigned long addr, unsigned long len, 
asmlinkage unsigned long

sys_mmap2 (unsigned long addr, unsigned long len, int prot, int flags, int fd, long pgoff)

{

	addr = sys_mmap_pgoff(addr, len, prot, flags, fd, pgoff);

	addr = ksys_mmap_pgoff(addr, len, prot, flags, fd, pgoff);

	if (!IS_ERR((void *) addr))

		force_successful_syscall_return();

	return addr;
@@ -151,7 +151,7 @@ sys_mmap (unsigned long addr, unsigned long len, int prot, int flags, int fd, lo 
	if (offset_in_page(off) != 0)

		return -EINVAL;



	addr = sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);

	addr = ksys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);

	if (!IS_ERR((void *) addr))

		force_successful_syscall_return();

	return addr;