time/posix-timers: Move the compat copyouts to the nanosleep implementations

Turn restart_block.nanosleep.{rmtp,compat_rmtp} into a tagged union (kind =
1 -> native, kind = 2 -> compat, kind = 0 -> nothing) and make the places
doing actual copyout handle compat as well as native (that will become a
helper in the next commit).  Result: compat wrappers, messing with
reassignments, etc. are gone.

[ tglx: Folded in a variant of Peter Zijlstras enum patch ]

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20170607084241.28657-6-viro@ZenIV.linux.org.uk

5 files changed, 129 insertions, 36 deletions

diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
index d859a3601ddd..57bcf94ee132 100644
--- a/kernel/time/alarmtimer.c
+++ b/kernel/time/alarmtimer.c
@@ -27,6 +27,7 @@
 #include <linux/posix-timers.h>
 #include <linux/workqueue.h>
 #include <linux/freezer.h>
+#include <linux/compat.h>
 
 #include "posix-timers.h"
 
@@ -691,7 +692,7 @@ static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
 static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp,
                                 enum alarmtimer_type type)
 {
-        struct timespec __user *rmtp;
+        struct restart_block *restart;
         alarm->data = (void *)current;
         do {
                 set_current_state(TASK_INTERRUPTIBLE);
@@ -709,8 +710,8 @@ static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp,
 
         if (freezing(current))
                 alarmtimer_freezerset(absexp, type);
-        rmtp = current->restart_block.nanosleep.rmtp;
-        if (rmtp) {
+        restart = &current->restart_block;
+        if (restart->nanosleep.type != TT_NONE) {
                 struct timespec rmt;
                 ktime_t rem;
 
@@ -720,7 +721,14 @@ static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp,
                         return 0;
                 rmt = ktime_to_timespec(rem);
 
-                if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
+#ifdef CONFIG_COMPAT
+                if (restart->nanosleep.type == TT_COMPAT) {
+                        if (compat_put_timespec(&rmt,
+                                                restart->nanosleep.compat_rmtp))
+                                return -EFAULT;
+                } else
+#endif
+                if (copy_to_user(restart->nanosleep.rmtp, &rmt, sizeof(rmt)))
                         return -EFAULT;
         }
         return -ERESTART_RESTARTBLOCK;
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index baa7b846b6e3..5370da8fc0a4 100644
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -51,6 +51,7 @@
 #include <linux/sched/debug.h>
 #include <linux/timer.h>
 #include <linux/freezer.h>
+#include <linux/compat.h>
 
 #include <linux/uaccess.h>
 
@@ -1441,7 +1442,8 @@ EXPORT_SYMBOL_GPL(hrtimer_init_sleeper);
 
 static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)
 {
-        struct timespec __user *rmtp;
+        struct restart_block *restart;
+
         hrtimer_init_sleeper(t, current);
 
         do {
@@ -1461,15 +1463,23 @@ static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mod
         if (!t->task)
                 return 0;
 
-        rmtp = current->restart_block.nanosleep.rmtp;
-        if (rmtp) {
-                struct timespec rmt;
+        restart = &current->restart_block;
+        if (restart->nanosleep.type != TT_NONE) {
                 ktime_t rem = hrtimer_expires_remaining(&t->timer);
+                struct timespec rmt;
+
                 if (rem <= 0)
                         return 0;
                 rmt = ktime_to_timespec(rem);
 
-                if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
+#ifdef CONFIG_COMPAT
+                if (restart->nanosleep.type == TT_COMPAT) {
+                        if (compat_put_timespec(&rmt,
+                                                restart->nanosleep.compat_rmtp))
+                                return -EFAULT;
+                } else
+#endif
+                if (copy_to_user(restart->nanosleep.rmtp, &rmt, sizeof(rmt)))
                         return -EFAULT;
         }
         return -ERESTART_RESTARTBLOCK;
@@ -1535,10 +1545,32 @@ SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
         if (!timespec64_valid(&tu64))
                 return -EINVAL;
 
+        current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
         current->restart_block.nanosleep.rmtp = rmtp;
         return hrtimer_nanosleep(&tu64, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
 }
 
+#ifdef CONFIG_COMPAT
+
+COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
+{
+        struct timespec64 tu64;
+        struct timespec tu;
+
+        if (compat_get_timespec(&tu, rqtp))
+                return -EFAULT;
+
+        tu64 = timespec_to_timespec64(tu);
+        if (!timespec64_valid(&tu64))
+                return -EINVAL;
+
+        current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
+        current->restart_block.nanosleep.compat_rmtp = rmtp;
+        return hrtimer_nanosleep(&tu64, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
+}
+#endif
+
 /*
  * Functions related to boot-time initialization:
  */
diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index ec6258c9cde5..1563ca22cf1f 100644
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -12,6 +12,7 @@
 #include <trace/events/timer.h>
 #include <linux/tick.h>
 #include <linux/workqueue.h>
+#include <linux/compat.h>
 
 #include "posix-timers.h"
 
@@ -1243,10 +1244,9 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
         timer.it_process = current;
         if (!error) {
                 static struct itimerspec64 zero_it;
-                struct restart_block *restart = &current->restart_block;
-                struct timespec __user *rmtp;
+                struct restart_block *restart;
 
-                memset(&it, 0, sizeof it);
+                memset(&it, 0, sizeof(it));
                 it.it_value = *rqtp;
 
                 spin_lock_irq(&timer.it_lock);
@@ -1311,12 +1311,20 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                 /*
                  * Report back to the user the time still remaining.
                  */
-                rmtp = restart->nanosleep.rmtp;
-                if (rmtp) {
+                restart = &current->restart_block;
+                if (restart->nanosleep.type != TT_NONE) {
                         struct timespec ts;
 
                         ts = timespec64_to_timespec(it.it_value);
-                        if (copy_to_user(rmtp, &ts, sizeof(*rmtp)))
+#ifdef CONFIG_COMPAT
+                        if (restart->nanosleep.type == TT_COMPAT) {
+                                if (compat_put_timespec(&ts,
+                                                restart->nanosleep.compat_rmtp))
+                                        return -EFAULT;
+                        } else
+#endif
+                        if (copy_to_user(restart->nanosleep.rmtp, &ts,
+                                        sizeof(ts)))
                                 return -EFAULT;
                 }
                 restart->nanosleep.expires = timespec64_to_ns(rqtp);
diff --git a/kernel/time/posix-stubs.c b/kernel/time/posix-stubs.c
index 156a5e6f3bd2..749b76f2d757 100644
--- a/kernel/time/posix-stubs.c
+++ b/kernel/time/posix-stubs.c
@@ -17,6 +17,7 @@
 #include <linux/ktime.h>
 #include <linux/timekeeping.h>
 #include <linux/posix-timers.h>
+#include <linux/compat.h>
 
 asmlinkage long sys_ni_posix_timers(void)
 {
@@ -110,25 +111,53 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
         case CLOCK_REALTIME:
         case CLOCK_MONOTONIC:
         case CLOCK_BOOTTIME:
-                if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
-                        return -EFAULT;
-                t64 = timespec_to_timespec64(t);
-                if (!timespec64_valid(&t64))
-                        return -EINVAL;
-                if (flags & TIMER_ABSTIME)
-                        rmtp = NULL;
-                current->restart_block.nanosleep.rmtp = rmtp;
-                return hrtimer_nanosleep(&t64, flags & TIMER_ABSTIME ?
-                                         HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
-                                         which_clock);
+                break;
         default:
                 return -EINVAL;
         }
+
+        if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
+                return -EFAULT;
+        t64 = timespec_to_timespec64(t);
+        if (!timespec64_valid(&t64))
+                return -EINVAL;
+        if (flags & TIMER_ABSTIME)
+                rmtp = NULL;
+        current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
+        current->restart_block.nanosleep.rmtp = rmtp;
+        return hrtimer_nanosleep(&t64, flags & TIMER_ABSTIME ?
+                                 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
+                                 which_clock);
 }
 
 #ifdef CONFIG_COMPAT
-long clock_nanosleep_restart(struct restart_block *restart_block)
+COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
+                       struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
 {
-        return hrtimer_nanosleep_restart(restart_block);
+        struct timespec64 t64;
+        struct timespec t;
+
+        switch (which_clock) {
+        case CLOCK_REALTIME:
+        case CLOCK_MONOTONIC:
+        case CLOCK_BOOTTIME:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (compat_get_timespec(&t, rqtp))
+                return -EFAULT;
+        t64 = timespec_to_timespec64(t);
+        if (!timespec64_valid(&t64))
+                return -EINVAL;
+        if (flags & TIMER_ABSTIME)
+                rmtp = NULL;
+        current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
+        current->restart_block.nanosleep.compat_rmtp = rmtp;
+        return hrtimer_nanosleep(&t64, flags & TIMER_ABSTIME ?
+                                 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
+                                 which_clock);
 }
 #endif
diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c
index a3e5c01b430e..bec86b6b9814 100644
--- a/kernel/time/posix-timers.c
+++ b/kernel/time/posix-timers.c
@@ -49,6 +49,7 @@
 #include <linux/workqueue.h>
 #include <linux/export.h>
 #include <linux/hashtable.h>
+#include <linux/compat.h>
 
 #include "timekeeping.h"
 #include "posix-timers.h"
@@ -1069,25 +1070,40 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
                 return -EINVAL;
         if (flags & TIMER_ABSTIME)
                 rmtp = NULL;
+        current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
         current->restart_block.nanosleep.rmtp = rmtp;
 
         return kc->nsleep(which_clock, flags, &t64);
 }
 
-/*
- * This will restart clock_nanosleep. This is required only by
- * compat_clock_nanosleep_restart for now.
- */
-long clock_nanosleep_restart(struct restart_block *restart_block)
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
+                       struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
 {
-        clockid_t which_clock = restart_block->nanosleep.clockid;
         const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 t64;
+        struct timespec t;
 
-        if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
+        if (!kc)
                 return -EINVAL;
+        if (!kc->nsleep)
+                return -ENANOSLEEP_NOTSUP;
+
+        if (compat_get_timespec(&t, rqtp))
+                return -EFAULT;
 
-        return kc->nsleep_restart(restart_block);
+        t64 = timespec_to_timespec64(t);
+        if (!timespec64_valid(&t64))
+                return -EINVAL;
+        if (flags & TIMER_ABSTIME)
+                rmtp = NULL;
+        current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
+        current->restart_block.nanosleep.compat_rmtp = rmtp;
+
+        return kc->nsleep(which_clock, flags, &t64);
 }
+#endif
 
 static const struct k_clock clock_realtime = {
         .clock_getres           = posix_get_hrtimer_res,