[PATCH 4/8] nanosleep: Use get_timespec64() and set_timespec64()

[Deepa Dinamani <deepa.kernel@gmail.com>]

Usage of these apis and their compat versions makes
the sys_nanosleep() and sys_compat_nanosleep()
implementations simpler.

This patch also serves as a preparatory patch for changing
syscalls to use new time_t data types to support the
y2038 effort by eliminating the processing of user pointers
down the call stack.

Signed-off-by: Deepa Dinamani <deepa.kernel@gmail.com>
---
 include/linux/hrtimer.h        |   5 +-
 kernel/time/Makefile           |   2 +-
 kernel/time/alarmtimer.c       |  26 +++------
 kernel/time/hrtimer.c          |  17 ++----
 kernel/time/nanosleep.c        | 130 +++++++++++++++++++++++++----------------
 kernel/time/nanosleep.h        |  19 ++++++
 kernel/time/posix-cpu-timers.c |  27 ++++-----
 kernel/time/posix-stubs.c      |  93 +++++++++++------------------
 kernel/time/posix-timers.c     | 105 +++++++++++++++------------------
 kernel/time/posix-timers.h     |   5 +-
 10 files changed, 211 insertions(+), 218 deletions(-)
 create mode 100644 kernel/time/nanosleep.h

diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 8c5b10eb7265..e1e6ca9a4db4 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -453,10 +453,11 @@ static inline u64 hrtimer_forward_now(struct hrtimer *timer,
 
 /* Precise sleep: */
 extern long hrtimer_nanosleep(struct timespec64 *rqtp,
-			      struct timespec __user *rmtp,
+			      struct timespec64 *rmtp,
 			      const enum hrtimer_mode mode,
 			      const clockid_t clockid);
-extern long hrtimer_nanosleep_restart(struct restart_block *restart_block);
+extern long hrtimer_nanosleep_restart(struct restart_block *restart_block,
+				struct timespec64 *rmtp);
 
 extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
 				 struct task_struct *tsk);
diff --git a/kernel/time/Makefile b/kernel/time/Makefile
index 938dbf33ef49..0dee7cfc792b 100644
--- a/kernel/time/Makefile
+++ b/kernel/time/Makefile
@@ -1,4 +1,4 @@
-obj-y += time.o timer.o hrtimer.o
+obj-y += time.o timer.o hrtimer.o nanosleep.o
 obj-y += timekeeping.o ntp.o clocksource.o jiffies.o timer_list.o
 obj-y += timeconv.o timecounter.o alarmtimer.o
 
diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
index d8a7a7e214de..567c9ca47974 100644
--- a/kernel/time/alarmtimer.c
+++ b/kernel/time/alarmtimer.c
@@ -710,28 +710,23 @@ static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
  * update_rmtp - Update remaining timespec value
  * @exp: expiration time
  * @type: timer type
- * @rmtp: user pointer to remaining timepsec value
+ * @rmtp: pointer to remaining timespec value
  *
  * Helper function that fills in rmtp value with time between
  * now and the exp value
  */
-static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
-			struct timespec __user *rmtp)
+static int update_rmtp(ktime_t exp, enum alarmtimer_type type,
+		       struct timespec64 *rmtp)
 {
-	struct timespec rmt;
 	ktime_t rem;
 
 	rem = ktime_sub(exp, alarm_bases[type].gettime());
 
 	if (rem <= 0)
 		return 0;
-	rmt = ktime_to_timespec(rem);
-
-	if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
-		return -EFAULT;
+	*rmtp = ktime_to_timespec64(rem);
 
 	return 1;
-
 }
 
 /**
@@ -740,12 +735,12 @@ static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
  *
  * Handles restarted clock_nanosleep calls
  */
