License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifndef _LINUX_COMPAT_H
|
|
|
|
#define _LINUX_COMPAT_H
|
|
|
|
/*
|
|
|
|
* These are the type definitions for the architecture specific
|
|
|
|
* syscall compatibility layer.
|
|
|
|
*/
|
|
|
|
|
2016-03-22 21:24:43 +00:00
|
|
|
#include <linux/types.h>
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
#include <linux/time.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/param.h> /* for HZ */
|
|
|
|
#include <linux/sem.h>
|
2009-11-06 08:09:03 +00:00
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/if.h>
|
2011-05-09 17:12:30 +00:00
|
|
|
#include <linux/fs.h>
|
2011-05-24 03:28:54 +00:00
|
|
|
#include <linux/aio_abi.h> /* for aio_context_t */
|
signals: Move put_compat_sigset to compat.h to silence hardened usercopy
Since commit afcc90f8621e ("usercopy: WARN() on slab cache usercopy
region violations"), MIPS systems booting with a compat root filesystem
emit a warning when copying compat siginfo to userspace:
WARNING: CPU: 0 PID: 953 at mm/usercopy.c:81 usercopy_warn+0x98/0xe8
Bad or missing usercopy whitelist? Kernel memory exposure attempt
detected from SLAB object 'task_struct' (offset 1432, size 16)!
Modules linked in:
CPU: 0 PID: 953 Comm: S01logging Not tainted 4.16.0-rc2 #10
Stack : ffffffff808c0000 0000000000000000 0000000000000001 65ac85163f3bdc4a
65ac85163f3bdc4a 0000000000000000 90000000ff667ab8 ffffffff808c0000
00000000000003f8 ffffffff808d0000 00000000000000d1 0000000000000000
000000000000003c 0000000000000000 ffffffff808c8ca8 ffffffff808d0000
ffffffff808d0000 ffffffff80810000 fffffc0000000000 ffffffff80785c30
0000000000000009 0000000000000051 90000000ff667eb0 90000000ff667db0
000000007fe0d938 0000000000000018 ffffffff80449958 0000000020052798
ffffffff808c0000 90000000ff664000 90000000ff667ab0 00000000100c0000
ffffffff80698810 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 ffffffff8010d02c 65ac85163f3bdc4a
...
Call Trace:
[<ffffffff8010d02c>] show_stack+0x9c/0x130
[<ffffffff80698810>] dump_stack+0x90/0xd0
[<ffffffff80137b78>] __warn+0x100/0x118
[<ffffffff80137bdc>] warn_slowpath_fmt+0x4c/0x70
[<ffffffff8021e4a8>] usercopy_warn+0x98/0xe8
[<ffffffff8021e68c>] __check_object_size+0xfc/0x250
[<ffffffff801bbfb8>] put_compat_sigset+0x30/0x88
[<ffffffff8011af24>] setup_rt_frame_n32+0xc4/0x160
[<ffffffff8010b8b4>] do_signal+0x19c/0x230
[<ffffffff8010c408>] do_notify_resume+0x60/0x78
[<ffffffff80106f50>] work_notifysig+0x10/0x18
---[ end trace 88fffbf69147f48a ]---
Commit 5905429ad856 ("fork: Provide usercopy whitelisting for
task_struct") noted that:
"While the blocked and saved_sigmask fields of task_struct are copied to
userspace (via sigmask_to_save() and setup_rt_frame()), it is always
copied with a static length (i.e. sizeof(sigset_t))."
However, this is not true in the case of compat signals, whose sigset
is copied by put_compat_sigset and receives size as an argument.
At most call sites, put_compat_sigset is copying a sigset from the
current task_struct. This triggers a warning when
CONFIG_HARDENED_USERCOPY is active. However, by marking this function as
static inline, the warning can be avoided because in all of these cases
the size is constant at compile time, which is allowed. The only site
where this is not the case is handling the rt_sigpending syscall, but
there the copy is being made from a stack local variable so does not
trigger the warning.
Move put_compat_sigset to compat.h, and mark it static inline. This
fixes the WARN on MIPS.
Fixes: afcc90f8621e ("usercopy: WARN() on slab cache usercopy region violations")
Signed-off-by: Matt Redfearn <matt.redfearn@mips.com>
Acked-by: Kees Cook <keescook@chromium.org>
Cc: "Dmitry V . Levin" <ldv@altlinux.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: kernel-hardening@lists.openwall.com
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/18639/
Signed-off-by: James Hogan <jhogan@kernel.org>
2018-02-19 16:55:06 +00:00
|
|
|
#include <linux/uaccess.h>
|
2014-03-20 14:30:14 +00:00
|
|
|
#include <linux/unistd.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/compat.h>
|
|
|
|
#include <asm/siginfo.h>
|
2006-10-02 13:12:31 +00:00
|
|
|
#include <asm/signal.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-04-05 09:53:03 +00:00
|
|
|
#ifdef CONFIG_ARCH_HAS_SYSCALL_WRAPPER
|
|
|
|
/*
|
|
|
|
* It may be useful for an architecture to override the definitions of the
|
|
|
|
* COMPAT_SYSCALL_DEFINE0 and COMPAT_SYSCALL_DEFINEx() macros, in particular
|
|
|
|
* to use a different calling convention for syscalls. To allow for that,
|
|
|
|
+ the prototypes for the compat_sys_*() functions below will *not* be included
|
|
|
|
* if CONFIG_ARCH_HAS_SYSCALL_WRAPPER is enabled.
|
|
|
|
*/
|
|
|
|
#include <asm/syscall_wrapper.h>
|
|
|
|
#endif /* CONFIG_ARCH_HAS_SYSCALL_WRAPPER */
|
|
|
|
|
2012-02-10 22:04:27 +00:00
|
|
|
#ifndef COMPAT_USE_64BIT_TIME
|
|
|
|
#define COMPAT_USE_64BIT_TIME 0
|
|
|
|
#endif
|
|
|
|
|
2012-11-23 14:12:59 +00:00
|
|
|
#ifndef __SC_DELOUSE
|
2017-07-08 15:40:39 +00:00
|
|
|
#define __SC_DELOUSE(t,v) ((__force t)(unsigned long)(v))
|
2012-11-23 14:12:59 +00:00
|
|
|
#endif
|
|
|
|
|
2018-04-05 09:53:03 +00:00
|
|
|
#ifndef COMPAT_SYSCALL_DEFINE0
|
2014-02-26 09:56:20 +00:00
|
|
|
#define COMPAT_SYSCALL_DEFINE0(name) \
|
2018-03-22 01:59:08 +00:00
|
|
|
asmlinkage long compat_sys_##name(void); \
|
|
|
|
ALLOW_ERROR_INJECTION(compat_sys_##name, ERRNO); \
|
2014-02-26 09:56:20 +00:00
|
|
|
asmlinkage long compat_sys_##name(void)
|
2018-04-05 09:53:03 +00:00
|
|
|
#endif /* COMPAT_SYSCALL_DEFINE0 */
|
2014-02-26 09:56:20 +00:00
|
|
|
|
2012-11-23 14:12:59 +00:00
|
|
|
#define COMPAT_SYSCALL_DEFINE1(name, ...) \
|
|
|
|
COMPAT_SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
|
|
|
|
#define COMPAT_SYSCALL_DEFINE2(name, ...) \
|
|
|
|
COMPAT_SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
|
|
|
|
#define COMPAT_SYSCALL_DEFINE3(name, ...) \
|
|
|
|
COMPAT_SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
|
|
|
|
#define COMPAT_SYSCALL_DEFINE4(name, ...) \
|
|
|
|
COMPAT_SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
|
|
|
|
#define COMPAT_SYSCALL_DEFINE5(name, ...) \
|
|
|
|
COMPAT_SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
|
|
|
|
#define COMPAT_SYSCALL_DEFINE6(name, ...) \
|
|
|
|
COMPAT_SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)
|
|
|
|
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
/*
|
|
|
|
* The asmlinkage stub is aliased to a function named __se_compat_sys_*() which
|
|
|
|
* sign-extends 32-bit ints to longs whenever needed. The actual work is
|
|
|
|
* done within __do_compat_sys_*().
|
|
|
|
*/
|
2018-04-05 09:53:03 +00:00
|
|
|
#ifndef COMPAT_SYSCALL_DEFINEx
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
#define COMPAT_SYSCALL_DEFINEx(x, name, ...) \
|
disable -Wattribute-alias warning for SYSCALL_DEFINEx()
gcc-8 warns for every single definition of a system call entry
point, e.g.:
include/linux/compat.h:56:18: error: 'compat_sys_rt_sigprocmask' alias between functions of incompatible types 'long int(int, compat_sigset_t *, compat_sigset_t *, compat_size_t)' {aka 'long int(int, struct <anonymous> *, struct <anonymous> *, unsigned int)'} and 'long int(long int, long int, long int, long int)' [-Werror=attribute-alias]
asmlinkage long compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))\
^~~~~~~~~~
include/linux/compat.h:45:2: note: in expansion of macro 'COMPAT_SYSCALL_DEFINEx'
COMPAT_SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
^~~~~~~~~~~~~~~~~~~~~~
kernel/signal.c:2601:1: note: in expansion of macro 'COMPAT_SYSCALL_DEFINE4'
COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
^~~~~~~~~~~~~~~~~~~~~~
include/linux/compat.h:60:18: note: aliased declaration here
asmlinkage long compat_SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__))\
^~~~~~~~~~
The new warning seems reasonable in principle, but it doesn't
help us here, since we rely on the type mismatch to sanitize the
system call arguments. After I reported this as GCC PR82435, a new
-Wno-attribute-alias option was added that could be used to turn the
warning off globally on the command line, but I'd prefer to do it a
little more fine-grained.
Interestingly, turning a warning off and on again inside of
a single macro doesn't always work, in this case I had to add
an extra statement inbetween and decided to copy the __SC_TEST
one from the native syscall to the compat syscall macro. See
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83256 for more details
about this.
[paul.burton@mips.com:
- Rebase atop current master.
- Split GCC & version arguments to __diag_ignore() in order to match
changes to the preceding patch.
- Add the comment argument to match the preceding patch.]
Link: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82435
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Paul Burton <paul.burton@mips.com>
Tested-by: Christophe Leroy <christophe.leroy@c-s.fr>
Tested-by: Stafford Horne <shorne@gmail.com>
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-06-19 20:14:57 +00:00
|
|
|
__diag_push(); \
|
|
|
|
__diag_ignore(GCC, 8, "-Wattribute-alias", \
|
|
|
|
"Type aliasing is used to sanitize syscall arguments");\
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
asmlinkage long compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) \
|
|
|
|
__attribute__((alias(__stringify(__se_compat_sys##name)))); \
|
|
|
|
ALLOW_ERROR_INJECTION(compat_sys##name, ERRNO); \
|
|
|
|
static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));\
|
|
|
|
asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \
|
|
|
|
asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \
|
|
|
|
{ \
|
disable -Wattribute-alias warning for SYSCALL_DEFINEx()
gcc-8 warns for every single definition of a system call entry
point, e.g.:
include/linux/compat.h:56:18: error: 'compat_sys_rt_sigprocmask' alias between functions of incompatible types 'long int(int, compat_sigset_t *, compat_sigset_t *, compat_size_t)' {aka 'long int(int, struct <anonymous> *, struct <anonymous> *, unsigned int)'} and 'long int(long int, long int, long int, long int)' [-Werror=attribute-alias]
asmlinkage long compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))\
^~~~~~~~~~
include/linux/compat.h:45:2: note: in expansion of macro 'COMPAT_SYSCALL_DEFINEx'
COMPAT_SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
^~~~~~~~~~~~~~~~~~~~~~
kernel/signal.c:2601:1: note: in expansion of macro 'COMPAT_SYSCALL_DEFINE4'
COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
^~~~~~~~~~~~~~~~~~~~~~
include/linux/compat.h:60:18: note: aliased declaration here
asmlinkage long compat_SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__))\
^~~~~~~~~~
The new warning seems reasonable in principle, but it doesn't
help us here, since we rely on the type mismatch to sanitize the
system call arguments. After I reported this as GCC PR82435, a new
-Wno-attribute-alias option was added that could be used to turn the
warning off globally on the command line, but I'd prefer to do it a
little more fine-grained.
Interestingly, turning a warning off and on again inside of
a single macro doesn't always work, in this case I had to add
an extra statement inbetween and decided to copy the __SC_TEST
one from the native syscall to the compat syscall macro. See
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83256 for more details
about this.
[paul.burton@mips.com:
- Rebase atop current master.
- Split GCC & version arguments to __diag_ignore() in order to match
changes to the preceding patch.
- Add the comment argument to match the preceding patch.]
Link: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82435
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Paul Burton <paul.burton@mips.com>
Tested-by: Christophe Leroy <christophe.leroy@c-s.fr>
Tested-by: Stafford Horne <shorne@gmail.com>
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-06-19 20:14:57 +00:00
|
|
|
long ret = __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));\
|
|
|
|
__MAP(x,__SC_TEST,__VA_ARGS__); \
|
|
|
|
return ret; \
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
} \
|
disable -Wattribute-alias warning for SYSCALL_DEFINEx()
gcc-8 warns for every single definition of a system call entry
point, e.g.:
include/linux/compat.h:56:18: error: 'compat_sys_rt_sigprocmask' alias between functions of incompatible types 'long int(int, compat_sigset_t *, compat_sigset_t *, compat_size_t)' {aka 'long int(int, struct <anonymous> *, struct <anonymous> *, unsigned int)'} and 'long int(long int, long int, long int, long int)' [-Werror=attribute-alias]
asmlinkage long compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))\
^~~~~~~~~~
include/linux/compat.h:45:2: note: in expansion of macro 'COMPAT_SYSCALL_DEFINEx'
COMPAT_SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
^~~~~~~~~~~~~~~~~~~~~~
kernel/signal.c:2601:1: note: in expansion of macro 'COMPAT_SYSCALL_DEFINE4'
COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
^~~~~~~~~~~~~~~~~~~~~~
include/linux/compat.h:60:18: note: aliased declaration here
asmlinkage long compat_SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__))\
^~~~~~~~~~
The new warning seems reasonable in principle, but it doesn't
help us here, since we rely on the type mismatch to sanitize the
system call arguments. After I reported this as GCC PR82435, a new
-Wno-attribute-alias option was added that could be used to turn the
warning off globally on the command line, but I'd prefer to do it a
little more fine-grained.
Interestingly, turning a warning off and on again inside of
a single macro doesn't always work, in this case I had to add
an extra statement inbetween and decided to copy the __SC_TEST
one from the native syscall to the compat syscall macro. See
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83256 for more details
about this.
[paul.burton@mips.com:
- Rebase atop current master.
- Split GCC & version arguments to __diag_ignore() in order to match
changes to the preceding patch.
- Add the comment argument to match the preceding patch.]
Link: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82435
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Paul Burton <paul.burton@mips.com>
Tested-by: Christophe Leroy <christophe.leroy@c-s.fr>
Tested-by: Stafford Horne <shorne@gmail.com>
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-06-19 20:14:57 +00:00
|
|
|
__diag_pop(); \
|
syscalls/core, syscalls/x86: Clean up compat syscall stub naming convention
Tidy the naming convention for compat syscall subs. Hints which describe
the purpose of the stub go in front and receive a double underscore to
denote that they are generated on-the-fly by the COMPAT_SYSCALL_DEFINEx()
macro.
For the generic case, this means:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
T __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T compat_sys_waitid # alias to __se_compat_sys_waitid()
# (taking parameters as declared), to
# be included in syscall table
For x86, the naming is as follows:
t kernel_waitid # common C function (see kernel/exit.c)
__do_compat_sys_waitid # inlined helper doing the actual work
# (takes original parameters as declared)
t __se_compat_sys_waitid # sign-extending C function calling inlined
# helper (takes parameters of type long,
# casts them to unsigned long and then to
# the declared type)
T __ia32_compat_sys_waitid # IA32_EMULATION 32-bit-ptregs -> C stub,
# calls __se_compat_sys_waitid(); to be
# included in syscall table
T __x32_compat_sys_waitid # x32 64-bit-ptregs -> C stub, calls
# __se_compat_sys_waitid(); to be included
# in syscall table
If only one of IA32_EMULATION and x32 is enabled, __se_compat_sys_waitid()
may be inlined into the stub __{ia32,x32}_compat_sys_waitid().
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20180409105145.5364-3-linux@dominikbrodowski.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-04-09 10:51:43 +00:00
|
|
|
static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
|
2018-04-05 09:53:03 +00:00
|
|
|
#endif /* COMPAT_SYSCALL_DEFINEx */
|
2012-11-23 14:12:59 +00:00
|
|
|
|
2020-09-25 04:51:40 +00:00
|
|
|
struct compat_iovec {
|
|
|
|
compat_uptr_t iov_base;
|
|
|
|
compat_size_t iov_len;
|
|
|
|
};
|
|
|
|
|
2012-12-14 18:49:35 +00:00
|
|
|
#ifndef compat_user_stack_pointer
|
|
|
|
#define compat_user_stack_pointer() current_user_stack_pointer()
|
|
|
|
#endif
|
2012-12-14 19:47:53 +00:00
|
|
|
#ifndef compat_sigaltstack /* we'll need that for MIPS */
|
|
|
|
typedef struct compat_sigaltstack {
|
|
|
|
compat_uptr_t ss_sp;
|
|
|
|
int ss_flags;
|
|
|
|
compat_size_t ss_size;
|
|
|
|
} compat_stack_t;
|
|
|
|
#endif
|
2018-09-05 14:34:42 +00:00
|
|
|
#ifndef COMPAT_MINSIGSTKSZ
|
|
|
|
#define COMPAT_MINSIGSTKSZ MINSIGSTKSZ
|
|
|
|
#endif
|
2012-12-14 19:47:53 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define compat_jiffies_to_clock_t(x) \
|
|
|
|
(((unsigned long)(x) * COMPAT_USER_HZ) / HZ)
|
|
|
|
|
2005-09-06 22:16:40 +00:00
|
|
|
typedef __compat_uid32_t compat_uid_t;
|
|
|
|
typedef __compat_gid32_t compat_gid_t;
|
|
|
|
|
2010-03-10 23:21:13 +00:00
|
|
|
struct compat_sel_arg_struct;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct rusage;
|
|
|
|
|
2019-10-25 08:46:22 +00:00
|
|
|
struct old_itimerval32;
|
2017-06-07 08:42:37 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct compat_tms {
|
|
|
|
compat_clock_t tms_utime;
|
|
|
|
compat_clock_t tms_stime;
|
|
|
|
compat_clock_t tms_cutime;
|
|
|
|
compat_clock_t tms_cstime;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define _COMPAT_NSIG_WORDS (_COMPAT_NSIG / _COMPAT_NSIG_BPW)
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
compat_sigset_word sig[_COMPAT_NSIG_WORDS];
|
|
|
|
} compat_sigset_t;
|
|
|
|
|
2019-07-16 23:29:53 +00:00
|
|
|
int set_compat_user_sigmask(const compat_sigset_t __user *umask,
|
2018-09-20 04:41:04 +00:00
|
|
|
size_t sigsetsize);
|
|
|
|
|
2012-12-25 23:38:15 +00:00
|
|
|
struct compat_sigaction {
|
2013-03-19 14:00:53 +00:00
|
|
|
#ifndef __ARCH_HAS_IRIX_SIGACTION
|
2012-12-25 23:38:15 +00:00
|
|
|
compat_uptr_t sa_handler;
|
|
|
|
compat_ulong_t sa_flags;
|
|
|
|
#else
|
2013-03-19 14:00:53 +00:00
|
|
|
compat_uint_t sa_flags;
|
2012-12-25 23:38:15 +00:00
|
|
|
compat_uptr_t sa_handler;
|
|
|
|
#endif
|
|
|
|
#ifdef __ARCH_HAS_SA_RESTORER
|
|
|
|
compat_uptr_t sa_restorer;
|
|
|
|
#endif
|
|
|
|
compat_sigset_t sa_mask __packed;
|
|
|
|
};
|
|
|
|
|
2017-07-09 19:53:17 +00:00
|
|
|
typedef union compat_sigval {
|
|
|
|
compat_int_t sival_int;
|
|
|
|
compat_uptr_t sival_ptr;
|
|
|
|
} compat_sigval_t;
|
|
|
|
|
|
|
|
typedef struct compat_siginfo {
|
|
|
|
int si_signo;
|
|
|
|
#ifndef __ARCH_HAS_SWAPPED_SIGINFO
|
|
|
|
int si_errno;
|
|
|
|
int si_code;
|
|
|
|
#else
|
|
|
|
int si_code;
|
|
|
|
int si_errno;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
union {
|
|
|
|
int _pad[128/sizeof(int) - 3];
|
|
|
|
|
|
|
|
/* kill() */
|
|
|
|
struct {
|
|
|
|
compat_pid_t _pid; /* sender's pid */
|
|
|
|
__compat_uid32_t _uid; /* sender's uid */
|
|
|
|
} _kill;
|
|
|
|
|
|
|
|
/* POSIX.1b timers */
|
|
|
|
struct {
|
|
|
|
compat_timer_t _tid; /* timer id */
|
|
|
|
int _overrun; /* overrun count */
|
|
|
|
compat_sigval_t _sigval; /* same as below */
|
|
|
|
} _timer;
|
|
|
|
|
|
|
|
/* POSIX.1b signals */
|
|
|
|
struct {
|
|
|
|
compat_pid_t _pid; /* sender's pid */
|
|
|
|
__compat_uid32_t _uid; /* sender's uid */
|
|
|
|
compat_sigval_t _sigval;
|
|
|
|
} _rt;
|
|
|
|
|
|
|
|
/* SIGCHLD */
|
|
|
|
struct {
|
|
|
|
compat_pid_t _pid; /* which child */
|
|
|
|
__compat_uid32_t _uid; /* sender's uid */
|
|
|
|
int _status; /* exit code */
|
|
|
|
compat_clock_t _utime;
|
|
|
|
compat_clock_t _stime;
|
|
|
|
} _sigchld;
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_X32_ABI
|
|
|
|
/* SIGCHLD (x32 version) */
|
|
|
|
struct {
|
|
|
|
compat_pid_t _pid; /* which child */
|
|
|
|
__compat_uid32_t _uid; /* sender's uid */
|
|
|
|
int _status; /* exit code */
|
|
|
|
compat_s64 _utime;
|
|
|
|
compat_s64 _stime;
|
|
|
|
} _sigchld_x32;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGTRAP, SIGEMT */
|
|
|
|
struct {
|
|
|
|
compat_uptr_t _addr; /* faulting insn/memory ref. */
|
2018-04-02 19:45:42 +00:00
|
|
|
#define __COMPAT_ADDR_BND_PKEY_PAD (__alignof__(compat_uptr_t) < sizeof(short) ? \
|
|
|
|
sizeof(short) : __alignof__(compat_uptr_t))
|
2017-07-09 19:53:17 +00:00
|
|
|
union {
|
siginfo: Move si_trapno inside the union inside _si_fault
It turns out that linux uses si_trapno very sparingly, and as such it
can be considered extra information for a very narrow selection of
signals, rather than information that is present with every fault
reported in siginfo.
As such move si_trapno inside the union inside of _si_fault. This
results in no change in placement, and makes it eaiser
to extend _si_fault in the future as this reduces the number of
special cases. In particular with si_trapno included in the union it
is no longer a concern that the union must be pointer aligned on most
architectures because the union follows immediately after si_addr
which is a pointer.
This change results in a difference in siginfo field placement on
sparc and alpha for the fields si_addr_lsb, si_lower, si_upper,
si_pkey, and si_perf. These architectures do not implement the
signals that would use si_addr_lsb, si_lower, si_upper, si_pkey, and
si_perf. Further these architecture have not yet implemented the
userspace that would use si_perf.
The point of this change is in fact to correct these placement issues
before sparc or alpha grow userspace that cares. This change was
discussed[1] and the agreement is that this change is currently safe.
[1]: https://lkml.kernel.org/r/CAK8P3a0+uKYwL1NhY6Hvtieghba2hKYGD6hcKx5n8=4Gtt+pHA@mail.gmail.com
Acked-by: Marco Elver <elver@google.com>
v1: https://lkml.kernel.org/r/m1tunns7yf.fsf_-_@fess.ebiederm.org
v2: https://lkml.kernel.org/r/20210505141101.11519-5-ebiederm@xmission.com
Link: https://lkml.kernel.org/r/20210517195748.8880-1-ebiederm@xmission.com
Signed-off-by: "Eric W. Biederman" <ebiederm@xmission.com>
2021-04-30 22:06:01 +00:00
|
|
|
/* used on alpha and sparc */
|
|
|
|
int _trapno; /* TRAP # which caused the signal */
|
2017-07-31 15:08:59 +00:00
|
|
|
/*
|
|
|
|
* used when si_code=BUS_MCEERR_AR or
|
|
|
|
* used when si_code=BUS_MCEERR_AO
|
|
|
|
*/
|
|
|
|
short int _addr_lsb; /* Valid LSB of the reported address. */
|
2017-07-09 19:53:17 +00:00
|
|
|
/* used when si_code=SEGV_BNDERR */
|
|
|
|
struct {
|
2018-04-02 19:45:42 +00:00
|
|
|
char _dummy_bnd[__COMPAT_ADDR_BND_PKEY_PAD];
|
2017-07-09 19:53:17 +00:00
|
|
|
compat_uptr_t _lower;
|
|
|
|
compat_uptr_t _upper;
|
|
|
|
} _addr_bnd;
|
|
|
|
/* used when si_code=SEGV_PKUERR */
|
2017-07-31 15:08:59 +00:00
|
|
|
struct {
|
2018-04-02 19:45:42 +00:00
|
|
|
char _dummy_pkey[__COMPAT_ADDR_BND_PKEY_PAD];
|
2017-07-31 15:08:59 +00:00
|
|
|
u32 _pkey;
|
|
|
|
} _addr_pkey;
|
2021-04-08 10:36:00 +00:00
|
|
|
/* used when si_code=TRAP_PERF */
|
2021-05-02 22:28:31 +00:00
|
|
|
struct {
|
|
|
|
compat_ulong_t _data;
|
|
|
|
u32 _type;
|
signal: Deliver SIGTRAP on perf event asynchronously if blocked
With SIGTRAP on perf events, we have encountered termination of
processes due to user space attempting to block delivery of SIGTRAP.
Consider this case:
<set up SIGTRAP on a perf event>
...
sigset_t s;
sigemptyset(&s);
sigaddset(&s, SIGTRAP | <and others>);
sigprocmask(SIG_BLOCK, &s, ...);
...
<perf event triggers>
When the perf event triggers, while SIGTRAP is blocked, force_sig_perf()
will force the signal, but revert back to the default handler, thus
terminating the task.
This makes sense for error conditions, but not so much for explicitly
requested monitoring. However, the expectation is still that signals
generated by perf events are synchronous, which will no longer be the
case if the signal is blocked and delivered later.
To give user space the ability to clearly distinguish synchronous from
asynchronous signals, introduce siginfo_t::si_perf_flags and
TRAP_PERF_FLAG_ASYNC (opted for flags in case more binary information is
required in future).
The resolution to the problem is then to (a) no longer force the signal
(avoiding the terminations), but (b) tell user space via si_perf_flags
if the signal was synchronous or not, so that such signals can be
handled differently (e.g. let user space decide to ignore or consider
the data imprecise).
The alternative of making the kernel ignore SIGTRAP on perf events if
the signal is blocked may work for some usecases, but likely causes
issues in others that then have to revert back to interception of
sigprocmask() (which we want to avoid). [ A concrete example: when using
breakpoint perf events to track data-flow, in a region of code where
signals are blocked, data-flow can no longer be tracked accurately.
When a relevant asynchronous signal is received after unblocking the
signal, the data-flow tracking logic needs to know its state is
imprecise. ]
Fixes: 97ba62b27867 ("perf: Add support for SIGTRAP on perf events")
Reported-by: Dmitry Vyukov <dvyukov@google.com>
Signed-off-by: Marco Elver <elver@google.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Geert Uytterhoeven <geert@linux-m68k.org>
Tested-by: Dmitry Vyukov <dvyukov@google.com>
Link: https://lore.kernel.org/r/20220404111204.935357-1-elver@google.com
2022-04-04 11:12:04 +00:00
|
|
|
u32 _flags;
|
2021-05-02 22:28:31 +00:00
|
|
|
} _perf;
|
2017-07-09 19:53:17 +00:00
|
|
|
};
|
|
|
|
} _sigfault;
|
|
|
|
|
|
|
|
/* SIGPOLL */
|
|
|
|
struct {
|
|
|
|
compat_long_t _band; /* POLL_IN, POLL_OUT, POLL_MSG */
|
|
|
|
int _fd;
|
|
|
|
} _sigpoll;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
compat_uptr_t _call_addr; /* calling user insn */
|
|
|
|
int _syscall; /* triggering system call number */
|
|
|
|
unsigned int _arch; /* AUDIT_ARCH_* of syscall */
|
|
|
|
} _sigsys;
|
|
|
|
} _sifields;
|
|
|
|
} compat_siginfo_t;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct compat_rlimit {
|
|
|
|
compat_ulong_t rlim_cur;
|
|
|
|
compat_ulong_t rlim_max;
|
|
|
|
};
|
|
|
|
|
2022-04-05 07:12:57 +00:00
|
|
|
#ifdef __ARCH_NEED_COMPAT_FLOCK64_PACKED
|
|
|
|
#define __ARCH_COMPAT_FLOCK64_PACK __attribute__((packed))
|
|
|
|
#else
|
|
|
|
#define __ARCH_COMPAT_FLOCK64_PACK
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct compat_flock {
|
|
|
|
short l_type;
|
|
|
|
short l_whence;
|
|
|
|
compat_off_t l_start;
|
|
|
|
compat_off_t l_len;
|
|
|
|
#ifdef __ARCH_COMPAT_FLOCK_EXTRA_SYSID
|
|
|
|
__ARCH_COMPAT_FLOCK_EXTRA_SYSID
|
|
|
|
#endif
|
|
|
|
compat_pid_t l_pid;
|
|
|
|
#ifdef __ARCH_COMPAT_FLOCK_PAD
|
|
|
|
__ARCH_COMPAT_FLOCK_PAD
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
struct compat_flock64 {
|
|
|
|
short l_type;
|
|
|
|
short l_whence;
|
|
|
|
compat_loff_t l_start;
|
|
|
|
compat_loff_t l_len;
|
|
|
|
compat_pid_t l_pid;
|
|
|
|
#ifdef __ARCH_COMPAT_FLOCK64_PAD
|
|
|
|
__ARCH_COMPAT_FLOCK64_PAD
|
|
|
|
#endif
|
|
|
|
} __ARCH_COMPAT_FLOCK64_PACK;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct compat_rusage {
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
struct old_timeval32 ru_utime;
|
|
|
|
struct old_timeval32 ru_stime;
|
2005-04-16 22:20:36 +00:00
|
|
|
compat_long_t ru_maxrss;
|
|
|
|
compat_long_t ru_ixrss;
|
|
|
|
compat_long_t ru_idrss;
|
|
|
|
compat_long_t ru_isrss;
|
|
|
|
compat_long_t ru_minflt;
|
|
|
|
compat_long_t ru_majflt;
|
|
|
|
compat_long_t ru_nswap;
|
|
|
|
compat_long_t ru_inblock;
|
|
|
|
compat_long_t ru_oublock;
|
|
|
|
compat_long_t ru_msgsnd;
|
|
|
|
compat_long_t ru_msgrcv;
|
|
|
|
compat_long_t ru_nsignals;
|
|
|
|
compat_long_t ru_nvcsw;
|
|
|
|
compat_long_t ru_nivcsw;
|
|
|
|
};
|
|
|
|
|
2011-05-17 18:41:06 +00:00
|
|
|
extern int put_compat_rusage(const struct rusage *,
|
|
|
|
struct compat_rusage __user *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct compat_siginfo;
|
aio: implement io_pgetevents
This is the io_getevents equivalent of ppoll/pselect and allows to
properly mix signals and aio completions (especially with IOCB_CMD_POLL)
and atomically executes the following sequence:
sigset_t origmask;
pthread_sigmask(SIG_SETMASK, &sigmask, &origmask);
ret = io_getevents(ctx, min_nr, nr, events, timeout);
pthread_sigmask(SIG_SETMASK, &origmask, NULL);
Note that unlike many other signal related calls we do not pass a sigmask
size, as that would get us to 7 arguments, which aren't easily supported
by the syscall infrastructure. It seems a lot less painful to just add a
new syscall variant in the unlikely case we're going to increase the
sigset size.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
2018-05-02 17:51:00 +00:00
|
|
|
struct __compat_aio_sigset;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct compat_dirent {
|
|
|
|
u32 d_ino;
|
|
|
|
compat_off_t d_off;
|
|
|
|
u16 d_reclen;
|
|
|
|
char d_name[256];
|
|
|
|
};
|
|
|
|
|
2008-11-28 09:09:09 +00:00
|
|
|
struct compat_ustat {
|
|
|
|
compat_daddr_t f_tfree;
|
|
|
|
compat_ino_t f_tinode;
|
|
|
|
char f_fname[6];
|
|
|
|
char f_fpack[6];
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define COMPAT_SIGEV_PAD_SIZE ((SIGEV_MAX_SIZE/sizeof(int)) - 3)
|
|
|
|
|
|
|
|
typedef struct compat_sigevent {
|
|
|
|
compat_sigval_t sigev_value;
|
|
|
|
compat_int_t sigev_signo;
|
|
|
|
compat_int_t sigev_notify;
|
|
|
|
union {
|
|
|
|
compat_int_t _pad[COMPAT_SIGEV_PAD_SIZE];
|
|
|
|
compat_int_t _tid;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
compat_uptr_t _function;
|
|
|
|
compat_uptr_t _attribute;
|
|
|
|
} _sigev_thread;
|
|
|
|
} _sigev_un;
|
|
|
|
} compat_sigevent_t;
|
|
|
|
|
2009-11-06 08:09:03 +00:00
|
|
|
struct compat_ifmap {
|
|
|
|
compat_ulong_t mem_start;
|
|
|
|
compat_ulong_t mem_end;
|
|
|
|
unsigned short base_addr;
|
|
|
|
unsigned char irq;
|
|
|
|
unsigned char dma;
|
|
|
|
unsigned char port;
|
|
|
|
};
|
|
|
|
|
2011-05-17 18:41:06 +00:00
|
|
|
struct compat_if_settings {
|
2009-11-09 04:57:03 +00:00
|
|
|
unsigned int type; /* Type of physical device or protocol */
|
|
|
|
unsigned int size; /* Size of the data allocated by the caller */
|
|
|
|
compat_uptr_t ifs_ifsu; /* union of pointers */
|
|
|
|
};
|
|
|
|
|
2009-11-06 08:09:03 +00:00
|
|
|
struct compat_ifreq {
|
2009-11-09 04:57:03 +00:00
|
|
|
union {
|
|
|
|
char ifrn_name[IFNAMSIZ]; /* if name, e.g. "en0" */
|
|
|
|
} ifr_ifrn;
|
|
|
|
union {
|
|
|
|
struct sockaddr ifru_addr;
|
|
|
|
struct sockaddr ifru_dstaddr;
|
|
|
|
struct sockaddr ifru_broadaddr;
|
|
|
|
struct sockaddr ifru_netmask;
|
|
|
|
struct sockaddr ifru_hwaddr;
|
|
|
|
short ifru_flags;
|
|
|
|
compat_int_t ifru_ivalue;
|
|
|
|
compat_int_t ifru_mtu;
|
|
|
|
struct compat_ifmap ifru_map;
|
|
|
|
char ifru_slave[IFNAMSIZ]; /* Just fits the size */
|
2009-11-06 08:09:03 +00:00
|
|
|
char ifru_newname[IFNAMSIZ];
|
2009-11-09 04:57:03 +00:00
|
|
|
compat_caddr_t ifru_data;
|
|
|
|
struct compat_if_settings ifru_settings;
|
|
|
|
} ifr_ifru;
|
2009-11-06 08:09:03 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct compat_ifconf {
|
2011-05-17 18:41:06 +00:00
|
|
|
compat_int_t ifc_len; /* size of buffer */
|
|
|
|
compat_caddr_t ifcbuf;
|
2009-11-06 08:09:03 +00:00
|
|
|
};
|
|
|
|
|
2006-03-27 09:16:24 +00:00
|
|
|
struct compat_robust_list {
|
|
|
|
compat_uptr_t next;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct compat_robust_list_head {
|
|
|
|
struct compat_robust_list list;
|
|
|
|
compat_long_t futex_offset;
|
|
|
|
compat_uptr_t list_op_pending;
|
|
|
|
};
|
|
|
|
|
2012-12-26 00:09:45 +00:00
|
|
|
#ifdef CONFIG_COMPAT_OLD_SIGACTION
|
|
|
|
struct compat_old_sigaction {
|
|
|
|
compat_uptr_t sa_handler;
|
|
|
|
compat_old_sigset_t sa_mask;
|
|
|
|
compat_ulong_t sa_flags;
|
|
|
|
compat_uptr_t sa_restorer;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2016-08-19 18:39:09 +00:00
|
|
|
struct compat_keyctl_kdf_params {
|
|
|
|
compat_uptr_t hashname;
|
|
|
|
compat_uptr_t otherinfo;
|
|
|
|
__u32 otherinfolen;
|
|
|
|
__u32 __spare[8];
|
|
|
|
};
|
|
|
|
|
2021-07-22 14:28:58 +00:00
|
|
|
struct compat_stat;
|
2011-05-09 17:12:30 +00:00
|
|
|
struct compat_statfs;
|
|
|
|
struct compat_statfs64;
|
|
|
|
struct compat_old_linux_dirent;
|
|
|
|
struct compat_linux_dirent;
|
|
|
|
struct linux_dirent64;
|
|
|
|
struct compat_msghdr;
|
|
|
|
struct compat_mmsghdr;
|
|
|
|
struct compat_sysinfo;
|
|
|
|
struct compat_sysctl_args;
|
|
|
|
struct compat_kexec_segment;
|
|
|
|
struct compat_mq_attr;
|
[PATCH v3] ipc: provide generic compat versions of IPC syscalls
When using the "compat" APIs, architectures will generally want to
be able to make direct syscalls to msgsnd(), shmctl(), etc., and
in the kernel we would want them to be handled directly by
compat_sys_xxx() functions, as is true for other compat syscalls.
However, for historical reasons, several of the existing compat IPC
syscalls do not do this. semctl() expects a pointer to the fourth
argument, instead of the fourth argument itself. msgsnd(), msgrcv()
and shmat() expect arguments in different order.
This change adds an ARCH_WANT_OLD_COMPAT_IPC config option that can be
set to preserve this behavior for ports that use it (x86, sparc, powerpc,
s390, and mips). No actual semantics are changed for those architectures,
and there is only a minimal amount of code refactoring in ipc/compat.c.
Newer architectures like tile (and perhaps future architectures such
as arm64 and unicore64) should not select this option, and thus can
avoid having any IPC-specific code at all in their architecture-specific
compat layer. In the same vein, if this option is not selected, IPC_64
mode is assumed, since that's what the <asm-generic> headers expect.
The workaround code in "tile" for msgsnd() and msgrcv() is removed
with this change; it also fixes the bug that shmat() and semctl() were
not being properly handled.
Reviewed-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Chris Metcalf <cmetcalf@tilera.com>
2012-03-15 17:13:38 +00:00
|
|
|
struct compat_msgbuf;
|
2011-05-09 17:12:30 +00:00
|
|
|
|
2020-05-05 10:12:53 +00:00
|
|
|
void copy_siginfo_to_external32(struct compat_siginfo *to,
|
|
|
|
const struct kernel_siginfo *from);
|
|
|
|
int copy_siginfo_from_user32(kernel_siginfo_t *to,
|
|
|
|
const struct compat_siginfo __user *from);
|
|
|
|
int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
|
|
|
|
const kernel_siginfo_t *from);
|
|
|
|
#ifndef copy_siginfo_to_user32
|
|
|
|
#define copy_siginfo_to_user32 __copy_siginfo_to_user32
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
int get_compat_sigevent(struct sigevent *event,
|
|
|
|
const struct compat_sigevent __user *u_event);
|
|
|
|
|
2017-09-04 01:45:17 +00:00
|
|
|
extern int get_compat_sigset(sigset_t *set, const compat_sigset_t __user *compat);
|
signals: Move put_compat_sigset to compat.h to silence hardened usercopy
Since commit afcc90f8621e ("usercopy: WARN() on slab cache usercopy
region violations"), MIPS systems booting with a compat root filesystem
emit a warning when copying compat siginfo to userspace:
WARNING: CPU: 0 PID: 953 at mm/usercopy.c:81 usercopy_warn+0x98/0xe8
Bad or missing usercopy whitelist? Kernel memory exposure attempt
detected from SLAB object 'task_struct' (offset 1432, size 16)!
Modules linked in:
CPU: 0 PID: 953 Comm: S01logging Not tainted 4.16.0-rc2 #10
Stack : ffffffff808c0000 0000000000000000 0000000000000001 65ac85163f3bdc4a
65ac85163f3bdc4a 0000000000000000 90000000ff667ab8 ffffffff808c0000
00000000000003f8 ffffffff808d0000 00000000000000d1 0000000000000000
000000000000003c 0000000000000000 ffffffff808c8ca8 ffffffff808d0000
ffffffff808d0000 ffffffff80810000 fffffc0000000000 ffffffff80785c30
0000000000000009 0000000000000051 90000000ff667eb0 90000000ff667db0
000000007fe0d938 0000000000000018 ffffffff80449958 0000000020052798
ffffffff808c0000 90000000ff664000 90000000ff667ab0 00000000100c0000
ffffffff80698810 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 ffffffff8010d02c 65ac85163f3bdc4a
...
Call Trace:
[<ffffffff8010d02c>] show_stack+0x9c/0x130
[<ffffffff80698810>] dump_stack+0x90/0xd0
[<ffffffff80137b78>] __warn+0x100/0x118
[<ffffffff80137bdc>] warn_slowpath_fmt+0x4c/0x70
[<ffffffff8021e4a8>] usercopy_warn+0x98/0xe8
[<ffffffff8021e68c>] __check_object_size+0xfc/0x250
[<ffffffff801bbfb8>] put_compat_sigset+0x30/0x88
[<ffffffff8011af24>] setup_rt_frame_n32+0xc4/0x160
[<ffffffff8010b8b4>] do_signal+0x19c/0x230
[<ffffffff8010c408>] do_notify_resume+0x60/0x78
[<ffffffff80106f50>] work_notifysig+0x10/0x18
---[ end trace 88fffbf69147f48a ]---
Commit 5905429ad856 ("fork: Provide usercopy whitelisting for
task_struct") noted that:
"While the blocked and saved_sigmask fields of task_struct are copied to
userspace (via sigmask_to_save() and setup_rt_frame()), it is always
copied with a static length (i.e. sizeof(sigset_t))."
However, this is not true in the case of compat signals, whose sigset
is copied by put_compat_sigset and receives size as an argument.
At most call sites, put_compat_sigset is copying a sigset from the
current task_struct. This triggers a warning when
CONFIG_HARDENED_USERCOPY is active. However, by marking this function as
static inline, the warning can be avoided because in all of these cases
the size is constant at compile time, which is allowed. The only site
where this is not the case is handling the rt_sigpending syscall, but
there the copy is being made from a stack local variable so does not
trigger the warning.
Move put_compat_sigset to compat.h, and mark it static inline. This
fixes the WARN on MIPS.
Fixes: afcc90f8621e ("usercopy: WARN() on slab cache usercopy region violations")
Signed-off-by: Matt Redfearn <matt.redfearn@mips.com>
Acked-by: Kees Cook <keescook@chromium.org>
Cc: "Dmitry V . Levin" <ldv@altlinux.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: kernel-hardening@lists.openwall.com
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/18639/
Signed-off-by: James Hogan <jhogan@kernel.org>
2018-02-19 16:55:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Defined inline such that size can be compile time constant, which avoids
|
|
|
|
* CONFIG_HARDENED_USERCOPY complaining about copies from task_struct
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
put_compat_sigset(compat_sigset_t __user *compat, const sigset_t *set,
|
|
|
|
unsigned int size)
|
|
|
|
{
|
|
|
|
/* size <= sizeof(compat_sigset_t) <= sizeof(sigset_t) */
|
2021-07-22 14:28:58 +00:00
|
|
|
#if defined(__BIG_ENDIAN) && defined(CONFIG_64BIT)
|
signals: Move put_compat_sigset to compat.h to silence hardened usercopy
Since commit afcc90f8621e ("usercopy: WARN() on slab cache usercopy
region violations"), MIPS systems booting with a compat root filesystem
emit a warning when copying compat siginfo to userspace:
WARNING: CPU: 0 PID: 953 at mm/usercopy.c:81 usercopy_warn+0x98/0xe8
Bad or missing usercopy whitelist? Kernel memory exposure attempt
detected from SLAB object 'task_struct' (offset 1432, size 16)!
Modules linked in:
CPU: 0 PID: 953 Comm: S01logging Not tainted 4.16.0-rc2 #10
Stack : ffffffff808c0000 0000000000000000 0000000000000001 65ac85163f3bdc4a
65ac85163f3bdc4a 0000000000000000 90000000ff667ab8 ffffffff808c0000
00000000000003f8 ffffffff808d0000 00000000000000d1 0000000000000000
000000000000003c 0000000000000000 ffffffff808c8ca8 ffffffff808d0000
ffffffff808d0000 ffffffff80810000 fffffc0000000000 ffffffff80785c30
0000000000000009 0000000000000051 90000000ff667eb0 90000000ff667db0
000000007fe0d938 0000000000000018 ffffffff80449958 0000000020052798
ffffffff808c0000 90000000ff664000 90000000ff667ab0 00000000100c0000
ffffffff80698810 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 ffffffff8010d02c 65ac85163f3bdc4a
...
Call Trace:
[<ffffffff8010d02c>] show_stack+0x9c/0x130
[<ffffffff80698810>] dump_stack+0x90/0xd0
[<ffffffff80137b78>] __warn+0x100/0x118
[<ffffffff80137bdc>] warn_slowpath_fmt+0x4c/0x70
[<ffffffff8021e4a8>] usercopy_warn+0x98/0xe8
[<ffffffff8021e68c>] __check_object_size+0xfc/0x250
[<ffffffff801bbfb8>] put_compat_sigset+0x30/0x88
[<ffffffff8011af24>] setup_rt_frame_n32+0xc4/0x160
[<ffffffff8010b8b4>] do_signal+0x19c/0x230
[<ffffffff8010c408>] do_notify_resume+0x60/0x78
[<ffffffff80106f50>] work_notifysig+0x10/0x18
---[ end trace 88fffbf69147f48a ]---
Commit 5905429ad856 ("fork: Provide usercopy whitelisting for
task_struct") noted that:
"While the blocked and saved_sigmask fields of task_struct are copied to
userspace (via sigmask_to_save() and setup_rt_frame()), it is always
copied with a static length (i.e. sizeof(sigset_t))."
However, this is not true in the case of compat signals, whose sigset
is copied by put_compat_sigset and receives size as an argument.
At most call sites, put_compat_sigset is copying a sigset from the
current task_struct. This triggers a warning when
CONFIG_HARDENED_USERCOPY is active. However, by marking this function as
static inline, the warning can be avoided because in all of these cases
the size is constant at compile time, which is allowed. The only site
where this is not the case is handling the rt_sigpending syscall, but
there the copy is being made from a stack local variable so does not
trigger the warning.
Move put_compat_sigset to compat.h, and mark it static inline. This
fixes the WARN on MIPS.
Fixes: afcc90f8621e ("usercopy: WARN() on slab cache usercopy region violations")
Signed-off-by: Matt Redfearn <matt.redfearn@mips.com>
Acked-by: Kees Cook <keescook@chromium.org>
Cc: "Dmitry V . Levin" <ldv@altlinux.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: kernel-hardening@lists.openwall.com
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/18639/
Signed-off-by: James Hogan <jhogan@kernel.org>
2018-02-19 16:55:06 +00:00
|
|
|
compat_sigset_t v;
|
|
|
|
switch (_NSIG_WORDS) {
|
|
|
|
case 4: v.sig[7] = (set->sig[3] >> 32); v.sig[6] = set->sig[3];
|
2020-08-23 22:36:59 +00:00
|
|
|
fallthrough;
|
signals: Move put_compat_sigset to compat.h to silence hardened usercopy
Since commit afcc90f8621e ("usercopy: WARN() on slab cache usercopy
region violations"), MIPS systems booting with a compat root filesystem
emit a warning when copying compat siginfo to userspace:
WARNING: CPU: 0 PID: 953 at mm/usercopy.c:81 usercopy_warn+0x98/0xe8
Bad or missing usercopy whitelist? Kernel memory exposure attempt
detected from SLAB object 'task_struct' (offset 1432, size 16)!
Modules linked in:
CPU: 0 PID: 953 Comm: S01logging Not tainted 4.16.0-rc2 #10
Stack : ffffffff808c0000 0000000000000000 0000000000000001 65ac85163f3bdc4a
65ac85163f3bdc4a 0000000000000000 90000000ff667ab8 ffffffff808c0000
00000000000003f8 ffffffff808d0000 00000000000000d1 0000000000000000
000000000000003c 0000000000000000 ffffffff808c8ca8 ffffffff808d0000
ffffffff808d0000 ffffffff80810000 fffffc0000000000 ffffffff80785c30
0000000000000009 0000000000000051 90000000ff667eb0 90000000ff667db0
000000007fe0d938 0000000000000018 ffffffff80449958 0000000020052798
ffffffff808c0000 90000000ff664000 90000000ff667ab0 00000000100c0000
ffffffff80698810 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 ffffffff8010d02c 65ac85163f3bdc4a
...
Call Trace:
[<ffffffff8010d02c>] show_stack+0x9c/0x130
[<ffffffff80698810>] dump_stack+0x90/0xd0
[<ffffffff80137b78>] __warn+0x100/0x118
[<ffffffff80137bdc>] warn_slowpath_fmt+0x4c/0x70
[<ffffffff8021e4a8>] usercopy_warn+0x98/0xe8
[<ffffffff8021e68c>] __check_object_size+0xfc/0x250
[<ffffffff801bbfb8>] put_compat_sigset+0x30/0x88
[<ffffffff8011af24>] setup_rt_frame_n32+0xc4/0x160
[<ffffffff8010b8b4>] do_signal+0x19c/0x230
[<ffffffff8010c408>] do_notify_resume+0x60/0x78
[<ffffffff80106f50>] work_notifysig+0x10/0x18
---[ end trace 88fffbf69147f48a ]---
Commit 5905429ad856 ("fork: Provide usercopy whitelisting for
task_struct") noted that:
"While the blocked and saved_sigmask fields of task_struct are copied to
userspace (via sigmask_to_save() and setup_rt_frame()), it is always
copied with a static length (i.e. sizeof(sigset_t))."
However, this is not true in the case of compat signals, whose sigset
is copied by put_compat_sigset and receives size as an argument.
At most call sites, put_compat_sigset is copying a sigset from the
current task_struct. This triggers a warning when
CONFIG_HARDENED_USERCOPY is active. However, by marking this function as
static inline, the warning can be avoided because in all of these cases
the size is constant at compile time, which is allowed. The only site
where this is not the case is handling the rt_sigpending syscall, but
there the copy is being made from a stack local variable so does not
trigger the warning.
Move put_compat_sigset to compat.h, and mark it static inline. This
fixes the WARN on MIPS.
Fixes: afcc90f8621e ("usercopy: WARN() on slab cache usercopy region violations")
Signed-off-by: Matt Redfearn <matt.redfearn@mips.com>
Acked-by: Kees Cook <keescook@chromium.org>
Cc: "Dmitry V . Levin" <ldv@altlinux.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: kernel-hardening@lists.openwall.com
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/18639/
Signed-off-by: James Hogan <jhogan@kernel.org>
2018-02-19 16:55:06 +00:00
|
|
|
case 3: v.sig[5] = (set->sig[2] >> 32); v.sig[4] = set->sig[2];
|
2020-08-23 22:36:59 +00:00
|
|
|
fallthrough;
|
signals: Move put_compat_sigset to compat.h to silence hardened usercopy
Since commit afcc90f8621e ("usercopy: WARN() on slab cache usercopy
region violations"), MIPS systems booting with a compat root filesystem
emit a warning when copying compat siginfo to userspace:
WARNING: CPU: 0 PID: 953 at mm/usercopy.c:81 usercopy_warn+0x98/0xe8
Bad or missing usercopy whitelist? Kernel memory exposure attempt
detected from SLAB object 'task_struct' (offset 1432, size 16)!
Modules linked in:
CPU: 0 PID: 953 Comm: S01logging Not tainted 4.16.0-rc2 #10
Stack : ffffffff808c0000 0000000000000000 0000000000000001 65ac85163f3bdc4a
65ac85163f3bdc4a 0000000000000000 90000000ff667ab8 ffffffff808c0000
00000000000003f8 ffffffff808d0000 00000000000000d1 0000000000000000
000000000000003c 0000000000000000 ffffffff808c8ca8 ffffffff808d0000
ffffffff808d0000 ffffffff80810000 fffffc0000000000 ffffffff80785c30
0000000000000009 0000000000000051 90000000ff667eb0 90000000ff667db0
000000007fe0d938 0000000000000018 ffffffff80449958 0000000020052798
ffffffff808c0000 90000000ff664000 90000000ff667ab0 00000000100c0000
ffffffff80698810 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 ffffffff8010d02c 65ac85163f3bdc4a
...
Call Trace:
[<ffffffff8010d02c>] show_stack+0x9c/0x130
[<ffffffff80698810>] dump_stack+0x90/0xd0
[<ffffffff80137b78>] __warn+0x100/0x118
[<ffffffff80137bdc>] warn_slowpath_fmt+0x4c/0x70
[<ffffffff8021e4a8>] usercopy_warn+0x98/0xe8
[<ffffffff8021e68c>] __check_object_size+0xfc/0x250
[<ffffffff801bbfb8>] put_compat_sigset+0x30/0x88
[<ffffffff8011af24>] setup_rt_frame_n32+0xc4/0x160
[<ffffffff8010b8b4>] do_signal+0x19c/0x230
[<ffffffff8010c408>] do_notify_resume+0x60/0x78
[<ffffffff80106f50>] work_notifysig+0x10/0x18
---[ end trace 88fffbf69147f48a ]---
Commit 5905429ad856 ("fork: Provide usercopy whitelisting for
task_struct") noted that:
"While the blocked and saved_sigmask fields of task_struct are copied to
userspace (via sigmask_to_save() and setup_rt_frame()), it is always
copied with a static length (i.e. sizeof(sigset_t))."
However, this is not true in the case of compat signals, whose sigset
is copied by put_compat_sigset and receives size as an argument.
At most call sites, put_compat_sigset is copying a sigset from the
current task_struct. This triggers a warning when
CONFIG_HARDENED_USERCOPY is active. However, by marking this function as
static inline, the warning can be avoided because in all of these cases
the size is constant at compile time, which is allowed. The only site
where this is not the case is handling the rt_sigpending syscall, but
there the copy is being made from a stack local variable so does not
trigger the warning.
Move put_compat_sigset to compat.h, and mark it static inline. This
fixes the WARN on MIPS.
Fixes: afcc90f8621e ("usercopy: WARN() on slab cache usercopy region violations")
Signed-off-by: Matt Redfearn <matt.redfearn@mips.com>
Acked-by: Kees Cook <keescook@chromium.org>
Cc: "Dmitry V . Levin" <ldv@altlinux.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: kernel-hardening@lists.openwall.com
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/18639/
Signed-off-by: James Hogan <jhogan@kernel.org>
2018-02-19 16:55:06 +00:00
|
|
|
case 2: v.sig[3] = (set->sig[1] >> 32); v.sig[2] = set->sig[1];
|
2020-08-23 22:36:59 +00:00
|
|
|
fallthrough;
|
signals: Move put_compat_sigset to compat.h to silence hardened usercopy
Since commit afcc90f8621e ("usercopy: WARN() on slab cache usercopy
region violations"), MIPS systems booting with a compat root filesystem
emit a warning when copying compat siginfo to userspace:
WARNING: CPU: 0 PID: 953 at mm/usercopy.c:81 usercopy_warn+0x98/0xe8
Bad or missing usercopy whitelist? Kernel memory exposure attempt
detected from SLAB object 'task_struct' (offset 1432, size 16)!
Modules linked in:
CPU: 0 PID: 953 Comm: S01logging Not tainted 4.16.0-rc2 #10
Stack : ffffffff808c0000 0000000000000000 0000000000000001 65ac85163f3bdc4a
65ac85163f3bdc4a 0000000000000000 90000000ff667ab8 ffffffff808c0000
00000000000003f8 ffffffff808d0000 00000000000000d1 0000000000000000
000000000000003c 0000000000000000 ffffffff808c8ca8 ffffffff808d0000
ffffffff808d0000 ffffffff80810000 fffffc0000000000 ffffffff80785c30
0000000000000009 0000000000000051 90000000ff667eb0 90000000ff667db0
000000007fe0d938 0000000000000018 ffffffff80449958 0000000020052798
ffffffff808c0000 90000000ff664000 90000000ff667ab0 00000000100c0000
ffffffff80698810 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 ffffffff8010d02c 65ac85163f3bdc4a
...
Call Trace:
[<ffffffff8010d02c>] show_stack+0x9c/0x130
[<ffffffff80698810>] dump_stack+0x90/0xd0
[<ffffffff80137b78>] __warn+0x100/0x118
[<ffffffff80137bdc>] warn_slowpath_fmt+0x4c/0x70
[<ffffffff8021e4a8>] usercopy_warn+0x98/0xe8
[<ffffffff8021e68c>] __check_object_size+0xfc/0x250
[<ffffffff801bbfb8>] put_compat_sigset+0x30/0x88
[<ffffffff8011af24>] setup_rt_frame_n32+0xc4/0x160
[<ffffffff8010b8b4>] do_signal+0x19c/0x230
[<ffffffff8010c408>] do_notify_resume+0x60/0x78
[<ffffffff80106f50>] work_notifysig+0x10/0x18
---[ end trace 88fffbf69147f48a ]---
Commit 5905429ad856 ("fork: Provide usercopy whitelisting for
task_struct") noted that:
"While the blocked and saved_sigmask fields of task_struct are copied to
userspace (via sigmask_to_save() and setup_rt_frame()), it is always
copied with a static length (i.e. sizeof(sigset_t))."
However, this is not true in the case of compat signals, whose sigset
is copied by put_compat_sigset and receives size as an argument.
At most call sites, put_compat_sigset is copying a sigset from the
current task_struct. This triggers a warning when
CONFIG_HARDENED_USERCOPY is active. However, by marking this function as
static inline, the warning can be avoided because in all of these cases
the size is constant at compile time, which is allowed. The only site
where this is not the case is handling the rt_sigpending syscall, but
there the copy is being made from a stack local variable so does not
trigger the warning.
Move put_compat_sigset to compat.h, and mark it static inline. This
fixes the WARN on MIPS.
Fixes: afcc90f8621e ("usercopy: WARN() on slab cache usercopy region violations")
Signed-off-by: Matt Redfearn <matt.redfearn@mips.com>
Acked-by: Kees Cook <keescook@chromium.org>
Cc: "Dmitry V . Levin" <ldv@altlinux.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: kernel-hardening@lists.openwall.com
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/18639/
Signed-off-by: James Hogan <jhogan@kernel.org>
2018-02-19 16:55:06 +00:00
|
|
|
case 1: v.sig[1] = (set->sig[0] >> 32); v.sig[0] = set->sig[0];
|
|
|
|
}
|
|
|
|
return copy_to_user(compat, &v, size) ? -EFAULT : 0;
|
|
|
|
#else
|
|
|
|
return copy_to_user(compat, set, size) ? -EFAULT : 0;
|
|
|
|
#endif
|
|
|
|
}
|
2006-06-26 11:56:52 +00:00
|
|
|
|
2020-08-18 17:19:32 +00:00
|
|
|
#ifdef CONFIG_CPU_BIG_ENDIAN
|
|
|
|
#define unsafe_put_compat_sigset(compat, set, label) do { \
|
|
|
|
compat_sigset_t __user *__c = compat; \
|
|
|
|
const sigset_t *__s = set; \
|
|
|
|
\
|
|
|
|
switch (_NSIG_WORDS) { \
|
|
|
|
case 4: \
|
|
|
|
unsafe_put_user(__s->sig[3] >> 32, &__c->sig[7], label); \
|
|
|
|
unsafe_put_user(__s->sig[3], &__c->sig[6], label); \
|
|
|
|
fallthrough; \
|
|
|
|
case 3: \
|
|
|
|
unsafe_put_user(__s->sig[2] >> 32, &__c->sig[5], label); \
|
|
|
|
unsafe_put_user(__s->sig[2], &__c->sig[4], label); \
|
|
|
|
fallthrough; \
|
|
|
|
case 2: \
|
|
|
|
unsafe_put_user(__s->sig[1] >> 32, &__c->sig[3], label); \
|
|
|
|
unsafe_put_user(__s->sig[1], &__c->sig[2], label); \
|
|
|
|
fallthrough; \
|
|
|
|
case 1: \
|
|
|
|
unsafe_put_user(__s->sig[0] >> 32, &__c->sig[1], label); \
|
|
|
|
unsafe_put_user(__s->sig[0], &__c->sig[0], label); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
2021-03-19 11:06:50 +00:00
|
|
|
|
|
|
|
#define unsafe_get_compat_sigset(set, compat, label) do { \
|
|
|
|
const compat_sigset_t __user *__c = compat; \
|
|
|
|
compat_sigset_word hi, lo; \
|
|
|
|
sigset_t *__s = set; \
|
|
|
|
\
|
|
|
|
switch (_NSIG_WORDS) { \
|
|
|
|
case 4: \
|
|
|
|
unsafe_get_user(lo, &__c->sig[7], label); \
|
|
|
|
unsafe_get_user(hi, &__c->sig[6], label); \
|
|
|
|
__s->sig[3] = hi | (((long)lo) << 32); \
|
|
|
|
fallthrough; \
|
|
|
|
case 3: \
|
|
|
|
unsafe_get_user(lo, &__c->sig[5], label); \
|
|
|
|
unsafe_get_user(hi, &__c->sig[4], label); \
|
|
|
|
__s->sig[2] = hi | (((long)lo) << 32); \
|
|
|
|
fallthrough; \
|
|
|
|
case 2: \
|
|
|
|
unsafe_get_user(lo, &__c->sig[3], label); \
|
|
|
|
unsafe_get_user(hi, &__c->sig[2], label); \
|
|
|
|
__s->sig[1] = hi | (((long)lo) << 32); \
|
|
|
|
fallthrough; \
|
|
|
|
case 1: \
|
|
|
|
unsafe_get_user(lo, &__c->sig[1], label); \
|
|
|
|
unsafe_get_user(hi, &__c->sig[0], label); \
|
|
|
|
__s->sig[0] = hi | (((long)lo) << 32); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
2020-08-18 17:19:32 +00:00
|
|
|
#else
|
|
|
|
#define unsafe_put_compat_sigset(compat, set, label) do { \
|
|
|
|
compat_sigset_t __user *__c = compat; \
|
|
|
|
const sigset_t *__s = set; \
|
|
|
|
\
|
|
|
|
unsafe_copy_to_user(__c, __s, sizeof(*__c), label); \
|
|
|
|
} while (0)
|
2021-03-19 11:06:50 +00:00
|
|
|
|
|
|
|
#define unsafe_get_compat_sigset(set, compat, label) do { \
|
|
|
|
const compat_sigset_t __user *__c = compat; \
|
|
|
|
sigset_t *__s = set; \
|
|
|
|
\
|
|
|
|
unsafe_copy_from_user(__s, __c, sizeof(*__c), label); \
|
|
|
|
} while (0)
|
2020-08-18 17:19:32 +00:00
|
|
|
#endif
|
|
|
|
|
2008-01-30 12:31:47 +00:00
|
|
|
extern int compat_ptrace_request(struct task_struct *child,
|
|
|
|
compat_long_t request,
|
|
|
|
compat_ulong_t addr, compat_ulong_t data);
|
|
|
|
|
2008-01-30 12:31:48 +00:00
|
|
|
extern long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
|
|
|
|
compat_ulong_t addr, compat_ulong_t data);
|
|
|
|
|
2018-03-25 21:04:48 +00:00
|
|
|
struct epoll_event; /* fortunately, this one is fixed-layout */
|
|
|
|
|
|
|
|
int compat_restore_altstack(const compat_stack_t __user *uss);
|
|
|
|
int __compat_save_altstack(compat_stack_t __user *, unsigned long);
|
2020-02-15 23:39:17 +00:00
|
|
|
#define unsafe_compat_save_altstack(uss, sp, label) do { \
|
2018-03-25 21:04:48 +00:00
|
|
|
compat_stack_t __user *__uss = uss; \
|
|
|
|
struct task_struct *t = current; \
|
2020-02-15 23:39:17 +00:00
|
|
|
unsafe_put_user(ptr_to_compat((void __user *)t->sas_ss_sp), \
|
|
|
|
&__uss->ss_sp, label); \
|
|
|
|
unsafe_put_user(t->sas_ss_flags, &__uss->ss_flags, label); \
|
|
|
|
unsafe_put_user(t->sas_ss_size, &__uss->ss_size, label); \
|
2018-03-25 21:04:48 +00:00
|
|
|
} while (0);
|
|
|
|
|
2007-03-08 04:41:21 +00:00
|
|
|
/*
|
2018-03-25 21:04:48 +00:00
|
|
|
* These syscall function prototypes are kept in the same order as
|
2018-03-22 13:09:17 +00:00
|
|
|
* include/uapi/asm-generic/unistd.h. Deprecated or obsolete system calls
|
|
|
|
* go below.
|
2018-03-25 21:04:48 +00:00
|
|
|
*
|
|
|
|
* Please note that these prototypes here are only provided for information
|
|
|
|
* purposes, for static analysis, and for linking from the syscall table.
|
|
|
|
* These functions should not be called elsewhere from kernel code.
|
2018-04-05 09:53:03 +00:00
|
|
|
*
|
|
|
|
* As the syscall calling convention may be different from the default
|
|
|
|
* for architectures overriding the syscall calling convention, do not
|
|
|
|
* include the prototypes if CONFIG_ARCH_HAS_SYSCALL_WRAPPER is enabled.
|
2007-03-08 04:41:21 +00:00
|
|
|
*/
|
2018-04-05 09:53:03 +00:00
|
|
|
#ifndef CONFIG_ARCH_HAS_SYSCALL_WRAPPER
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p);
|
|
|
|
asmlinkage long compat_sys_io_submit(compat_aio_context_t ctx_id, int nr,
|
|
|
|
u32 __user *iocb);
|
aio: implement io_pgetevents
This is the io_getevents equivalent of ppoll/pselect and allows to
properly mix signals and aio completions (especially with IOCB_CMD_POLL)
and atomically executes the following sequence:
sigset_t origmask;
pthread_sigmask(SIG_SETMASK, &sigmask, &origmask);
ret = io_getevents(ctx, min_nr, nr, events, timeout);
pthread_sigmask(SIG_SETMASK, &origmask, NULL);
Note that unlike many other signal related calls we do not pass a sigmask
size, as that would get us to 7 arguments, which aren't easily supported
by the syscall infrastructure. It seems a lot less painful to just add a
new syscall variant in the unlikely case we're going to increase the
sigset size.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
2018-05-02 17:51:00 +00:00
|
|
|
asmlinkage long compat_sys_io_pgetevents(compat_aio_context_t ctx_id,
|
|
|
|
compat_long_t min_nr,
|
|
|
|
compat_long_t nr,
|
|
|
|
struct io_event __user *events,
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
struct old_timespec32 __user *timeout,
|
aio: implement io_pgetevents
This is the io_getevents equivalent of ppoll/pselect and allows to
properly mix signals and aio completions (especially with IOCB_CMD_POLL)
and atomically executes the following sequence:
sigset_t origmask;
pthread_sigmask(SIG_SETMASK, &sigmask, &origmask);
ret = io_getevents(ctx, min_nr, nr, events, timeout);
pthread_sigmask(SIG_SETMASK, &origmask, NULL);
Note that unlike many other signal related calls we do not pass a sigmask
size, as that would get us to 7 arguments, which aren't easily supported
by the syscall infrastructure. It seems a lot less painful to just add a
new syscall variant in the unlikely case we're going to increase the
sigset size.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
2018-05-02 17:51:00 +00:00
|
|
|
const struct __compat_aio_sigset __user *usig);
|
2018-09-20 04:41:08 +00:00
|
|
|
asmlinkage long compat_sys_io_pgetevents_time64(compat_aio_context_t ctx_id,
|
|
|
|
compat_long_t min_nr,
|
|
|
|
compat_long_t nr,
|
|
|
|
struct io_event __user *events,
|
|
|
|
struct __kernel_timespec __user *timeout,
|
|
|
|
const struct __compat_aio_sigset __user *usig);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_lookup_dcookie(u32, u32, char __user *, compat_size_t);
|
2007-03-08 04:41:21 +00:00
|
|
|
asmlinkage long compat_sys_epoll_pwait(int epfd,
|
2013-02-24 19:52:17 +00:00
|
|
|
struct epoll_event __user *events,
|
2007-03-08 04:41:21 +00:00
|
|
|
int maxevents, int timeout,
|
|
|
|
const compat_sigset_t __user *sigmask,
|
|
|
|
compat_size_t sigsetsize);
|
2020-12-18 22:05:41 +00:00
|
|
|
asmlinkage long compat_sys_epoll_pwait2(int epfd,
|
|
|
|
struct epoll_event __user *events,
|
|
|
|
int maxevents,
|
|
|
|
const struct __kernel_timespec __user *timeout,
|
|
|
|
const compat_sigset_t __user *sigmask,
|
|
|
|
compat_size_t sigsetsize);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
|
|
|
|
compat_ulong_t arg);
|
|
|
|
asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
|
|
|
|
compat_ulong_t arg);
|
|
|
|
asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
|
|
|
|
compat_ulong_t arg);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_statfs(const char __user *pathname,
|
|
|
|
struct compat_statfs __user *buf);
|
|
|
|
asmlinkage long compat_sys_statfs64(const char __user *pathname,
|
|
|
|
compat_size_t sz,
|
|
|
|
struct compat_statfs64 __user *buf);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_fstatfs(unsigned int fd,
|
|
|
|
struct compat_statfs __user *buf);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
|
|
|
|
struct compat_statfs64 __user *buf);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_truncate(const char __user *, compat_off_t);
|
|
|
|
asmlinkage long compat_sys_ftruncate(unsigned int, compat_ulong_t);
|
|
|
|
/* No generic prototype for truncate64, ftruncate64, fallocate */
|
|
|
|
asmlinkage long compat_sys_openat(int dfd, const char __user *filename,
|
|
|
|
int flags, umode_t mode);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_getdents(unsigned int fd,
|
|
|
|
struct compat_linux_dirent __user *dirent,
|
|
|
|
unsigned int count);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_lseek(unsigned int, compat_off_t, unsigned int);
|
|
|
|
/* No generic prototype for pread64 and pwrite64 */
|
|
|
|
asmlinkage ssize_t compat_sys_preadv(compat_ulong_t fd,
|
2020-09-25 04:51:42 +00:00
|
|
|
const struct iovec __user *vec,
|
2018-03-25 21:04:48 +00:00
|
|
|
compat_ulong_t vlen, u32 pos_low, u32 pos_high);
|
|
|
|
asmlinkage ssize_t compat_sys_pwritev(compat_ulong_t fd,
|
2020-09-25 04:51:42 +00:00
|
|
|
const struct iovec __user *vec,
|
2018-03-25 21:04:48 +00:00
|
|
|
compat_ulong_t vlen, u32 pos_low, u32 pos_high);
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
|
|
|
|
asmlinkage long compat_sys_preadv64(unsigned long fd,
|
2020-09-25 04:51:42 +00:00
|
|
|
const struct iovec __user *vec,
|
2018-03-25 21:04:48 +00:00
|
|
|
unsigned long vlen, loff_t pos);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64
|
|
|
|
asmlinkage long compat_sys_pwritev64(unsigned long fd,
|
2020-09-25 04:51:42 +00:00
|
|
|
const struct iovec __user *vec,
|
2018-03-25 21:04:48 +00:00
|
|
|
unsigned long vlen, loff_t pos);
|
|
|
|
#endif
|
|
|
|
asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
|
|
|
|
compat_off_t __user *offset, compat_size_t count);
|
|
|
|
asmlinkage long compat_sys_sendfile64(int out_fd, int in_fd,
|
|
|
|
compat_loff_t __user *offset, compat_size_t count);
|
2019-01-06 23:33:08 +00:00
|
|
|
asmlinkage long compat_sys_pselect6_time32(int n, compat_ulong_t __user *inp,
|
2011-05-09 17:12:30 +00:00
|
|
|
compat_ulong_t __user *outp,
|
|
|
|
compat_ulong_t __user *exp,
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
struct old_timespec32 __user *tsp,
|
2011-05-09 17:12:30 +00:00
|
|
|
void __user *sig);
|
2018-09-20 04:41:07 +00:00
|
|
|
asmlinkage long compat_sys_pselect6_time64(int n, compat_ulong_t __user *inp,
|
|
|
|
compat_ulong_t __user *outp,
|
|
|
|
compat_ulong_t __user *exp,
|
|
|
|
struct __kernel_timespec __user *tsp,
|
|
|
|
void __user *sig);
|
2019-01-06 23:33:08 +00:00
|
|
|
asmlinkage long compat_sys_ppoll_time32(struct pollfd __user *ufds,
|
2011-05-09 17:12:30 +00:00
|
|
|
unsigned int nfds,
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
struct old_timespec32 __user *tsp,
|
2011-05-09 17:12:30 +00:00
|
|
|
const compat_sigset_t __user *sigmask,
|
|
|
|
compat_size_t sigsetsize);
|
2018-09-20 04:41:06 +00:00
|
|
|
asmlinkage long compat_sys_ppoll_time64(struct pollfd __user *ufds,
|
|
|
|
unsigned int nfds,
|
|
|
|
struct __kernel_timespec __user *tsp,
|
|
|
|
const compat_sigset_t __user *sigmask,
|
|
|
|
compat_size_t sigsetsize);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_signalfd4(int ufd,
|
|
|
|
const compat_sigset_t __user *sigmask,
|
|
|
|
compat_size_t sigsetsize, int flags);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_newfstatat(unsigned int dfd,
|
|
|
|
const char __user *filename,
|
|
|
|
struct compat_stat __user *statbuf,
|
|
|
|
int flag);
|
|
|
|
asmlinkage long compat_sys_newfstat(unsigned int fd,
|
|
|
|
struct compat_stat __user *statbuf);
|
2023-06-21 22:36:00 +00:00
|
|
|
/* No generic prototype for sync_file_range and sync_file_range2 */
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_waitid(int, compat_pid_t,
|
|
|
|
struct compat_siginfo __user *, int,
|
|
|
|
struct compat_rusage __user *);
|
|
|
|
asmlinkage long
|
|
|
|
compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
|
|
|
|
compat_size_t len);
|
|
|
|
asmlinkage long
|
|
|
|
compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr,
|
|
|
|
compat_size_t __user *len_ptr);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_getitimer(int which,
|
2019-10-25 08:46:22 +00:00
|
|
|
struct old_itimerval32 __user *it);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_setitimer(int which,
|
2019-10-25 08:46:22 +00:00
|
|
|
struct old_itimerval32 __user *in,
|
|
|
|
struct old_itimerval32 __user *out);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_kexec_load(compat_ulong_t entry,
|
|
|
|
compat_ulong_t nr_segments,
|
|
|
|
struct compat_kexec_segment __user *,
|
|
|
|
compat_ulong_t flags);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_timer_create(clockid_t which_clock,
|
|
|
|
struct compat_sigevent __user *timer_event_spec,
|
|
|
|
timer_t __user *created_timer_id);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
|
|
|
|
compat_long_t addr, compat_long_t data);
|
|
|
|
asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
|
|
|
|
unsigned int len,
|
|
|
|
compat_ulong_t __user *user_mask_ptr);
|
|
|
|
asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid,
|
|
|
|
unsigned int len,
|
|
|
|
compat_ulong_t __user *user_mask_ptr);
|
|
|
|
asmlinkage long compat_sys_sigaltstack(const compat_stack_t __user *uss_ptr,
|
|
|
|
compat_stack_t __user *uoss_ptr);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_rt_sigsuspend(compat_sigset_t __user *unewset,
|
|
|
|
compat_size_t sigsetsize);
|
2012-12-25 23:38:15 +00:00
|
|
|
#ifndef CONFIG_ODD_RT_SIGACTION
|
|
|
|
asmlinkage long compat_sys_rt_sigaction(int,
|
|
|
|
const struct compat_sigaction __user *,
|
|
|
|
struct compat_sigaction __user *,
|
|
|
|
compat_size_t);
|
|
|
|
#endif
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_rt_sigprocmask(int how, compat_sigset_t __user *set,
|
|
|
|
compat_sigset_t __user *oset,
|
|
|
|
compat_size_t sigsetsize);
|
|
|
|
asmlinkage long compat_sys_rt_sigpending(compat_sigset_t __user *uset,
|
|
|
|
compat_size_t sigsetsize);
|
2019-01-06 23:33:08 +00:00
|
|
|
asmlinkage long compat_sys_rt_sigtimedwait_time32(compat_sigset_t __user *uthese,
|
2018-03-25 21:04:48 +00:00
|
|
|
struct compat_siginfo __user *uinfo,
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
struct old_timespec32 __user *uts, compat_size_t sigsetsize);
|
2018-04-18 14:18:35 +00:00
|
|
|
asmlinkage long compat_sys_rt_sigtimedwait_time64(compat_sigset_t __user *uthese,
|
|
|
|
struct compat_siginfo __user *uinfo,
|
|
|
|
struct __kernel_timespec __user *uts, compat_size_t sigsetsize);
|
2012-12-25 20:19:12 +00:00
|
|
|
asmlinkage long compat_sys_rt_sigqueueinfo(compat_pid_t pid, int sig,
|
|
|
|
struct compat_siginfo __user *uinfo);
|
2018-03-25 21:04:48 +00:00
|
|
|
/* No generic prototype for rt_sigreturn */
|
|
|
|
asmlinkage long compat_sys_times(struct compat_tms __user *tbuf);
|
|
|
|
asmlinkage long compat_sys_getrlimit(unsigned int resource,
|
|
|
|
struct compat_rlimit __user *rlim);
|
|
|
|
asmlinkage long compat_sys_setrlimit(unsigned int resource,
|
|
|
|
struct compat_rlimit __user *rlim);
|
|
|
|
asmlinkage long compat_sys_getrusage(int who, struct compat_rusage __user *ru);
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
asmlinkage long compat_sys_gettimeofday(struct old_timeval32 __user *tv,
|
2018-03-25 21:04:48 +00:00
|
|
|
struct timezone __user *tz);
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
asmlinkage long compat_sys_settimeofday(struct old_timeval32 __user *tv,
|
2018-03-25 21:04:48 +00:00
|
|
|
struct timezone __user *tz);
|
2011-05-09 17:12:30 +00:00
|
|
|
asmlinkage long compat_sys_sysinfo(struct compat_sysinfo __user *info);
|
|
|
|
asmlinkage long compat_sys_mq_open(const char __user *u_name,
|
|
|
|
int oflag, compat_mode_t mode,
|
|
|
|
struct compat_mq_attr __user *u_attr);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_mq_notify(mqd_t mqdes,
|
|
|
|
const struct compat_sigevent __user *u_notification);
|
|
|
|
asmlinkage long compat_sys_mq_getsetattr(mqd_t mqdes,
|
|
|
|
const struct compat_mq_attr __user *u_mqstat,
|
|
|
|
struct compat_mq_attr __user *u_omqstat);
|
|
|
|
asmlinkage long compat_sys_msgctl(int first, int second, void __user *uptr);
|
|
|
|
asmlinkage long compat_sys_msgrcv(int msqid, compat_uptr_t msgp,
|
|
|
|
compat_ssize_t msgsz, compat_long_t msgtyp, int msgflg);
|
|
|
|
asmlinkage long compat_sys_msgsnd(int msqid, compat_uptr_t msgp,
|
|
|
|
compat_ssize_t msgsz, int msgflg);
|
|
|
|
asmlinkage long compat_sys_semctl(int semid, int semnum, int cmd, int arg);
|
|
|
|
asmlinkage long compat_sys_shmctl(int first, int second, void __user *uptr);
|
|
|
|
asmlinkage long compat_sys_shmat(int shmid, compat_uptr_t shmaddr, int shmflg);
|
|
|
|
asmlinkage long compat_sys_recvfrom(int fd, void __user *buf, compat_size_t len,
|
|
|
|
unsigned flags, struct sockaddr __user *addr,
|
|
|
|
int __user *addrlen);
|
|
|
|
asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg,
|
|
|
|
unsigned flags);
|
|
|
|
asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg,
|
|
|
|
unsigned int flags);
|
2023-06-21 22:36:00 +00:00
|
|
|
/* No generic prototype for readahead */
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_keyctl(u32 option,
|
|
|
|
u32 arg2, u32 arg3, u32 arg4, u32 arg5);
|
|
|
|
asmlinkage long compat_sys_execve(const char __user *filename, const compat_uptr_t __user *argv,
|
|
|
|
const compat_uptr_t __user *envp);
|
2023-06-21 22:36:00 +00:00
|
|
|
/* No generic prototype for fadvise64_64 */
|
|
|
|
/* CONFIG_MMU only */
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_rt_tgsigqueueinfo(compat_pid_t tgid,
|
|
|
|
compat_pid_t pid, int sig,
|
|
|
|
struct compat_siginfo __user *uinfo);
|
y2038: socket: Add compat_sys_recvmmsg_time64
recvmmsg() takes two arguments to pointers of structures that differ
between 32-bit and 64-bit architectures: mmsghdr and timespec.
For y2038 compatbility, we are changing the native system call from
timespec to __kernel_timespec with a 64-bit time_t (in another patch),
and use the existing compat system call on both 32-bit and 64-bit
architectures for compatibility with traditional 32-bit user space.
As we now have two variants of recvmmsg() for 32-bit tasks that are both
different from the variant that we use on 64-bit tasks, this means we
also require two compat system calls!
The solution I picked is to flip things around: The existing
compat_sys_recvmmsg() call gets moved from net/compat.c into net/socket.c
and now handles the case for old user space on all architectures that
have set CONFIG_COMPAT_32BIT_TIME. A new compat_sys_recvmmsg_time64()
call gets added in the old place for 64-bit architectures only, this
one handles the case of a compat mmsghdr structure combined with
__kernel_timespec.
In the indirect sys_socketcall(), we now need to call either
do_sys_recvmmsg() or __compat_sys_recvmmsg(), depending on what kind of
architecture we are on. For compat_sys_socketcall(), no such change is
needed, we always call __compat_sys_recvmmsg().
I decided to not add a new SYS_RECVMMSG_TIME64 socketcall: Any libc
implementation for 64-bit time_t will need significant changes including
an updated asm/unistd.h, and it seems better to consistently use the
separate syscalls that configuration, leaving the socketcall only for
backward compatibility with 32-bit time_t based libc.
The naming is asymmetric for the moment, so both existing syscalls
entry points keep their names, while the new ones are recvmmsg_time32
and compat_recvmmsg_time64 respectively. I expect that we will rename
the compat syscalls later as we start using generated syscall tables
everywhere and add these entry points.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-04-18 11:43:52 +00:00
|
|
|
asmlinkage long compat_sys_recvmmsg_time64(int fd, struct compat_mmsghdr __user *mmsg,
|
|
|
|
unsigned vlen, unsigned int flags,
|
|
|
|
struct __kernel_timespec __user *timeout);
|
2019-01-06 23:33:08 +00:00
|
|
|
asmlinkage long compat_sys_recvmmsg_time32(int fd, struct compat_mmsghdr __user *mmsg,
|
2018-03-25 21:04:48 +00:00
|
|
|
unsigned vlen, unsigned int flags,
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
struct old_timespec32 __user *timeout);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_wait4(compat_pid_t pid,
|
|
|
|
compat_uint_t __user *stat_addr, int options,
|
|
|
|
struct compat_rusage __user *ru);
|
|
|
|
asmlinkage long compat_sys_fanotify_mark(int, unsigned int, __u32, __u32,
|
|
|
|
int, const char __user *);
|
|
|
|
asmlinkage long compat_sys_open_by_handle_at(int mountdirfd,
|
|
|
|
struct file_handle __user *handle,
|
|
|
|
int flags);
|
|
|
|
asmlinkage long compat_sys_sendmmsg(int fd, struct compat_mmsghdr __user *mmsg,
|
|
|
|
unsigned vlen, unsigned int flags);
|
|
|
|
asmlinkage long compat_sys_execveat(int dfd, const char __user *filename,
|
|
|
|
const compat_uptr_t __user *argv,
|
|
|
|
const compat_uptr_t __user *envp, int flags);
|
|
|
|
asmlinkage ssize_t compat_sys_preadv2(compat_ulong_t fd,
|
2020-09-25 04:51:42 +00:00
|
|
|
const struct iovec __user *vec,
|
2018-03-25 21:04:48 +00:00
|
|
|
compat_ulong_t vlen, u32 pos_low, u32 pos_high, rwf_t flags);
|
|
|
|
asmlinkage ssize_t compat_sys_pwritev2(compat_ulong_t fd,
|
2020-09-25 04:51:42 +00:00
|
|
|
const struct iovec __user *vec,
|
2018-03-25 21:04:48 +00:00
|
|
|
compat_ulong_t vlen, u32 pos_low, u32 pos_high, rwf_t flags);
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_SYS_PREADV64V2
|
2020-09-25 04:51:38 +00:00
|
|
|
asmlinkage long compat_sys_preadv64v2(unsigned long fd,
|
2020-09-25 04:51:42 +00:00
|
|
|
const struct iovec __user *vec,
|
2018-03-25 21:04:48 +00:00
|
|
|
unsigned long vlen, loff_t pos, rwf_t flags);
|
|
|
|
#endif
|
2011-12-01 17:54:31 +00:00
|
|
|
|
2018-03-25 21:04:48 +00:00
|
|
|
#ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64V2
|
|
|
|
asmlinkage long compat_sys_pwritev64v2(unsigned long fd,
|
2020-09-25 04:51:42 +00:00
|
|
|
const struct iovec __user *vec,
|
2018-03-25 21:04:48 +00:00
|
|
|
unsigned long vlen, loff_t pos, rwf_t flags);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deprecated system calls which are still defined in
|
|
|
|
* include/uapi/asm-generic/unistd.h and wanted by >= 1 arch
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* __ARCH_WANT_SYSCALL_NO_AT */
|
|
|
|
asmlinkage long compat_sys_open(const char __user *filename, int flags,
|
|
|
|
umode_t mode);
|
|
|
|
|
|
|
|
/* __ARCH_WANT_SYSCALL_NO_FLAGS */
|
|
|
|
asmlinkage long compat_sys_signalfd(int ufd,
|
|
|
|
const compat_sigset_t __user *sigmask,
|
|
|
|
compat_size_t sigsetsize);
|
|
|
|
|
|
|
|
/* __ARCH_WANT_SYSCALL_OFF_T */
|
|
|
|
asmlinkage long compat_sys_newstat(const char __user *filename,
|
|
|
|
struct compat_stat __user *statbuf);
|
|
|
|
asmlinkage long compat_sys_newlstat(const char __user *filename,
|
|
|
|
struct compat_stat __user *statbuf);
|
|
|
|
|
|
|
|
/* __ARCH_WANT_SYSCALL_DEPRECATED */
|
|
|
|
asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
|
|
|
|
compat_ulong_t __user *outp, compat_ulong_t __user *exp,
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
struct old_timeval32 __user *tvp);
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_ustat(unsigned dev, struct compat_ustat __user *u32);
|
|
|
|
asmlinkage long compat_sys_recv(int fd, void __user *buf, compat_size_t len,
|
|
|
|
unsigned flags);
|
|
|
|
|
2023-06-21 22:36:00 +00:00
|
|
|
/* obsolete */
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_old_readdir(unsigned int fd,
|
|
|
|
struct compat_old_linux_dirent __user *,
|
|
|
|
unsigned int count);
|
|
|
|
|
2023-06-21 22:36:00 +00:00
|
|
|
/* obsolete */
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_old_select(struct compat_sel_arg_struct __user *arg);
|
|
|
|
|
2023-06-21 22:36:00 +00:00
|
|
|
/* obsolete */
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_ipc(u32, int, int, u32, compat_uptr_t, u32);
|
2012-12-14 19:47:53 +00:00
|
|
|
|
2023-06-21 22:36:00 +00:00
|
|
|
/* obsolete */
|
2015-01-06 16:48:36 +00:00
|
|
|
#ifdef __ARCH_WANT_SYS_SIGPENDING
|
|
|
|
asmlinkage long compat_sys_sigpending(compat_old_sigset_t __user *set);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_SYS_SIGPROCMASK
|
|
|
|
asmlinkage long compat_sys_sigprocmask(int how, compat_old_sigset_t __user *nset,
|
|
|
|
compat_old_sigset_t __user *oset);
|
|
|
|
#endif
|
2018-03-25 21:04:48 +00:00
|
|
|
#ifdef CONFIG_COMPAT_OLD_SIGACTION
|
|
|
|
asmlinkage long compat_sys_sigaction(int sig,
|
|
|
|
const struct compat_old_sigaction __user *act,
|
|
|
|
struct compat_old_sigaction __user *oact);
|
|
|
|
#endif
|
2015-01-06 16:48:36 +00:00
|
|
|
|
2023-06-21 22:36:00 +00:00
|
|
|
/* obsolete */
|
2018-03-25 21:04:48 +00:00
|
|
|
asmlinkage long compat_sys_socketcall(int call, u32 __user *args);
|
2016-03-22 21:24:43 +00:00
|
|
|
|
2022-04-05 07:13:05 +00:00
|
|
|
#ifdef __ARCH_WANT_COMPAT_TRUNCATE64
|
|
|
|
asmlinkage long compat_sys_truncate64(const char __user *pathname, compat_arg_u64(len));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_FTRUNCATE64
|
|
|
|
asmlinkage long compat_sys_ftruncate64(unsigned int fd, compat_arg_u64(len));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_FALLOCATE
|
|
|
|
asmlinkage long compat_sys_fallocate(int fd, int mode, compat_arg_u64(offset),
|
|
|
|
compat_arg_u64(len));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_PREAD64
|
|
|
|
asmlinkage long compat_sys_pread64(unsigned int fd, char __user *buf, size_t count,
|
|
|
|
compat_arg_u64(pos));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_PWRITE64
|
|
|
|
asmlinkage long compat_sys_pwrite64(unsigned int fd, const char __user *buf, size_t count,
|
|
|
|
compat_arg_u64(pos));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_SYNC_FILE_RANGE
|
|
|
|
asmlinkage long compat_sys_sync_file_range(int fd, compat_arg_u64(pos),
|
|
|
|
compat_arg_u64(nbytes), unsigned int flags);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_FADVISE64_64
|
|
|
|
asmlinkage long compat_sys_fadvise64_64(int fd, compat_arg_u64(pos),
|
|
|
|
compat_arg_u64(len), int advice);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __ARCH_WANT_COMPAT_READAHEAD
|
|
|
|
asmlinkage long compat_sys_readahead(int fd, compat_arg_u64(offset), size_t count);
|
|
|
|
#endif
|
|
|
|
|
2018-04-05 09:53:03 +00:00
|
|
|
#endif /* CONFIG_ARCH_HAS_SYSCALL_WRAPPER */
|
|
|
|
|
2017-01-31 03:09:27 +00:00
|
|
|
/**
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
* ns_to_old_timeval32 - Compat version of ns_to_timeval
|
2017-01-31 03:09:27 +00:00
|
|
|
* @nsec: the nanoseconds value to be converted
|
|
|
|
*
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
* Returns the old_timeval32 representation of the nsec parameter.
|
2017-01-31 03:09:27 +00:00
|
|
|
*/
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
static inline struct old_timeval32 ns_to_old_timeval32(s64 nsec)
|
2017-01-31 03:09:27 +00:00
|
|
|
{
|
2017-11-23 13:22:06 +00:00
|
|
|
struct __kernel_old_timeval tv;
|
y2038: globally rename compat_time to old_time32
Christoph Hellwig suggested a slightly different path for handling
backwards compatibility with the 32-bit time_t based system calls:
Rather than simply reusing the compat_sys_* entry points on 32-bit
architectures unchanged, we get rid of those entry points and the
compat_time types by renaming them to something that makes more sense
on 32-bit architectures (which don't have a compat mode otherwise),
and then share the entry points under the new name with the 64-bit
architectures that use them for implementing the compatibility.
The following types and interfaces are renamed here, and moved
from linux/compat_time.h to linux/time32.h:
old new
--- ---
compat_time_t old_time32_t
struct compat_timeval struct old_timeval32
struct compat_timespec struct old_timespec32
struct compat_itimerspec struct old_itimerspec32
ns_to_compat_timeval() ns_to_old_timeval32()
get_compat_itimerspec64() get_old_itimerspec32()
put_compat_itimerspec64() put_old_itimerspec32()
compat_get_timespec64() get_old_timespec32()
compat_put_timespec64() put_old_timespec32()
As we already have aliases in place, this patch addresses only the
instances that are relevant to the system call interface in particular,
not those that occur in device drivers and other modules. Those
will get handled separately, while providing the 64-bit version
of the respective interfaces.
I'm not renaming the timex, rusage and itimerval structures, as we are
still debating what the new interface will look like, and whether we
will need a replacement at all.
This also doesn't change the names of the syscall entry points, which can
be done more easily when we actually switch over the 32-bit architectures
to use them, at that point we need to change COMPAT_SYSCALL_DEFINEx to
SYSCALL_DEFINEx with a new name, e.g. with a _time32 suffix.
Suggested-by: Christoph Hellwig <hch@infradead.org>
Link: https://lore.kernel.org/lkml/20180705222110.GA5698@infradead.org/
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
2018-07-13 10:52:28 +00:00
|
|
|
struct old_timeval32 ctv;
|
2017-01-31 03:09:27 +00:00
|
|
|
|
2017-11-23 13:22:06 +00:00
|
|
|
tv = ns_to_kernel_old_timeval(nsec);
|
2017-01-31 03:09:27 +00:00
|
|
|
ctv.tv_sec = tv.tv_sec;
|
|
|
|
ctv.tv_usec = tv.tv_usec;
|
|
|
|
|
|
|
|
return ctv;
|
|
|
|
}
|
|
|
|
|
2018-07-11 13:56:51 +00:00
|
|
|
/*
|
|
|
|
* Kernel code should not call compat syscalls (i.e., compat_sys_xyzyyz())
|
|
|
|
* directly. Instead, use one of the functions which work equivalently, such
|
|
|
|
* as the kcompat_sys_xyzyyz() functions prototyped below.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int kcompat_sys_statfs64(const char __user * pathname, compat_size_t sz,
|
|
|
|
struct compat_statfs64 __user * buf);
|
|
|
|
int kcompat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
|
|
|
|
struct compat_statfs64 __user * buf);
|
|
|
|
|
2021-07-22 14:28:58 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For most but not all architectures, "am I in a compat syscall?" and
|
|
|
|
* "am I a compat task?" are the same question. For architectures on which
|
|
|
|
* they aren't the same question, arch code can override in_compat_syscall.
|
|
|
|
*/
|
|
|
|
#ifndef in_compat_syscall
|
|
|
|
static inline bool in_compat_syscall(void) { return is_compat_task(); }
|
|
|
|
#endif
|
|
|
|
|
2017-01-31 03:09:27 +00:00
|
|
|
#else /* !CONFIG_COMPAT */
|
2012-02-26 17:44:55 +00:00
|
|
|
|
|
|
|
#define is_compat_task() (0)
|
2018-10-12 13:42:52 +00:00
|
|
|
/* Ensure no one redefines in_compat_syscall() under !CONFIG_COMPAT */
|
|
|
|
#define in_compat_syscall in_compat_syscall
|
2016-03-22 21:24:43 +00:00
|
|
|
static inline bool in_compat_syscall(void) { return false; }
|
2012-02-26 17:44:55 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* CONFIG_COMPAT */
|
2016-03-22 21:24:43 +00:00
|
|
|
|
2021-09-08 22:18:21 +00:00
|
|
|
#define BITS_PER_COMPAT_LONG (8*sizeof(compat_long_t))
|
|
|
|
|
|
|
|
#define BITS_TO_COMPAT_LONGS(bits) DIV_ROUND_UP(bits, BITS_PER_COMPAT_LONG)
|
|
|
|
|
|
|
|
long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
|
|
|
|
unsigned long bitmap_size);
|
|
|
|
long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
|
|
|
|
unsigned long bitmap_size);
|
|
|
|
|
2020-09-17 07:41:58 +00:00
|
|
|
/*
|
|
|
|
* Some legacy ABIs like the i386 one use less than natural alignment for 64-bit
|
|
|
|
* types, and will need special compat treatment for that. Most architectures
|
|
|
|
* don't need that special handling even for compat syscalls.
|
|
|
|
*/
|
|
|
|
#ifndef compat_need_64bit_alignment_fixup
|
|
|
|
#define compat_need_64bit_alignment_fixup() false
|
|
|
|
#endif
|
|
|
|
|
2019-12-12 17:15:25 +00:00
|
|
|
/*
|
|
|
|
* A pointer passed in from user mode. This should not
|
|
|
|
* be used for syscall parameters, just declare them
|
|
|
|
* as pointers because the syscall entry code will have
|
|
|
|
* appropriately converted them already.
|
|
|
|
*/
|
|
|
|
#ifndef compat_ptr
|
|
|
|
static inline void __user *compat_ptr(compat_uptr_t uptr)
|
|
|
|
{
|
|
|
|
return (void __user *)(unsigned long)uptr;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static inline compat_uptr_t ptr_to_compat(void __user *uptr)
|
|
|
|
{
|
|
|
|
return (u32)(unsigned long)uptr;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* _LINUX_COMPAT_H */
|