aio: implement io_pgetevents

This is the io_getevents equivalent of ppoll/pselect and allows to
properly mix signals and aio completions (especially with IOCB_CMD_POLL)
and atomically executes the following sequence:

	sigset_t origmask;

	pthread_sigmask(SIG_SETMASK, &sigmask, &origmask);
	ret = io_getevents(ctx, min_nr, nr, events, timeout);
	pthread_sigmask(SIG_SETMASK, &origmask, NULL);

Note that unlike many other signal related calls we do not pass a sigmask
size, as that would get us to 7 arguments, which aren't easily supported
by the syscall infrastructure.  It seems a lot less painful to just add a
new syscall variant in the unlikely case we're going to increase the
sigset size.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>

1 files changed, 104 insertions, 10 deletions

diff --git a/fs/aio.c b/fs/aio.c
index 61d2e6942951..f3eae5d5771b 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -1303,10 +1303,6 @@ static long read_events(struct kioctx *ctx, long min_nr, long nr,
                 wait_event_interruptible_hrtimeout(ctx->wait,
                                 aio_read_events(ctx, min_nr, nr, event, &ret),
                                 until);
-
-        if (!ret && signal_pending(current))
-                ret = -EINTR;
-
         return ret;
 }
 
@@ -1921,13 +1917,60 @@ SYSCALL_DEFINE5(io_getevents, aio_context_t, ctx_id,
                 struct timespec __user *, timeout)
 {
         struct timespec64       ts;
+        int                     ret;
+
+        if (timeout && unlikely(get_timespec64(&ts, timeout)))
+                return -EFAULT;
+
+        ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
+        if (!ret && signal_pending(current))
+                ret = -EINTR;
+        return ret;
+}
 
-        if (timeout) {
-                if (unlikely(get_timespec64(&ts, timeout)))
+SYSCALL_DEFINE6(io_pgetevents,
+                aio_context_t, ctx_id,
+                long, min_nr,
+                long, nr,
+                struct io_event __user *, events,
+                struct timespec __user *, timeout,
+                const struct __aio_sigset __user *, usig)
+{
+        struct __aio_sigset     ksig = { NULL, };
+        sigset_t                ksigmask, sigsaved;
+        struct timespec64       ts;
+        int ret;
+
+        if (timeout && unlikely(get_timespec64(&ts, timeout)))
+                return -EFAULT;
+
+        if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
+                return -EFAULT;
+
+        if (ksig.sigmask) {
+                if (ksig.sigsetsize != sizeof(sigset_t))
+                        return -EINVAL;
+                if (copy_from_user(&ksigmask, ksig.sigmask, sizeof(ksigmask)))
                         return -EFAULT;
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
+
+        ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
+        if (signal_pending(current)) {
+                if (ksig.sigmask) {
+                        current->saved_sigmask = sigsaved;
+                        set_restore_sigmask();
+                }
+
+                if (!ret)
+                        ret = -ERESTARTNOHAND;
+        } else {
+                if (ksig.sigmask)
+                        sigprocmask(SIG_SETMASK, &sigsaved, NULL);
         }
 
-        return do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
+        return ret;
 }
 
 #ifdef CONFIG_COMPAT
@@ -1938,13 +1981,64 @@ COMPAT_SYSCALL_DEFINE5(io_getevents, compat_aio_context_t, ctx_id,
                        struct compat_timespec __user *, timeout)
 {
         struct timespec64 t;
+        int ret;
+
+        if (timeout && compat_get_timespec64(&t, timeout))
+                return -EFAULT;
+
+        ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
+        if (!ret && signal_pending(current))
+                ret = -EINTR;
+        return ret;
+}
+
 
-        if (timeout) {
-                if (compat_get_timespec64(&t, timeout))
+struct __compat_aio_sigset {
+        compat_sigset_t __user  *sigmask;
+        compat_size_t           sigsetsize;
+};
+
+COMPAT_SYSCALL_DEFINE6(io_pgetevents,
+                compat_aio_context_t, ctx_id,
+                compat_long_t, min_nr,
+                compat_long_t, nr,
+                struct io_event __user *, events,
+                struct compat_timespec __user *, timeout,
+                const struct __compat_aio_sigset __user *, usig)
+{
+        struct __compat_aio_sigset ksig = { NULL, };
+        sigset_t ksigmask, sigsaved;
+        struct timespec64 t;
+        int ret;
+
+        if (timeout && compat_get_timespec64(&t, timeout))
+                return -EFAULT;
+
+        if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
+                return -EFAULT;
+
+        if (ksig.sigmask) {
+                if (ksig.sigsetsize != sizeof(compat_sigset_t))
+                        return -EINVAL;
+                if (get_compat_sigset(&ksigmask, ksig.sigmask))
                         return -EFAULT;
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
 
+        ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
+        if (signal_pending(current)) {
+                if (ksig.sigmask) {
+                        current->saved_sigmask = sigsaved;
+                        set_restore_sigmask();
+                }
+                if (!ret)
+                        ret = -ERESTARTNOHAND;
+        } else {
+                if (ksig.sigmask)
+                        sigprocmask(SIG_SETMASK, &sigsaved, NULL);
         }
 
-        return do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
+        return ret;
 }
 #endif