-static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
+static long __sched alarm_timer_nsleep_restart(struct restart_block *restart,
+			struct timespec64 *rmtp)
 {
 	enum  alarmtimer_type type = restart->nanosleep.clockid;
-	ktime_t exp;
-	struct timespec __user  *rmtp;
 	struct alarm alarm;
+	ktime_t exp;
 	int ret = 0;
 
 	exp = restart->nanosleep.expires;
@@ -757,14 +752,12 @@ static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
 	if (freezing(current))
 		alarmtimer_freezerset(exp, type);
 
-	rmtp = restart->nanosleep.rmtp;
 	if (rmtp) {
 		ret = update_rmtp(exp, type, rmtp);
 		if (ret <= 0)
 			goto out;
 	}
 
-
 	/* The other values in restart are already filled in */
 	ret = -ERESTART_RESTARTBLOCK;
 out:
@@ -782,7 +775,7 @@ static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
  */
 static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
 			      struct timespec64 *tsreq,
-			      struct timespec __user *rmtp)
+			      struct timespec64 *rmtp)
 {
 	enum  alarmtimer_type type = clock2alarm(which_clock);
 	struct restart_block *restart;
@@ -827,10 +820,8 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
 	}
 
 	restart = &current->restart_block;
-	restart->fn = alarm_timer_nsleep_restart;
 	restart->nanosleep.clockid = type;
 	restart->nanosleep.expires = exp;
-	restart->nanosleep.rmtp = rmtp;
 	ret = -ERESTART_RESTARTBLOCK;
 
 out:
@@ -850,6 +841,7 @@ const struct k_clock alarm_clock = {
 	.timer_remaining	= alarm_timer_remaining,
 	.timer_try_to_cancel	= alarm_timer_try_to_cancel,
 	.nsleep			= alarm_timer_nsleep,
+	.nsleep_restart		= alarm_timer_nsleep_restart,
 };
 #endif /* CONFIG_POSIX_TIMERS */
 
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index e95628910b00..a53857ca28b4 100644
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -1461,26 +1461,22 @@ static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mod
 	return t->task == NULL;
 }
 
-static int update_rmtp(struct hrtimer *timer, struct timespec __user *rmtp)
+static int update_rmtp(struct hrtimer *timer, struct timespec64 *rmtp)
 {
-	struct timespec rmt;
 	ktime_t rem;
 
 	rem = hrtimer_expires_remaining(timer);
 	if (rem <= 0)
 		return 0;
-	rmt = ktime_to_timespec(rem);
-
-	if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
-		return -EFAULT;
+	*rmtp = ktime_to_timespec64(rem);
 
 	return 1;
 }
 
