signal: sys_rt_sigtimedwait: simplify the timeout logic

No functional changes, cleanup compat_sys_rt_sigtimedwait() and
sys_rt_sigtimedwait().

Calculate the timeout before we take ->siglock, this simplifies and
lessens the code. Use timespec_valid() to check the timespec.

Signed-off-by: Oleg Nesterov <oleg@redhat.com>
Acked-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Matt Fleming <matt.fleming@linux.intel.com>

1 files changed, 21 insertions, 27 deletions

diff --git a/kernel/signal.c b/kernel/signal.c
index bb9200070ea0..c734619554f6 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -2519,7 +2519,7 @@ SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
         sigset_t these;
         struct timespec ts;
         siginfo_t info;
-        long timeout = 0;
+        long timeout;
 
         /* XXX: Don't preclude handling different sized sigset_t's.  */
         if (sigsetsize != sizeof(sigset_t))
@@ -2535,41 +2535,35 @@ SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
         signotset(&these);
 
+        timeout = MAX_SCHEDULE_TIMEOUT;
         if (uts) {
                 if (copy_from_user(&ts, uts, sizeof(ts)))
                         return -EFAULT;
-                if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
-                    || ts.tv_sec < 0)
+                if (!timespec_valid(&ts))
                         return -EINVAL;
+                timeout = timespec_to_jiffies(&ts) + (ts.tv_sec || ts.tv_nsec);
         }
 
         spin_lock_irq(&current->sighand->siglock);
         sig = dequeue_signal(current, &these, &info);
-        if (!sig) {
-                timeout = MAX_SCHEDULE_TIMEOUT;
-                if (uts)
-                        timeout = (timespec_to_jiffies(&ts)
-                                   + (ts.tv_sec || ts.tv_nsec));
+        if (!sig && timeout) {
+                /*
+                 * None ready -- temporarily unblock those we're
+                 * interested while we are sleeping in so that we'll
+                 * be awakened when they arrive.
+                 */
+                current->real_blocked = current->blocked;
+                sigandsets(&current->blocked, &current->blocked, &these);
+                recalc_sigpending();
+                spin_unlock_irq(&current->sighand->siglock);
 
-                if (timeout) {
-                        /*
-                         * None ready -- temporarily unblock those we're
-                         * interested while we are sleeping in so that we'll
-                         * be awakened when they arrive.
-                         */
-                        current->real_blocked = current->blocked;
-                        sigandsets(&current->blocked, &current->blocked, &these);
-                        recalc_sigpending();
-                        spin_unlock_irq(&current->sighand->siglock);
-
-                        timeout = schedule_timeout_interruptible(timeout);
-
-                        spin_lock_irq(&current->sighand->siglock);
-                        sig = dequeue_signal(current, &these, &info);
-                        current->blocked = current->real_blocked;
-                        siginitset(&current->real_blocked, 0);
-                        recalc_sigpending();
-                }
+                timeout = schedule_timeout_interruptible(timeout);
+
+                spin_lock_irq(&current->sighand->siglock);
+                sig = dequeue_signal(current, &these, &info);
+                current->blocked = current->real_blocked;
+                siginitset(&current->real_blocked, 0);
+                recalc_sigpending();
         }
         spin_unlock_irq(&current->sighand->siglock);