5.10.162-rc1 review
Subsystems (14)
Greg Kroah-Hartman
maintainercover 5.10.162-rc1 review
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gz
or in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git linux-5.10.y
and the diffstat can be found below.
thanks,
greg k-h
-------------
Pseudo-Shortlog of commits:
Greg Kroah-Hartman <[email protected]>
Linux 5.10.162-rc1
Jens Axboe <[email protected]>
io_uring: pass in EPOLL_URING_WAKE for eventfd signaling and wakeups
Jens Axboe <[email protected]>
eventfd: provide a eventfd_signal_mask() helper
Jens Axboe <[email protected]>
eventpoll: add EPOLL_URING_WAKE poll wakeup flag
Jens Axboe <[email protected]>
Revert "proc: don't allow async path resolution of /proc/self components"
Jens Axboe <[email protected]>
Revert "proc: don't allow async path resolution of /proc/thread-self components"
Jens Axboe <[email protected]>
net: remove cmsg restriction from io_uring based send/recvmsg calls
Jens Axboe <[email protected]>
task_work: unconditionally run task_work from get_signal()
Jens Axboe <[email protected]>
signal: kill JOBCTL_TASK_WORK
Jens Axboe <[email protected]>
io_uring: import 5.15-stable io_uring
Jens Axboe <[email protected]>
task_work: add helper for more targeted task_work canceling
Jens Axboe <[email protected]>
kernel: don't call do_exit() for PF_IO_WORKER threads
Jens Axboe <[email protected]>
kernel: stop masking signals in create_io_thread()
Stefan Metzmacher <[email protected]>
x86/process: setup io_threads more like normal user space threads
Jens Axboe <[email protected]>
arch: ensure parisc/powerpc handle PF_IO_WORKER in copy_thread()
Jens Axboe <[email protected]>
arch: setup PF_IO_WORKER threads like PF_KTHREAD
Seth Forshee <[email protected]>
entry/kvm: Exit to user mode when TIF_NOTIFY_SIGNAL is set
Jens Axboe <[email protected]>
kernel: allow fork with TIF_NOTIFY_SIGNAL pending
Eric W. Biederman <[email protected]>
coredump: Limit what can interrupt coredumps
Jens Axboe <[email protected]>
kernel: remove checking for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
task_work: remove legacy TWA_SIGNAL path
Al Viro <[email protected]>
alpha: fix TIF_NOTIFY_SIGNAL handling
Vineet Gupta <[email protected]>
ARC: unbork 5.11 bootup: fix snafu in _TIF_NOTIFY_SIGNAL handling
Jens Axboe <[email protected]>
ia64: don't call handle_signal() unless there's actually a signal queued
Jens Axboe <[email protected]>
sparc: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
riscv: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
nds32: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
ia64: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
h8300: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
c6x: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
alpha: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
xtensa: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
arm: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
microblaze: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
hexagon: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
csky: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
openrisc: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
sh: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
um: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
s390: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
mips: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
powerpc: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
parisc: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
nios32: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
m68k: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
arm64: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
arc: add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
x86: Wire up TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
task_work: Use TIF_NOTIFY_SIGNAL if available
Jens Axboe <[email protected]>
entry: Add support for TIF_NOTIFY_SIGNAL
Jens Axboe <[email protected]>
fs: provide locked helper variant of close_fd_get_file()
Eric W. Biederman <[email protected]>
file: Rename __close_fd_get_file close_fd_get_file
Jens Axboe <[email protected]>
fs: make do_renameat2() take struct filename
Jens Axboe <[email protected]>
signal: Add task_sigpending() helper
Pavel Begunkov <[email protected]>
net: add accept helper not installing fd
Jens Axboe <[email protected]>
net: provide __sys_shutdown_sock() that takes a socket
Arnaldo Carvalho de Melo <[email protected]>
tools headers UAPI: Sync openat2.h with the kernel sources
Jens Axboe <[email protected]>
fs: expose LOOKUP_CACHED through openat2() RESOLVE_CACHED
Al Viro <[email protected]>
Make sure nd->path.mnt and nd->path.dentry are always valid pointers
Al Viro <[email protected]>
fix handling of nd->depth on LOOKUP_CACHED failures in try_to_unlazy*
Jens Axboe <[email protected]>
fs: add support for LOOKUP_CACHED
Al Viro <[email protected]>
saner calling conventions for unlazy_child()
Jens Axboe <[email protected]>
iov_iter: add helper to save iov_iter state
Jens Axboe <[email protected]>
kernel: provide create_io_thread() helper
-------------
Diffstat:
Makefile | 6 +-
arch/alpha/include/asm/thread_info.h | 4 +-
arch/alpha/kernel/entry.S | 2 +-
arch/alpha/kernel/process.c | 2 +-
arch/alpha/kernel/signal.c | 2 +-
arch/arc/include/asm/thread_info.h | 4 +-
arch/arc/kernel/entry.S | 3 +-
arch/arc/kernel/process.c | 2 +-
arch/arc/kernel/signal.c | 2 +-
arch/arm/include/asm/thread_info.h | 7 +-
arch/arm/kernel/entry-common.S | 6 +-
arch/arm/kernel/entry-v7m.S | 2 +-
arch/arm/kernel/process.c | 2 +-
arch/arm/kernel/signal.c | 2 +-
arch/arm64/include/asm/thread_info.h | 5 +-
arch/arm64/kernel/process.c | 2 +-
arch/arm64/kernel/signal.c | 2 +-
arch/c6x/include/asm/thread_info.h | 1 +
arch/c6x/kernel/asm-offsets.c | 1 +
arch/c6x/kernel/signal.c | 3 +-
arch/csky/include/asm/thread_info.h | 5 +-
arch/csky/kernel/process.c | 2 +-
arch/csky/kernel/signal.c | 2 +-
arch/h8300/include/asm/thread_info.h | 4 +-
arch/h8300/kernel/process.c | 2 +-
arch/h8300/kernel/signal.c | 2 +-
arch/hexagon/include/asm/thread_info.h | 2 +
arch/hexagon/kernel/process.c | 4 +-
arch/ia64/include/asm/thread_info.h | 4 +-
arch/ia64/kernel/process.c | 5 +-
arch/ia64/kernel/signal.c | 3 +-
arch/m68k/include/asm/thread_info.h | 1 +
arch/m68k/kernel/process.c | 2 +-
arch/m68k/kernel/signal.c | 3 +-
arch/microblaze/include/asm/thread_info.h | 2 +
arch/microblaze/kernel/process.c | 2 +-
arch/microblaze/kernel/signal.c | 3 +-
arch/mips/include/asm/thread_info.h | 4 +-
arch/mips/kernel/process.c | 2 +-
arch/mips/kernel/signal.c | 2 +-
arch/nds32/include/asm/thread_info.h | 2 +
arch/nds32/kernel/ex-exit.S | 2 +-
arch/nds32/kernel/process.c | 2 +-
arch/nds32/kernel/signal.c | 2 +-
arch/nios2/include/asm/thread_info.h | 2 +
arch/nios2/kernel/process.c | 2 +-
arch/nios2/kernel/signal.c | 3 +-
arch/openrisc/include/asm/thread_info.h | 2 +
arch/openrisc/kernel/process.c | 2 +-
arch/openrisc/kernel/signal.c | 2 +-
arch/parisc/include/asm/thread_info.h | 4 +-
arch/parisc/kernel/process.c | 2 +-
arch/parisc/kernel/signal.c | 3 +-
arch/powerpc/include/asm/thread_info.h | 5 +-
arch/powerpc/kernel/process.c | 2 +-
arch/powerpc/kernel/signal.c | 2 +-
arch/riscv/include/asm/thread_info.h | 5 +-
arch/riscv/kernel/process.c | 2 +-
arch/riscv/kernel/signal.c | 2 +-
arch/s390/include/asm/thread_info.h | 2 +
arch/s390/kernel/entry.S | 11 +-
arch/s390/kernel/process.c | 2 +-
arch/s390/kernel/signal.c | 2 +-
arch/sh/include/asm/thread_info.h | 4 +-
arch/sh/kernel/process_32.c | 2 +-
arch/sh/kernel/signal_32.c | 2 +-
arch/sparc/include/asm/thread_info_32.h | 4 +-
arch/sparc/include/asm/thread_info_64.h | 6 +-
arch/sparc/kernel/process_32.c | 2 +-
arch/sparc/kernel/process_64.c | 2 +-
arch/sparc/kernel/signal_32.c | 2 +-
arch/sparc/kernel/signal_64.c | 2 +-
arch/um/include/asm/thread_info.h | 2 +
arch/um/kernel/process.c | 5 +-
arch/x86/include/asm/thread_info.h | 2 +
arch/x86/kernel/process.c | 17 +
arch/x86/kernel/signal.c | 4 +-
arch/xtensa/include/asm/thread_info.h | 5 +-
arch/xtensa/kernel/entry.S | 4 +-
arch/xtensa/kernel/process.c | 2 +-
arch/xtensa/kernel/signal.c | 3 +-
drivers/android/binder.c | 2 +-
fs/Makefile | 2 -
fs/coredump.c | 2 +-
fs/eventfd.c | 37 +-
fs/eventpoll.c | 18 +-
fs/file.c | 34 +-
fs/internal.h | 3 +
fs/io-wq.c | 1242 ----
fs/namei.c | 84 +-
fs/open.c | 6 +
fs/proc/self.c | 7 -
fs/proc/thread_self.c | 7 -
include/linux/entry-common.h | 7 +-
include/linux/entry-kvm.h | 4 +-
include/linux/eventfd.h | 7 +
include/linux/fcntl.h | 2 +-
include/linux/fdtable.h | 2 +-
include/linux/io_uring.h | 46 +-
include/linux/namei.h | 1 +
include/linux/net.h | 3 -
include/linux/sched.h | 3 +
include/linux/sched/jobctl.h | 4 +-
include/linux/sched/signal.h | 18 +-
include/linux/sched/task.h | 2 +
include/linux/socket.h | 4 +
include/linux/syscalls.h | 2 +-
include/linux/task_work.h | 2 +
include/linux/tracehook.h | 23 +
include/linux/uio.h | 15 +
include/trace/events/io_uring.h | 121 +-
include/uapi/linux/eventpoll.h | 6 +
include/uapi/linux/io_uring.h | 115 +-
include/uapi/linux/openat2.h | 4 +
io_uring/Makefile | 6 +
io_uring/io-wq.c | 1398 +++++
{fs => io_uring}/io-wq.h | 47 +-
{fs => io_uring}/io_uring.c | 9209 ++++++++++++++++-------------
kernel/entry/common.c | 14 +-
kernel/entry/kvm.c | 2 +-
kernel/events/uprobes.c | 2 +-
kernel/exit.c | 2 +-
kernel/fork.c | 33 +-
kernel/sched/core.c | 2 +-
kernel/signal.c | 53 +-
kernel/task_work.c | 48 +-
lib/iov_iter.c | 52 +-
net/ipv4/af_inet.c | 1 -
net/ipv6/af_inet6.c | 1 -
net/socket.c | 92 +-
tools/include/uapi/linux/openat2.h | 4 +
131 files changed, 7279 insertions(+), 5773 deletions(-)Greg Kroah-Hartman
maintainerPATCH 1/63 kernel: provide create_io_thread() helper
From: Jens Axboe <[email protected]>
[ Upstream commit cc440e8738e5c875297ac0e90316745093be7e28 ]
Provide a generic helper for setting up an io_uring worker. Returns a task_struct so that the caller can do whatever setup is needed, then call wake_up_new_task() to kick it into gear.
Add a kernel_clone_args member, io_thread, which tells copy_process() to mark the task with PF_IO_WORKER.
--- include/linux/sched/task.h | 2 ++ kernel/fork.c | 30 ++++++++++++++++++++++++++++++ 2 files changed, 32 insertions(+)
include/linux/sched/task.h +2 -0
@@ -31,6 +31,7 @@ struct kernel_clone_args {/* Number of elements in *set_tid */ size_t set_tid_size;int cgroup; +int io_thread;struct cgroup *cgrp;struct css_set *cset; };
@@ -85,6 +86,7 @@ extern void exit_files(struct task_strucextern void exit_itimers (struct task_struct *);extern pid_t kernel_clone (struct kernel_clone_args *kargs); +struct task_struct *create_io_thread (int (*fn)(void *),void *arg,int node);struct task_struct *fork_idle (int );struct mm_struct *copy_init_mm (void );extern pid_t kernel_thread (int (*fn)(void *),void *arg,unsigned long flags);
kernel/fork.c +30 -0
@@ -1949,6 +1949,8 @@ static __latent_entropy struct task_stru p =dup_task_struct (current, node);if (!p) goto fork_out; +if (args->io_thread) + p->flags |=PF_IO_WORKER ;/* * This _must_ happen before we call free_task(), i.e. before we jump
@@ -2416,6 +2418,34 @@ struct mm_struct *copy_init_mm(void) }/* +* This is like kernel_clone(), but shaved down and tailored to just +* creating io_uring workers. It returns a created task, or an error pointer. +* The returned task is inactive, and the caller must fire it up through +* wake_up_new_task(p). All signals are blocked in the created task. +*/ +struct task_struct *create_io_thread (int (*fn)(void *),void *arg,int node) +{ +unsigned long flags =CLONE_FS |CLONE_FILES |CLONE_SIGHAND |CLONE_THREAD | +CLONE_IO ; +struct kernel_clone_args args = { + .flags = ((lower_32_bits (flags) |CLONE_VM | +CLONE_UNTRACED ) & ~CSIGNAL ), + .exit_signal = (lower_32_bits (flags) &CSIGNAL ), + .stack = (unsigned long )fn, + .stack_size = (unsigned long )arg, + .io_thread =1 , + }; +struct task_struct *tsk; + + tsk =copy_process (NULL ,0 , node, &args); +if (!IS_ERR (tsk)) { +sigfillset (&tsk->blocked); +sigdelsetmask (&tsk->blocked,sigmask (SIGKILL )); + } +return tsk; +} + +/* * Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts
Greg Kroah-Hartman
maintainerPATCH 2/63 iov_iter: add helper to save iov_iter state
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 8fb0f47a9d7acf620d0fd97831b69da9bc5e22ed ]
In an ideal world, when someone is passed an iov_iter and returns X bytes, then X bytes would have been consumed/advanced from the iov_iter. But we have use cases that always consume the entire iterator, a few examples of that are iomap and bdev O_DIRECT. This means we cannot rely on the state of the iov_iter once we've called ->read_iter() or ->write_iter().
This would be easier if we didn't always have to deal with truncate of the iov_iter, as rewinding would be trivial without that. We recently added a commit to track the truncate state, but that grew the iov_iter by 8 bytes and wasn't the best solution.
Implement a helper to save enough of the iov_iter state to sanely restore it after we've called the read/write iterator helpers. This currently only works for IOVEC/BVEC/KVEC as that's all we need, support for other iterator types are left as an exercise for the reader.
--- include/linux/uio.h | 15 +++++++++++++++ lib/iov_iter.c | 52 +++++++++++++++++++++++++++++++++------------------- 2 files changed, 48 insertions(+), 19 deletions(-)
include/linux/uio.h +15 -0
@@ -26,6 +26,12 @@ enum iter_type { ITER_DISCARD = 64, }; +struct iov_iter_state { +size_t iov_offset; +size_t count; +unsigned long nr_segs; +}; +struct iov_iter {/* * Bit 0 is the read/write bit, set if we're writing.
@@ -55,6 +61,14 @@ static inline enum iter_type iov_iter_tyreturn i->type & ~(READ |WRITE ); } +static inline void iov_iter_save_state (struct iov_iter *iter, +struct iov_iter_state *state) +{ + state->iov_offset = iter->iov_offset; + state->count = iter->count; + state->nr_segs = iter->nr_segs; +} +static inline bool iter_is_iovec (const struct iov_iter *i) {return iov_iter_type (i) ==ITER_IOVEC ;
@@ -226,6 +240,7 @@ ssize_t iov_iter_get_pages(struct iov_itssize_t iov_iter_get_pages_alloc (struct iov_iter *i,struct page ***pages,size_t maxsize,size_t *start);int iov_iter_npages (const struct iov_iter *i,int maxpages); +void iov_iter_restore (struct iov_iter *i,struct iov_iter_state *state);const void *dup_iter (struct iov_iter *new,struct iov_iter *old,gfp_t flags);
lib/iov_iter.c +33 -19
57 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 3/63 saner calling conventions for unlazy_child()
In reply to Greg Kroah-HartmanFrom: Al Viro <[email protected]>
[ Upstream commit ae66db45fd309fd1c6d4e846dfc8414dfec7d6ad ]
same as for the previous commit - instead of 0/-ECHILD make it return true/false, rename to try_to_unlazy_child().
--- fs/namei.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-)
fs/namei.c +15 -15
@@ -705,19 +705,19 @@ out: }/** -* unlazy_child - try to switch to ref-walk mode. +* try_to_unlazy_next - try to switch to ref-walk mode. * @nd: nameidata pathwalk data -* @dentry: child of nd->path.dentry -* @seq: seq number to check dentry against -* Returns: 0 on success, -ECHILD on failure -* -* unlazy_child attempts to legitimize the current nd->path, nd->root and dentry -* for ref-walk mode. @dentry must be a path found by a do_lookup call on -* @nd. Must be called from rcu-walk context. -* Nothing should touch nameidata between unlazy_child() failure and +* @dentry: next dentry to step into +* @seq: seq number to check @dentry against +* Returns: true on success, false on failure +* +* Similar to to try_to_unlazy(), but here we have the next dentry already +* picked by rcu-walk and want to legitimize that in addition to the current +* nd->path and nd->root for ref-walk mode. Must be called from rcu-walk context. +* Nothing should touch nameidata between try_to_unlazy_next() failure and * terminate_walk(). */ -static int unlazy_child (struct nameidata *nd,struct dentry *dentry,unsigned seq) +static bool try_to_unlazy_next (struct nameidata *nd,struct dentry *dentry,unsigned seq) {BUG_ON (!(nd->flags &LOOKUP_RCU ));
@@ -747,7 +747,7 @@ static int unlazy_child(struct nameidataif (unlikely (!legitimize_root (nd))) goto out_dput;rcu_read_unlock (); -return 0 ; +return true; out2: nd->path.mnt =NULL ;
@@ -755,11 +755,11 @@ out1: nd->path.dentry =NULL ; out:rcu_read_unlock (); -return -ECHILD ; +return false; out_dput:rcu_read_unlock ();dput (dentry); -return -ECHILD ; +return false; }static inline int d_revalidate (struct dentry *dentry,unsigned int flags)
@@ -1374,7 +1374,7 @@ static inline int handle_mounts(struct nreturn -ENOENT ;if (likely (__follow_mount_rcu (nd, path, inode, seqp)))return 0 ; -if (unlazy_child (nd, dentry, seq)) +if (!try_to_unlazy_next (nd, dentry, seq))return -ECHILD ;// *path might've been clobbered by __follow_mount_rcu() path->mnt = nd->path.mnt;
@@ -1495,7 +1495,7 @@ static struct dentry *lookup_fast(struct status =d_revalidate (dentry, nd->flags);if (likely (status >0 ))return dentry; -if (unlazy_child (nd, dentry, seq)) +if (!try_to_unlazy_next (nd, dentry, seq))return ERR_PTR (-ECHILD );if (unlikely (status == -ECHILD ))/* we'd been told to redo it in non-rcu mode */
Greg Kroah-Hartman
maintainerPATCH 4/63 fs: add support for LOOKUP_CACHED
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 6c6ec2b0a3e0381d886d531bd1471dfdb1509237 ]
io_uring always punts opens to async context, since there's no control over whether the lookup blocks or not. Add LOOKUP_CACHED to support just doing the fast RCU based lookups, which we know will not block. If we can do a cached path resolution of the filename, then we don't have to always punt lookups for a worker.
During path resolution, we always do LOOKUP_RCU first. If that fails and we terminate LOOKUP_RCU, then fail a LOOKUP_CACHED attempt as well.
--- fs/namei.c | 9 +++++++++ include/linux/namei.h | 1 + 2 files changed, 10 insertions(+)
fs/namei.c +9 -0
@@ -686,6 +686,8 @@ static bool try_to_unlazy(struct nameidaBUG_ON (!(nd->flags &LOOKUP_RCU )); nd->flags &= ~LOOKUP_RCU ; +if (nd->flags &LOOKUP_CACHED ) + goto out1;if (unlikely (!legitimize_links (nd))) goto out1;if (unlikely (!legitimize_path (nd, &nd->path, nd->seq)))
@@ -722,6 +724,8 @@ static bool try_to_unlazy_next(struct naBUG_ON (!(nd->flags &LOOKUP_RCU )); nd->flags &= ~LOOKUP_RCU ; +if (nd->flags &LOOKUP_CACHED ) + goto out2;if (unlikely (!legitimize_links (nd))) goto out2;if (unlikely (!legitimize_mnt (nd->path.mnt, nd->m_seq)))
@@ -792,6 +796,7 @@ static int complete_walk(struct nameidat*/ if (!(nd->flags & (LOOKUP_ROOT |LOOKUP_IS_SCOPED ))) nd->root.mnt =NULL ; + nd->flags &= ~LOOKUP_CACHED ;if (!try_to_unlazy (nd))return -ECHILD ; }
@@ -2204,6 +2209,10 @@ static const char *path_init(struct nameint error;const char *s = nd->name->name; +/* LOOKUP_CACHED requires RCU, ask caller to retry */ +if ((flags & (LOOKUP_RCU |LOOKUP_CACHED )) ==LOOKUP_CACHED ) +return ERR_PTR (-EAGAIN ); +if (!*s) flags &= ~LOOKUP_RCU ;if (flags &LOOKUP_RCU )
include/linux/namei.h +1 -0
@@ -46,6 +46,7 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LA#define LOOKUP_NO_XDEV 0x040000/* No mountpoint crossing. */ #define LOOKUP_BENEATH 0x080000/* No escaping from starting point. */ #define LOOKUP_IN_ROOT 0x100000/* Treat dirfd as fs root. */ +#define LOOKUP_CACHED 0x200000/* Only do cached lookup */ /* LOOKUP_* flags which do scope-related checks based on the dirfd. */ #define LOOKUP_IS_SCOPED (LOOKUP_BENEATH | LOOKUP_IN_ROOT)
Greg Kroah-Hartman
maintainerPATCH 5/63 fix handling of nd->depth on LOOKUP_CACHED failures in try_to_unlazy*
In reply to Greg Kroah-HartmanFrom: Al Viro <[email protected]>
[ Upstream commit eacd9aa8cedeb412842c7b339adbaa0477fdd5ad ]
After switching to non-RCU mode, we want nd->depth to match the number of entries in nd->stack[] that need eventual path_put(). legitimize_links() takes care of that on failures; unfortunately, failure exits added for LOOKUP_CACHED do not.
We could add the logics for that into those failure exits, both in try_to_unlazy() and in try_to_unlazy_next(), but since both checks are immediately followed by legitimize_links() and there's no calls of legitimize_links() other than those two... It's easier to move the check (and required handling of nd->depth on failure) into legitimize_links() itself.
[caught by Jens: ... and since we are zeroing ->depth here, we need to do drop_links() first]
--- fs/namei.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
fs/namei.c +5 -4
@@ -630,6 +630,11 @@ static inline bool legitimize_path(strucstatic bool legitimize_links (struct nameidata *nd) {int i; +if (unlikely (nd->flags &LOOKUP_CACHED )) { +drop_links (nd); + nd->depth =0 ; +return false; + }for (i =0 ; i < nd->depth; i++) {struct saved *last = nd->stack + i;if (unlikely (!legitimize_path (nd, &last->link, last->seq))) {
@@ -686,8 +691,6 @@ static bool try_to_unlazy(struct nameidaBUG_ON (!(nd->flags &LOOKUP_RCU )); nd->flags &= ~LOOKUP_RCU ; -if (nd->flags &LOOKUP_CACHED ) - goto out1;if (unlikely (!legitimize_links (nd))) goto out1;if (unlikely (!legitimize_path (nd, &nd->path, nd->seq)))
@@ -724,8 +727,6 @@ static bool try_to_unlazy_next(struct naBUG_ON (!(nd->flags &LOOKUP_RCU )); nd->flags &= ~LOOKUP_RCU ; -if (nd->flags &LOOKUP_CACHED ) - goto out2;if (unlikely (!legitimize_links (nd))) goto out2;if (unlikely (!legitimize_mnt (nd->path.mnt, nd->m_seq)))
Greg Kroah-Hartman
maintainerPATCH 6/63 Make sure nd->path.mnt and nd->path.dentry are always valid pointers
In reply to Greg Kroah-HartmanFrom: Al Viro <[email protected]>
[ Upstream commit 7d01ef7585c07afaf487759a48486228cd065726 ]
Initialize them in set_nameidata() and make sure that terminate_walk() clears them once the pointers become potentially invalid (i.e. we leave RCU mode or drop them in non-RCU one). Currently we have "path_init() always initializes them and nobody accesses them outside of path_init()/terminate_walk() segments", which is asking for trouble.
With that change we would have nd->path.{mnt,dentry}
1) always valid - NULL or pointing to currently allocated objects.
2) non-NULL while we are successfully walking
3) NULL when we are not walking at all
4) contributing to refcounts whenever non-NULL outside of RCU mode.
--- fs/namei.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/namei.c +4 -2
@@ -529,6 +529,8 @@ static void set_nameidata(struct nameida p->stack = p->internal; p->dfd = dfd; p->name = name; + p->path.mnt =NULL ; + p->path.dentry =NULL ; p->total_link_count = old ? old->total_link_count :0 ; p->saved = old; current->nameidata = p;
@@ -602,6 +604,8 @@ static void terminate_walk(struct nameidrcu_read_unlock (); } nd->depth =0 ; + nd->path.mnt =NULL ; + nd->path.dentry =NULL ; }/* path_put is needed afterwards regardless of success or failure */
@@ -2243,8 +2247,6 @@ static const char *path_init(struct name } nd->root.mnt =NULL ; - nd->path.mnt =NULL ; - nd->path.dentry =NULL ;/* Absolute pathname -- fetch the root (LOOKUP_IN_ROOT uses nd->dfd). */ if (*s =='/' && !(flags &LOOKUP_IN_ROOT )) {
Greg Kroah-Hartman
maintainerPATCH 7/63 fs: expose LOOKUP_CACHED through openat2() RESOLVE_CACHED
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 99668f618062816ca7ba639b007eb145b9d3d41e ]
Now that we support non-blocking path resolution internally, expose it via openat2() in the struct open_how ->resolve flags. This allows applications using openat2() to limit path resolution to the extent that it is already cached.
If the lookup cannot be satisfied in a non-blocking manner, openat2(2) will return -1/-EAGAIN.
--- fs/open.c | 6 ++++++ include/linux/fcntl.h | 2 +- include/uapi/linux/openat2.h | 4 ++++ 3 files changed, 11 insertions(+), 1 deletion(-)
fs/open.c +6 -0
@@ -1099,6 +1099,12 @@ inline int build_open_flags(const struct lookup_flags |=LOOKUP_BENEATH ;if (how->resolve &RESOLVE_IN_ROOT ) lookup_flags |=LOOKUP_IN_ROOT ; +if (how->resolve &RESOLVE_CACHED ) { +/* Don't bother even trying for create/truncate/tmpfile open */ +if (flags & (O_TRUNC |O_CREAT |O_TMPFILE )) +return -EAGAIN ; + lookup_flags |=LOOKUP_CACHED ; + } op->lookup_flags = lookup_flags;return 0 ;
include/linux/fcntl.h +1 -1
@@ -19,7 +19,7 @@/* List of all valid flags for the how->resolve argument: */ #define VALID_RESOLVE_FLAGS \ (RESOLVE_NO_XDEV | RESOLVE_NO_MAGICLINKS | RESOLVE_NO_SYMLINKS | \ - RESOLVE_BENEATH | RESOLVE_IN_ROOT) + RESOLVE_BENEATH | RESOLVE_IN_ROOT | RESOLVE_CACHED)/* List of all open_how "versions". */ #define OPEN_HOW_SIZE_VER0 24/* sizeof first published struct */
include/uapi/linux/openat2.h +4 -0
@@ -35,5 +35,9 @@ struct open_how {#define RESOLVE_IN_ROOT 0x10/* Make all jumps to "/" and ".." be scoped inside the dirfd (similar to chroot(2)). */ +#define RESOLVE_CACHED 0x20/* Only complete if resolution can be +completed through cached lookup. May +return -EAGAIN if that's not +possible. */ #endif /* _UAPI_LINUX_OPENAT2_H */
Greg Kroah-Hartman
maintainerPATCH 8/63 tools headers UAPI: Sync openat2.h with the kernel sources
In reply to Greg Kroah-HartmanFrom: Arnaldo Carvalho de Melo <[email protected]>
[ Upstream commit 1e61463cfcd0b3e7a19ba36b8a98c64ebaac5c6e ]
To pick the changes in:
99668f618062816c ("fs: expose LOOKUP_CACHED through openat2() RESOLVE_CACHED")
That don't result in any change in tooling, only silences this perf build warning:
Warning: Kernel ABI header at 'tools/include/uapi/linux/openat2.h' differs from latest version at 'include/uapi/linux/openat2.h' diff -u tools/include/uapi/linux/openat2.h include/uapi/linux/openat2.h
--- tools/include/uapi/linux/openat2.h | 4 ++++ 1 file changed, 4 insertions(+)
tools/include/uapi/linux/openat2.h +4 -0
@@ -35,5 +35,9 @@ struct open_how {#define RESOLVE_IN_ROOT 0x10/* Make all jumps to "/" and ".." be scoped inside the dirfd (similar to chroot(2)). */ +#define RESOLVE_CACHED 0x20/* Only complete if resolution can be +completed through cached lookup. May +return -EAGAIN if that's not +possible. */ #endif /* _UAPI_LINUX_OPENAT2_H */
Greg Kroah-Hartman
maintainerPATCH 9/63 net: provide __sys_shutdown_sock() that takes a socket
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit b713c195d59332277a31a59c91f755e53b5b302b ]
No functional changes in this patch, needed to provide io_uring support for shutdown(2).
--- include/linux/socket.h | 1 + net/socket.c | 15 ++++++++++++--- 2 files changed, 13 insertions(+), 3 deletions(-)
include/linux/socket.h +1 -0
@@ -436,5 +436,6 @@ extern int __sys_getpeername(int fd, str int __user *usockaddr_len);extern int __sys_socketpair (int family,int type,int protocol,int __user *usockvec); +extern int __sys_shutdown_sock (struct socket *sock,int how);extern int __sys_shutdown (int fd,int how);#endif /* _LINUX_SOCKET_H */
net/socket.c +12 -3
@@ -2181,6 +2181,17 @@ SYSCALL_DEFINE5(getsockopt, int, fd, int* Shutdown a socket. */ +int __sys_shutdown_sock (struct socket *sock,int how) +{ +int err; + + err =security_socket_shutdown (sock, how); +if (!err) + err = sock->ops->shutdown (sock, how); + +return err; +} +int __sys_shutdown (int fd,int how) {int err, fput_needed;
@@ -2188,9 +2199,7 @@ int __sys_shutdown(int fd, int how) sock =sockfd_lookup_light (fd, &err, &fput_needed);if (sock !=NULL ) { - err =security_socket_shutdown (sock, how); -if (!err) - err = sock->ops->shutdown (sock, how); + err =__sys_shutdown_sock (sock, how);fput_light (sock->file, fput_needed); }return err;
Greg Kroah-Hartman
maintainerPATCH 10/63 net: add accept helper not installing fd
In reply to Greg Kroah-HartmanFrom: Pavel Begunkov <[email protected]>
[ Upstream commit d32f89da7fa8ccc8b3fb8f909d61e42b9bc39329 ]
Introduce and reuse a helper that acts similarly to __sys_accept4_file() but returns struct file instead of installing file descriptor. Will be used by io_uring.
--- include/linux/socket.h | 3 ++ net/socket.c | 67 ++++++++++++++++++++++++++----------------------- 2 files changed, 39 insertions(+), 31 deletions(-)
include/linux/socket.h +3 -0
@@ -421,6 +421,9 @@ extern int __sys_accept4_file(struct filstruct sockaddr __user *upeer_sockaddr, int __user *upeer_addrlen, int flags, unsigned long nofile); +extern struct file *do_accept (struct file *file,unsigned file_flags, +struct sockaddr __user *upeer_sockaddr, +int __user *upeer_addrlen,int flags);extern int __sys_accept4 (int fd,struct sockaddr __user *upeer_sockaddr,int __user *upeer_addrlen,int flags);extern int __sys_socket (int family,int type,int protocol);
net/socket.c +36 -31
100 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 11/63 signal: Add task_sigpending() helper
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 5c251e9dc0e127bac6fc5b8e6696363d2e35f515 ]
This is in preparation for maintaining signal_pending() as the decider of whether or not a schedule() loop should be broken, or continue sleeping. This is different than the core signal use cases, which really need to know whether an actual signal is pending or not. task_sigpending() returns non-zero if TIF_SIGPENDING is set.
Only core kernel use cases should care about the distinction between the two, make sure those use the task_sigpending() helper.
--- include/linux/sched/signal.h | 9 +++++++-- kernel/events/uprobes.c | 2 +- kernel/signal.c | 8 ++++---- 3 files changed, 12 insertions(+), 7 deletions(-)
include/linux/sched/signal.h +7 -2
@@ -354,11 +354,16 @@ static inline int restart_syscall(void)return -ERESTARTNOINTR ; } -static inline int signal_pending (struct task_struct *p) +static inline int task_sigpending (struct task_struct *p) {return unlikely (test_tsk_thread_flag (p,TIF_SIGPENDING )); } +static inline int signal_pending (struct task_struct *p) +{ +return task_sigpending (p); +} +static inline int __fatal_signal_pending (struct task_struct *p) {return unlikely (sigismember (&p->pending.signal,SIGKILL ));
@@ -366,7 +371,7 @@ static inline int __fatal_signal_pendingstatic inline int fatal_signal_pending (struct task_struct *p) { -return signal_pending (p) &&__fatal_signal_pending (p); +return task_sigpending (p) &&__fatal_signal_pending (p); }static inline int signal_pending_state (long state,struct task_struct *p)
kernel/events/uprobes.c +1 -1
@@ -1973,7 +1973,7 @@ bool uprobe_deny_signal(void)WARN_ON_ONCE (utask->state !=UTASK_SSTEP ); -if (signal_pending (t)) { +if (task_sigpending (t)) {spin_lock_irq (&t->sighand->siglock);clear_tsk_thread_flag (t,TIF_SIGPENDING );spin_unlock_irq (&t->sighand->siglock);
kernel/signal.c +4 -4
@@ -984,7 +984,7 @@ static inline bool wants_signal(int sig,if (task_is_stopped_or_traced (p))return false; -return task_curr (p) || !signal_pending (p); +return task_curr (p) || !task_sigpending (p); }static void complete_signal (int sig,struct task_struct *p,enum pid_type type)
@@ -2813,7 +2813,7 @@ static void retarget_shared_pending(stru/* Remove the signals this thread can handle. */ sigandsets (&retarget, &retarget, &t->blocked); -if (!signal_pending (t)) +if (!task_sigpending (t))signal_wake_up (t,0 );if (sigisemptyset (&retarget))
@@ -2847,7 +2847,7 @@ void exit_signals(struct task_struct *tscgroup_threadgroup_change_end (tsk); -if (!signal_pending (tsk)) +if (!task_sigpending (tsk)) goto out; unblocked = tsk->blocked;
@@ -2891,7 +2891,7 @@ long do_no_restart_syscall(struct restarstatic void __set_task_blocked (struct task_struct *tsk,const sigset_t *newset) { -if (signal_pending (tsk) && !thread_group_empty (tsk)) { +if (task_sigpending (tsk) && !thread_group_empty (tsk)) {sigset_t newblocked;/* A set of now blocked but previously unblocked signals. */ sigandnsets (&newblocked, newset, ¤t->blocked);
Greg Kroah-Hartman
maintainerPATCH 12/63 fs: make do_renameat2() take struct filename
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit e886663cfd029b64a1d8da7efae7014526d884e9 ]
Pass in the struct filename pointers instead of the user string, and update the three callers to do the same.
This behaves like do_unlinkat(), which also takes a filename struct and puts it when it is done. Converting callers is then trivial.
--- fs/internal.h | 2 ++ fs/namei.c | 40 ++++++++++++++++++++++------------------ 2 files changed, 24 insertions(+), 18 deletions(-)
fs/internal.h +2 -0
@@ -77,6 +77,8 @@ extern int vfs_path_lookup(struct dentrylong do_rmdir (int dfd,struct filename *name);long do_unlinkat (int dfd,struct filename *name);int may_linkat (struct path *link); +int do_renameat2 (int olddfd,struct filename *oldname,int newdfd, +struct filename *newname,unsigned int flags);/* * namespace.c
fs/namei.c +22 -18
@@ -4353,8 +4353,8 @@ out: }EXPORT_SYMBOL (vfs_rename); -static int do_renameat2 (int olddfd,const char __user *oldname,int newdfd, -const char __user *newname,unsigned int flags) +int do_renameat2 (int olddfd,struct filename *from,int newdfd, +struct filename *to,unsigned int flags) {struct dentry *old_dentry, *new_dentry;struct dentry *trap;
@@ -4362,32 +4362,30 @@ static int do_renameat2(int olddfd, consstruct qstr old_last, new_last;int old_type, new_type;struct inode *delegated_inode =NULL ; -struct filename *from; -struct filename *to;unsigned int lookup_flags =0 , target_flags =LOOKUP_RENAME_TARGET ;bool should_retry = false; -int error; +int error = -EINVAL ;if (flags & ~(RENAME_NOREPLACE |RENAME_EXCHANGE |RENAME_WHITEOUT )) -return -EINVAL ; + goto put_both;if ((flags & (RENAME_NOREPLACE |RENAME_WHITEOUT )) && (flags &RENAME_EXCHANGE )) -return -EINVAL ; + goto put_both;if (flags &RENAME_EXCHANGE ) target_flags =0 ; retry: - from =filename_parentat (olddfd,getname (oldname), lookup_flags, - &old_path, &old_last, &old_type); + from =filename_parentat (olddfd, from, lookup_flags, &old_path, + &old_last, &old_type);if (IS_ERR (from)) { error =PTR_ERR (from); - goto exit; + goto put_new; } - to =filename_parentat (newdfd,getname (newname), lookup_flags, - &new_path, &new_last, &new_type); + to =filename_parentat (newdfd, to, lookup_flags, &new_path, &new_last, + &new_type);if (IS_ERR (to)) { error =PTR_ERR (to); goto exit1;
@@ -4480,34 +4478,40 @@ exit2:if (retry_estale (error, lookup_flags)) should_retry = true;path_put (&new_path); -putname (to); exit1:path_put (&old_path); -putname (from);if (should_retry) { should_retry = false; lookup_flags |=LOOKUP_REVAL ; goto retry; } -exit: +put_both: +if (!IS_ERR (from)) +putname (from); +put_new: +if (!IS_ERR (to)) +putname (to);return error; } SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user *, oldname, int, newdfd, const char __user *, newname, unsigned int, flags) { -return do_renameat2 (olddfd, oldname, newdfd, newname, flags); +return do_renameat2 (olddfd,getname (oldname), newdfd,getname (newname), + flags); } SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname, int, newdfd, const char __user *, newname) { -return do_renameat2 (olddfd, oldname, newdfd, newname,0 ); +return do_renameat2 (olddfd,getname (oldname), newdfd,getname (newname), +0 ); } SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname) { -return do_renameat2 (AT_FDCWD , oldname,AT_FDCWD , newname,0 ); +return do_renameat2 (AT_FDCWD ,getname (oldname),AT_FDCWD , +getname (newname),0 ); }int readlink_copy (char __user *buffer,int buflen,const char *link)
Greg Kroah-Hartman
maintainerPATCH 13/63 file: Rename __close_fd_get_file close_fd_get_file
In reply to Greg Kroah-HartmanFrom: "Eric W. Biederman" <[email protected]>
[ Upstream commit 9fe83c43e71cdb8e5b9520bcb98706a2b3c680c8 ]
The function close_fd_get_file is explicitly a variant of __close_fd[1]. Now that __close_fd has been renamed close_fd, rename close_fd_get_file to be consistent with close_fd.
When __alloc_fd, __close_fd and __fd_install were introduced the double underscore indicated that the function took a struct files_struct parameter. The function __close_fd_get_file never has so the naming has always been inconsistent. This just cleans things up so there are not any lingering mentions or references __close_fd left in the code.
[1] 80cd795630d6 ("binder: fix use-after-free due to ksys_close() during fdget()")
--- drivers/android/binder.c | 2 +- fs/file.c | 4 ++-- fs/io_uring.c | 2 +- include/linux/fdtable.h | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-)
drivers/android/binder.c +1 -1
@@ -2255,7 +2255,7 @@ static void binder_deferred_fd_close(intif (!twcb)return ;init_task_work (&twcb->twork, binder_do_fd_close); -__close_fd_get_file (fd, &twcb->file); +close_fd_get_file (fd, &twcb->file);if (twcb->file) {filp_close (twcb->file, current->files);task_work_add (current, &twcb->twork,TWA_RESUME );
fs/file.c +2 -2
@@ -780,11 +780,11 @@ int __close_range(unsigned fd, unsigned }/* -* variant of __close_fd that gets a ref on the file for later fput. +* variant of close_fd that gets a ref on the file for later fput. * The caller must ensure that filp_close() called on the file, and then * an fput(). */ -int __close_fd_get_file (unsigned int fd,struct file **res) +int close_fd_get_file (unsigned int fd,struct file **res) {struct files_struct *files = current->files;struct file *file;
fs/io_uring.c +1 -1
@@ -4270,7 +4270,7 @@ static int io_close(struct io_kiocb *req/* might be already done during nonblock submission */ if (!close->put_file) { - ret =__close_fd_get_file (close->fd, &close->put_file); + ret =close_fd_get_file (close->fd, &close->put_file);if (ret <0 )return (ret == -ENOENT ) ? -EBADF : ret; }
include/linux/fdtable.h +1 -1
@@ -123,7 +123,7 @@ extern void __fd_install(struct files_stextern int __close_fd (struct files_struct *files,unsigned int fd);extern int __close_range (unsigned int fd,unsigned int max_fd,unsigned int flags); -extern int __close_fd_get_file (unsigned int fd,struct file **res); +extern int close_fd_get_file (unsigned int fd,struct file **res);extern int unshare_fd (unsigned long unshare_flags,unsigned int max_fds,struct files_struct **new_fdp);
Greg Kroah-Hartman
maintainerPATCH 14/63 fs: provide locked helper variant of close_fd_get_file()
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 53dec2ea74f2ef360e8455439be96a780baa6097 ]
Assumes current->files->file_lock is already held on invocation. Helps the caller check the file before removing the fd, if it needs to.
--- fs/file.c | 36 +++++++++++++++++++++++++----------- fs/internal.h | 1 + 2 files changed, 26 insertions(+), 11 deletions(-)
fs/file.c +25 -11
@@ -22,6 +22,8 @@#include <linux/close_range.h> #include <net/sock.h> +#include "internal.h" +unsigned int sysctl_nr_open__read_mostly =1024 *1024 ;unsigned int sysctl_nr_open_min =BITS_PER_LONG ;/* our min() is unusable in constant expressions ;-/ */
@@ -780,36 +782,48 @@ int __close_range(unsigned fd, unsigned }/* -* variant of close_fd that gets a ref on the file for later fput. -* The caller must ensure that filp_close() called on the file, and then -* an fput(). +* See close_fd_get_file() below, this variant assumes current->files->file_lock +* is held. */ -int close_fd_get_file (unsigned int fd,struct file **res) +int __close_fd_get_file (unsigned int fd,struct file **res) {struct files_struct *files = current->files;struct file *file;struct fdtable *fdt; -spin_lock (&files->file_lock); fdt =files_fdtable (files);if (fd >= fdt->max_fds) - goto out_unlock; + goto out_err; file = fdt->fd[fd];if (!file) - goto out_unlock; + goto out_err;rcu_assign_pointer (fdt->fd[fd],NULL );__put_unused_fd (files, fd); -spin_unlock (&files->file_lock);get_file (file); *res = file;return 0 ; - -out_unlock: -spin_unlock (&files->file_lock); +out_err: *res =NULL ;return -ENOENT ; } +/* +* variant of close_fd that gets a ref on the file for later fput. +* The caller must ensure that filp_close() called on the file, and then +* an fput(). +*/ +int close_fd_get_file (unsigned int fd,struct file **res) +{ +struct files_struct *files = current->files; +int ret; + +spin_lock (&files->file_lock); + ret =__close_fd_get_file (fd, res); +spin_unlock (&files->file_lock); + +return ret; +} +void do_close_on_exec (struct files_struct *files) {unsigned i;
fs/internal.h +1 -0
@@ -134,6 +134,7 @@ extern struct file *do_file_open_root(st const char *, const struct open_flags *);extern struct open_how build_open_how (int flags,umode_t mode);extern int build_open_flags (const struct open_how *how,struct open_flags *op); +extern int __close_fd_get_file (unsigned int fd,struct file **res);long do_sys_ftruncate (unsigned int fd,loff_t length,int small);int chmod_common (const struct path *path,umode_t mode);
Greg Kroah-Hartman
maintainerPATCH 15/63 entry: Add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 12db8b690010ccfadf9d0b49a1e1798e47dbbe1a ]
Add TIF_NOTIFY_SIGNAL handling in the generic entry code, which if set, will return true if signal_pending() is used in a wait loop. That causes an exit of the loop so that notify_signal tracehooks can be run. If the wait loop is currently inside a system call, the system call is restarted once task_work has been processed.
In preparation for only having arch_do_signal() handle syscall restarts if _TIF_SIGPENDING isn't set, rename it to arch_do_signal_or_restart(). Pass in a boolean that tells the architecture specific signal handler if it should attempt to get a signal, or just process a potential syscall restart.
For !CONFIG_GENERIC_ENTRY archs, add the TIF_NOTIFY_SIGNAL handling to get_signal(). This is done to minimize the needed architecture changes to support this feature.
--- arch/x86/kernel/signal.c | 4 ++-- include/linux/entry-common.h | 11 ++++++++--- include/linux/entry-kvm.h | 4 ++-- include/linux/sched/signal.h | 11 ++++++++++- include/linux/tracehook.h | 27 +++++++++++++++++++++++++++ kernel/entry/common.c | 14 +++++++++++--- kernel/entry/kvm.c | 3 +++ kernel/signal.c | 14 ++++++++++++++ 8 files changed, 77 insertions(+), 11 deletions(-)
arch/x86/kernel/signal.c +2 -2
@@ -798,11 +798,11 @@ static inline unsigned long get_nr_resta* want to handle. Thus you cannot kill init even with a SIGKILL even by * mistake. */ -void arch_do_signal (struct pt_regs *regs) +void arch_do_signal_or_restart (struct pt_regs *regs,bool has_signal) {struct ksignal ksig; -if (get_signal (&ksig)) { +if (has_signal &&get_signal (&ksig)) {/* Whee! Actually deliver the signal. */ handle_signal (&ksig, regs);return ;
include/linux/entry-common.h +8 -3
@@ -37,6 +37,10 @@# define _TIF_UPROBE (0)#endif +#ifndef _TIF_NOTIFY_SIGNAL +# define _TIF_NOTIFY_SIGNAL (0) +#endif +/* * TIF flags handled in syscall_enter_from_user_mode() */
@@ -69,7 +73,7 @@#define EXIT_TO_USER_MODE_WORK \ (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_UPROBE | \ - _TIF_NEED_RESCHED | _TIF_PATCH_PENDING | \ + _TIF_NEED_RESCHED | _TIF_PATCH_PENDING | _TIF_NOTIFY_SIGNAL | \ ARCH_EXIT_TO_USER_MODE_WORK)/**
@@ -259,12 +263,13 @@ static __always_inline void arch_exit_to#endif /** -* arch_do_signal - Architecture specific signal delivery function +* arch_do_signal_or_restart - Architecture specific signal delivery function * @regs: Pointer to currents pt_regs +* @has_signal: actual signal to handle * * Invoked from exit_to_user_mode_loop(). */ -void arch_do_signal (struct pt_regs *regs); +void arch_do_signal_or_restart (struct pt_regs *regs,bool has_signal);/** * arch_syscall_exit_tracehook - Wrapper around tracehook_report_syscall_exit()
include/linux/entry-kvm.h +2 -2
@@ -11,8 +11,8 @@# define ARCH_XFER_TO_GUEST_MODE_WORK (0)#endif -#define XFER_TO_GUEST_MODE_WORK \ - (_TIF_NEED_RESCHED | _TIF_SIGPENDING | \ +#define XFER_TO_GUEST_MODE_WORK \ + (_TIF_NEED_RESCHED | _TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL | \ _TIF_NOTIFY_RESUME | ARCH_XFER_TO_GUEST_MODE_WORK)struct kvm_vcpu ;
include/linux/sched/signal.h +10 -1
@@ -361,6 +361,15 @@ static inline int task_sigpending(structstatic inline int signal_pending (struct task_struct *p) { +#if defined(TIF_NOTIFY_SIGNAL ) +/* +* TIF_NOTIFY_SIGNAL isn't really a signal, but it requires the same +* behavior in terms of ensuring that we break out of wait loops +* so that notify signal callbacks can be processed. +*/ +if (unlikely (test_tsk_thread_flag (p,TIF_NOTIFY_SIGNAL ))) +return 1 ; +#endif return task_sigpending (p); }
@@ -508,7 +517,7 @@ extern int set_user_sigmask(const sigsetstatic inline void restore_saved_sigmask_unless (bool interrupted) {if (interrupted) -WARN_ON (!test_thread_flag (TIF_SIGPENDING )); +WARN_ON (!signal_pending (current));else restore_saved_sigmask (); }
include/linux/tracehook.h +27 -0
@@ -198,4 +198,31 @@ static inline void tracehook_notify_resu blkcg_maybe_throttle_current(); } +/* +* called by exit_to_user_mode_loop() if ti_work & _TIF_NOTIFY_SIGNAL. This +* is currently used by TWA_SIGNAL based task_work, which requires breaking +* wait loops to ensure that task_work is noticed and run. +*/ +static inline void tracehook_notify_signal (void ) +{ +#if defined(TIF_NOTIFY_SIGNAL ) +clear_thread_flag (TIF_NOTIFY_SIGNAL ); +smp_mb__after_atomic (); +if (current->task_works) +task_work_run (); +#endif +} + +/* +* Called when we have work to process from exit_to_user_mode_loop() +*/ +static inline void set_notify_signal (struct task_struct *task) +{ +#if defined(TIF_NOTIFY_SIGNAL ) +if (!test_and_set_tsk_thread_flag (task,TIF_NOTIFY_SIGNAL ) && + !wake_up_state (task,TASK_INTERRUPTIBLE )) +kick_process (task); +#endif +} +#endif /* <linux/tracehook.h> */
kernel/entry/common.c +11 -3
@@ -135,7 +135,15 @@ static __always_inline void exit_to_user }/* Workaround to allow gradual conversion of architecture code */ -void __weak arch_do_signal (struct pt_regs *regs) { } +void __weak arch_do_signal_or_restart (struct pt_regs *regs,bool has_signal) { } + +static void handle_signal_work (struct pt_regs *regs,unsigned long ti_work) +{ +if (ti_work & _TIF_NOTIFY_SIGNAL) +tracehook_notify_signal (); + +arch_do_signal_or_restart (regs, ti_work & _TIF_SIGPENDING); +}static unsigned long exit_to_user_mode_loop (struct pt_regs *regs,unsigned long ti_work)
@@ -157,8 +165,8 @@ static unsigned long exit_to_user_mode_lif (ti_work & _TIF_PATCH_PENDING)klp_update_patch_state (current); -if (ti_work & _TIF_SIGPENDING) -arch_do_signal (regs); +if (ti_work & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) +handle_signal_work (regs, ti_work);if (ti_work & _TIF_NOTIFY_RESUME) {tracehook_notify_resume (regs);
kernel/entry/kvm.c +3 -0
@@ -8,6 +8,9 @@ static int xfer_to_guest_mode_work(struc do { int ret; + if (ti_work & _TIF_NOTIFY_SIGNAL) + tracehook_notify_signal(); + if (ti_work & _TIF_SIGPENDING) { kvm_handle_signal_exit(vcpu); return -EINTR;
kernel/signal.c +14 -0
@@ -2520,6 +2520,20 @@ bool get_signal(struct ksignal *ksig)struct signal_struct *signal = current->signal;int signr; +/* +* For non-generic architectures, check for TIF_NOTIFY_SIGNAL so +* that the arch handlers don't all have to do it. If we get here +* without TIF_SIGPENDING, just exit after running signal work. +*/ +#ifdef TIF_NOTIFY_SIGNAL +if (!IS_ENABLED (CONFIG_GENERIC_ENTRY )) { +if (test_thread_flag (TIF_NOTIFY_SIGNAL )) +tracehook_notify_signal (); +if (!task_sigpending (current)) +return false; + } +#endif +if (unlikely (uprobe_deny_signal ()))return false;
Greg Kroah-Hartman
maintainerPATCH 16/63 task_work: Use TIF_NOTIFY_SIGNAL if available
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 114518eb6430b832d2f9f5a008043b913ccf0e24 ]
If the arch supports TIF_NOTIFY_SIGNAL, then use that for TWA_SIGNAL as it's more efficient than using the signal delivery method. This is especially true on threaded applications, where ->sighand is shared across threads, but it's also lighter weight on non-shared cases.
io_uring is a heavy consumer of TWA_SIGNAL based task_work. A test with threads shows a nice improvement running an io_uring based echo server.
stock kernel:
0.01% <= 0.1 milliseconds
95.86% <= 0.2 milliseconds
98.27% <= 0.3 milliseconds
99.71% <= 0.4 milliseconds
100.00% <= 0.5 milliseconds
100.00% <= 0.6 milliseconds
100.00% <= 0.7 milliseconds
100.00% <= 0.8 milliseconds
100.00% <= 0.9 milliseconds
100.00% <= 1.0 milliseconds
100.00% <= 1.1 milliseconds
100.00% <= 2 milliseconds
100.00% <= 3 milliseconds
100.00% <= 3 milliseconds
1378930.00 requests per second
~1600% CPU
1.38M requests/second, and all 16 CPUs are maxed out.
patched kernel:
0.01% <= 0.1 milliseconds
98.24% <= 0.2 milliseconds
99.47% <= 0.3 milliseconds
99.99% <= 0.4 milliseconds
100.00% <= 0.5 milliseconds
100.00% <= 0.6 milliseconds
100.00% <= 0.7 milliseconds
100.00% <= 0.8 milliseconds
100.00% <= 0.9 milliseconds
100.00% <= 1.2 milliseconds
1666111.38 requests per second
~1450% CPU
1.67M requests/second, and we're no longer just hammering on the sighand lock. The original reporter states:
"For 5.7.15 my benchmark achieves 1.6M qps and system cpu is at ~80%.
for 5.7.16 or later it achieves only 1M qps and the system cpu is is at ~100%"
with the only difference there being that TWA_SIGNAL is used unconditionally in 5.7.16, since it's required to be able to handle the inability to run task_work if the application is waiting in the kernel already on an event that needs task_work run to be satisfied. Also see commit 0ba9c9edcd15.
--- kernel/task_work.c | 41 +++++++++++++++++++++++++++++------------ 1 file changed, 29 insertions(+), 12 deletions(-)
kernel/task_work.c +29 -12
@@ -5,6 +5,34 @@static struct callback_head work_exited;/* all we need is ->next == NULL */ +/* +* TWA_SIGNAL signaling - use TIF_NOTIFY_SIGNAL, if available, as it's faster +* than TIF_SIGPENDING as there's no dependency on ->sighand. The latter is +* shared for threads, and can cause contention on sighand->lock. Even for +* the non-threaded case TIF_NOTIFY_SIGNAL is more efficient, as no locking +* or IRQ disabling is involved for notification (or running) purposes. +*/ +static void task_work_notify_signal (struct task_struct *task) +{ +#if defined(TIF_NOTIFY_SIGNAL ) +set_notify_signal (task); +#else +unsigned long flags; + +/* +* Only grab the sighand lock if we don't already have some +* task_work pending. This pairs with the smp_store_mb() +* in get_signal(), see comment there. +*/ +if (!(READ_ONCE (task->jobctl) &JOBCTL_TASK_WORK ) && +lock_task_sighand (task, &flags)) { + task->jobctl |=JOBCTL_TASK_WORK ; +signal_wake_up (task,0 ); +unlock_task_sighand (task, &flags); + } +#endif +} +/** * task_work_add - ask the @task to execute @work->func() * @task: the task which should run the callback
@@ -33,7 +61,6 @@ int task_work_add(struct task_struct *ta enum task_work_notify_mode notify) {struct callback_head *head; -unsigned long flags; do { head = READ_ONCE(task->task_works);
@@ -49,17 +76,7 @@ int task_work_add(struct task_struct *taset_notify_resume (task);break ;case TWA_SIGNAL : -/* -* Only grab the sighand lock if we don't already have some -* task_work pending. This pairs with the smp_store_mb() -* in get_signal(), see comment there. -*/ -if (!(READ_ONCE (task->jobctl) &JOBCTL_TASK_WORK ) && -lock_task_sighand (task, &flags)) { - task->jobctl |=JOBCTL_TASK_WORK ; -signal_wake_up (task,0 ); -unlock_task_sighand (task, &flags); - } +task_work_notify_signal (task);break ;default :WARN_ON_ONCE (1 );
Greg Kroah-Hartman
maintainerPATCH 17/63 x86: Wire up TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit c8d5ed67936fddbe2ae845fc80397718006322d7 ]
The generic entry code has support for TIF_NOTIFY_SIGNAL already. Just provide the TIF bit.
[ tglx: Adopted to other TIF changes in x86 ]
--- arch/x86/include/asm/thread_info.h | 2 ++ 1 file changed, 2 insertions(+)
arch/x86/include/asm/thread_info.h +2 -0
@@ -93,6 +93,7 @@ struct thread_info {#define TIF_NOTSC 16/* TSC is not accessible in userland */ #define TIF_IA32 17/* IA32 compatibility process */ #define TIF_SLD 18/* Restore split lock detection on context switch */ +#define TIF_NOTIFY_SIGNAL 19/* signal notifications exist */ #define TIF_MEMDIE 20/* is terminating due to OOM killer */ #define TIF_POLLING_NRFLAG 21/* idle is polling for TIF_NEED_RESCHED */ #define TIF_IO_BITMAP 22/* uses I/O bitmap */
@@ -121,6 +122,7 @@ struct thread_info {#define _TIF_NOCPUID (1 << TIF_NOCPUID)#define _TIF_NOTSC (1 << TIF_NOTSC)#define _TIF_IA32 (1 << TIF_IA32) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_SLD (1 << TIF_SLD)#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG)#define _TIF_IO_BITMAP (1 << TIF_IO_BITMAP)
Greg Kroah-Hartman
maintainerPATCH 18/63 arc: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 53855e12588743ea128ee31f913d1c6e2f1d32c8 ]
Wire up TIF_NOTIFY_SIGNAL handling for arc.
--- arch/arc/include/asm/thread_info.h | 4 +++- arch/arc/kernel/entry.S | 3 ++- arch/arc/kernel/signal.c | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-)
arch/arc/include/asm/thread_info.h +3 -1
@@ -79,6 +79,7 @@ static inline __attribute_const__ struct#define TIF_SIGPENDING 2/* signal pending */ #define TIF_NEED_RESCHED 3/* rescheduling necessary */ #define TIF_SYSCALL_AUDIT 4/* syscall auditing active */ +#define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_SYSCALL_TRACE 15/* syscall trace active */ /* true if poll_idle() is polling TIF_NEED_RESCHED */
@@ -89,11 +90,12 @@ static inline __attribute_const__ struct#define _TIF_SIGPENDING (1<<TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED)#define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT) +#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL)#define _TIF_MEMDIE (1<<TIF_MEMDIE)/* work to do on interrupt/exception return */ #define _TIF_WORK_MASK (_TIF_NEED_RESCHED | _TIF_SIGPENDING | \ - _TIF_NOTIFY_RESUME) + _TIF_NOTIFY_RESUME | _TIF_NOTIFY_SIGNAL)/* * _TIF_ALLWORK_MASK includes SYSCALL_TRACE, but we don't need it.
arch/arc/kernel/entry.S +2 -1
@@ -308,7 +308,8 @@ resume_user_mode_begin: mov r0, sp ; pt_regs for arg to do_signal()/do_notify_resume() GET_CURR_THR_INFO_FLAGS r9 - bbit0 r9, TIF_SIGPENDING, .Lchk_notify_resume + and.f 0, r9, TIF_SIGPENDING|TIF_NOTIFY_SIGNAL + bz .Lchk_notify_resume ; Normal Trap/IRQ entry only saves Scratch (caller-saved) regs ; in pt_reg since the "C" ABI (kernel code) will automatically
arch/arc/kernel/signal.c +1 -1
@@ -405,7 +405,7 @@ void do_signal(struct pt_regs *regs) restart_scall =in_syscall (regs) &&syscall_restartable (regs); -if (get_signal (&ksig)) { +if (test_thread_flag (TIF_SIGPENDING ) &&get_signal (&ksig)) {if (restart_scall) {arc_restart_syscall (&ksig.ka, regs);syscall_wont_restart (regs);/* No more restarts */
Greg Kroah-Hartman
maintainerPATCH 19/63 arm64: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 192caabd4dd92c98d23ed4334d7596af05af2fb4 ]
Wire up TIF_NOTIFY_SIGNAL handling for arm64.
--- arch/arm64/include/asm/thread_info.h | 5 ++++- arch/arm64/kernel/signal.c | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-)
arch/arm64/include/asm/thread_info.h +4 -1
@@ -68,6 +68,7 @@ void arch_release_task_struct(struct tas#define TIF_UPROBE 4/* uprobe breakpoint or singlestep */ #define TIF_FSCHECK 5/* Check FS is USER_DS on return */ #define TIF_MTE_ASYNC_FAULT 6/* MTE Asynchronous Tag Check Fault */ +#define TIF_NOTIFY_SIGNAL 7/* signal notifications exist */ #define TIF_SYSCALL_TRACE 8/* syscall trace active */ #define TIF_SYSCALL_AUDIT 9/* syscall auditing */ #define TIF_SYSCALL_TRACEPOINT 10/* syscall tracepoint for ftrace */
@@ -98,10 +99,12 @@ void arch_release_task_struct(struct tas#define _TIF_32BIT (1 << TIF_32BIT)#define _TIF_SVE (1 << TIF_SVE)#define _TIF_MTE_ASYNC_FAULT (1 << TIF_MTE_ASYNC_FAULT) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_WORK_MASK (_TIF_NEED_RESCHED | _TIF_SIGPENDING | \ _TIF_NOTIFY_RESUME | _TIF_FOREIGN_FPSTATE | \ - _TIF_UPROBE | _TIF_FSCHECK | _TIF_MTE_ASYNC_FAULT) + _TIF_UPROBE | _TIF_FSCHECK | _TIF_MTE_ASYNC_FAULT | \ + _TIF_NOTIFY_SIGNAL)#define _TIF_SYSCALL_WORK (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | \ _TIF_SYSCALL_TRACEPOINT | _TIF_SECCOMP | \
arch/arm64/kernel/signal.c +1 -1
@@ -938,7 +938,7 @@ asmlinkage void do_notify_resume(struct (void __user *)NULL, current); } -if (thread_flags & _TIF_SIGPENDING) +if (thread_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs);if (thread_flags & _TIF_NOTIFY_RESUME) {
Greg Kroah-Hartman
maintainerPATCH 20/63 m68k: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit e660653cd9f2df470d156c249631f68b9dee51ee ]
Wire up TIF_NOTIFY_SIGNAL handling for m68k.
--- arch/m68k/include/asm/thread_info.h | 1 + arch/m68k/kernel/signal.c | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-)
arch/m68k/include/asm/thread_info.h +1 -0
@@ -60,6 +60,7 @@ static inline struct thread_info *curren* bits 0-7 are tested at every exception exit * bits 8-15 are also tested at syscall exit */ +#define TIF_NOTIFY_SIGNAL 4#define TIF_NOTIFY_RESUME 5/* callback before returning to user */ #define TIF_SIGPENDING 6/* signal pending */ #define TIF_NEED_RESCHED 7/* rescheduling necessary */
arch/m68k/kernel/signal.c +2 -1
@@ -1129,7 +1129,8 @@ static void do_signal(struct pt_regs *revoid do_notify_resume (struct pt_regs *regs) { -if (test_thread_flag (TIF_SIGPENDING )) +if (test_thread_flag (TIF_NOTIFY_SIGNAL ) || +test_thread_flag (TIF_SIGPENDING ))do_signal (regs);if (test_thread_flag (TIF_NOTIFY_RESUME ))
Greg Kroah-Hartman
maintainerPATCH 21/63 nios32: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 42020064274c235d720d9c4b7d9a678b133e59cf ]
Wire up TIF_NOTIFY_SIGNAL handling for nios32.
--- arch/nios2/include/asm/thread_info.h | 2 ++ arch/nios2/kernel/signal.c | 3 ++- 2 files changed, 4 insertions(+), 1 deletion(-)
arch/nios2/include/asm/thread_info.h +2 -0
@@ -86,6 +86,7 @@ static inline struct thread_info *curren#define TIF_MEMDIE 4/* is terminating due to OOM killer */ #define TIF_SECCOMP 5/* secure computing */ #define TIF_SYSCALL_AUDIT 6/* syscall auditing active */ +#define TIF_NOTIFY_SIGNAL 7/* signal notifications exist */ #define TIF_RESTORE_SIGMASK 9/* restore signal mask in do_signal() */ #define TIF_POLLING_NRFLAG 16/* true if poll_idle() is polling
@@ -97,6 +98,7 @@ static inline struct thread_info *curren#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)#define _TIF_SECCOMP (1 << TIF_SECCOMP)#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK)#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG)
arch/nios2/kernel/signal.c +2 -1
@@ -309,7 +309,8 @@ asmlinkage int do_notify_resume(struct pif (!user_mode (regs))return 0 ; -if (test_thread_flag (TIF_SIGPENDING )) { +if (test_thread_flag (TIF_SIGPENDING ) || +test_thread_flag (TIF_NOTIFY_SIGNAL )) {int restart =do_signal (regs);if (unlikely (restart)) {
Greg Kroah-Hartman
maintainerPATCH 22/63 parisc: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 18cb3281285d2190c0605d2e53543802319bd1a1 ]
Wire up TIF_NOTIFY_SIGNAL handling for parisc.
--- arch/parisc/include/asm/thread_info.h | 4 +++- arch/parisc/kernel/signal.c | 3 ++- 2 files changed, 5 insertions(+), 2 deletions(-)
arch/parisc/include/asm/thread_info.h +3 -1
@@ -52,6 +52,7 @@ struct thread_info {#define TIF_POLLING_NRFLAG 3/* true if poll_idle() is polling TIF_NEED_RESCHED */ #define TIF_32BIT 4/* 32 bit binary */ #define TIF_MEMDIE 5/* is terminating due to OOM killer */ +#define TIF_NOTIFY_SIGNAL 6/* signal notifications exist */ #define TIF_SYSCALL_AUDIT 7/* syscall auditing active */ #define TIF_NOTIFY_RESUME 8/* callback before returning to user */ #define TIF_SINGLESTEP 9/* single stepping? */
@@ -61,6 +62,7 @@ struct thread_info {#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)#define _TIF_SIGPENDING (1 << TIF_SIGPENDING) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG)#define _TIF_32BIT (1 << TIF_32BIT)
@@ -72,7 +74,7 @@ struct thread_info {#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)#define _TIF_USER_WORK_MASK (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | \ - _TIF_NEED_RESCHED) + _TIF_NEED_RESCHED | _TIF_NOTIFY_SIGNAL)#define _TIF_SYSCALL_TRACE_MASK (_TIF_SYSCALL_TRACE | _TIF_SINGLESTEP | \ _TIF_BLOCKSTEP | _TIF_SYSCALL_AUDIT | \ _TIF_SECCOMP | _TIF_SYSCALL_TRACEPOINT)
arch/parisc/kernel/signal.c +2 -1
@@ -609,7 +609,8 @@ do_signal(struct pt_regs *regs, long in_void do_notify_resume (struct pt_regs *regs,long in_syscall) { -if (test_thread_flag (TIF_SIGPENDING )) +if (test_thread_flag (TIF_SIGPENDING ) || +test_thread_flag (TIF_NOTIFY_SIGNAL ))do_signal (regs, in_syscall);if (test_thread_flag (TIF_NOTIFY_RESUME ))
Greg Kroah-Hartman
maintainerPATCH 23/63 powerpc: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 900f0713fdd730fab0f0bfa4a8ca4db2a8985bbe ]
Wire up TIF_NOTIFY_SIGNAL handling for powerpc.
--- arch/powerpc/include/asm/thread_info.h | 5 ++++- arch/powerpc/kernel/signal.c | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-)
arch/powerpc/include/asm/thread_info.h +4 -1
@@ -96,6 +96,7 @@ void arch_setup_new_exec(void);#define TIF_SYSCALL_TRACE 0/* syscall trace active */ #define TIF_SIGPENDING 1/* signal pending */ #define TIF_NEED_RESCHED 2/* rescheduling necessary */ +#define TIF_NOTIFY_SIGNAL 3/* signal notifications exist */ #define TIF_SYSCALL_EMU 4/* syscall emulation active */ #define TIF_RESTORE_TM 5/* need to restore TM FP/VEC/VSX */ #define TIF_PATCH_PENDING 6/* pending live patching update */
@@ -121,6 +122,7 @@ void arch_setup_new_exec(void);#define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE)#define _TIF_SIGPENDING (1<<TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) +#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL)#define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG)#define _TIF_32BIT (1<<TIF_32BIT)#define _TIF_RESTORE_TM (1<<TIF_RESTORE_TM)
@@ -142,7 +144,8 @@ void arch_setup_new_exec(void);#define _TIF_USER_WORK_MASK (_TIF_SIGPENDING | _TIF_NEED_RESCHED | \ _TIF_NOTIFY_RESUME | _TIF_UPROBE | \ - _TIF_RESTORE_TM | _TIF_PATCH_PENDING) + _TIF_RESTORE_TM | _TIF_PATCH_PENDING | \ + _TIF_NOTIFY_SIGNAL)#define _TIF_PERSYSCALL_MASK (_TIF_RESTOREALL|_TIF_NOERROR)/* Bits in local_flags */
arch/powerpc/kernel/signal.c +1 -1
@@ -318,7 +318,7 @@ void do_notify_resume(struct pt_regs *reif (thread_info_flags & _TIF_PATCH_PENDING)klp_update_patch_state (current); -if (thread_info_flags & _TIF_SIGPENDING) { +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) {BUG_ON (regs != current->thread.regs);do_signal (current); }
Greg Kroah-Hartman
maintainerPATCH 24/63 mips: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit f45c184bce15f4a314c0210519bc3b4aab408838 ]
Wire up TIF_NOTIFY_SIGNAL handling for mips.
--- arch/mips/include/asm/thread_info.h | 4 +++- arch/mips/kernel/signal.c | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-)
arch/mips/include/asm/thread_info.h +3 -1
@@ -115,6 +115,7 @@ static inline struct thread_info *curren#define TIF_SECCOMP 4/* secure computing */ #define TIF_NOTIFY_RESUME 5/* callback before returning to user */ #define TIF_UPROBE 6/* breakpointed or singlestepping */ +#define TIF_NOTIFY_SIGNAL 7/* signal notifications exist */ #define TIF_RESTORE_SIGMASK 9/* restore signal mask in do_signal() */ #define TIF_USEDFPU 16/* FPU was used by this task this quantum (SMP) */ #define TIF_MEMDIE 18/* is terminating due to OOM killer */
@@ -139,6 +140,7 @@ static inline struct thread_info *curren#define _TIF_SECCOMP (1<<TIF_SECCOMP)#define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME)#define _TIF_UPROBE (1<<TIF_UPROBE) +#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL)#define _TIF_USEDFPU (1<<TIF_USEDFPU)#define _TIF_NOHZ (1<<TIF_NOHZ)#define _TIF_FIXADE (1<<TIF_FIXADE)
@@ -164,7 +166,7 @@ static inline struct thread_info *curren/* work to do on interrupt/exception return */ #define _TIF_WORK_MASK \ (_TIF_SIGPENDING | _TIF_NEED_RESCHED | _TIF_NOTIFY_RESUME | \ - _TIF_UPROBE) + _TIF_UPROBE | _TIF_NOTIFY_SIGNAL)/* work to do on any return to u-space */ #define _TIF_ALLWORK_MASK (_TIF_NOHZ | _TIF_WORK_MASK | \ _TIF_WORK_SYSCALL_EXIT | \
arch/mips/kernel/signal.c +1 -1
@@ -903,7 +903,7 @@ asmlinkage void do_notify_resume(structuprobe_notify_resume (regs);/* deal with pending signal delivery */ -if (thread_info_flags & _TIF_SIGPENDING) +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs);if (thread_info_flags & _TIF_NOTIFY_RESUME) {
Greg Kroah-Hartman
maintainerPATCH 25/63 s390: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 75309018a24ddfb930c51bad8f4070b9bc2c923b ]
Wire up TIF_NOTIFY_SIGNAL handling for s390.
--- arch/s390/include/asm/thread_info.h | 2 ++ arch/s390/kernel/entry.S | 11 ++++++----- arch/s390/kernel/signal.c | 2 +- 3 files changed, 9 insertions(+), 6 deletions(-)
arch/s390/include/asm/thread_info.h +2 -0
@@ -65,6 +65,7 @@ void arch_setup_new_exec(void);#define TIF_GUARDED_STORAGE 4/* load guarded storage control block */ #define TIF_PATCH_PENDING 5/* pending live patching update */ #define TIF_PGSTE 6/* New mm's will use 4K page tables */ +#define TIF_NOTIFY_SIGNAL 7/* signal notifications exist */ #define TIF_ISOLATE_BP 8/* Run process with isolated BP */ #define TIF_ISOLATE_BP_GUEST 9/* Run KVM guests with isolated BP */
@@ -82,6 +83,7 @@ void arch_setup_new_exec(void);#define TIF_SYSCALL_TRACEPOINT 27/* syscall tracepoint instrumentation */ #define _TIF_NOTIFY_RESUME BIT(TIF_NOTIFY_RESUME) +#define _TIF_NOTIFY_SIGNAL BIT(TIF_NOTIFY_SIGNAL)#define _TIF_SIGPENDING BIT(TIF_SIGPENDING)#define _TIF_NEED_RESCHED BIT(TIF_NEED_RESCHED)#define _TIF_UPROBE BIT(TIF_UPROBE)
arch/s390/kernel/entry.S +6 -5
@@ -52,7 +52,8 @@ STACK_SIZE = 1 << STACK_SHIFT STACK_INIT = STACK_SIZE - STACK_FRAME_OVERHEAD - __PT_SIZE _TIF_WORK = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \ - _TIF_UPROBE | _TIF_GUARDED_STORAGE | _TIF_PATCH_PENDING) + _TIF_UPROBE | _TIF_GUARDED_STORAGE | _TIF_PATCH_PENDING | \ + _TIF_NOTIFY_SIGNAL) _TIF_TRACE = (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP | \ _TIF_SYSCALL_TRACEPOINT) _CIF_WORK = (_CIF_ASCE_PRIMARY | _CIF_ASCE_SECONDARY | _CIF_FPU)
@@ -481,8 +482,8 @@ ENTRY(system_call) #endif TSTMSK __PT_FLAGS(%r11),_PIF_SYSCALL_RESTART jo .Lsysc_syscall_restart - TSTMSK __TI_flags(%r12),_TIF_SIGPENDING - jo .Lsysc_sigpending + TSTMSK __TI_flags(%r12),(_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL) + jnz .Lsysc_sigpending TSTMSK __TI_flags(%r12),_TIF_NOTIFY_RESUME jo .Lsysc_notify_resume TSTMSK __LC_CPU_FLAGS,(_CIF_ASCE_PRIMARY|_CIF_ASCE_SECONDARY)
@@ -863,8 +864,8 @@ ENTRY(io_int_handler) TSTMSK __TI_flags(%r12),_TIF_PATCH_PENDING jo .Lio_patch_pending #endif - TSTMSK __TI_flags(%r12),_TIF_SIGPENDING - jo .Lio_sigpending + TSTMSK __TI_flags(%r12),(_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL) + jnz .Lio_sigpending TSTMSK __TI_flags(%r12),_TIF_NOTIFY_RESUME jo .Lio_notify_resume TSTMSK __TI_flags(%r12),_TIF_GUARDED_STORAGE
arch/s390/kernel/signal.c +1 -1
@@ -472,7 +472,7 @@ void do_signal(struct pt_regs *regs) current->thread.system_call =test_pt_regs_flag (regs,PIF_SYSCALL ) ? regs->int_code :0 ; -if (get_signal (&ksig)) { +if (test_thread_flag (TIF_SIGPENDING ) &&get_signal (&ksig)) {/* Whee! Actually deliver the signal. */ if (current->thread.system_call) { regs->int_code = current->thread.system_call;
Greg Kroah-Hartman
maintainerPATCH 26/63 um: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit a5b3cd32ff238b87e94d47b927aff117e22d13c0 ]
Wire up TIF_NOTIFY_SIGNAL handling for um.
--- arch/um/include/asm/thread_info.h | 2 ++ arch/um/kernel/process.c | 3 ++- 2 files changed, 4 insertions(+), 1 deletion(-)
arch/um/include/asm/thread_info.h +2 -0
@@ -57,6 +57,7 @@ static inline struct thread_info *curren#define TIF_SYSCALL_TRACE 0/* syscall trace active */ #define TIF_SIGPENDING 1/* signal pending */ #define TIF_NEED_RESCHED 2/* rescheduling necessary */ +#define TIF_NOTIFY_SIGNAL 3/* signal notifications exist */ #define TIF_RESTART_BLOCK 4#define TIF_MEMDIE 5/* is terminating due to OOM killer */ #define TIF_SYSCALL_AUDIT 6
@@ -68,6 +69,7 @@ static inline struct thread_info *curren#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_MEMDIE (1 << TIF_MEMDIE)#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)#define _TIF_SECCOMP (1 << TIF_SECCOMP)
arch/um/kernel/process.c +2 -1
@@ -99,7 +99,8 @@ void interrupt_end(void)if (need_resched ())schedule (); -if (test_thread_flag (TIF_SIGPENDING )) +if (test_thread_flag (TIF_SIGPENDING ) || +test_thread_flag (TIF_NOTIFY_SIGNAL ))do_signal (regs);if (test_thread_flag (TIF_NOTIFY_RESUME ))tracehook_notify_resume (regs);
Greg Kroah-Hartman
maintainerPATCH 27/63 sh: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 6d3a273355e3c8471ddf9e8ce9a7cc4472bf1ccc ]
Wire up TIF_NOTIFY_SIGNAL handling for sh.
--- arch/sh/include/asm/thread_info.h | 4 +++- arch/sh/kernel/signal_32.c | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-)
arch/sh/include/asm/thread_info.h +3 -1
@@ -105,6 +105,7 @@ extern void init_thread_xstate(void);#define TIF_SYSCALL_TRACE 0/* syscall trace active */ #define TIF_SIGPENDING 1/* signal pending */ #define TIF_NEED_RESCHED 2/* rescheduling necessary */ +#define TIF_NOTIFY_SIGNAL 3/* signal notifications exist */ #define TIF_SINGLESTEP 4/* singlestepping active */ #define TIF_SYSCALL_AUDIT 5/* syscall auditing active */ #define TIF_SECCOMP 6/* secure computing */
@@ -116,6 +117,7 @@ extern void init_thread_xstate(void);#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP)#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)#define _TIF_SECCOMP (1 << TIF_SECCOMP)
@@ -132,7 +134,7 @@ extern void init_thread_xstate(void);#define _TIF_ALLWORK_MASK (_TIF_SYSCALL_TRACE | _TIF_SIGPENDING | \ _TIF_NEED_RESCHED | _TIF_SYSCALL_AUDIT | \ _TIF_SINGLESTEP | _TIF_NOTIFY_RESUME | \ - _TIF_SYSCALL_TRACEPOINT) + _TIF_SYSCALL_TRACEPOINT | _TIF_NOTIFY_SIGNAL)/* work to do on interrupt/exception return */ #define _TIF_WORK_MASK (_TIF_ALLWORK_MASK & ~(_TIF_SYSCALL_TRACE | \
arch/sh/kernel/signal_32.c +1 -1
@@ -499,7 +499,7 @@ asmlinkage void do_notify_resume(struct unsigned long thread_info_flags) {/* deal with pending signal delivery */ -if (thread_info_flags & _TIF_SIGPENDING) +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs, save_r0);if (thread_info_flags & _TIF_NOTIFY_RESUME)
Greg Kroah-Hartman
maintainerPATCH 28/63 openrisc: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit e181c0aa2e532af2b17128fbde699f8578cc0562 ]
Wire up TIF_NOTIFY_SIGNAL handling for openrisc.
--- arch/openrisc/include/asm/thread_info.h | 2 ++ arch/openrisc/kernel/signal.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-)
arch/openrisc/include/asm/thread_info.h +2 -0
@@ -98,6 +98,7 @@ register struct thread_info *current_thr#define TIF_SINGLESTEP 4/* restore singlestep on return to user * mode */ +#define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_SYSCALL_TRACEPOINT 8/* for ftrace syscall instrumentation */ #define TIF_RESTORE_SIGMASK 9#define TIF_POLLING_NRFLAG 16/* true if poll_idle() is polling * TIF_NEED_RESCHED
@@ -109,6 +110,7 @@ register struct thread_info *current_thr#define _TIF_SIGPENDING (1<<TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED)#define _TIF_SINGLESTEP (1<<TIF_SINGLESTEP) +#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL)#define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG)
arch/openrisc/kernel/signal.c +1 -1
@@ -299,7 +299,7 @@ do_work_pending(struct pt_regs *regs, unif (unlikely (!user_mode (regs)))return 0 ;local_irq_enable (); -if (thread_flags & _TIF_SIGPENDING) { +if (thread_flags & (_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL)) {int restart =do_signal (regs, syscall);if (unlikely (restart)) {/*
Greg Kroah-Hartman
maintainerPATCH 29/63 csky: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit f3924d763c8af4c5d441b666c01f4de03ac9449e ]
Wire up TIF_NOTIFY_SIGNAL handling for csky.
--- arch/csky/include/asm/thread_info.h | 5 ++++- arch/csky/kernel/signal.c | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-)
arch/csky/include/asm/thread_info.h +4 -1
@@ -64,6 +64,7 @@ static inline struct thread_info *curren#define TIF_SYSCALL_TRACE 4/* syscall trace active */ #define TIF_SYSCALL_TRACEPOINT 5/* syscall tracepoint instrumentation */ #define TIF_SYSCALL_AUDIT 6/* syscall auditing */ +#define TIF_NOTIFY_SIGNAL 7/* signal notifications exist */ #define TIF_POLLING_NRFLAG 16/* poll_idle() is TIF_NEED_RESCHED */ #define TIF_MEMDIE 18/* is terminating due to OOM killer */ #define TIF_RESTORE_SIGMASK 20/* restore signal mask in do_signal() */
@@ -75,6 +76,7 @@ static inline struct thread_info *curren#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_UPROBE (1 << TIF_UPROBE)#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG)#define _TIF_MEMDIE (1 << TIF_MEMDIE)
@@ -82,7 +84,8 @@ static inline struct thread_info *curren#define _TIF_SECCOMP (1 << TIF_SECCOMP)#define _TIF_WORK_MASK (_TIF_NEED_RESCHED | _TIF_SIGPENDING | \ - _TIF_NOTIFY_RESUME | _TIF_UPROBE) + _TIF_NOTIFY_RESUME | _TIF_UPROBE | \ + _TIF_NOTIFY_SIGNAL)#define _TIF_SYSCALL_WORK (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | \ _TIF_SYSCALL_TRACEPOINT | _TIF_SECCOMP)
arch/csky/kernel/signal.c +1 -1
@@ -261,7 +261,7 @@ asmlinkage void do_notify_resume(structuprobe_notify_resume (regs);/* Handle pending signal delivery */ -if (thread_info_flags & _TIF_SIGPENDING) +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs);if (thread_info_flags & _TIF_NOTIFY_RESUME) {
Greg Kroah-Hartman
maintainerPATCH 30/63 hexagon: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit aeec8193578a71d0aee21218351849d38121ce90 ]
Wire up TIF_NOTIFY_SIGNAL handling for hexagon.
--- arch/hexagon/include/asm/thread_info.h | 2 ++ arch/hexagon/kernel/process.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-)
arch/hexagon/include/asm/thread_info.h +2 -0
@@ -95,6 +95,7 @@ register struct thread_info *__current_t#define TIF_NEED_RESCHED 3/* rescheduling necessary */ #define TIF_SINGLESTEP 4/* restore ss @ return to usr mode */ #define TIF_RESTORE_SIGMASK 6/* restore sig mask in do_signal() */ +#define TIF_NOTIFY_SIGNAL 7/* signal notifications exist */ /* true if poll_idle() is polling TIF_NEED_RESCHED */ #define TIF_MEMDIE 17/* OOM killer killed process */
@@ -103,6 +104,7 @@ register struct thread_info *__current_t#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)#define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)/* work to do on interrupt/exception return - All but TIF_SYSCALL_TRACE */ #define _TIF_WORK_MASK (0x0000FFFF & ~_TIF_SYSCALL_TRACE)
arch/hexagon/kernel/process.c +1 -1
@@ -174,7 +174,7 @@ int do_work_pending(struct pt_regs *regsreturn 1 ; } -if (thread_info_flags & _TIF_SIGPENDING) { +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) {do_signal (regs);return 1 ; }
Greg Kroah-Hartman
maintainerPATCH 31/63 microblaze: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit f4ea089e429e0d366cd1a34a2cbe3c7b13d98d75 ]
Wire up TIF_NOTIFY_SIGNAL handling for microblaze.
--- arch/microblaze/include/asm/thread_info.h | 2 ++ arch/microblaze/kernel/signal.c | 3 ++- 2 files changed, 4 insertions(+), 1 deletion(-)
arch/microblaze/include/asm/thread_info.h +2 -0
@@ -107,6 +107,7 @@ static inline struct thread_info *curren#define TIF_NEED_RESCHED 3/* rescheduling necessary */ /* restore singlestep on return to user mode */ #define TIF_SINGLESTEP 4 +#define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_MEMDIE 6/* is terminating due to OOM killer */ #define TIF_SYSCALL_AUDIT 9/* syscall auditing active */ #define TIF_SECCOMP 10/* secure computing */
@@ -119,6 +120,7 @@ static inline struct thread_info *curren#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)#define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG)#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)#define _TIF_SECCOMP (1 << TIF_SECCOMP)
arch/microblaze/kernel/signal.c +2 -1
@@ -313,7 +313,8 @@ static void do_signal(struct pt_regs *re asmlinkage void do_notify_resume(struct pt_regs *regs, int in_syscall) { -if (test_thread_flag (TIF_SIGPENDING )) +if (test_thread_flag (TIF_SIGPENDING ) || +test_thread_flag (TIF_NOTIFY_SIGNAL ))do_signal (regs, in_syscall);if (test_thread_flag (TIF_NOTIFY_RESUME ))
Greg Kroah-Hartman
maintainerPATCH 32/63 arm: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 32d59773da38cd83e497a70eb9754d4bbae3aeae ]
Wire up TIF_NOTIFY_SIGNAL handling for arm.
--- arch/arm/include/asm/thread_info.h | 7 ++++++- arch/arm/kernel/entry-common.S | 6 +++--- arch/arm/kernel/entry-v7m.S | 2 +- arch/arm/kernel/signal.c | 2 +- 4 files changed, 11 insertions(+), 6 deletions(-)
arch/arm/include/asm/thread_info.h +6 -1
@@ -126,6 +126,8 @@ extern int vfp_restore_user_hwstate(stru* thread information flags: * TIF_USEDFPU - FPU was used by this task this quantum (SMP) * TIF_POLLING_NRFLAG - true if poll_idle() is polling TIF_NEED_RESCHED +* +* Any bit in the range of 0..15 will cause do_work_pending() to be invoked. */ #define TIF_SIGPENDING 0/* signal pending */ #define TIF_NEED_RESCHED 1/* rescheduling necessary */
@@ -135,6 +137,7 @@ extern int vfp_restore_user_hwstate(stru#define TIF_SYSCALL_AUDIT 5/* syscall auditing active */ #define TIF_SYSCALL_TRACEPOINT 6/* syscall tracepoint instrumentation */ #define TIF_SECCOMP 7/* seccomp syscall filtering active */ +#define TIF_NOTIFY_SIGNAL 8/* signal notifications exist */ #define TIF_USING_IWMMXT 17#define TIF_MEMDIE 18/* is terminating due to OOM killer */
@@ -148,6 +151,7 @@ extern int vfp_restore_user_hwstate(stru#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)#define _TIF_SECCOMP (1 << TIF_SECCOMP) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_USING_IWMMXT (1 << TIF_USING_IWMMXT)/* Checks for any syscall work in entry-common.S */
@@ -158,7 +162,8 @@ extern int vfp_restore_user_hwstate(stru* Change these and you break ASM code in entry-common.S */ #define _TIF_WORK_MASK (_TIF_NEED_RESCHED | _TIF_SIGPENDING | \ - _TIF_NOTIFY_RESUME | _TIF_UPROBE) + _TIF_NOTIFY_RESUME | _TIF_UPROBE | \ + _TIF_NOTIFY_SIGNAL)#endif /* __KERNEL__ */ #endif /* __ASM_ARM_THREAD_INFO_H */
arch/arm/kernel/entry-common.S +3 -3
@@ -53,7 +53,7 @@ __ret_fast_syscall: cmp r2, #TASK_SIZE blne addr_limit_check_failed ldr r1, [tsk, #TI_FLAGS] @ re-check for syscall tracing - tst r1, #_TIF_SYSCALL_WORK | _TIF_WORK_MASK + movs r1, r1, lsl #16 bne fast_work_pending
@@ -90,7 +90,7 @@ __ret_fast_syscall: cmp r2, #TASK_SIZE blne addr_limit_check_failed ldr r1, [tsk, #TI_FLAGS] @ re-check for syscall tracing - tst r1, #_TIF_SYSCALL_WORK | _TIF_WORK_MASK + movs r1, r1, lsl #16 beq no_work_pending UNWIND(.fnend ) ENDPROC(ret_fast_syscall)
@@ -131,7 +131,7 @@ ENTRY(ret_to_user_from_irq) cmp r2, #TASK_SIZE blne addr_limit_check_failed ldr r1, [tsk, #TI_FLAGS] - tst r1, #_TIF_WORK_MASK + movs r1, r1, lsl #16 bne slow_work_pending no_work_pending: asm_trace_hardirqs_on save = 0
arch/arm/kernel/entry-v7m.S +1 -1
@@ -59,7 +59,7 @@ __irq_entry: get_thread_info tsk ldr r2, [tsk, #TI_FLAGS] - tst r2, #_TIF_WORK_MASK + movs r2, r2, lsl #16 beq 2f @ no work pending mov r0, #V7M_SCB_ICSR_PENDSVSET str r0, [r1, V7M_SCB_ICSR] @ raise PendSV
arch/arm/kernel/signal.c +1 -1
@@ -655,7 +655,7 @@ do_work_pending(struct pt_regs *regs, unif (unlikely (!user_mode (regs)))return 0 ;local_irq_enable (); -if (thread_flags & _TIF_SIGPENDING) { +if (thread_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) {int restart =do_signal (regs, syscall);if (unlikely (restart)) {/*
Greg Kroah-Hartman
maintainerPATCH 33/63 xtensa: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit bec58f40d6c5372d812c93cc3947f3bc97440e57 ]
Wire up TIF_NOTIFY_SIGNAL handling for xtensa.
Thanks to Max Filippov <[email protected]> for making the asm correct.
--- arch/xtensa/include/asm/thread_info.h | 5 ++++- arch/xtensa/kernel/entry.S | 4 ++-- arch/xtensa/kernel/signal.c | 3 ++- 3 files changed, 8 insertions(+), 4 deletions(-)
arch/xtensa/include/asm/thread_info.h +4 -1
@@ -111,18 +111,21 @@ static inline struct thread_info *curren#define TIF_NEED_RESCHED 2/* rescheduling necessary */ #define TIF_SINGLESTEP 3/* restore singlestep on return to user mode */ #define TIF_SYSCALL_TRACEPOINT 4/* syscall tracepoint instrumentation */ -#define TIF_MEMDIE 5/* is terminating due to OOM killer */ +#define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_RESTORE_SIGMASK 6/* restore signal mask in do_signal() */ #define TIF_NOTIFY_RESUME 7/* callback before returning to user */ #define TIF_DB_DISABLED 8/* debug trap disabled for syscall */ #define TIF_SYSCALL_AUDIT 9/* syscall auditing active */ #define TIF_SECCOMP 10/* secure computing */ +#define TIF_MEMDIE 11/* is terminating due to OOM killer */ #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE)#define _TIF_SIGPENDING (1<<TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED)#define _TIF_SINGLESTEP (1<<TIF_SINGLESTEP)#define _TIF_SYSCALL_TRACEPOINT (1<<TIF_SYSCALL_TRACEPOINT) +#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL) +#define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME)#define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT)#define _TIF_SECCOMP (1<<TIF_SECCOMP)
arch/xtensa/kernel/entry.S +2 -2
@@ -500,8 +500,8 @@ common_exception_return: */ _bbsi.l a4, TIF_NEED_RESCHED, 3f - _bbsi.l a4, TIF_NOTIFY_RESUME, 2f - _bbci.l a4, TIF_SIGPENDING, 5f + movi a2, _TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NOTIFY_SIGNAL + bnone a4, a2, 5f 2: l32i a4, a1, PT_DEPC bgeui a4, VALID_DOUBLE_EXCEPTION_ADDRESS, 4f
arch/xtensa/kernel/signal.c +2 -1
@@ -498,7 +498,8 @@ static void do_signal(struct pt_regs *revoid do_notify_resume (struct pt_regs *regs) { -if (test_thread_flag (TIF_SIGPENDING )) +if (test_thread_flag (TIF_SIGPENDING ) || +test_thread_flag (TIF_NOTIFY_SIGNAL ))do_signal (regs);if (test_thread_flag (TIF_NOTIFY_RESUME ))
Greg Kroah-Hartman
maintainerPATCH 34/63 alpha: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 5a9a8897c253a075805401d38d987ec1ac1824b6 ]
Wire up TIF_NOTIFY_SIGNAL handling for alpha.
--- arch/alpha/include/asm/thread_info.h | 2 ++ arch/alpha/kernel/entry.S | 2 +- arch/alpha/kernel/signal.c | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-)
arch/alpha/include/asm/thread_info.h +2 -0
@@ -62,6 +62,7 @@ register struct thread_info *__current_t#define TIF_SIGPENDING 2/* signal pending */ #define TIF_NEED_RESCHED 3/* rescheduling necessary */ #define TIF_SYSCALL_AUDIT 4/* syscall audit active */ +#define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_DIE_IF_KERNEL 9/* dik recursion lock */ #define TIF_MEMDIE 13/* is terminating due to OOM killer */ #define TIF_POLLING_NRFLAG 14/* idle is polling for TIF_NEED_RESCHED */
@@ -71,6 +72,7 @@ register struct thread_info *__current_t#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED)#define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME)#define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT) +#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL)#define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG)/* Work to do on interrupt/exception return. */
arch/alpha/kernel/entry.S +1 -1
@@ -544,7 +544,7 @@ $ret_success: .align 4 .type work_pending, @function work_pending: - and $17, _TIF_NOTIFY_RESUME | _TIF_SIGPENDING, $2 + and $17, _TIF_NOTIFY_RESUME | _TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL, $2 bne $2, $work_notifysig $work_resched:
arch/alpha/kernel/signal.c +1 -1
@@ -527,7 +527,7 @@ do_work_pending(struct pt_regs *regs, unschedule (); }else {local_irq_enable (); -if (thread_flags & _TIF_SIGPENDING) { +if (thread_flags & (_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL)) {do_signal (regs, r0, r19); r0 =0 ; }else {
Greg Kroah-Hartman
maintainerPATCH 35/63 c6x: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 6d665a4d8b4264def0fbb72da3a500d9904ffe3e ]
Wire up TIF_NOTIFY_SIGNAL handling for c6x.
--- arch/c6x/include/asm/thread_info.h | 1 + arch/c6x/kernel/asm-offsets.c | 1 + arch/c6x/kernel/signal.c | 3 ++- 3 files changed, 4 insertions(+), 1 deletion(-)
arch/c6x/include/asm/thread_info.h +1 -0
@@ -82,6 +82,7 @@ struct thread_info *current_thread_info(#define TIF_SIGPENDING 2/* signal pending */ #define TIF_NEED_RESCHED 3/* rescheduling necessary */ #define TIF_RESTORE_SIGMASK 4/* restore signal mask in do_signal() */ +#define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_MEMDIE 17/* OOM killer killed process */
arch/c6x/kernel/asm-offsets.c +1 -0
@@ -116,6 +116,7 @@ void foo(void)DEFINE (_TIF_NOTIFY_RESUME, (1 <<TIF_NOTIFY_RESUME ));DEFINE (_TIF_SIGPENDING, (1 <<TIF_SIGPENDING ));DEFINE (_TIF_NEED_RESCHED, (1 <<TIF_NEED_RESCHED )); +DEFINE (_TIF_NOTIFY_SIGNAL, (1 <<TIF_NOTIFY_SIGNAL ));DEFINE (_TIF_ALLWORK_MASK,TIF_ALLWORK_MASK );DEFINE (_TIF_WORK_MASK,TIF_WORK_MASK );
arch/c6x/kernel/signal.c +2 -1
@@ -13,6 +13,7 @@#include <linux/syscalls.h> #include <linux/tracehook.h> +#include <asm/asm-offsets.h> #include <asm/ucontext.h> #include <asm/cacheflush.h>
@@ -313,7 +314,7 @@ asmlinkage void do_notify_resume(struct int syscall) {/* deal with pending signal delivery */ -if (thread_info_flags & (1 <<TIF_SIGPENDING )) +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs, syscall);if (thread_info_flags & (1 <<TIF_NOTIFY_RESUME ))
Greg Kroah-Hartman
maintainerPATCH 36/63 h8300: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 2f9799ad0111ee742ccc02dd2ea2c87646746fc1 ]
Wire up TIF_NOTIFY_SIGNAL handling for h8300.
--- arch/h8300/include/asm/thread_info.h | 4 +++- arch/h8300/kernel/signal.c | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-)
arch/h8300/include/asm/thread_info.h +3 -1
@@ -73,6 +73,7 @@ static inline struct thread_info *curren#define TIF_SYSCALL_AUDIT 7/* syscall auditing active */ #define TIF_SYSCALL_TRACEPOINT 8/* for ftrace syscall instrumentation */ #define TIF_POLLING_NRFLAG 9/* true if poll_idle() is polling TIF_NEED_RESCHED */ +#define TIF_NOTIFY_SIGNAL 10/* signal notifications exist */ /* as above, but as bit values */ #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)
@@ -83,6 +84,7 @@ static inline struct thread_info *curren#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)/* work to do in syscall trace */ #define _TIF_WORK_SYSCALL_MASK (_TIF_SYSCALL_TRACE | _TIF_SINGLESTEP | \
@@ -92,7 +94,7 @@ static inline struct thread_info *curren#define _TIF_ALLWORK_MASK (_TIF_SYSCALL_TRACE | _TIF_SIGPENDING | \ _TIF_NEED_RESCHED | _TIF_SYSCALL_AUDIT | \ _TIF_SINGLESTEP | _TIF_NOTIFY_RESUME | \ - _TIF_SYSCALL_TRACEPOINT) + _TIF_SYSCALL_TRACEPOINT | _TIF_NOTIFY_SIGNAL)/* work to do on interrupt/exception return */ #define _TIF_WORK_MASK (_TIF_ALLWORK_MASK & ~(_TIF_SYSCALL_TRACE | \
arch/h8300/kernel/signal.c +1 -1
@@ -279,7 +279,7 @@ static void do_signal(struct pt_regs *re asmlinkage void do_notify_resume(struct pt_regs *regs, u32 thread_info_flags) { -if (thread_info_flags & _TIF_SIGPENDING) +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs);if (thread_info_flags & _TIF_NOTIFY_RESUME)
Greg Kroah-Hartman
maintainerPATCH 37/63 ia64: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit b269c229b0e89aedb7943c06673b56b6052cf5e5 ]
Wire up TIF_NOTIFY_SIGNAL handling for ia64.
--- arch/ia64/include/asm/thread_info.h | 4 +++- arch/ia64/kernel/process.c | 3 ++- 2 files changed, 5 insertions(+), 2 deletions(-)
arch/ia64/include/asm/thread_info.h +3 -1
@@ -103,6 +103,7 @@ struct thread_info {#define TIF_SYSCALL_TRACE 2/* syscall trace active */ #define TIF_SYSCALL_AUDIT 3/* syscall auditing active */ #define TIF_SINGLESTEP 4/* restore singlestep on return to user mode */ +#define TIF_NOTIFY_SIGNAL 5/* signal notification exist */ #define TIF_NOTIFY_RESUME 6/* resumption notification requested */ #define TIF_MEMDIE 17/* is terminating due to OOM killer */ #define TIF_MCA_INIT 18/* this task is processing MCA or INIT */
@@ -115,6 +116,7 @@ struct thread_info {#define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP)#define _TIF_SYSCALL_TRACEAUDIT (_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SINGLESTEP)#define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)#define _TIF_MCA_INIT (1 << TIF_MCA_INIT)
@@ -124,7 +126,7 @@ struct thread_info {/* "work to do on user-return" bits */ #define TIF_ALLWORK_MASK (_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SYSCALL_AUDIT|\ - _TIF_NEED_RESCHED|_TIF_SYSCALL_TRACE) + _TIF_NEED_RESCHED|_TIF_SYSCALL_TRACE|_TIF_NOTIFY_SIGNAL)/* like TIF_ALLWORK_BITS but sans TIF_SYSCALL_TRACE or TIF_SYSCALL_AUDIT */ #define TIF_WORK_MASK (TIF_ALLWORK_MASK&~(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT))
arch/ia64/kernel/process.c +2 -1
@@ -171,7 +171,8 @@ do_notify_resume_user(sigset_t *unused, }/* deal with pending signal delivery */ -if (test_thread_flag (TIF_SIGPENDING )) { +if (test_thread_flag (TIF_SIGPENDING ) || +test_thread_flag (TIF_NOTIFY_SIGNAL )) {local_irq_enable ();/* force interrupt enable */ ia64_do_signal (scr, in_syscall); }
Greg Kroah-Hartman
maintainerPATCH 38/63 nds32: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit b13e8bf615fe26fb6a6dfe1b5a1c65e1624dfee2 ]
Wire up TIF_NOTIFY_SIGNAL handling for nds32.
--- arch/nds32/include/asm/thread_info.h | 2 ++ arch/nds32/kernel/ex-exit.S | 2 +- arch/nds32/kernel/signal.c | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-)
arch/nds32/include/asm/thread_info.h +2 -0
@@ -48,6 +48,7 @@ struct thread_info {#define TIF_NEED_RESCHED 2#define TIF_SINGLESTEP 3#define TIF_NOTIFY_RESUME 4/* callback before returning to user */ +#define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_SYSCALL_TRACE 8#define TIF_POLLING_NRFLAG 17#define TIF_MEMDIE 18
@@ -57,6 +58,7 @@ struct thread_info {#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)#define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP)#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG)
arch/nds32/kernel/ex-exit.S +1 -1
@@ -120,7 +120,7 @@ work_pending: andi $p1, $r1, #_TIF_NEED_RESCHED bnez $p1, work_resched - andi $p1, $r1, #_TIF_SIGPENDING|#_TIF_NOTIFY_RESUME + andi $p1, $r1, #_TIF_SIGPENDING|#_TIF_NOTIFY_RESUME|#_TIF_NOTIFY_SIGNAL beqz $p1, no_work_pending move $r0, $sp ! 'regs'
arch/nds32/kernel/signal.c +1 -1
@@ -376,7 +376,7 @@ static void do_signal(struct pt_regs *re asmlinkage voiddo_notify_resume (struct pt_regs *regs,unsigned int thread_flags) { -if (thread_flags & _TIF_SIGPENDING) +if (thread_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs);if (thread_flags & _TIF_NOTIFY_RESUME)
Greg Kroah-Hartman
maintainerPATCH 39/63 riscv: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 24a31b81e38309b1604f24520110aae1f83f3cbf ]
Wire up TIF_NOTIFY_SIGNAL handling for riscv.
--- arch/riscv/include/asm/thread_info.h | 5 ++++- arch/riscv/kernel/signal.c | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-)
arch/riscv/include/asm/thread_info.h +4 -1
@@ -80,6 +80,7 @@ struct thread_info {#define TIF_SYSCALL_TRACEPOINT 6/* syscall tracepoint instrumentation */ #define TIF_SYSCALL_AUDIT 7/* syscall auditing */ #define TIF_SECCOMP 8/* syscall secure computing */ +#define TIF_NOTIFY_SIGNAL 9/* signal notifications exist */ #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)#define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME)
@@ -88,9 +89,11 @@ struct thread_info {#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)#define _TIF_SECCOMP (1 << TIF_SECCOMP) +#define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)#define _TIF_WORK_MASK \ - (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING | _TIF_NEED_RESCHED) + (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING | _TIF_NEED_RESCHED | \ + _TIF_NOTIFY_SIGNAL)#define _TIF_SYSCALL_WORK \ (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_TRACEPOINT | _TIF_SYSCALL_AUDIT | \
arch/riscv/kernel/signal.c +1 -1
@@ -312,7 +312,7 @@ asmlinkage __visible void do_notify_resu unsigned long thread_info_flags) {/* Handle pending signal delivery */ -if (thread_info_flags & _TIF_SIGPENDING) +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs);if (thread_info_flags & _TIF_NOTIFY_RESUME)
Greg Kroah-Hartman
maintainerPATCH 40/63 sparc: add support for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit f50a7052f5e70ee7a6a5e2ed08660994dc3df2a5 ]
Wire up TIF_NOTIFY_SIGNAL handling for sparc.
--- arch/sparc/include/asm/thread_info_32.h | 4 +++- arch/sparc/include/asm/thread_info_64.h | 6 ++++-- arch/sparc/kernel/signal_32.c | 2 +- arch/sparc/kernel/signal_64.c | 2 +- 4 files changed, 9 insertions(+), 5 deletions(-)
arch/sparc/include/asm/thread_info_32.h +3 -1
@@ -104,6 +104,7 @@ register struct thread_info *current_thr#define TIF_SIGPENDING 2/* signal pending */ #define TIF_NEED_RESCHED 3/* rescheduling necessary */ #define TIF_RESTORE_SIGMASK 4/* restore signal mask in do_signal() */ +#define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_USEDFPU 8/* FPU was used by this task * this quantum (SMP) */ #define TIF_POLLING_NRFLAG 9/* true if poll_idle() is polling
@@ -115,11 +116,12 @@ register struct thread_info *current_thr#define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME)#define _TIF_SIGPENDING (1<<TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) +#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL)#define _TIF_USEDFPU (1<<TIF_USEDFPU)#define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG)#define _TIF_DO_NOTIFY_RESUME_MASK (_TIF_NOTIFY_RESUME | \ - _TIF_SIGPENDING) + _TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)#define is_32bit_task () (1)
arch/sparc/include/asm/thread_info_64.h +4 -2
@@ -180,7 +180,7 @@ extern struct thread_info *current_threa#define TIF_NOTIFY_RESUME 1/* callback before returning to user */ #define TIF_SIGPENDING 2/* signal pending */ #define TIF_NEED_RESCHED 3/* rescheduling necessary */ -/* flag bit 4 is available */ +#define TIF_NOTIFY_SIGNAL 4/* signal notifications exist */ #define TIF_UNALIGNED 5/* allowed to do unaligned accesses */ #define TIF_UPROBE 6/* breakpointed or singlestepped */ #define TIF_32BIT 7/* 32-bit binary */
@@ -200,6 +200,7 @@ extern struct thread_info *current_threa#define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME)#define _TIF_SIGPENDING (1<<TIF_SIGPENDING)#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) +#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL)#define _TIF_UNALIGNED (1<<TIF_UNALIGNED)#define _TIF_UPROBE (1<<TIF_UPROBE)#define _TIF_32BIT (1<<TIF_32BIT)
@@ -213,7 +214,8 @@ extern struct thread_info *current_threa _TIF_DO_NOTIFY_RESUME_MASK | \ _TIF_NEED_RESCHED)#define _TIF_DO_NOTIFY_RESUME_MASK (_TIF_NOTIFY_RESUME | \ - _TIF_SIGPENDING | _TIF_UPROBE) + _TIF_SIGPENDING | _TIF_UPROBE | \ + _TIF_NOTIFY_SIGNAL)#define is_32bit_task () (test_thread_flag(TIF_32BIT))
arch/sparc/kernel/signal_32.c +1 -1
@@ -521,7 +521,7 @@ static void do_signal(struct pt_regs *revoid do_notify_resume (struct pt_regs *regs,unsigned long orig_i0,unsigned long thread_info_flags) { -if (thread_info_flags & _TIF_SIGPENDING) +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs, orig_i0);if (thread_info_flags & _TIF_NOTIFY_RESUME)tracehook_notify_resume (regs);
arch/sparc/kernel/signal_64.c +1 -1
@@ -549,7 +549,7 @@ void do_notify_resume(struct pt_regs *reuser_exit ();if (thread_info_flags & _TIF_UPROBE)uprobe_notify_resume (regs); -if (thread_info_flags & _TIF_SIGPENDING) +if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))do_signal (regs, orig_i0);if (thread_info_flags & _TIF_NOTIFY_RESUME)tracehook_notify_resume (regs);
Greg Kroah-Hartman
maintainerPATCH 41/63 ia64: dont call handle_signal() unless theres actually a signal queued
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit f5f4fc4649ae542b1a25670b17aaf3cbb6187acc ]
Sergei and John both reported that ia64 failed to boot in 5.11, and it was related to signals. Turns out the ia64 signal handling is a bit odd, it doesn't check the return value of get_signal() for whether there's a signal to deliver or not. With the introduction of TIF_NOTIFY_SIGNAL, then task_work could trigger it.
Fix it by only calling handle_signal() if we actually have a real signal to deliver. This brings it in line with all other archs, too.
--- arch/ia64/kernel/signal.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/ia64/kernel/signal.c +2 -1
@@ -341,7 +341,8 @@ ia64_do_signal (struct sigscratch *scr,* need to push through a forced SIGSEGV. */ while (1 ) { -get_signal (&ksig); +if (!get_signal (&ksig)) +break ;/* * get_signal() may have run a debugger (via notify_parent())
Greg Kroah-Hartman
maintainerPATCH 42/63 ARC: unbork 5.11 bootup: fix snafu in _TIF_NOTIFY_SIGNAL handling
In reply to Greg Kroah-HartmanFrom: Vineet Gupta <[email protected]>
[ Upstream commit bb12433bf56e76789c6b08b36c546f745a6aa6e1 ]
Linux 5.11.rcX was failing to boot on ARC HSDK board. Turns out we have a couple of issues, this being the first one, and I'm to blame as I didn't pay attention during review.
TIF_NOTIFY_SIGNAL support requires checking multiple TIF_* bits in kernel return code path. Old code only needed to check a single bit so BBIT0 <TIF_SIGPENDING> worked. New code needs to check multiple bits so AND <bit-mask> instruction. So needs to use bit mask variant _TIF_SIGPENDING
--- arch/arc/kernel/entry.S | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arc/kernel/entry.S +1 -1
@@ -308,7 +308,7 @@ resume_user_mode_begin: mov r0, sp ; pt_regs for arg to do_signal()/do_notify_resume() GET_CURR_THR_INFO_FLAGS r9 - and.f 0, r9, TIF_SIGPENDING|TIF_NOTIFY_SIGNAL + and.f 0, r9, _TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL bz .Lchk_notify_resume ; Normal Trap/IRQ entry only saves Scratch (caller-saved) regs
Greg Kroah-Hartman
maintainerPATCH 43/63 alpha: fix TIF_NOTIFY_SIGNAL handling
In reply to Greg Kroah-HartmanFrom: Al Viro <[email protected]>
[ Upstream commit e2c7554cc6d85f95e3c6635f270ec839ab9fe05e ]
it needs to be added to _TIF_WORK_MASK, or we might not reach do_work_pending() in the first place...
--- arch/alpha/include/asm/thread_info.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/alpha/include/asm/thread_info.h +1 -1
@@ -77,7 +77,7 @@ register struct thread_info *__current_t/* Work to do on interrupt/exception return. */ #define _TIF_WORK_MASK (_TIF_SIGPENDING | _TIF_NEED_RESCHED | \ - _TIF_NOTIFY_RESUME) + _TIF_NOTIFY_RESUME | _TIF_NOTIFY_SIGNAL)/* Work to do on any return to userspace. */ #define _TIF_ALLWORK_MASK (_TIF_WORK_MASK \
Greg Kroah-Hartman
maintainerPATCH 44/63 task_work: remove legacy TWA_SIGNAL path
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 03941ccfda161c2680147fa5ab92aead2a79cac1 ]
All archs now support TIF_NOTIFY_SIGNAL.
--- kernel/task_work.c | 30 +----------------------------- 1 file changed, 1 insertion(+), 29 deletions(-)
kernel/task_work.c +1 -29
@@ -5,34 +5,6 @@static struct callback_head work_exited;/* all we need is ->next == NULL */ -/* -* TWA_SIGNAL signaling - use TIF_NOTIFY_SIGNAL, if available, as it's faster -* than TIF_SIGPENDING as there's no dependency on ->sighand. The latter is -* shared for threads, and can cause contention on sighand->lock. Even for -* the non-threaded case TIF_NOTIFY_SIGNAL is more efficient, as no locking -* or IRQ disabling is involved for notification (or running) purposes. -*/ -static void task_work_notify_signal (struct task_struct *task) -{ -#if defined(TIF_NOTIFY_SIGNAL ) -set_notify_signal (task); -#else -unsigned long flags; - -/* -* Only grab the sighand lock if we don't already have some -* task_work pending. This pairs with the smp_store_mb() -* in get_signal(), see comment there. -*/ -if (!(READ_ONCE (task->jobctl) &JOBCTL_TASK_WORK ) && -lock_task_sighand (task, &flags)) { - task->jobctl |=JOBCTL_TASK_WORK ; -signal_wake_up (task,0 ); -unlock_task_sighand (task, &flags); - } -#endif -} -/** * task_work_add - ask the @task to execute @work->func() * @task: the task which should run the callback
@@ -76,7 +48,7 @@ int task_work_add(struct task_struct *taset_notify_resume (task);break ;case TWA_SIGNAL : -task_work_notify_signal (task); +set_notify_signal (task);break ;default :WARN_ON_ONCE (1 );
Greg Kroah-Hartman
maintainerPATCH 45/63 kernel: remove checking for TIF_NOTIFY_SIGNAL
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit e296dc4996b8094ccde45d19090d804c4103513e ]
It's available everywhere now, no need to check or add dummy defines.
--- include/linux/entry-common.h | 4 ---- include/linux/sched/signal.h | 2 -- include/linux/tracehook.h | 4 ---- kernel/signal.c | 2 -- 4 files changed, 12 deletions(-)
include/linux/entry-common.h +0 -4
@@ -37,10 +37,6 @@# define _TIF_UPROBE (0)#endif -#ifndef _TIF_NOTIFY_SIGNAL -# define _TIF_NOTIFY_SIGNAL (0) -#endif -/* * TIF flags handled in syscall_enter_from_user_mode() */
include/linux/sched/signal.h +0 -2
@@ -361,7 +361,6 @@ static inline int task_sigpending(structstatic inline int signal_pending (struct task_struct *p) { -#if defined(TIF_NOTIFY_SIGNAL )/* * TIF_NOTIFY_SIGNAL isn't really a signal, but it requires the same * behavior in terms of ensuring that we break out of wait loops
@@ -369,7 +368,6 @@ static inline int signal_pending(struct*/ if (unlikely (test_tsk_thread_flag (p,TIF_NOTIFY_SIGNAL )))return 1 ; -#endif return task_sigpending (p); }
include/linux/tracehook.h +0 -4
@@ -205,12 +205,10 @@ static inline void tracehook_notify_resu*/ static inline void tracehook_notify_signal (void ) { -#if defined(TIF_NOTIFY_SIGNAL )clear_thread_flag (TIF_NOTIFY_SIGNAL );smp_mb__after_atomic ();if (current->task_works)task_work_run (); -#endif }/*
@@ -218,11 +216,9 @@ static inline void tracehook_notify_sign*/ static inline void set_notify_signal (struct task_struct *task) { -#if defined(TIF_NOTIFY_SIGNAL )if (!test_and_set_tsk_thread_flag (task,TIF_NOTIFY_SIGNAL ) && !wake_up_state (task,TASK_INTERRUPTIBLE ))kick_process (task); -#endif }#endif /* <linux/tracehook.h> */
kernel/signal.c +0 -2
@@ -2525,14 +2525,12 @@ bool get_signal(struct ksignal *ksig)* that the arch handlers don't all have to do it. If we get here * without TIF_SIGPENDING, just exit after running signal work. */ -#ifdef TIF_NOTIFY_SIGNAL if (!IS_ENABLED (CONFIG_GENERIC_ENTRY )) {if (test_thread_flag (TIF_NOTIFY_SIGNAL ))tracehook_notify_signal ();if (!task_sigpending (current))return false; } -#endif if (unlikely (uprobe_deny_signal ()))return false;
Greg Kroah-Hartman
maintainerPATCH 46/63 coredump: Limit what can interrupt coredumps
In reply to Greg Kroah-HartmanFrom: "Eric W. Biederman" <[email protected]>
[ Upstream commit 06af8679449d4ed282df13191fc52d5ba28ec536 ]
Olivier Langlois has been struggling with coredumps being incompletely written in processes using io_uring.
Quoted 10 lines · Olivier Langlois
io_uringis a big user oftask_workand any event thatio_uringmade a task waiting for that occurs during the core dump generation will generate aTIF_NOTIFY_SIGNAL.Here are the detailed steps of the problem:
1.io_uringcallsvfs_poll()to install a task to a file wait queue withio_async_wake()as the wakeup function cb fromio_arm_poll_handler()
2. wakeup function ends up callingtask_work_add()withTWA_SIGNAL
3.task_work_add()sets theTIF_NOTIFY_SIGNALbit by callingset_notify_signal()
The coredump code deliberately supports being interrupted by SIGKILL,
and depends upon prepare_signal to filter out all other signals. Now
that signal_pending includes wake ups for TIF_NOTIFY_SIGNAL this hack in dump_emitted by the coredump code no longer works.
Make the coredump code more robust by explicitly testing for all of the wakeup conditions the coredump code supports. This prevents new wakeup conditions from breaking the coredump code, as well as fixing the current issue.
The filesystem code that the coredump code uses already limits itself to only aborting on fatal_signal_pending. So it should not develop surprising wake-up reasons either.
v2: Don't remove the now unnecessary code in prepare_signal.
--- fs/coredump.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/coredump.c +1 -1
@@ -523,7 +523,7 @@ static bool dump_interrupted(void)* but then we need to teach dump_write() to restart and clear * TIF_SIGPENDING. */ -return signal_pending (current); +return fatal_signal_pending (current) ||freezing (current); }static void wait_for_dump_helpers (struct file *file)
Greg Kroah-Hartman
maintainerPATCH 47/63 kernel: allow fork with TIF_NOTIFY_SIGNAL pending
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 66ae0d1e2d9fe6ec70e73fcfdcf4b390e271c1ac ]
fork() fails if signal_pending() is true, but there are two conditions that can lead to that:
1) An actual signal is pending. We want fork to fail for that one, like we always have.
2) TIF_NOTIFY_SIGNAL is pending, because the task has pending task_work. We don't need to make it fail for that case.
Allow fork() to proceed if just task_work is pending, by changing the signal_pending() check to task_sigpending().
--- kernel/fork.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/fork.c +1 -1
@@ -1942,7 +1942,7 @@ static __latent_entropy struct task_strurecalc_sigpending ();spin_unlock_irq (¤t->sighand->siglock); retval = -ERESTARTNOINTR ; -if (signal_pending (current)) +if (task_sigpending (current)) goto fork_out; retval = -ENOMEM ;
Greg Kroah-Hartman
maintainerPATCH 48/63 entry/kvm: Exit to user mode when TIF_NOTIFY_SIGNAL is set
In reply to Greg Kroah-HartmanFrom: Seth Forshee <[email protected]>
[ Upstream commit 3e684903a8574ffc9475fdf13c4780a7adb506ad ]
A livepatch transition may stall indefinitely when a kvm vCPU is heavily loaded. To the host, the vCPU task is a user thread which is spending a very long time in the ioctl(KVM_RUN) syscall. During livepatch transition, set_notify_signal() will be called on such tasks to interrupt the syscall so that the task can be transitioned. This interrupts guest execution, but when xfer_to_guest_mode_work() sees that TIF_NOTIFY_SIGNAL is set but not TIF_SIGPENDING it concludes that an exit to user mode is unnecessary, and guest execution is resumed without transitioning the task for the livepatch.
This handling of TIF_NOTIFY_SIGNAL is incorrect, as set_notify_signal() is expected to break tasks out of interruptible kernel loops and cause them to return to userspace. Change xfer_to_guest_mode_work() to handle TIF_NOTIFY_SIGNAL the same as TIF_SIGPENDING, signaling to the vCPU run loop that an exit to userpsace is needed. Any pending task_work will be run when get_signal() is called from exit_to_user_mode_loop(), so there is no longer any need to run task work from xfer_to_guest_mode_work().
Message-Id: <[email protected]>
--- kernel/entry/kvm.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
kernel/entry/kvm.c +1 -4
@@ -8,10 +8,7 @@ static int xfer_to_guest_mode_work(struc do { int ret; - if (ti_work & _TIF_NOTIFY_SIGNAL) - tracehook_notify_signal(); - - if (ti_work & _TIF_SIGPENDING) { + if (ti_work & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) { kvm_handle_signal_exit(vcpu); return -EINTR; }
Greg Kroah-Hartman
maintainerPATCH 49/63 arch: setup PF_IO_WORKER threads like PF_KTHREAD
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 4727dc20e0422211a0e0c72b1ace4ed6096df8a6 ]
PF_IO_WORKER are kernel threads too, but they aren't PF_KTHREAD in the sense that we don't assign ->set_child_tid with our own structure. Just ensure that every arch sets up the PF_IO_WORKER threads like kthreads in the arch implementation of copy_thread().
--- arch/alpha/kernel/process.c | 2 +- arch/arc/kernel/process.c | 2 +- arch/arm/kernel/process.c | 2 +- arch/arm64/kernel/process.c | 2 +- arch/csky/kernel/process.c | 2 +- arch/h8300/kernel/process.c | 2 +- arch/hexagon/kernel/process.c | 2 +- arch/ia64/kernel/process.c | 2 +- arch/m68k/kernel/process.c | 2 +- arch/microblaze/kernel/process.c | 2 +- arch/mips/kernel/process.c | 2 +- arch/nds32/kernel/process.c | 2 +- arch/nios2/kernel/process.c | 2 +- arch/openrisc/kernel/process.c | 2 +- arch/riscv/kernel/process.c | 2 +- arch/s390/kernel/process.c | 2 +- arch/sh/kernel/process_32.c | 2 +- arch/sparc/kernel/process_32.c | 2 +- arch/sparc/kernel/process_64.c | 2 +- arch/um/kernel/process.c | 2 +- arch/x86/kernel/process.c | 2 +- arch/xtensa/kernel/process.c | 2 +- 22 files changed, 22 insertions(+), 22 deletions(-)
arch/alpha/kernel/process.c +1 -1
@@ -249,7 +249,7 @@ int copy_thread(unsigned long clone_flag childti->pcb.ksp = (unsigned long ) childstack; childti->pcb.flags =1 ;/* set FEN, clear everything else */ -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {/* kernel thread */ memset (childstack,0 ,sizeof (struct switch_stack ) +sizeof (struct pt_regs ));
arch/arc/kernel/process.c +1 -1
@@ -191,7 +191,7 @@ int copy_thread(unsigned long clone_flag childksp[0 ] =0 ;/* fp */ childksp[1 ] = (unsigned long )ret_from_fork;/* blink */ -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (c_regs,0 ,sizeof (struct pt_regs )); c_callee->r13 = kthread_arg;
arch/arm/kernel/process.c +1 -1
@@ -243,7 +243,7 @@ int copy_thread(unsigned long clone_flag thread->cpu_domain =get_domain ();#endif -if (likely (!(p->flags &PF_KTHREAD ))) { +if (likely (!(p->flags & (PF_KTHREAD |PF_IO_WORKER )))) { *childregs = *current_pt_regs (); childregs->ARM_r0 =0 ;if (stack_start)
arch/arm64/kernel/process.c +1 -1
@@ -398,7 +398,7 @@ int copy_thread(unsigned long clone_flagptrauth_thread_init_kernel (p); -if (likely (!(p->flags &PF_KTHREAD ))) { +if (likely (!(p->flags & (PF_KTHREAD |PF_IO_WORKER )))) { *childregs = *current_pt_regs (); childregs->regs[0 ] =0 ;
arch/csky/kernel/process.c +1 -1
@@ -49,7 +49,7 @@ int copy_thread(unsigned long clone_flag/* setup thread.sp for switch_to !!! */ p->thread.sp = (unsigned long )childstack; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (childregs,0 ,sizeof (struct pt_regs )); childstack->r15 = (unsigned long ) ret_from_kernel_thread; childstack->r10 = kthread_arg;
arch/h8300/kernel/process.c +1 -1
@@ -112,7 +112,7 @@ int copy_thread(unsigned long clone_flag childregs = (struct pt_regs *) (THREAD_SIZE +task_stack_page (p)) -1 ; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (childregs,0 ,sizeof (struct pt_regs )); childregs->retpc = (unsigned long ) ret_from_kernel_thread; childregs->er4 = topstk;/* arg */
arch/hexagon/kernel/process.c +1 -1
@@ -73,7 +73,7 @@ int copy_thread(unsigned long clone_flag sizeof(*ss)); ss->lr = (unsigned long )ret_from_fork; p->thread.switch_sp = ss; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (childregs,0 ,sizeof (struct pt_regs ));/* r24 <- fn, r25 <- arg */ ss->r24 = usp;
arch/ia64/kernel/process.c +1 -1
@@ -338,7 +338,7 @@ copy_thread(unsigned long clone_flags, uia64_drop_fpu (p);/* don't pick up stale state from a CPU's fph */ -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {if (unlikely (!user_stack_base)) {/* fork_idle() called us */ return 0 ;
arch/m68k/kernel/process.c +1 -1
@@ -157,7 +157,7 @@ int copy_thread(unsigned long clone_flag*/ p->thread.fs =get_fs ().seg; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {/* kernel thread */ memset (frame,0 ,sizeof (struct fork_frame )); frame->regs.sr =PS_S ;
arch/microblaze/kernel/process.c +1 -1
@@ -59,7 +59,7 @@ int copy_thread(unsigned long clone_flagstruct pt_regs *childregs =task_pt_regs (p);struct thread_info *ti =task_thread_info (p); -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {/* if we're creating a new kernel thread then just zeroing all * the registers. That's OK for a brand new thread.*/ memset (childregs,0 ,sizeof (struct pt_regs ));
arch/mips/kernel/process.c +1 -1
@@ -135,7 +135,7 @@ int copy_thread(unsigned long clone_flag/* Put the stack after the struct pt_regs. */ childksp = (unsigned long ) childregs; p->thread.cp0_status = (read_c0_status () & ~(ST0_CU2 |ST0_CU1 )) |ST0_KERNEL_CUMASK ; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {/* kernel thread */ unsigned long status = p->thread.cp0_status;memset (childregs,0 ,sizeof (struct pt_regs ));
arch/nds32/kernel/process.c +1 -1
@@ -156,7 +156,7 @@ int copy_thread(unsigned long clone_flagmemset (&p->thread.cpu_context,0 ,sizeof (struct cpu_context )); -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (childregs,0 ,sizeof (struct pt_regs ));/* kernel thread fn */ p->thread.cpu_context.r6 = stack_start;
arch/nios2/kernel/process.c +1 -1
@@ -109,7 +109,7 @@ int copy_thread(unsigned long clone_flagstruct switch_stack *childstack = ((struct switch_stack *)childregs) -1 ; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (childstack,0 ,sizeof (struct switch_stack ) +sizeof (struct pt_regs ));
arch/openrisc/kernel/process.c +1 -1
@@ -167,7 +167,7 @@ copy_thread(unsigned long clone_flags, u sp -=sizeof (struct pt_regs ); kregs = (struct pt_regs *)sp; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (kregs,0 ,sizeof (struct pt_regs )); kregs->gpr[20 ] = usp;/* fn, kernel thread */ kregs->gpr[22 ] = arg;
arch/riscv/kernel/process.c +1 -1
@@ -114,7 +114,7 @@ int copy_thread(unsigned long clone_flagmemset (&p->thread.s,0 ,sizeof (p->thread.s));/* p->thread holds context to be restored by __switch_to() */ -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {/* Kernel thread */ memset (childregs,0 ,sizeof (struct pt_regs )); childregs->gp = gp_in_global;
arch/s390/kernel/process.c +1 -1
@@ -127,7 +127,7 @@ int copy_thread(unsigned long clone_flag frame->sf.gprs[9 ] = (unsigned long ) frame;/* Store access registers to kernel stack of new process. */ -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {/* kernel thread */ memset (&frame->childregs,0 ,sizeof (struct pt_regs )); frame->childregs.psw.mask = PSW_KERNEL_BITS | PSW_MASK_DAT |
arch/sh/kernel/process_32.c +1 -1
@@ -114,7 +114,7 @@ int copy_thread(unsigned long clone_flag childregs =task_pt_regs (p); p->thread.sp = (unsigned long ) childregs; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (childregs,0 ,sizeof (struct pt_regs )); p->thread.pc = (unsigned long ) ret_from_kernel_thread; childregs->regs[4 ] = arg;
arch/sparc/kernel/process_32.c +1 -1
@@ -309,7 +309,7 @@ int copy_thread(unsigned long clone_flag ti->ksp = (unsigned long ) new_stack; p->thread.kregs = childregs; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {extern int nwindows;unsigned long psr;memset (new_stack,0 ,STACKFRAME_SZ +TRACEREG_SZ );
arch/sparc/kernel/process_64.c +1 -1
@@ -597,7 +597,7 @@ int copy_thread(unsigned long clone_flag sizeof(struct sparc_stackf)); t->fpsaved[0 ] =0 ; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (child_trap_frame,0 , child_stack_sz);__thread_flag_byte_ptr (t)[TI_FLAG_BYTE_CWP ] = (current_pt_regs ()->tstate +1 ) &TSTATE_CWP ;
arch/um/kernel/process.c +1 -1
@@ -157,7 +157,7 @@ int copy_thread(unsigned long clone_flag unsigned long arg, struct task_struct * p, unsigned long tls) { void (*handler)(void); -int kthread = current->flags &PF_KTHREAD ; +int kthread = current->flags & (PF_KTHREAD |PF_IO_WORKER );int ret =0 ; p->thread = (struct thread_struct )INIT_THREAD ;
arch/x86/kernel/process.c +1 -1
@@ -162,7 +162,7 @@ int copy_thread(unsigned long clone_flag#endif /* Kernel thread ? */ -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {memset (childregs,0 ,sizeof (struct pt_regs ));kthread_frame_init (frame, sp, arg);return 0 ;
arch/xtensa/kernel/process.c +1 -1
@@ -217,7 +217,7 @@ int copy_thread(unsigned long clone_flag p->thread.sp = (unsigned long )childregs; -if (!(p->flags &PF_KTHREAD )) { +if (!(p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {struct pt_regs *regs =current_pt_regs ();unsigned long usp = usp_thread_fn ? usp_thread_fn : regs->areg[1 ];
Greg Kroah-Hartman
maintainerPATCH 50/63 arch: ensure parisc/powerpc handle PF_IO_WORKER in copy_thread()
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 0100e6bbdbb79404e56939313662b42737026574 ]
In the arch addition of PF_IO_WORKER, I missed parisc and powerpc for some reason. Fix that up, ensuring they handle PF_IO_WORKER like they do PF_KTHREAD in copy_thread().
--- arch/parisc/kernel/process.c | 2 +- arch/powerpc/kernel/process.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
arch/parisc/kernel/process.c +1 -1
@@ -200,7 +200,7 @@ copy_thread(unsigned long clone_flags, uextern void *const ret_from_kernel_thread;extern void *const child_return; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {/* kernel thread */ memset (cregs,0 ,sizeof (struct pt_regs ));if (!usp)/* idle thread */
arch/powerpc/kernel/process.c +1 -1
@@ -1684,7 +1684,7 @@ int copy_thread(unsigned long clone_flag/* Copy registers */ sp -=sizeof (struct pt_regs ); childregs = (struct pt_regs *) sp; -if (unlikely (p->flags &PF_KTHREAD )) { +if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) {/* kernel thread */ memset (childregs,0 ,sizeof (struct pt_regs )); childregs->gpr[1 ] = sp +sizeof (struct pt_regs );
Greg Kroah-Hartman
maintainerPATCH 51/63 x86/process: setup io_threads more like normal user space threads
In reply to Greg Kroah-HartmanFrom: Stefan Metzmacher <[email protected]>
[ Upstream commit 50b7b6f29de3e18e9d6c09641256a0296361cfee ]
As io_threads are fully set up USER threads it's clearer to separate the code path from the KTHREAD logic.
The only remaining difference to user space threads is that io_threads never return to user space again. Instead they loop within the given worker function.
The fact that they never return to user space means they don't have an user space thread stack. In order to indicate that to tools like gdb we reset the stack and instruction pointers to 0.
This allows gdb attach to user space processes using io-uring, which like means that they have io_threads, without printing worrying message like this:
warning: Selected architecture i386:x86-64 is not compatible with reported target architecture i386
warning: Architecture rejected target-supplied description
The output will be something like this:
(gdb) info threads
Id Target Id Frame
* 1 LWP 4863 "io_uring-cp-for" syscall () at ../sysdeps/unix/sysv/linux/x86_64/syscall.S:38
2 LWP 4864 "iou-mgr-4863" 0x0000000000000000 in ?? ()
3 LWP 4865 "iou-wrk-4863" 0x0000000000000000 in ?? () (gdb) thread 3
[Switching to thread 3 (LWP 4865)]
#0 0x0000000000000000 in ?? ()
(gdb) bt
#0 0x0000000000000000 in ?? ()
Backtrace stopped: Cannot access memory at address 0x0
--- arch/x86/kernel/process.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)
arch/x86/kernel/process.c +18 -1
@@ -162,7 +162,7 @@ int copy_thread(unsigned long clone_flag#endif /* Kernel thread ? */ -if (unlikely (p->flags & (PF_KTHREAD |PF_IO_WORKER ))) { +if (unlikely (p->flags &PF_KTHREAD )) {memset (childregs,0 ,sizeof (struct pt_regs ));kthread_frame_init (frame, sp, arg);return 0 ;
@@ -178,6 +178,23 @@ int copy_thread(unsigned long clone_flagtask_user_gs (p) =get_user_gs (current_pt_regs ());#endif +if (unlikely (p->flags &PF_IO_WORKER )) { +/* +* An IO thread is a user space thread, but it doesn't +* return to ret_after_fork(). +* +* In order to indicate that to tools like gdb, +* we reset the stack and instruction pointers. +* +* It does the same kernel frame setup to return to a kernel +* function that a kernel thread does. +*/ + childregs->sp =0 ; + childregs->ip =0 ; +kthread_frame_init (frame, sp, arg); +return 0 ; + } +/* Set a new TLS for the child thread? */ if (clone_flags &CLONE_SETTLS ) ret =set_new_tls (p, tls);
Greg Kroah-Hartman
maintainerPATCH 52/63 kernel: stop masking signals in create_io_thread()
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit b16b3855d89fba640996fefdd3a113c0aa0e380d ]
This is racy - move the blocking into when the task is created and we're marking it as PF_IO_WORKER anyway. The IO threads are now prepared to handle signals like SIGSTOP as well, so clear that from the mask to allow proper stopping of IO threads.
--- kernel/fork.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
kernel/fork.c +8 -8
@@ -1949,8 +1949,14 @@ static __latent_entropy struct task_stru p =dup_task_struct (current, node);if (!p) goto fork_out; -if (args->io_thread) +if (args->io_thread) { +/* +* Mark us an IO worker, and block any signal that isn't +* fatal or STOP +*/ p->flags |=PF_IO_WORKER ; +siginitsetinv (&p->blocked,sigmask (SIGKILL )|sigmask (SIGSTOP )); + }/* * This _must_ happen before we call free_task(), i.e. before we jump
@@ -2435,14 +2441,8 @@ struct task_struct *create_io_thread(int .stack_size = (unsigned long)arg, .io_thread = 1, }; -struct task_struct *tsk; - tsk =copy_process (NULL ,0 , node, &args); -if (!IS_ERR (tsk)) { -sigfillset (&tsk->blocked); -sigdelsetmask (&tsk->blocked,sigmask (SIGKILL )); - } -return tsk; +return copy_process (NULL ,0 , node, &args); }/*
Greg Kroah-Hartman
maintainerPATCH 53/63 kernel: dont call do_exit() for PF_IO_WORKER threads
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 10442994ba195efef6fdcc0c3699e4633cb5161b ]
Right now we're never calling get_signal() from PF_IO_WORKER threads, but in preparation for doing so, don't handle a fatal signal for them. The workers have state they need to cleanup when exiting, so just return instead of calling do_exit() on their behalf. The threads themselves will detect a fatal signal and do proper shutdown.
--- kernel/signal.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
kernel/signal.c +9 -1
@@ -2755,13 +2755,21 @@ relock: }/* +* PF_IO_WORKER threads will catch and exit on fatal signals +* themselves. They have cleanup that must be performed, so +* we cannot call do_exit() on their behalf. +*/ +if (current->flags &PF_IO_WORKER ) + goto out; + +/* * Death signals, no core dump. */ do_group_exit (ksig->info.si_signo);/* NOTREACHED */ }spin_unlock_irq (&sighand->siglock); - +out: ksig->sig = signr;return ksig->sig >0 ; }
Greg Kroah-Hartman
maintainerPATCH 54/63 task_work: add helper for more targeted task_work canceling
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit c7aab1a7c52b82d9afd7e03c398eb03dc2aa0507 ]
The only exported helper we have right now is task_work_cancel(), which cancels any task_work from a given task where func matches the queued work item. This is a bit too coarse for some use cases. Add a task_work_cancel_match() that allows to more specifically target individual work items outside of purely the callback function used.
task_work_cancel() can be trivially implemented on top of that, hence do so.
--- include/linux/task_work.h | 2 ++ kernel/task_work.c | 35 ++++++++++++++++++++++++++++------- 2 files changed, 30 insertions(+), 7 deletions(-)
include/linux/task_work.h +2 -0
@@ -22,6 +22,8 @@ enum task_work_notify_mode {int task_work_add (struct task_struct *task,struct callback_head *twork,enum task_work_notify_mode mode); +struct callback_head *task_work_cancel_match (struct task_struct *task, +bool (*match)(struct callback_head *,void *data),void *data);struct callback_head *task_work_cancel (struct task_struct *,task_work_func_t );void task_work_run (void );
kernel/task_work.c +28 -7
@@ -59,18 +59,17 @@ int task_work_add(struct task_struct *ta }/** -* task_work_cancel - cancel a pending work added by task_work_add() +* task_work_cancel_match - cancel a pending work added by task_work_add() * @task: the task which should execute the work -* @func: identifies the work to remove -* -* Find the last queued pending work with ->func == @func and remove -* it from queue. +* @match: match function to call * * RETURNS: * The found work or NULL if not found. */ struct callback_head * -task_work_cancel (struct task_struct *task,task_work_func_t func) +task_work_cancel_match (struct task_struct *task, +bool (*match)(struct callback_head *,void *data), +void *data) {struct callback_head **pprev = &task->task_works;struct callback_head *work;
@@ -86,7 +85,7 @@ task_work_cancel(struct task_struct *tas*/ raw_spin_lock_irqsave (&task->pi_lock, flags);while ((work =READ_ONCE (*pprev))) { -if (work->func != func) +if (!match (work, data)) pprev = &work->next;else if (cmpxchg (pprev, work, work->next) == work)break ;
@@ -96,6 +95,28 @@ task_work_cancel(struct task_struct *tasreturn work; } +static bool task_work_func_match (struct callback_head *cb,void *data) +{ +return cb->func == data; +} + +/** +* task_work_cancel - cancel a pending work added by task_work_add() +* @task: the task which should execute the work +* @func: identifies the work to remove +* +* Find the last queued pending work with ->func == @func and remove +* it from queue. +* +* RETURNS: +* The found work or NULL if not found. +*/ +struct callback_head * +task_work_cancel (struct task_struct *task,task_work_func_t func) +{ +return task_work_cancel_match (task, task_work_func_match, func); +} +/** * task_work_run - execute the works added by task_work_add() *
Greg Kroah-Hartman
maintainerPATCH 55/63 io_uring: import 5.15-stable io_uring
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
No upstream commit exists.
This imports the io_uring codebase from 5.15.85, wholesale. Changes from that code base:
- Drop IOCB_ALLOC_CACHE, we don't have that in 5.10.
- Drop MKDIRAT/SYMLINKAT/LINKAT. Would require further VFS backports, and we don't support these in 5.10 to begin with.
- sock_from_file() old style calling convention.
- Use compat_get_bitmap() only for CONFIG_COMPAT=y
---
Makefile | 2
fs/Makefile | 2
fs/io-wq.c | 1242 ----
fs/io-wq.h | 157
fs/io_uring.c | 9971 ------------------------------------
include/linux/io_uring.h | 46
include/linux/sched.h | 3
include/linux/syscalls.h | 2
include/trace/events/io_uring.h | 121
include/uapi/linux/io_uring.h | 115
io_uring/Makefile | 6
io_uring/io-wq.c | 1398 +++++
io_uring/io-wq.h | 160
io_uring/io_uring.c |10945 ++++++++++++++++++++++++++++++++++++++++
kernel/exit.c | 2
kernel/fork.c | 1
kernel/sched/core.c | 2
17 files changed, 12704 insertions(+), 11471 deletions(-)
delete mode 100644 fs/io-wq.c
create mode 100644 io_uring/Makefile
create mode 100644 io_uring/io-wq.c
rename {fs => io_uring}/io-wq.h (81%)
rename {fs => io_uring}/io_uring.c (51%)Makefile +1 -1
@@ -1128,7 +1128,7 @@ export MODORDER := $(extmod-prefix)modul export MODULES_NSDEPS := $(extmod-prefix)modules.nsdeps ifeq ($(KBUILD_EXTMOD),) -core-y += kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ block/ +core-y += kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ block/ io_uring/ vmlinux-dirs := $(patsubst %/,%,$(filter %/, \ $(core-y) $(core-m) $(drivers-y) $(drivers-m) \
fs/Makefile +0 -2
@@ -32,8 +32,6 @@ obj-$(CONFIG_TIMERFD) += timerfd.o obj-$(CONFIG_EVENTFD) += eventfd.o obj-$(CONFIG_USERFAULTFD) += userfaultfd.o obj-$(CONFIG_AIO) += aio.o -obj-$(CONFIG_IO_URING) += io_uring.o -obj-$(CONFIG_IO_WQ) += io-wq.o obj-$(CONFIG_FS_DAX) += dax.o obj-$(CONFIG_FS_ENCRYPTION) += crypto/ obj-$(CONFIG_FS_VERITY) += verity/
fs/io-wq.c deleted +0 -1242
1,242 lines not on this page · raw message
fs/io-wq.h deleted +0 -157
157 lines not on this page · raw message
fs/io_uring.c deleted +0 -9971
1,585 lines not on this page · raw message
include/linux/io_uring.h +8 -38
46 lines not on this page · raw message
include/linux/sched.h +3 -0
Lines of this file are not shown. View the raw message.
include/linux/syscalls.h +1 -1
Lines of this file are not shown. View the raw message.
include/trace/events/io_uring.h +79 -42
121 lines not on this page · raw message
include/uapi/linux/io_uring.h +100 -15
115 lines not on this page · raw message
io_uring/Makefile new file +6 -0
Lines of this file are not shown. View the raw message.
io_uring/io-wq.c new file +1398 -0
1,398 lines not on this page · raw message
io_uring/io-wq.h new file +160 -0
160 lines not on this page · raw message
io_uring/io_uring.c new file +10945 -0
10,945 lines not on this page · raw message
kernel/exit.c +1 -1
Lines of this file are not shown. View the raw message.
kernel/fork.c +1 -0
Lines of this file are not shown. View the raw message.
kernel/sched/core.c +1 -1
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Part of the diff is not shown here. View the raw message.
Greg Kroah-Hartman
maintainerPATCH 56/63 signal: kill JOBCTL_TASK_WORK
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 98b89b649fce39dacb9dc036d6d0fdb8caff73f7 ]
It's no longer used, get rid of it.
--- include/linux/sched/jobctl.h | 4 +--- kernel/signal.c | 20 -------------------- 2 files changed, 1 insertion(+), 23 deletions(-)
include/linux/sched/jobctl.h +1 -3
@@ -19,7 +19,6 @@ struct task_struct;#define JOBCTL_TRAPPING_BIT 21/* switching to TRACED */ #define JOBCTL_LISTENING_BIT 22/* ptracer is listening for events */ #define JOBCTL_TRAP_FREEZE_BIT 23/* trap for cgroup freezer */ -#define JOBCTL_TASK_WORK_BIT 24/* set by TWA_SIGNAL */ #define JOBCTL_STOP_DEQUEUED (1UL << JOBCTL_STOP_DEQUEUED_BIT)#define JOBCTL_STOP_PENDING (1UL << JOBCTL_STOP_PENDING_BIT)
@@ -29,10 +28,9 @@ struct task_struct;#define JOBCTL_TRAPPING (1UL << JOBCTL_TRAPPING_BIT)#define JOBCTL_LISTENING (1UL << JOBCTL_LISTENING_BIT)#define JOBCTL_TRAP_FREEZE (1UL << JOBCTL_TRAP_FREEZE_BIT) -#define JOBCTL_TASK_WORK (1UL << JOBCTL_TASK_WORK_BIT)#define JOBCTL_TRAP_MASK (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY) -#define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK | JOBCTL_TASK_WORK) +#define JOBCTL_PENDING_MASK (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)extern bool task_set_jobctl_pending (struct task_struct *task,unsigned long mask);extern void task_clear_jobctl_trapping (struct task_struct *task);
kernel/signal.c +0 -20
@@ -2544,26 +2544,6 @@ bool get_signal(struct ksignal *ksig) relock:spin_lock_irq (&sighand->siglock); -/* -* Make sure we can safely read ->jobctl() in task_work add. As Oleg -* states: -* -* It pairs with mb (implied by cmpxchg) before READ_ONCE. So we -* roughly have -* -* task_work_add: get_signal: -* STORE(task->task_works, new_work); STORE(task->jobctl); -* mb(); mb(); -* LOAD(task->jobctl); LOAD(task->task_works); -* -* and we can rely on STORE-MB-LOAD [ in task_work_add]. -*/ -smp_store_mb (current->jobctl, current->jobctl & ~JOBCTL_TASK_WORK ); -if (unlikely (current->task_works)) { -spin_unlock_irq (&sighand->siglock); -task_work_run (); - goto relock; - }/* * Every stopped thread goes here after wakeup. Check to see if
Greg Kroah-Hartman
maintainerPATCH 57/63 task_work: unconditionally run task_work from get_signal()
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 35d0b389f3b23439ad15b610d6e43fc72fc75779 ]
Song reported a boot regression in a kvm image with 5.11-rc, and bisected it down to the below patch. Debugging this issue, turns out that the boot stalled when a task is waiting on a pipe being released. As we no longer run task_work from get_signal() unless it's queued with TWA_SIGNAL, the task goes idle without running the task_work. This prevents ->release() from being called on the pipe, which another boot task is waiting on.
For now, re-instate the unconditional task_work run from get_signal(). For 5.12, we'll collapse TWA_RESUME and TWA_SIGNAL, as it no longer makes sense to have a distinction between the two. This will turn task_work notification into a simple boolean, whether to notify or not.
--- kernel/signal.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/signal.c +3 -0
@@ -2520,6 +2520,9 @@ bool get_signal(struct ksignal *ksig)struct signal_struct *signal = current->signal;int signr; +if (unlikely (current->task_works)) +task_work_run (); +/* * For non-generic architectures, check for TIF_NOTIFY_SIGNAL so * that the arch handlers don't all have to do it. If we get here
Greg Kroah-Hartman
maintainerPATCH 58/63 net: remove cmsg restriction from io_uring based send/recvmsg calls
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit e54937963fa249595824439dc839c948188dea83 ]
No need to restrict these anymore, as the worker threads are direct clones of the original task. Hence we know for a fact that we can support anything that the regular task can.
Since the only user of proto_ops->flags was to flag PROTO_CMSG_DATA_ONLY, kill the member and the flag definition too.
--- include/linux/net.h | 3 --- net/ipv4/af_inet.c | 1 - net/ipv6/af_inet6.c | 1 - net/socket.c | 10 ---------- 4 files changed, 15 deletions(-)
include/linux/net.h +0 -3
@@ -42,8 +42,6 @@ struct net;#define SOCK_PASSCRED 3#define SOCK_PASSSEC 4 -#define PROTO_CMSG_DATA_ONLY 0x0001 -#ifndef ARCH_HAS_SOCKET_TYPES /** * enum sock_type - Socket types
@@ -138,7 +136,6 @@ typedef int (*sk_read_actor_t)(read_descstruct proto_ops {int family; -unsigned int flags;struct module *owner;int (*release) (struct socket *sock); int (*bind) (struct socket *sock,
net/ipv4/af_inet.c +0 -1
@@ -1017,7 +1017,6 @@ static int inet_compat_ioctl(struct sockconst struct proto_ops inet_stream_ops = { .family =PF_INET , - .flags =PROTO_CMSG_DATA_ONLY , .owner =THIS_MODULE , .release = inet_release, .bind = inet_bind,
net/ipv6/af_inet6.c +0 -1
@@ -661,7 +661,6 @@ int inet6_recvmsg(struct socket *sock, sconst struct proto_ops inet6_stream_ops = { .family =PF_INET6 , - .flags =PROTO_CMSG_DATA_ONLY , .owner =THIS_MODULE , .release = inet6_release, .bind = inet6_bind,
net/socket.c +0 -10
@@ -2419,10 +2419,6 @@ static int ___sys_sendmsg(struct socketlong __sys_sendmsg_sock (struct socket *sock,struct msghdr *msg,unsigned int flags) { -/* disallow ancillary data requests from this path */ -if (msg->msg_control || msg->msg_controllen) -return -EINVAL ; -return ____sys_sendmsg (sock, msg, flags,NULL ,0 ); }
@@ -2631,12 +2627,6 @@ long __sys_recvmsg_sock(struct socket *sstruct user_msghdr __user *umsg, struct sockaddr __user *uaddr, unsigned int flags) { - if (msg->msg_control || msg->msg_controllen) { - /* disallow ancillary data reqs unless cmsg is plain data */ - if (!(sock->ops->flags & PROTO_CMSG_DATA_ONLY)) - return -EINVAL; - } - return ____sys_recvmsg(sock, msg, umsg, uaddr, flags, 0); }
Greg Kroah-Hartman
maintainerPATCH 59/63 Revert "proc: dont allow async path resolution of /proc/thread-self components"
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 2587890b5e2892dfecaa5e5126bdac8076a4e6f7 ]
This reverts commit 0d4370cfe36b7f1719123b621a4ec4d9c7a25f89.
No longer needed, as the io-wq worker threads have the right identity.
--- fs/proc/self.c | 2 +- fs/proc/thread_self.c | 7 ------- 2 files changed, 1 insertion(+), 8 deletions(-)
fs/proc/self.c +1 -1
@@ -20,7 +20,7 @@ static const char *proc_self_get_link(st* Not currently supported. Once we can inherit all of struct pid, * we can allow this. */ -if (current->flags &PF_IO_WORKER ) +if (current->flags &PF_KTHREAD )return ERR_PTR (-EOPNOTSUPP );if (!tgid)
fs/proc/thread_self.c +0 -7
@@ -17,13 +17,6 @@ static const char *proc_thread_self_get_pid_t pid =task_pid_nr_ns (current, ns);char *name; -/* -* Not currently supported. Once we can inherit all of struct pid, -* we can allow this. -*/ -if (current->flags &PF_IO_WORKER ) -return ERR_PTR (-EOPNOTSUPP ); -if (!pid)return ERR_PTR (-ENOENT ); name =kmalloc (10 +6 +10 +1 , dentry ?GFP_KERNEL :GFP_ATOMIC );
Greg Kroah-Hartman
maintainerPATCH 60/63 Revert "proc: dont allow async path resolution of /proc/self components"
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 9e8d9e829c2142cf1d7756e9ed2e0b4c7569d84c ]
This reverts commit 8d4c3e76e3be11a64df95ddee52e99092d42fc19.
No longer needed, as the io-wq worker threads have the right identity.
--- fs/proc/self.c | 7 ------- 1 file changed, 7 deletions(-)
fs/proc/self.c +0 -7
@@ -16,13 +16,6 @@ static const char *proc_self_get_link(stpid_t tgid =task_tgid_nr_ns (current, ns);char *name; -/* -* Not currently supported. Once we can inherit all of struct pid, -* we can allow this. -*/ -if (current->flags &PF_KTHREAD ) -return ERR_PTR (-EOPNOTSUPP ); -if (!tgid)return ERR_PTR (-ENOENT );/* max length of unsigned int in decimal + NULL term */
Greg Kroah-Hartman
maintainerPATCH 61/63 eventpoll: add EPOLL_URING_WAKE poll wakeup flag
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit caf1aeaffc3b09649a56769e559333ae2c4f1802 ]
We can have dependencies between epoll and io_uring. Consider an epoll context, identified by the epfd file descriptor, and an io_uring file descriptor identified by iofd. If we add iofd to the epfd context, and arm a multishot poll request for epfd with iofd, then the multishot poll request will repeatedly trigger and generate events until terminated by CQ ring overflow. This isn't a desired behavior.
Add EPOLL_URING so that io_uring can pass it in as part of the poll wakeup key, and io_uring can check for that to detect a potential recursive invocation.
--- fs/eventpoll.c | 18 ++++++++++-------- include/uapi/linux/eventpoll.h | 6 ++++++ 2 files changed, 16 insertions(+), 8 deletions(-)
fs/eventpoll.c +10 -8
@@ -548,7 +548,8 @@ out_unlock:*/ #ifdef CONFIG_DEBUG_LOCK_ALLOC -static void ep_poll_safewake (struct eventpoll *ep,struct epitem *epi) +static void ep_poll_safewake (struct eventpoll *ep,struct epitem *epi, +unsigned pollflags) {struct eventpoll *ep_src;unsigned long flags;
@@ -579,16 +580,17 @@ static void ep_poll_safewake(struct even }spin_lock_irqsave_nested (&ep->poll_wait.lock, flags, nests); ep->nests = nests +1 ; -wake_up_locked_poll (&ep->poll_wait,EPOLLIN ); +wake_up_locked_poll (&ep->poll_wait,EPOLLIN | pollflags); ep->nests =0 ;spin_unlock_irqrestore (&ep->poll_wait.lock, flags); }#else -static void ep_poll_safewake (struct eventpoll *ep,struct epitem *epi) +static void ep_poll_safewake (struct eventpoll *ep,struct epitem *epi, +unsigned pollflags) { -wake_up_poll (&ep->poll_wait,EPOLLIN ); +wake_up_poll (&ep->poll_wait,EPOLLIN | pollflags); }#endif
@@ -815,7 +817,7 @@ static void ep_free(struct eventpoll *ep/* We need to release all tasks waiting for these file */ if (waitqueue_active (&ep->poll_wait)) -ep_poll_safewake (ep,NULL ); +ep_poll_safewake (ep,NULL ,0 );/* * We need to lock this because we could be hit by
@@ -1284,7 +1286,7 @@ out_unlock:/* We have to call this outside the lock */ if (pwake) -ep_poll_safewake (ep, epi); +ep_poll_safewake (ep, epi, pollflags &EPOLL_URING_WAKE );if (!(epi->event.events &EPOLLEXCLUSIVE )) ewake =1 ;
@@ -1589,7 +1591,7 @@ static int ep_insert(struct eventpoll *e/* We have to call this outside the lock */ if (pwake) -ep_poll_safewake (ep,NULL ); +ep_poll_safewake (ep,NULL ,0 );return 0 ;
@@ -1692,7 +1694,7 @@ static int ep_modify(struct eventpoll *e/* We have to call this outside the lock */ if (pwake) -ep_poll_safewake (ep,NULL ); +ep_poll_safewake (ep,NULL ,0 );return 0 ; }
include/uapi/linux/eventpoll.h +6 -0
@@ -41,6 +41,12 @@#define EPOLLMSG (__force __poll_t)0x00000400#define EPOLLRDHUP (__force __poll_t)0x00002000 +/* +* Internal flag - wakeup generated by io_uring, used to detect recursion back +* into the io_uring poll handler. +*/ +#define EPOLL_URING_WAKE ((__force __poll_t)(1U << 27)) +/* Set exclusive wakeup mode for the target file descriptor */ #define EPOLLEXCLUSIVE ((__force __poll_t)(1U << 28))
Greg Kroah-Hartman
maintainerPATCH 62/63 eventfd: provide a eventfd_signal_mask() helper
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 03e02acda8e267a8183e1e0ed289ff1ef9cd7ed8 ]
This is identical to eventfd_signal(), but it allows the caller to pass in a mask to be used for the poll wakeup key. The use case is avoiding repeated multishot triggers if we have a dependency between eventfd and io_uring.
If we setup an eventfd context and register that as the io_uring eventfd, and at the same time queue a multishot poll request for the eventfd context, then any CQE posted will repeatedly trigger the multishot request until it terminates when the CQ ring overflows.
In preparation for io_uring detecting this circular dependency, add the mentioned helper so that io_uring can pass in EPOLL_URING as part of the poll wakeup key.
--- fs/eventfd.c | 37 +++++++++++++++++++++---------------- include/linux/eventfd.h | 7 +++++++ 2 files changed, 28 insertions(+), 16 deletions(-)
fs/eventfd.c +21 -16
@@ -45,21 +45,7 @@ struct eventfd_ctx {int id; }; -/** -* eventfd_signal - Adds @n to the eventfd counter. -* @ctx: [in] Pointer to the eventfd context. -* @n: [in] Value of the counter to be added to the eventfd internal counter. -* The value cannot be negative. -* -* This function is supposed to be called by the kernel in paths that do not -* allow sleeping. In this function we allow the counter to reach the ULLONG_MAX -* value, and we signal this as overflow condition by returning a EPOLLERR -* to poll(2). -* -* Returns the amount by which the counter was incremented. This will be less -* than @n if the counter has overflowed. -*/ -__u64 eventfd_signal (struct eventfd_ctx *ctx,__u64 n) +__u64 eventfd_signal_mask (struct eventfd_ctx *ctx,__u64 n,unsigned mask) {unsigned long flags;
@@ -80,12 +66,31 @@ __u64 eventfd_signal(struct eventfd_ctx n =ULLONG_MAX - ctx->count; ctx->count += n;if (waitqueue_active (&ctx->wqh)) -wake_up_locked_poll (&ctx->wqh,EPOLLIN ); +wake_up_locked_poll (&ctx->wqh,EPOLLIN | mask);this_cpu_dec (eventfd_wake_count);spin_unlock_irqrestore (&ctx->wqh.lock, flags);return n; } + +/** +* eventfd_signal - Adds @n to the eventfd counter. +* @ctx: [in] Pointer to the eventfd context. +* @n: [in] Value of the counter to be added to the eventfd internal counter. +* The value cannot be negative. +* +* This function is supposed to be called by the kernel in paths that do not +* allow sleeping. In this function we allow the counter to reach the ULLONG_MAX +* value, and we signal this as overflow condition by returning a EPOLLERR +* to poll(2). +* +* Returns the amount by which the counter was incremented. This will be less +* than @n if the counter has overflowed. +*/ +__u64 eventfd_signal (struct eventfd_ctx *ctx,__u64 n) +{ +return eventfd_signal_mask (ctx, n,0 ); +}EXPORT_SYMBOL_GPL (eventfd_signal);static void eventfd_free_ctx (struct eventfd_ctx *ctx)
include/linux/eventfd.h +7 -0
@@ -39,6 +39,7 @@ struct file *eventfd_fget(int fd);struct eventfd_ctx *eventfd_ctx_fdget (int fd);struct eventfd_ctx *eventfd_ctx_fileget (struct file *file);__u64 eventfd_signal (struct eventfd_ctx *ctx,__u64 n); +__u64 eventfd_signal_mask (struct eventfd_ctx *ctx,__u64 n,unsigned mask);int eventfd_ctx_remove_wait_queue (struct eventfd_ctx *ctx,wait_queue_entry_t *wait,__u64 *cnt);
@@ -65,6 +66,12 @@ static inline int eventfd_signal(struct {return -ENOSYS ; } + +static inline int eventfd_signal_mask (struct eventfd_ctx *ctx,__u64 n, +unsigned mask) +{ +return -ENOSYS ; +}static inline void eventfd_ctx_put (struct eventfd_ctx *ctx) {
Greg Kroah-Hartman
maintainerPATCH 63/63 io_uring: pass in EPOLL_URING_WAKE for eventfd signaling and wakeups
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
[ Upstream commit 4464853277d0ccdb9914608dd1332f0fa2f9846f ]
Pass in EPOLL_URING_WAKE when signaling eventfd or doing poll related wakups, so that we can check for a circular event dependency between eventfd and epoll. If this flag is set when our wakeup handlers are called, then we know we have a dependency that needs to terminate multishot requests.
eventfd and epoll are the only such possible dependencies.
--- io_uring/io_uring.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-)
io_uring/io_uring.c +20 -7
@@ -1626,13 +1626,15 @@ static void io_cqring_ev_posted(struct i* wake as many waiters as we need to. */ if (wq_has_sleeper (&ctx->cq_wait)) -wake_up_all (&ctx->cq_wait); +__wake_up (&ctx->cq_wait,TASK_NORMAL ,0 , +poll_to_key (EPOLL_URING_WAKE |EPOLLIN ));if (ctx->sq_data &&waitqueue_active (&ctx->sq_data->wait))wake_up (&ctx->sq_data->wait);if (io_should_trigger_evfd (ctx)) -eventfd_signal (ctx->cq_ev_fd,1 ); +eventfd_signal_mask (ctx->cq_ev_fd,1 ,EPOLL_URING_WAKE );if (waitqueue_active (&ctx->poll_wait)) -wake_up_interruptible (&ctx->poll_wait); +__wake_up (&ctx->poll_wait,TASK_INTERRUPTIBLE ,0 , +poll_to_key (EPOLL_URING_WAKE |EPOLLIN )); }static void io_cqring_ev_posted_iopoll (struct io_ring_ctx *ctx)
@@ -1642,12 +1644,14 @@ static void io_cqring_ev_posted_iopoll(sif (ctx->flags &IORING_SETUP_SQPOLL ) {if (waitqueue_active (&ctx->cq_wait)) -wake_up_all (&ctx->cq_wait); +__wake_up (&ctx->cq_wait,TASK_NORMAL ,0 , +poll_to_key (EPOLL_URING_WAKE |EPOLLIN )); }if (io_should_trigger_evfd (ctx)) -eventfd_signal (ctx->cq_ev_fd,1 ); +eventfd_signal_mask (ctx->cq_ev_fd,1 ,EPOLL_URING_WAKE );if (waitqueue_active (&ctx->poll_wait)) -wake_up_interruptible (&ctx->poll_wait); +__wake_up (&ctx->poll_wait,TASK_INTERRUPTIBLE ,0 , +poll_to_key (EPOLL_URING_WAKE |EPOLLIN )); }/* Returns true if there are no backlogged entries after the flush */
@@ -5477,8 +5481,17 @@ static int io_poll_wake(struct wait_queuif (mask && !(mask & poll->events))return 0 ; -if (io_poll_get_ownership (req)) +if (io_poll_get_ownership (req)) { +/* +* If we trigger a multishot poll off our own wakeup path, +* disable multishot as there is a circular dependency between +* CQ posting and triggering the event. +*/ +if (mask &EPOLL_URING_WAKE ) + poll->events |=EPOLLONESHOT ; +__io_poll_execute (req, mask); + }return 1 ; }
Hi!
Quoted 4 lines
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
CIP testing did not find any problems here:
https://gitlab.com/cip-project/cip-testing/linux-stable-rc-ci/-/tree/linux-5.10.y
Best regards,
Pavel
Signature · 2 lines
DENX Software Engineering GmbH, Managing Director: Wolfgang Denk HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
Build results:
total: 162 pass: 162 fail: 0 Qemu test results: total: 475 pass: 475 fail: 0
Guenter
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.10.y
and the diffstat can be found below.thanks,
greg k-h
All tests passing for Tegra ...
Test results for stable-v5.10:
11 builds: 11 pass, 0 fail
28 boots: 28 pass, 0 fail
75 tests: 75 pass, 0 failLinux version: 5.10.162-rc1-gc5bc645ae6f9
Boards tested: tegra124-jetson-tk1, tegra186-p2771-0000,
tegra194-p2972-0000, tegra194-p3509-0000+p3668-0000,
tegra20-ventana, tegra210-p2371-2180,
tegra210-p3450-0000, tegra30-cardhu-a04Jon
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
Quoted 7 lines
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.10.y
and the diffstat can be found below.thanks,
Testing fails. Could you please pick these 2 up?
https://lore.kernel.org/r/[email protected]
https://lore.kernel.org/all/[email protected]/
Thank you,
- Joel
Quoted 337 lines
greg k-h
-------------
Pseudo-Shortlog of commits:Greg Kroah-Hartman <[email protected]>
Linux 5.10.162-rc1Jens Axboe <[email protected]>
io_uring: pass inEPOLL_URING_WAKEfor eventfd signaling and wakeupsJens Axboe <[email protected]>
eventfd: provide aeventfd_signal_mask()helperJens Axboe <[email protected]>
eventpoll: addEPOLL_URING_WAKEpoll wakeup flagJens Axboe <[email protected]>
Revert "proc: don't allow async path resolution of/proc/selfcomponents"Jens Axboe <[email protected]>
Revert "proc: don't allow async path resolution of/proc/thread-selfcomponents"Jens Axboe <[email protected]>
net: remove cmsg restriction fromio_uringbased send/recvmsg callsJens Axboe <[email protected]>
task_work: unconditionally runtask_workfromget_signal()Jens Axboe <[email protected]>
signal: killJOBCTL_TASK_WORKJens Axboe <[email protected]>
io_uring: import 5.15-stableio_uringJens Axboe <[email protected]>
task_work: add helper for more targetedtask_workcancelingJens Axboe <[email protected]>
kernel: don't calldo_exit()forPF_IO_WORKERthreadsJens Axboe <[email protected]>
kernel: stop masking signals increate_io_thread()Stefan Metzmacher <[email protected]>
x86/process: setupio_threadsmore like normal user space threadsJens Axboe <[email protected]>
arch: ensure parisc/powerpc handlePF_IO_WORKERincopy_thread()Jens Axboe <[email protected]>
arch: setupPF_IO_WORKERthreads likePF_KTHREADSeth Forshee <[email protected]>
entry/kvm: Exit to user mode whenTIF_NOTIFY_SIGNALis setJens Axboe <[email protected]>
kernel: allow fork withTIF_NOTIFY_SIGNALpendingEric W. Biederman <[email protected]>
coredump: Limit what can interrupt coredumpsJens Axboe <[email protected]>
kernel: remove checking forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
task_work: remove legacyTWA_SIGNALpathAl Viro <[email protected]>
alpha: fixTIF_NOTIFY_SIGNALhandlingVineet Gupta <[email protected]>
ARC: unbork 5.11 bootup: fix snafu in_TIF_NOTIFY_SIGNALhandlingJens Axboe <[email protected]>
ia64: don't callhandle_signal()unless there's actually a signal queuedJens Axboe <[email protected]>
sparc: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
riscv: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
nds32: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
ia64: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
h8300: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
c6x: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
alpha: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
xtensa: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
arm: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
microblaze: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
hexagon: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
csky: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
openrisc: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
sh: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
um: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
s390: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
mips: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
powerpc: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
parisc: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
nios32: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
m68k: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
arm64: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
arc: add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
x86: Wire upTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
task_work: UseTIF_NOTIFY_SIGNALif availableJens Axboe <[email protected]>
entry: Add support forTIF_NOTIFY_SIGNALJens Axboe <[email protected]>
fs: provide locked helper variant ofclose_fd_get_file()Eric W. Biederman <[email protected]>
file: Rename__close_fd_get_fileclose_fd_get_fileJens Axboe <[email protected]>
fs: makedo_renameat2()take struct filenameJens Axboe <[email protected]>
signal: Addtask_sigpending()helperPavel Begunkov <[email protected]>
net: add accept helper not installing fdJens Axboe <[email protected]>
net: provide__sys_shutdown_sock()that takes a socketArnaldo Carvalho de Melo <[email protected]>
tools headers UAPI: Syncopenat2.hwith the kernel sourcesJens Axboe <[email protected]>
fs: exposeLOOKUP_CACHEDthroughopenat2()RESOLVE_CACHEDAl Viro <[email protected]>
Make sure nd->path.mnt and nd->path.dentry are always valid pointersAl Viro <[email protected]>
fix handling of nd->depth on LOOKUP_CACHED failures in try_to_unlazy*Jens Axboe <[email protected]>
fs: add support forLOOKUP_CACHEDAl Viro <[email protected]>
saner calling conventions forunlazy_child()Jens Axboe <[email protected]>
iov_iter: add helper to saveiov_iterstateJens Axboe <[email protected]>
kernel: providecreate_io_thread()helper-------------
Diffstat:
Makefile | 6 +- arch/alpha/include/asm/thread_info.h | 4 +- arch/alpha/kernel/entry.S | 2 +- arch/alpha/kernel/process.c | 2 +- arch/alpha/kernel/signal.c | 2 +- arch/arc/include/asm/thread_info.h | 4 +- arch/arc/kernel/entry.S | 3 +- arch/arc/kernel/process.c | 2 +- arch/arc/kernel/signal.c | 2 +- arch/arm/include/asm/thread_info.h | 7 +- arch/arm/kernel/entry-common.S | 6 +- arch/arm/kernel/entry-v7m.S | 2 +- arch/arm/kernel/process.c | 2 +- arch/arm/kernel/signal.c | 2 +- arch/arm64/include/asm/thread_info.h | 5 +- arch/arm64/kernel/process.c | 2 +- arch/arm64/kernel/signal.c | 2 +- arch/c6x/include/asm/thread_info.h | 1 + arch/c6x/kernel/asm-offsets.c | 1 + arch/c6x/kernel/signal.c | 3 +- arch/csky/include/asm/thread_info.h | 5 +- arch/csky/kernel/process.c | 2 +- arch/csky/kernel/signal.c | 2 +- arch/h8300/include/asm/thread_info.h | 4 +- arch/h8300/kernel/process.c | 2 +- arch/h8300/kernel/signal.c | 2 +- arch/hexagon/include/asm/thread_info.h | 2 + arch/hexagon/kernel/process.c | 4 +- arch/ia64/include/asm/thread_info.h | 4 +- arch/ia64/kernel/process.c | 5 +- arch/ia64/kernel/signal.c | 3 +- arch/m68k/include/asm/thread_info.h | 1 + arch/m68k/kernel/process.c | 2 +- arch/m68k/kernel/signal.c | 3 +- arch/microblaze/include/asm/thread_info.h | 2 + arch/microblaze/kernel/process.c | 2 +- arch/microblaze/kernel/signal.c | 3 +- arch/mips/include/asm/thread_info.h | 4 +- arch/mips/kernel/process.c | 2 +- arch/mips/kernel/signal.c | 2 +- arch/nds32/include/asm/thread_info.h | 2 + arch/nds32/kernel/ex-exit.S | 2 +- arch/nds32/kernel/process.c | 2 +- arch/nds32/kernel/signal.c | 2 +- arch/nios2/include/asm/thread_info.h | 2 + arch/nios2/kernel/process.c | 2 +- arch/nios2/kernel/signal.c | 3 +- arch/openrisc/include/asm/thread_info.h | 2 + arch/openrisc/kernel/process.c | 2 +- arch/openrisc/kernel/signal.c | 2 +- arch/parisc/include/asm/thread_info.h | 4 +- arch/parisc/kernel/process.c | 2 +- arch/parisc/kernel/signal.c | 3 +- arch/powerpc/include/asm/thread_info.h | 5 +- arch/powerpc/kernel/process.c | 2 +- arch/powerpc/kernel/signal.c | 2 +- arch/riscv/include/asm/thread_info.h | 5 +- arch/riscv/kernel/process.c | 2 +- arch/riscv/kernel/signal.c | 2 +- arch/s390/include/asm/thread_info.h | 2 + arch/s390/kernel/entry.S | 11 +- arch/s390/kernel/process.c | 2 +- arch/s390/kernel/signal.c | 2 +- arch/sh/include/asm/thread_info.h | 4 +- arch/sh/kernel/process_32.c | 2 +- arch/sh/kernel/signal_32.c | 2 +- arch/sparc/include/asm/thread_info_32.h | 4 +- arch/sparc/include/asm/thread_info_64.h | 6 +- arch/sparc/kernel/process_32.c | 2 +- arch/sparc/kernel/process_64.c | 2 +- arch/sparc/kernel/signal_32.c | 2 +- arch/sparc/kernel/signal_64.c | 2 +- arch/um/include/asm/thread_info.h | 2 + arch/um/kernel/process.c | 5 +- arch/x86/include/asm/thread_info.h | 2 + arch/x86/kernel/process.c | 17 + arch/x86/kernel/signal.c | 4 +- arch/xtensa/include/asm/thread_info.h | 5 +- arch/xtensa/kernel/entry.S | 4 +- arch/xtensa/kernel/process.c | 2 +- arch/xtensa/kernel/signal.c | 3 +- drivers/android/binder.c | 2 +- fs/Makefile | 2 - fs/coredump.c | 2 +- fs/eventfd.c | 37 +- fs/eventpoll.c | 18 +- fs/file.c | 34 +- fs/internal.h | 3 + fs/io-wq.c | 1242 ---- fs/namei.c | 84 +- fs/open.c | 6 + fs/proc/self.c | 7 - fs/proc/thread_self.c | 7 - include/linux/entry-common.h | 7 +- include/linux/entry-kvm.h | 4 +- include/linux/eventfd.h | 7 + include/linux/fcntl.h | 2 +- include/linux/fdtable.h | 2 +- include/linux/io_uring.h | 46 +- include/linux/namei.h | 1 + include/linux/net.h | 3 - include/linux/sched.h | 3 + include/linux/sched/jobctl.h | 4 +- include/linux/sched/signal.h | 18 +- include/linux/sched/task.h | 2 + include/linux/socket.h | 4 + include/linux/syscalls.h | 2 +- include/linux/task_work.h | 2 + include/linux/tracehook.h | 23 + include/linux/uio.h | 15 + include/trace/events/io_uring.h | 121 +- include/uapi/linux/eventpoll.h | 6 + include/uapi/linux/io_uring.h | 115 +- include/uapi/linux/openat2.h | 4 + io_uring/Makefile | 6 + io_uring/io-wq.c | 1398 +++++ {fs => io_uring}/io-wq.h | 47 +- {fs => io_uring}/io_uring.c | 9209 ++++++++++++++++------------- kernel/entry/common.c | 14 +- kernel/entry/kvm.c | 2 +- kernel/events/uprobes.c | 2 +- kernel/exit.c | 2 +- kernel/fork.c | 33 +- kernel/sched/core.c | 2 +- kernel/signal.c | 53 +- kernel/task_work.c | 48 +- lib/iov_iter.c | 52 +- net/ipv4/af_inet.c | 1 - net/ipv6/af_inet6.c | 1 - net/socket.c | 92 +- tools/include/uapi/linux/openat2.h | 4 + 131 files changed, 7279 insertions(+), 5773 deletions(-)
Greg Kroah-Hartman
maintainerQuoted 15 lines · Joel Fernandes
Quoted 14 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.10.y
and the diffstat can be found below.
Quoted 5 lines
Quoted 1 line
thanks,
Testing fails. Could you please pick these 2 up?
https://lore.kernel.org/r/[email protected]
https://lore.kernel.org/all/[email protected]/
That is not a regression from 5.10.161, right? This release is only for the io_uring stuff to make sure that backport was done correctly.
The current "to apply" queue for the stable trees is very large right now due to everyone waiting to get tiny things into -rc1 instead of before then, so the above two are still not yet queued up, sorry.
thanks,
greg k-h
Quoted 20 lines · Greg Kroah-Hartman
Quoted 15 lines · Joel Fernandes
Quoted 15 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.10.y
and the diffstat can be found below.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
thanks,
Testing fails. Could you please pick these 2 up?
https://lore.kernel.org/r/[email protected]
https://lore.kernel.org/all/[email protected]/That is not a regression from 5.10.161, right?
Yes it is not.
Quoted 6 lines
This release is only for
theio_uringstuff to make sure that backport was done correctly.The current "to apply" queue for the stable trees is very large right now due to everyone waiting to get tiny things into -rc1 instead of before then, so the above two are still not yet queued up, sorry.
Sure not a problem, I can resend again later if it is still not queued.
Thanks,
- Joel
Quoted 4 lines
thanks,
greg k-h
Greg Kroah-Hartman
maintainerQuoted 30 lines · Joel Fernandes
Quoted 20 lines · Greg Kroah-Hartman
Quoted 15 lines · Joel Fernandes
Quoted 15 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.10.y
and the diffstat can be found below.Quoted 7 lines
Quoted 5 lines
Quoted 1 line
thanks,
Testing fails. Could you please pick these 2 up?
https://lore.kernel.org/r/[email protected]
https://lore.kernel.org/all/[email protected]/That is not a regression from 5.10.161, right?
Yes it is not.
Quoted 8 lines
Quoted 6 lines
This release is only for
theio_uringstuff to make sure that backport was done correctly.The current "to apply" queue for the stable trees is very large right now due to everyone waiting to get tiny things into -rc1 instead of before then, so the above two are still not yet queued up, sorry.
Sure not a problem, I can resend again later if it is still not queued.
You should have already received the email notices saying they were queued :)
Quoted 10 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.10.y
and the diffstat can be found below.thanks,
greg k-h
Results from Linaro’s test farm.
No regressions on arm64, arm, x86_64, and i386.
## Build
* kernel: 5.10.162-rc1
* git: https://gitlab.com/Linaro/lkft/mirrors/stable/linux-stable-rc
* git branch: linux-5.10.y
* git commit: c5bc645ae6f96d3949dcf1f0fb0a7c243fb525d1
* git describe: v5.10.161-64-gc5bc645ae6f9
* test details:
https://qa-reports.linaro.org/lkft/linux-stable-rc-linux-5.10.y/build/v5.10.161-64-gc5bc645ae6f9
## Test Regressions (compared to v5.10.160-19-gbc32b2c55e20)
## Metric Regressions (compared to v5.10.160-19-gbc32b2c55e20)
## Test Fixes (compared to v5.10.160-19-gbc32b2c55e20)
## Metric Fixes (compared to v5.10.160-19-gbc32b2c55e20)
## Test result summary
total: 138327, pass: 116359, fail: 3491, skip: 18160, xfail: 317
## Build Summary
* arc: 5 total, 5 passed, 0 failed
* arm: 151 total, 148 passed, 3 failed
* arm64: 49 total, 46 passed, 3 failed
* i386: 39 total, 37 passed, 2 failed
* mips: 31 total, 29 passed, 2 failed
* parisc: 8 total, 8 passed, 0 failed
* powerpc: 32 total, 25 passed, 7 failed
* riscv: 16 total, 14 passed, 2 failed
* s390: 16 total, 16 passed, 0 failed
* sh: 14 total, 12 passed, 2 failed
* sparc: 8 total, 8 passed, 0 failed
* x86_64: 42 total, 40 passed, 2 failed
## Test suites summary
* boot
* fwts
* igt-gpu-tools
* kselftest-android
* kselftest-arm64
* kselftest-breakpoints
* kselftest-capabilities
* kselftest-cgroup
* kselftest-clone3
* kselftest-core
* kselftest-cpu-hotplug
* kselftest-cpufreq
* kselftest-drivers-dma-buf
* kselftest-efivarfs
* kselftest-filesystems
* kselftest-filesystems-binderfs
* kselftest-firmware
* kselftest-fpu
* kselftest-futex
* kselftest-gpio
* kselftest-intel_pstate
* kselftest-ipc
* kselftest-ir
* kselftest-kcmp
* kselftest-kexec
* kselftest-kvm
* kselftest-lib
* kselftest-livepatch
* kselftest-membarrier
* kselftest-memfd
* kselftest-memory-hotplug
* kselftest-mincore
* kselftest-mount
* kselftest-mqueue
* kselftest-net
* kselftest-net-forwarding
* kselftest-net-mptcp
* kselftest-netfilter
* kselftest-nsfs
* kselftest-openat2
* kselftest-pid_namespace
* kselftest-pidfd
* kselftest-proc
* kselftest-pstore
* kselftest-ptrace
* kselftest-rseq
* kselftest-rtc
* kselftest-seccomp
* kselftest-tc-testing
* kselftest-timens
* kselftest-timers
* kselftest-tmpfs
* kselftest-tpm2
* kselftest-user
* kselftest-vm
* kselftest-x86
* kselftest-zram
* kunit
* kvm-unit-tests
* libgpiod
* libhugetlbfs
* log-parser-boot
* log-parser-test
* ltp-cap_bounds
* ltp-commands
* ltp-containers
* ltp-controllers
* ltp-cpuhotplug
* ltp-crypto
* ltp-cve
* ltp-dio
* ltp-fcntl-locktests
* ltp-filecaps
* ltp-fs
* ltp-fs_bind
* ltp-fs_perms_simple
* ltp-fsx
* ltp-hugetlb
* ltp-io
* ltp-ipc
* ltp-math
* ltp-mm
* ltp-nptl
* ltp-open-posix-tests
* ltp-pty
* ltp-sched
* ltp-securebits
* ltp-smoke
* ltp-syscalls
* ltp-tracing
* network-basic-tests
* packetdrill
* perf
* rcutorture
* v4l2-compliance
* vdso
--
Linaro LKFT
https://lkft.linaro.org
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.10.y
and the diffstat can be found below.thanks,
greg k-h
On ARCH_BRCMSTB using 32-bit and 64-bit ARM kernels, build tested on BMIPS_GENERIC:
Signature · 1 line
Florian
Quoted 9 lines
This is the start of the stable review cycle for the 5.10.162 release. There are 63 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Thu, 05 Jan 2023 08:12:47 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 9 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.10.162-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.10.y
and the diffstat can be found below.thanks,
greg k-h
Compiled and booted on my x86_64 and ARM64 test systems. No errors or regressions.
Thanks.