-long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
+long __sched hrtimer_nanosleep_restart(struct restart_block *restart,
+		struct timespec64 *rmtp)
 {
 	struct hrtimer_sleeper t;
-	struct timespec __user  *rmtp;
 	int ret = 0;
 
 	hrtimer_init_on_stack(&t.timer, restart->nanosleep.clockid,
@@ -1490,7 +1486,6 @@ long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
 	if (do_nanosleep(&t, HRTIMER_MODE_ABS))
 		goto out;
 
-	rmtp = restart->nanosleep.rmtp;
 	if (rmtp) {
 		ret = update_rmtp(&t.timer, rmtp);
 		if (ret <= 0)
@@ -1504,7 +1499,7 @@ long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
 	return ret;
 }
 
-long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
+long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec64 *rmtp,
 		       const enum hrtimer_mode mode, const clockid_t clockid)
 {
 	struct restart_block *restart;
@@ -1534,9 +1529,7 @@ long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
 	}
 
 	restart = &current->restart_block;
-	restart->fn = hrtimer_nanosleep_restart;
 	restart->nanosleep.clockid = t.timer.base->clockid;
-	restart->nanosleep.rmtp = rmtp;
 	restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
 
 	ret = -ERESTART_RESTARTBLOCK;
diff --git a/kernel/time/nanosleep.c b/kernel/time/nanosleep.c
index 2b6e6980b65d..dd7d792b008b 100644
--- a/kernel/time/nanosleep.c
+++ b/kernel/time/nanosleep.c
@@ -1,64 +1,67 @@
-SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
-		struct timespec __user *, rmtp)
+#include <linux/syscalls.h>
+#include <linux/compat.h>
+
+#include "nanosleep.h"
+
+long nanosleep_process_return(long ret,
+			   const struct timespec64 *rmtp_kernel,
+			   struct timespec __user *rmtp,
+			   long (*fn)(struct restart_block *))
 {
-	struct timespec64 tu64;
-	struct timespec tu;
+	struct restart_block *restart = &current->restart_block;
 
-	if (copy_from_user(&tu, rqtp, sizeof(tu)))
+	if ((ret == -ERESTART_RESTARTBLOCK) && rmtp &&
+	    put_timespec64(rmtp_kernel, rmtp))
 		return -EFAULT;
 
-	tu64 = timespec_to_timespec64(tu);
-	if (!timespec64_valid(&tu64))
-		return -EINVAL;
+	if (ret == -ERESTART_RESTARTBLOCK) {
+		restart->nanosleep.rmtp = rmtp;
+		restart->fn = fn;
+	}
 
-	return hrtimer_nanosleep(&tu64, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
+	return ret;
 }
 
-#ifdef CONFIG_COMPAT
-static long compat_nanosleep_restart(struct restart_block *restart)
+long nanosleep_restart(struct restart_block *restart_block)
 {
-	struct compat_timespec __user *rmtp;
-	struct timespec rmt;
-	mm_segment_t oldfs;
+	struct timespec __user *rmtp = restart_block->nanosleep.rmtp;
+	struct timespec64 rmt;
 	long ret;
 
-	restart->nanosleep.rmtp = (struct timespec __user *) &rmt;
-	oldfs = get_fs();
-	set_fs(KERNEL_DS);
-	ret = hrtimer_nanosleep_restart(restart);
-	set_fs(oldfs);
-
-	if (ret == -ERESTART_RESTARTBLOCK) {
-		rmtp = restart->nanosleep.compat_rmtp;
-
-		if (rmtp && compat_put_timespec(&rmt, rmtp))
-			return -EFAULT;
-	}
+	ret = hrtimer_nanosleep_restart(restart_block,
+					rmtp ? &rmt : NULL);
 
-	return ret;
+	return nanosleep_process_return(ret, &rmt,
+					rmtp,
+					nanosleep_restart);
 }
 
-COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
-		       struct compat_timespec __user *, rmtp)
+SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
+		struct timespec __user *, rmtp)
 {
-	struct timespec tu, rmt;
-	struct timespec64 tu64;
-	mm_segment_t oldfs;
-	long ret;
+	struct timespec64 in;
+	struct timespec64 out;
+	int err;
 
-	if (compat_get_timespec(&tu, rqtp))
+	if (get_timespec64(&in, rqtp))
 		return -EFAULT;
 
-	tu64 = timespec_to_timespec64(tu);
-	if (!timespec64_valid(&tu64))
+	if (!timespec64_valid(&in))
 		return -EINVAL;
 
-	oldfs = get_fs();
-	set_fs(KERNEL_DS);
-	ret = hrtimer_nanosleep(&tu64,
-				rmtp ? (struct timespec __user *)&rmt : NULL,
+	err = hrtimer_nanosleep(&in, rmtp ? &out : NULL,
 				HRTIMER_MODE_REL, CLOCK_MONOTONIC);
-	set_fs(oldfs);
+
+	return nanosleep_process_return(err, &out, rmtp, nanosleep_restart);
+}
+
+#ifdef CONFIG_COMPAT
+long compat_nanosleep_process_return(long err,
+			struct timespec64 *rmt,
+			struct compat_timespec __user *rmtp,
+			long (*fn)(struct restart_block *))
+{
+	struct restart_block *restart = &current->restart_block;
 
 	/*
 	 * hrtimer_nanosleep() can only return 0 or
@@ -79,16 +82,45 @@ COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
 	 * We check for -ERESTART_RESTARTBLOCK nevertheless if the
 	 * core implementation decides to return random nonsense.
 	 */
-	if (ret == -ERESTART_RESTARTBLOCK) {
-		struct restart_block *restart = &current->restart_block;
+	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
+	    compat_put_timespec64(rmt, rmtp))
+		return -EFAULT;
 
-		restart->fn = compat_nanosleep_restart;
+	if (err == -ERESTART_RESTARTBLOCK) {
+		restart->fn = fn;
 		restart->nanosleep.compat_rmtp = rmtp;
-
-		if (rmtp && compat_put_timespec(&rmt, rmtp))
-			return -EFAULT;
 	}
-	return ret;
+	return err;
 }
-#endif
 
+long compat_nanosleep_restart(struct restart_block *restart)
+{
+	struct compat_timespec __user *rmtp = restart->nanosleep.compat_rmtp;
+	struct timespec64 kernel_rmt;
+	long ret;
+
+	ret = hrtimer_nanosleep_restart(restart, rmtp ?  &kernel_rmt : NULL);
+
+	return compat_nanosleep_process_return(ret, &kernel_rmt, rmtp,
+					       compat_nanosleep_restart);
+}
+
+COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
+		       struct compat_timespec __user *, rmtp)
+{
+	struct timespec64 tu, rmt;
+	long ret;
+
+	if (compat_get_timespec64(&tu, rqtp))
+		return -EFAULT;
+
+	if (!timespec64_valid(&tu))
+		return -EINVAL;
+
+	ret = hrtimer_nanosleep(&tu, rmtp ? &rmt : NULL,
+				HRTIMER_MODE_REL, CLOCK_MONOTONIC);
+
+	return compat_nanosleep_process_return(ret, &rmt, rmtp,
+					       compat_nanosleep_restart);
+}
+#endif
diff --git a/kernel/time/nanosleep.h b/kernel/time/nanosleep.h
new file mode 100644
index 000000000000..68c924e0af14
--- /dev/null
+++ b/kernel/time/nanosleep.h
@@ -0,0 +1,19 @@
+#include <linux/compat.h>
+
+long nanosleep_restart(struct restart_block *restart_block);
+
+long nanosleep_process_return(long ret,
+		const struct timespec64 *rmtp_kernel,
+		struct timespec __user *rmtp,
+		long (*fn)(struct restart_block *));
+
+
+#ifdef CONFIG_COMPAT
+long compat_nanosleep_restart(struct restart_block *restart);
+
+long compat_nanosleep_process_return(long err,
+	struct timespec64 *rmt,
+	struct compat_timespec __user *rmtp,
+	long (*fn)(struct restart_block *));
+
+#endif
diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index cb4a4eb44279..24df407e2a6d 100644
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -1310,14 +1310,14 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
 	return error;
 }
 
-static long posix_cpu_nsleep_restart(struct restart_block *restart_block);
+static long posix_cpu_nsleep_restart(struct restart_block *restart_block,
+				     struct timespec64 *rmtp);
 
 static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
-			    struct timespec64 *rqtp, struct timespec __user *rmtp)
+			    struct timespec64 *rqtp, struct timespec64 *rmtp)
 {
 	struct restart_block *restart_block = &current->restart_block;
 	struct itimerspec64 it;
-	struct timespec ts;
 	int error;
 
 	/*
@@ -1337,24 +1337,20 @@ static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
 		/*
 		 * Report back to the user the time still remaining.
 		 */
-		ts = timespec64_to_timespec(it.it_value);
-		if (rmtp && copy_to_user(rmtp, &ts, sizeof(*rmtp)))
-			return -EFAULT;
+		*rmtp = it.it_value;
 
-		restart_block->fn = posix_cpu_nsleep_restart;
 		restart_block->nanosleep.clockid = which_clock;
-		restart_block->nanosleep.rmtp = rmtp;
 		restart_block->nanosleep.expires = timespec64_to_ns(rqtp);
 	}
 	return error;
 }
 
-static long posix_cpu_nsleep_restart(struct restart_block *restart_block)
+static long posix_cpu_nsleep_restart(struct restart_block *restart_block,
+				     struct timespec64 *rmtp)
 {
 	clockid_t which_clock = restart_block->nanosleep.clockid;
 	struct itimerspec64 it;
 	struct timespec64 t;
-	struct timespec tmp;
 	int error;
 
 	t = ns_to_timespec64(restart_block->nanosleep.expires);
@@ -1362,14 +1358,10 @@ static long posix_cpu_nsleep_restart(struct restart_block *restart_block)
 	error = do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t, &it);
 
 	if (error == -ERESTART_RESTARTBLOCK) {
-		struct timespec __user *rmtp = restart_block->nanosleep.rmtp;
 		/*
 		 * Report back to the user the time still remaining.
 		 */
-		 tmp = timespec64_to_timespec(it.it_value);
-		if (rmtp && copy_to_user(rmtp, &tmp, sizeof(*rmtp)))
-			return -EFAULT;
-
+		*rmtp = it.it_value;
 		restart_block->nanosleep.expires = timespec64_to_ns(&t);
 	}
 	return error;
@@ -1396,11 +1388,12 @@ static int process_cpu_timer_create(struct k_itimer *timer)
 }
 static int process_cpu_nsleep(const clockid_t which_clock, int flags,
 			      struct timespec64 *rqtp,
-			      struct timespec __user *rmtp)
+			      struct timespec64 *rmtp)
 {
 	return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp, rmtp);
 }
-static long process_cpu_nsleep_restart(struct restart_block *restart_block)
+static long process_cpu_nsleep_restart(struct restart_block *restart_block,
+				       struct timespec64 *tp)
 {
 	return -EINVAL;
 }
diff --git a/kernel/time/posix-stubs.c b/kernel/time/posix-stubs.c
index cd1b9a2e2618..61daf3576e85 100644
--- a/kernel/time/posix-stubs.c
+++ b/kernel/time/posix-stubs.c
@@ -11,6 +11,7 @@
 
 #include <linux/linkage.h>
 #include <linux/kernel.h>
+#include <linux/compat.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/syscalls.h>
@@ -19,6 +20,8 @@
 #include <linux/timekeeping.h>
 #include <linux/posix-timers.h>
 
+#include "nanosleep.h"
+
 asmlinkage long sys_ni_posix_timers(void)
 {
 	pr_err_once("process %d (%s) attempted a POSIX timer syscall "
@@ -100,28 +103,44 @@ SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, struct timespec __us
 	}
 }
 
-SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
-		const struct timespec __user *, rqtp,
-		struct timespec __user *, rmtp)
+static long do_clock_nanosleep(const clockid_t which_clock,
+				int flags,
+				struct timespec64 *rqtp,
+				struct timespec64 *rmtp)
 {
-	struct timespec64 t64;
-	struct timespec t;
+	long ret;
 
 	switch (which_clock) {
 	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))
+		if (!timespec64_valid(rqtp))
 			return -EINVAL;
-		return hrtimer_nanosleep(&t64, rmtp, flags & TIMER_ABSTIME ?
+		ret = hrtimer_nanosleep(rqtp, rmtp, flags & TIMER_ABSTIME ?
 					 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
 					 which_clock);
+		break;
 	default:
 		return -EINVAL;
 	}
+
+	return ret;
+}
+
+SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
+		const struct timespec __user *, rqtp,
+		struct timespec __user *, rmtp)
+{
+	struct timespec64 in, out;
+	struct timespec64 *rtn = rmtp ? &out : NULL;
+	long ret;
+
+	if (get_timespec64(&in, rqtp))
+		return -EFAULT;
+
+	ret = do_clock_nanosleep(which_clock, flags, &in, rtn);
+
+	return nanosleep_process_return(ret, rtn, rmtp, nanosleep_restart);
 }
 
 #ifdef CONFIG_COMPAT
@@ -180,63 +199,19 @@ COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
 	return err;
 }
 
-long clock_nanosleep_restart(struct restart_block *restart_block)
-{
-	return hrtimer_nanosleep_restart(restart_block);
-}
-
-static long compat_clock_nanosleep_restart(struct restart_block *restart)
-{
-	long err;
-	mm_segment_t oldfs;
-	struct timespec tu;
-	struct compat_timespec __user *rmtp = restart->nanosleep.compat_rmtp;
-
-	restart->nanosleep.rmtp = (struct timespec __user *) &tu;
-	oldfs = get_fs();
-	set_fs(KERNEL_DS);
-	err = clock_nanosleep_restart(restart);
-	set_fs(oldfs);
-
-	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
-	    compat_put_timespec(&tu, rmtp))
-		return -EFAULT;
-
-	if (err == -ERESTART_RESTARTBLOCK) {
-		restart->fn = compat_clock_nanosleep_restart;
-		restart->nanosleep.compat_rmtp = rmtp;
-	}
-	return err;
-}
-
 COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
 		       struct compat_timespec __user *, rqtp,
 		       struct compat_timespec __user *, rmtp)
 {
+	struct timespec64 in, out;
 	long err;
-	mm_segment_t oldfs;
-	struct timespec in, out;
-	struct restart_block *restart;
 
-	if (compat_get_timespec(&in, rqtp))
+	if (compat_get_timespec64(&in, rqtp))
 		return -EFAULT;
 
-	oldfs = get_fs();
-	set_fs(KERNEL_DS);
-	err = sys_clock_nanosleep(which_clock, flags,
-				  (struct timespec __user *) &in,
-				  (struct timespec __user *) &out);
-	set_fs(oldfs);
-
-	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
-	    compat_put_timespec(&out, rmtp))
-		return -EFAULT;
+	err = do_clock_nanosleep(which_clock, flags, &in, &out);
 
-	if (err == -ERESTART_RESTARTBLOCK) {
-		restart = &current->restart_block;
-		restart->fn = compat_clock_nanosleep_restart;
-		restart->nanosleep.compat_rmtp = rmtp;
-	}
-	return err;
+	return compat_nanosleep_process_return(err, &out, rmtp,
+					       compat_nanosleep_restart);
 }
 #endif
diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c
index 009a9145d64d..58c2f9c2c2c8 100644
--- a/kernel/time/posix-timers.c
+++ b/kernel/time/posix-timers.c
@@ -37,6 +37,7 @@
 #include <linux/mutex.h>
 #include <linux/sched/task.h>
 
+#include <linux/compat.h>
 #include <linux/uaccess.h>
 #include <linux/list.h>
 #include <linux/init.h>
@@ -53,6 +54,7 @@
 
 #include "timekeeping.h"
 #include "posix-timers.h"
+#include "nanosleep.h"
 
 /*
  * Management arrays for POSIX timers. Timers are now kept in static hash table
@@ -1027,49 +1029,52 @@ SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
  * nanosleep for monotonic and realtime clocks
  */
 static int common_nsleep(const clockid_t which_clock, int flags,
-			 struct timespec64 *tsave, struct timespec __user *rmtp)
+			 struct timespec64 *tsave, struct timespec64 *rmtp)
 {
 	return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
 				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
 				 which_clock);
 }
 
+long clock_nanosleep_restart(struct restart_block *restart_block)
+{
+	clockid_t which_clock = restart_block->nanosleep.clockid;
+	const struct k_clock *kc = clockid_to_kclock(which_clock);
+	struct timespec64 rmt;
+	long ret;
+
+	if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
+		return -EINVAL;
+
+	ret = kc->nsleep_restart(restart_block,
+		restart_block->nanosleep.rmtp ? &rmt : NULL);
+	return nanosleep_process_return(ret, &rmt,
+					restart_block->nanosleep.rmtp,
+					clock_nanosleep_restart);
+}
+
 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
 		const struct timespec __user *, rqtp,
 		struct timespec __user *, rmtp)
 {
 	const struct k_clock *kc = clockid_to_kclock(which_clock);
-	struct timespec64 t64;
-	struct timespec t;
+	struct timespec64 in, out;
+	long err;
 
 	if (!kc)
 		return -EINVAL;
 	if (!kc->nsleep)
 		return -ENANOSLEEP_NOTSUP;
 
-	if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
+	if (get_timespec64(&in, rqtp))
 		return -EFAULT;
 
-	t64 = timespec_to_timespec64(t);
-	if (!timespec64_valid(&t64))
+	if (!timespec64_valid(&in))
 		return -EINVAL;
 
-	return kc->nsleep(which_clock, flags, &t64, rmtp);
-}
-
-/*
- * 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)
-{
-	clockid_t which_clock = restart_block->nanosleep.clockid;
-	const struct k_clock *kc = clockid_to_kclock(which_clock);
-
-	if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
-		return -EINVAL;
-
-	return kc->nsleep_restart(restart_block);
+	err = kc->nsleep(which_clock, flags, &in, rmtp ? &out : NULL);
+	return nanosleep_process_return(err, &out, rmtp,
+					clock_nanosleep_restart);
 }
 
 static const struct k_clock clock_realtime = {
@@ -1181,57 +1186,40 @@ static const struct k_clock *clockid_to_kclock(const clockid_t id)
 #ifdef CONFIG_COMPAT
 static long compat_clock_nanosleep_restart(struct restart_block *restart)
 {
-	long err;
-	mm_segment_t oldfs;
-	struct timespec tu;
 	struct compat_timespec __user *rmtp = restart->nanosleep.compat_rmtp;
+	clockid_t which_clock = restart->nanosleep.clockid;
+	const struct k_clock *kc = clockid_to_kclock(which_clock);
+	struct timespec64 rmt;
+	long err;
 
-	restart->nanosleep.rmtp = (struct timespec __user *) &tu;
-	oldfs = get_fs();
-	set_fs(KERNEL_DS);
-	err = clock_nanosleep_restart(restart);
-	set_fs(oldfs);
+	if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
+		return -EINVAL;
 
-	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
-	    compat_put_timespec(&tu, rmtp))
-		return -EFAULT;
+	err = kc->nsleep_restart(restart, rmtp ? &rmt : NULL);
 
-	if (err == -ERESTART_RESTARTBLOCK) {
-		restart->fn = compat_clock_nanosleep_restart;
-		restart->nanosleep.compat_rmtp = rmtp;
-	}
-	return err;
+	return compat_nanosleep_process_return(err, &rmt, rmtp,
+					       compat_clock_nanosleep_restart);
 }
 
 COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
 		       struct compat_timespec __user *, rqtp,
 		       struct compat_timespec __user *, rmtp)
 {
+	const struct k_clock *kc = clockid_to_kclock(which_clock);
+	struct timespec64 in, out;
 	long err;
-	mm_segment_t oldfs;
-	struct timespec in, out;
-	struct restart_block *restart;
 
-	if (compat_get_timespec(&in, rqtp))
+	if (compat_get_timespec64(&in, rqtp))
 		return -EFAULT;
 
-	oldfs = get_fs();
-	set_fs(KERNEL_DS);
-	err = sys_clock_nanosleep(which_clock, flags,
-				  (struct timespec __user *) &in,
-				  (struct timespec __user *) &out);
-	set_fs(oldfs);
-
-	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
-	    compat_put_timespec(&out, rmtp))
-		return -EFAULT;
+	if (!kc)
+		return -EINVAL;
+	if (!kc->nsleep)
+		return -ENANOSLEEP_NOTSUP;
+	err = kc->nsleep(which_clock, flags, &in, rmtp ? &out : NULL);
 
-	if (err == -ERESTART_RESTARTBLOCK) {
-		restart = &current->restart_block;
-		restart->fn = compat_clock_nanosleep_restart;
-		restart->nanosleep.compat_rmtp = rmtp;
-	}
-	return err;
+	return compat_nanosleep_process_return(err, &out, rmtp,
+					       compat_clock_nanosleep_restart);
 }
 
 COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
@@ -1324,5 +1312,4 @@ COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
 		return -EFAULT;
 	return err;
 }
-
 #endif
diff --git a/kernel/time/posix-timers.h b/kernel/time/posix-timers.h
index b086f5ba2f5b..85a3f34593df 100644
--- a/kernel/time/posix-timers.h
+++ b/kernel/time/posix-timers.h
@@ -10,8 +10,9 @@ struct k_clock {
 	int	(*clock_adj)(const clockid_t which_clock, struct timex *tx);
 	int	(*timer_create)(struct k_itimer *timer);
 	int	(*nsleep)(const clockid_t which_clock, int flags,
-			  struct timespec64 *, struct timespec __user *);
-	long	(*nsleep_restart)(struct restart_block *restart_block);
+			  struct timespec64 *, struct timespec64 *);
+	long	(*nsleep_restart)(struct restart_block *restart_block,
+				  struct timespec64 *);
 	int	(*timer_set)(struct k_itimer *timr, int flags,
 			     struct itimerspec64 *new_setting,
 			     struct itimerspec64 *old_setting);
-- 
2.11.0