1 files changed, 67 insertions, 459 deletions
diff --git a/kernel/compat.c b/kernel/compat.c
index 933bcb31ae10..ebd8bdc3fd68 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -30,100 +30,66 @@
 #include <linux/uaccess.h>
-static int compat_get_timex(struct timex *txc, struct compat_timex __user *utp)
+int compat_get_timex(struct timex *txc, const struct compat_timex __user *utp)
 {
-        memset(txc, 0, sizeof(struct timex));
+        struct compat_timex tx32;
-        if (!access_ok(VERIFY_READ, utp, sizeof(struct compat_timex)) ||
-                        __get_user(txc->modes, &utp->modes) ||
-                        __get_user(txc->offset, &utp->offset) ||
-                        __get_user(txc->freq, &utp->freq) ||
-                        __get_user(txc->maxerror, &utp->maxerror) ||
-                        __get_user(txc->esterror, &utp->esterror) ||
-                        __get_user(txc->status, &utp->status) ||
-                        __get_user(txc->constant, &utp->constant) ||
-                        __get_user(txc->precision, &utp->precision) ||
-                        __get_user(txc->tolerance, &utp->tolerance) ||
-                        __get_user(txc->time.tv_sec, &utp->time.tv_sec) ||
-                        __get_user(txc->time.tv_usec, &utp->time.tv_usec) ||
-                        __get_user(txc->tick, &utp->tick) ||
-                        __get_user(txc->ppsfreq, &utp->ppsfreq) ||
-                        __get_user(txc->jitter, &utp->jitter) ||
-                        __get_user(txc->shift, &utp->shift) ||
-                        __get_user(txc->stabil, &utp->stabil) ||
-                        __get_user(txc->jitcnt, &utp->jitcnt) ||
-                        __get_user(txc->calcnt, &utp->calcnt) ||
-                        __get_user(txc->errcnt, &utp->errcnt) ||
-                        __get_user(txc->stbcnt, &utp->stbcnt))
-                return -EFAULT;
-        return 0;
+        if (copy_from_user(&tx32, utp, sizeof(struct compat_timex)))
-}
-static int compat_put_timex(struct compat_timex __user *utp, struct timex *txc)
-{
-        if (!access_ok(VERIFY_WRITE, utp, sizeof(struct compat_timex)) ||
-                        __put_user(txc->modes, &utp->modes) ||
-                        __put_user(txc->offset, &utp->offset) ||
-                        __put_user(txc->freq, &utp->freq) ||
-                        __put_user(txc->maxerror, &utp->maxerror) ||
-                        __put_user(txc->esterror, &utp->esterror) ||
-                        __put_user(txc->status, &utp->status) ||
-                        __put_user(txc->constant, &utp->constant) ||
-                        __put_user(txc->precision, &utp->precision) ||
-                        __put_user(txc->tolerance, &utp->tolerance) ||
-                        __put_user(txc->time.tv_sec, &utp->time.tv_sec) ||
-                        __put_user(txc->time.tv_usec, &utp->time.tv_usec) ||
-                        __put_user(txc->tick, &utp->tick) ||
-                        __put_user(txc->ppsfreq, &utp->ppsfreq) ||
-                        __put_user(txc->jitter, &utp->jitter) ||
-                        __put_user(txc->shift, &utp->shift) ||
-                        __put_user(txc->stabil, &utp->stabil) ||
-                        __put_user(txc->jitcnt, &utp->jitcnt) ||
-                        __put_user(txc->calcnt, &utp->calcnt) ||
-                        __put_user(txc->errcnt, &utp->errcnt) ||
-                        __put_user(txc->stbcnt, &utp->stbcnt) ||
-                        __put_user(txc->tai, &utp->tai))
                return -EFAULT;
-        return 0;
-}
-COMPAT_SYSCALL_DEFINE2(gettimeofday, struct compat_timeval __user *, tv,
+        txc->modes = tx32.modes;
-                       struct timezone __user *, tz)
+        txc->offset = tx32.offset;
-{
+        txc->freq = tx32.freq;
-        if (tv) {
+        txc->maxerror = tx32.maxerror;
-                struct timeval ktv;
+        txc->esterror = tx32.esterror;
-                do_gettimeofday(&ktv);
+        txc->status = tx32.status;
-                if (compat_put_timeval(&ktv, tv))
+        txc->constant = tx32.constant;
-                        return -EFAULT;
+        txc->precision = tx32.precision;
-        }
+        txc->tolerance = tx32.tolerance;
-        if (tz) {
+        txc->time.tv_sec = tx32.time.tv_sec;
-                if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
+        txc->time.tv_usec = tx32.time.tv_usec;
-                        return -EFAULT;
+        txc->tick = tx32.tick;
-        }
+        txc->ppsfreq = tx32.ppsfreq;
+        txc->jitter = tx32.jitter;
+        txc->shift = tx32.shift;
+        txc->stabil = tx32.stabil;
+        txc->jitcnt = tx32.jitcnt;
+        txc->calcnt = tx32.calcnt;
+        txc->errcnt = tx32.errcnt;
+        txc->stbcnt = tx32.stbcnt;
        return 0;
 }
-COMPAT_SYSCALL_DEFINE2(settimeofday, struct compat_timeval __user *, tv,
+int compat_put_timex(struct compat_timex __user *utp, const struct timex *txc)
-                       struct timezone __user *, tz)
+{
-{
+        struct compat_timex tx32;
-        struct timespec64 new_ts;
-        struct timeval user_tv;
+        memset(&tx32, 0, sizeof(struct compat_timex));
-        struct timezone new_tz;
+        tx32.modes = txc->modes;
+        tx32.offset = txc->offset;
-        if (tv) {
+        tx32.freq = txc->freq;
-                if (compat_get_timeval(&user_tv, tv))
+        tx32.maxerror = txc->maxerror;
-                        return -EFAULT;
+        tx32.esterror = txc->esterror;
-                new_ts.tv_sec = user_tv.tv_sec;
+        tx32.status = txc->status;
-                new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
+        tx32.constant = txc->constant;
-        }
+        tx32.precision = txc->precision;
-        if (tz) {
+        tx32.tolerance = txc->tolerance;
-                if (copy_from_user(&new_tz, tz, sizeof(*tz)))
+        tx32.time.tv_sec = txc->time.tv_sec;
-                        return -EFAULT;
+        tx32.time.tv_usec = txc->time.tv_usec;
-        }
+        tx32.tick = txc->tick;
+        tx32.ppsfreq = txc->ppsfreq;
-        return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
+        tx32.jitter = txc->jitter;
+        tx32.shift = txc->shift;
+        tx32.stabil = txc->stabil;
+        tx32.jitcnt = txc->jitcnt;
+        tx32.calcnt = txc->calcnt;
+        tx32.errcnt = txc->errcnt;
+        tx32.stbcnt = txc->stbcnt;
+        tx32.tai = txc->tai;
+        if (copy_to_user(utp, &tx32, sizeof(struct compat_timex)))
+                return -EFAULT;
+        return 0;
 }
 static int __compat_get_timeval(struct timeval *tv, const struct compat_timeval __user *ctv)
@@ -213,141 +179,28 @@ int compat_convert_timespec(struct timespec __user **kts,
        return 0;
 }
-static long compat_nanosleep_restart(struct restart_block *restart)
+int get_compat_itimerval(struct itimerval *o, const struct compat_itimerval __user *i)
-{
-        struct compat_timespec __user *rmtp;
-        struct timespec rmt;
-        mm_segment_t oldfs;
-        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;
-        }
-        return ret;
-}
-COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
-                       struct compat_timespec __user *, rmtp)
 {
-        struct timespec tu, rmt;
+        struct compat_itimerval v32;
-        struct timespec64 tu64;
-        mm_segment_t oldfs;
-        long ret;
-        if (compat_get_timespec(&tu, rqtp))
+        if (copy_from_user(&v32, i, sizeof(struct compat_itimerval)))
                return -EFAULT;
+        o->it_interval.tv_sec = v32.it_interval.tv_sec;
-        tu64 = timespec_to_timespec64(tu);
+        o->it_interval.tv_usec = v32.it_interval.tv_usec;
-        if (!timespec64_valid(&tu64))
+        o->it_value.tv_sec = v32.it_value.tv_sec;
-                return -EINVAL;
+        o->it_value.tv_usec = v32.it_value.tv_usec;
+        return 0;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        ret = hrtimer_nanosleep(&tu64,
-                                rmtp ? (struct timespec __user *)&rmt : NULL,
-                                HRTIMER_MODE_REL, CLOCK_MONOTONIC);
-        set_fs(oldfs);
-        /*
-         * hrtimer_nanosleep() can only return 0 or
-         * -ERESTART_RESTARTBLOCK here because:
-         *
-         * - we call it with HRTIMER_MODE_REL and therefor exclude the
-         *   -ERESTARTNOHAND return path.
-         *
-         * - we supply the rmtp argument from the task stack (due to
-         *   the necessary compat conversion. So the update cannot
-         *   fail, which excludes the -EFAULT return path as well. If
-         *   it fails nevertheless we have a bigger problem and wont
-         *   reach this place anymore.
-         *
-         * - if the return value is 0, we do not have to update rmtp
-         *    because there is no remaining time.
-         *
-         * 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;
-                restart->fn = compat_nanosleep_restart;
-                restart->nanosleep.compat_rmtp = rmtp;
-                if (rmtp && compat_put_timespec(&rmt, rmtp))
-                        return -EFAULT;
-        }
-        return ret;
-}
-static inline long get_compat_itimerval(struct itimerval *o,
-                struct compat_itimerval __user *i)
-{
-        return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
-                (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
-                 __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
-                 __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
-                 __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
-}
-static inline long put_compat_itimerval(struct compat_itimerval __user *o,
-                struct itimerval *i)
-{
-        return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
-                (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
-                 __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
-                 __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
-                 __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
-}
-asmlinkage long sys_ni_posix_timers(void);
-COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
-                struct compat_itimerval __user *, it)
-{
-        struct itimerval kit;
-        int error;
-        if (!IS_ENABLED(CONFIG_POSIX_TIMERS))
-                return sys_ni_posix_timers();
-        error = do_getitimer(which, &kit);
-        if (!error && put_compat_itimerval(it, &kit))
-                error = -EFAULT;
-        return error;
 }
-COMPAT_SYSCALL_DEFINE3(setitimer, int, which,
+int put_compat_itimerval(struct compat_itimerval __user *o, const struct itimerval *i)
-                struct compat_itimerval __user *, in,
-                struct compat_itimerval __user *, out)
 {
-        struct itimerval kin, kout;
+        struct compat_itimerval v32;
-        int error;
-        if (!IS_ENABLED(CONFIG_POSIX_TIMERS))
-                return sys_ni_posix_timers();
-        if (in) {
+        v32.it_interval.tv_sec = i->it_interval.tv_sec;
-                if (get_compat_itimerval(&kin, in))
+        v32.it_interval.tv_usec = i->it_interval.tv_usec;
-                        return -EFAULT;
+        v32.it_value.tv_sec = i->it_value.tv_sec;
-        } else
+        v32.it_value.tv_usec = i->it_value.tv_usec;
-                memset(&kin, 0, sizeof(kin));
+        return copy_to_user(o, &v32, sizeof(struct compat_itimerval)) ? -EFAULT : 0;
-        error = do_setitimer(which, &kin, out ? &kout : NULL);
-        if (error || !out)
-                return error;
-        if (put_compat_itimerval(out, &kout))
-                return -EFAULT;
-        return 0;
 }
 static compat_clock_t clock_t_to_compat_clock_t(clock_t x)
@@ -689,193 +542,6 @@ int put_compat_itimerspec(struct compat_itimerspec __user *dst,
        return 0;
 }
-COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
-                       struct compat_sigevent __user *, timer_event_spec,
-                       timer_t __user *, created_timer_id)
-{
-        struct sigevent __user *event = NULL;
-        if (timer_event_spec) {
-                struct sigevent kevent;
-                event = compat_alloc_user_space(sizeof(*event));
-                if (get_compat_sigevent(&kevent, timer_event_spec) ||
-                    copy_to_user(event, &kevent, sizeof(*event)))
-                        return -EFAULT;
-        }
-        return sys_timer_create(which_clock, event, created_timer_id);
-}
-COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
-                       struct compat_itimerspec __user *, new,
-                       struct compat_itimerspec __user *, old)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct itimerspec newts, oldts;
-        if (!new)
-                return -EINVAL;
-        if (get_compat_itimerspec(&newts, new))
-                return -EFAULT;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_timer_settime(timer_id, flags,
-                                (struct itimerspec __user *) &newts,
-                                (struct itimerspec __user *) &oldts);
-        set_fs(oldfs);
-        if (!err && old && put_compat_itimerspec(old, &oldts))
-                return -EFAULT;
-        return err;
-}
-COMPAT_SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
-                       struct compat_itimerspec __user *, setting)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct itimerspec ts;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_timer_gettime(timer_id,
-                                (struct itimerspec __user *) &ts);
-        set_fs(oldfs);
-        if (!err && put_compat_itimerspec(setting, &ts))
-                return -EFAULT;
-        return err;
-}
-COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
-                       struct compat_timespec __user *, tp)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct timespec ts;
-        if (compat_get_timespec(&ts, tp))
-                return -EFAULT;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_clock_settime(which_clock,
-                                (struct timespec __user *) &ts);
-        set_fs(oldfs);
-        return err;
-}
-COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
-                       struct compat_timespec __user *, tp)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct timespec ts;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_clock_gettime(which_clock,
-                                (struct timespec __user *) &ts);
-        set_fs(oldfs);
-        if (!err && compat_put_timespec(&ts, tp))
-                return -EFAULT;
-        return err;
-}
-COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
-                       struct compat_timex __user *, utp)
-{
-        struct timex txc;
-        mm_segment_t oldfs;
-        int err, ret;
-        err = compat_get_timex(&txc, utp);
-        if (err)
-                return err;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        ret = sys_clock_adjtime(which_clock, (struct timex __user *) &txc);
-        set_fs(oldfs);
-        err = compat_put_timex(utp, &txc);
-        if (err)
-                return err;
-        return ret;
-}
-COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
-                       struct compat_timespec __user *, tp)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct timespec ts;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_clock_getres(which_clock,
-                               (struct timespec __user *) &ts);
-        set_fs(oldfs);
-        if (!err && tp && compat_put_timespec(&ts, tp))
-                return -EFAULT;
-        return err;
-}
-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)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct timespec in, out;
-        struct restart_block *restart;
-        if (compat_get_timespec(&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 (err == -ERESTART_RESTARTBLOCK) {
-                restart = &current->restart_block;
-                restart->fn = compat_clock_nanosleep_restart;
-                restart->nanosleep.compat_rmtp = rmtp;
-        }
-        return err;
-}
 /*
 * We currently only need the following fields from the sigevent
 * structure: sigev_value, sigev_signo, sig_notify and (sometimes
@@ -1035,64 +701,6 @@ COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
        return ret;
 }
-#ifdef __ARCH_WANT_COMPAT_SYS_TIME
-/* compat_time_t is a 32 bit "long" and needs to get converted. */
-COMPAT_SYSCALL_DEFINE1(time, compat_time_t __user *, tloc)
-{
-        compat_time_t i;
-        struct timeval tv;
-        do_gettimeofday(&tv);
-        i = tv.tv_sec;
-        if (tloc) {
-                if (put_user(i,tloc))
-                        return -EFAULT;
-        }
-        force_successful_syscall_return();
-        return i;
-}
-COMPAT_SYSCALL_DEFINE1(stime, compat_time_t __user *, tptr)
-{
-        struct timespec tv;
-        int err;
-        if (get_user(tv.tv_sec, tptr))
-                return -EFAULT;
-        tv.tv_nsec = 0;
-        err = security_settime(&tv, NULL);
-        if (err)
-                return err;
-        do_settimeofday(&tv);
-        return 0;
-}
-#endif /* __ARCH_WANT_COMPAT_SYS_TIME */
-COMPAT_SYSCALL_DEFINE1(adjtimex, struct compat_timex __user *, utp)
-{
-        struct timex txc;
-        int err, ret;
-        err = compat_get_timex(&txc, utp);
-        if (err)
-                return err;
-        ret = do_adjtimex(&txc);
-        err = compat_put_timex(utp, &txc);
-        if (err)
-                return err;
-        return ret;
-}
 #ifdef CONFIG_NUMA
 COMPAT_SYSCALL_DEFINE6(move_pages, pid_t, pid, compat_ulong_t, nr_pages,
                       compat_uptr_t __user *, pages32,

diff --git a/kernel/compat.c b/kernel/compat.c index 933bcb31ae10..ebd8bdc3fd68 100644 --- a/kernel/compat.c +++ b/kernel/compat.c
@@ -30,100 +30,66 @@
30		30
31	#include <linux/uaccess.h>	31	#include <linux/uaccess.h>
32		32
33	static int compat_get_timex(struct timex txc, struct compat_timex __user utp)	33	int compat_get_timex(struct timex txc, const struct compat_timex __user utp)
34	{	34	{
35	memset(txc, 0, sizeof(struct timex));	35	struct compat_timex tx32;
36
37	if (!access_ok(VERIFY_READ, utp, sizeof(struct compat_timex)) \|\|
38	__get_user(txc->modes, &utp->modes) \|\|
39	__get_user(txc->offset, &utp->offset) \|\|
40	__get_user(txc->freq, &utp->freq) \|\|
41	__get_user(txc->maxerror, &utp->maxerror) \|\|
42	__get_user(txc->esterror, &utp->esterror) \|\|
43	__get_user(txc->status, &utp->status) \|\|
44	__get_user(txc->constant, &utp->constant) \|\|
45	__get_user(txc->precision, &utp->precision) \|\|
46	__get_user(txc->tolerance, &utp->tolerance) \|\|
47	__get_user(txc->time.tv_sec, &utp->time.tv_sec) \|\|
48	__get_user(txc->time.tv_usec, &utp->time.tv_usec) \|\|
49	__get_user(txc->tick, &utp->tick) \|\|
50	__get_user(txc->ppsfreq, &utp->ppsfreq) \|\|
51	__get_user(txc->jitter, &utp->jitter) \|\|
52	__get_user(txc->shift, &utp->shift) \|\|
53	__get_user(txc->stabil, &utp->stabil) \|\|
54	__get_user(txc->jitcnt, &utp->jitcnt) \|\|
55	__get_user(txc->calcnt, &utp->calcnt) \|\|
56	__get_user(txc->errcnt, &utp->errcnt) \|\|
57	__get_user(txc->stbcnt, &utp->stbcnt))
58	return -EFAULT;
59		36
60	return 0;	37	if (copy_from_user(&tx32, utp, sizeof(struct compat_timex)))
61	}
62
63	static int compat_put_timex(struct compat_timex __user utp, struct timex txc)
64	{
65	if (!access_ok(VERIFY_WRITE, utp, sizeof(struct compat_timex)) \|\|
66	__put_user(txc->modes, &utp->modes) \|\|
67	__put_user(txc->offset, &utp->offset) \|\|
68	__put_user(txc->freq, &utp->freq) \|\|
69	__put_user(txc->maxerror, &utp->maxerror) \|\|
70	__put_user(txc->esterror, &utp->esterror) \|\|
71	__put_user(txc->status, &utp->status) \|\|
72	__put_user(txc->constant, &utp->constant) \|\|
73	__put_user(txc->precision, &utp->precision) \|\|
74	__put_user(txc->tolerance, &utp->tolerance) \|\|
75	__put_user(txc->time.tv_sec, &utp->time.tv_sec) \|\|
76	__put_user(txc->time.tv_usec, &utp->time.tv_usec) \|\|
77	__put_user(txc->tick, &utp->tick) \|\|
78	__put_user(txc->ppsfreq, &utp->ppsfreq) \|\|
79	__put_user(txc->jitter, &utp->jitter) \|\|
80	__put_user(txc->shift, &utp->shift) \|\|
81	__put_user(txc->stabil, &utp->stabil) \|\|
82	__put_user(txc->jitcnt, &utp->jitcnt) \|\|
83	__put_user(txc->calcnt, &utp->calcnt) \|\|
84	__put_user(txc->errcnt, &utp->errcnt) \|\|
85	__put_user(txc->stbcnt, &utp->stbcnt) \|\|
86	__put_user(txc->tai, &utp->tai))
87	return -EFAULT;	38	return -EFAULT;
88	return 0;
89	}
90		39
91	COMPAT_SYSCALL_DEFINE2(gettimeofday, struct compat_timeval __user *, tv,	40	txc->modes = tx32.modes;
92	struct timezone __user *, tz)	41	txc->offset = tx32.offset;
93	{	42	txc->freq = tx32.freq;
94	if (tv) {	43	txc->maxerror = tx32.maxerror;
95	struct timeval ktv;	44	txc->esterror = tx32.esterror;
96	do_gettimeofday(&ktv);	45	txc->status = tx32.status;
97	if (compat_put_timeval(&ktv, tv))	46	txc->constant = tx32.constant;
98	return -EFAULT;	47	txc->precision = tx32.precision;
99	}	48	txc->tolerance = tx32.tolerance;
100	if (tz) {	49	txc->time.tv_sec = tx32.time.tv_sec;
101	if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))	50	txc->time.tv_usec = tx32.time.tv_usec;
102	return -EFAULT;	51	txc->tick = tx32.tick;
103	}	52	txc->ppsfreq = tx32.ppsfreq;
		53	txc->jitter = tx32.jitter;
		54	txc->shift = tx32.shift;
		55	txc->stabil = tx32.stabil;
		56	txc->jitcnt = tx32.jitcnt;
		57	txc->calcnt = tx32.calcnt;
		58	txc->errcnt = tx32.errcnt;
		59	txc->stbcnt = tx32.stbcnt;
104		60
105	return 0;	61	return 0;
106	}	62	}
107		63
108	COMPAT_SYSCALL_DEFINE2(settimeofday, struct compat_timeval __user *, tv,	64	int compat_put_timex(struct compat_timex __user utp, const struct timex txc)
109	struct timezone __user *, tz)	65	{
110	{	66	struct compat_timex tx32;
111	struct timespec64 new_ts;	67
112	struct timeval user_tv;	68	memset(&tx32, 0, sizeof(struct compat_timex));
113	struct timezone new_tz;	69	tx32.modes = txc->modes;
114		70	tx32.offset = txc->offset;
115	if (tv) {	71	tx32.freq = txc->freq;
116	if (compat_get_timeval(&user_tv, tv))	72	tx32.maxerror = txc->maxerror;
117	return -EFAULT;	73	tx32.esterror = txc->esterror;
118	new_ts.tv_sec = user_tv.tv_sec;	74	tx32.status = txc->status;
119	new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;	75	tx32.constant = txc->constant;
120	}	76	tx32.precision = txc->precision;
121	if (tz) {	77	tx32.tolerance = txc->tolerance;
122	if (copy_from_user(&new_tz, tz, sizeof(*tz)))	78	tx32.time.tv_sec = txc->time.tv_sec;
123	return -EFAULT;	79	tx32.time.tv_usec = txc->time.tv_usec;
124	}	80	tx32.tick = txc->tick;
125		81	tx32.ppsfreq = txc->ppsfreq;
126	return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);	82	tx32.jitter = txc->jitter;
		83	tx32.shift = txc->shift;
		84	tx32.stabil = txc->stabil;
		85	tx32.jitcnt = txc->jitcnt;
		86	tx32.calcnt = txc->calcnt;
		87	tx32.errcnt = txc->errcnt;
		88	tx32.stbcnt = txc->stbcnt;
		89	tx32.tai = txc->tai;
		90	if (copy_to_user(utp, &tx32, sizeof(struct compat_timex)))
		91	return -EFAULT;
		92	return 0;
127	}	93	}
128		94
129	static int __compat_get_timeval(struct timeval tv, const struct compat_timeval __user ctv)	95	static int __compat_get_timeval(struct timeval tv, const struct compat_timeval __user ctv)
@@ -213,141 +179,28 @@ int compat_convert_timespec(struct timespec __user **kts,
213	return 0;	179	return 0;
214	}	180	}
215		181
216	static long compat_nanosleep_restart(struct restart_block *restart)	182	int get_compat_itimerval(struct itimerval o, const struct compat_itimerval __user i)
217	{
218	struct compat_timespec __user *rmtp;
219	struct timespec rmt;
220	mm_segment_t oldfs;
221	long ret;
222
223	restart->nanosleep.rmtp = (struct timespec __user *) &rmt;
224	oldfs = get_fs();
225	set_fs(KERNEL_DS);
226	ret = hrtimer_nanosleep_restart(restart);
227	set_fs(oldfs);
228
229	if (ret == -ERESTART_RESTARTBLOCK) {
230	rmtp = restart->nanosleep.compat_rmtp;
231
232	if (rmtp && compat_put_timespec(&rmt, rmtp))
233	return -EFAULT;
234	}
235
236	return ret;
237	}
238
239	COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
240	struct compat_timespec __user *, rmtp)
241	{	183	{
242	struct timespec tu, rmt;	184	struct compat_itimerval v32;
243	struct timespec64 tu64;
244	mm_segment_t oldfs;
245	long ret;
246		185
247	if (compat_get_timespec(&tu, rqtp))	186	if (copy_from_user(&v32, i, sizeof(struct compat_itimerval)))
248	return -EFAULT;	187	return -EFAULT;
249		188	o->it_interval.tv_sec = v32.it_interval.tv_sec;
250	tu64 = timespec_to_timespec64(tu);	189	o->it_interval.tv_usec = v32.it_interval.tv_usec;
251	if (!timespec64_valid(&tu64))	190	o->it_value.tv_sec = v32.it_value.tv_sec;
252	return -EINVAL;	191	o->it_value.tv_usec = v32.it_value.tv_usec;
253		192	return 0;
254	oldfs = get_fs();
255	set_fs(KERNEL_DS);
256	ret = hrtimer_nanosleep(&tu64,
257	rmtp ? (struct timespec __user *)&rmt : NULL,
258	HRTIMER_MODE_REL, CLOCK_MONOTONIC);
259	set_fs(oldfs);
260
261	/*
262	* hrtimer_nanosleep() can only return 0 or
263	* -ERESTART_RESTARTBLOCK here because:
264	*
265	* - we call it with HRTIMER_MODE_REL and therefor exclude the
266	* -ERESTARTNOHAND return path.
267	*
268	* - we supply the rmtp argument from the task stack (due to
269	* the necessary compat conversion. So the update cannot
270	* fail, which excludes the -EFAULT return path as well. If
271	* it fails nevertheless we have a bigger problem and wont
272	* reach this place anymore.
273	*
274	* - if the return value is 0, we do not have to update rmtp
275	* because there is no remaining time.
276	*
277	* We check for -ERESTART_RESTARTBLOCK nevertheless if the
278	* core implementation decides to return random nonsense.
279	*/
280	if (ret == -ERESTART_RESTARTBLOCK) {
281	struct restart_block *restart = &current->restart_block;
282
283	restart->fn = compat_nanosleep_restart;
284	restart->nanosleep.compat_rmtp = rmtp;
285
286	if (rmtp && compat_put_timespec(&rmt, rmtp))
287	return -EFAULT;
288	}
289	return ret;
290	}
291
292	static inline long get_compat_itimerval(struct itimerval *o,
293	struct compat_itimerval __user *i)
294	{
295	return (!access_ok(VERIFY_READ, i, sizeof(*i)) \|\|
296	(__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) \|
297	__get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) \|
298	__get_user(o->it_value.tv_sec, &i->it_value.tv_sec) \|
299	__get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
300	}
301
302	static inline long put_compat_itimerval(struct compat_itimerval __user *o,
303	struct itimerval *i)
304	{
305	return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) \|\|
306	(__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) \|
307	__put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) \|
308	__put_user(i->it_value.tv_sec, &o->it_value.tv_sec) \|
309	__put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
310	}
311
312	asmlinkage long sys_ni_posix_timers(void);
313
314	COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
315	struct compat_itimerval __user *, it)
316	{
317	struct itimerval kit;
318	int error;
319
320	if (!IS_ENABLED(CONFIG_POSIX_TIMERS))
321	return sys_ni_posix_timers();
322
323	error = do_getitimer(which, &kit);
324	if (!error && put_compat_itimerval(it, &kit))
325	error = -EFAULT;
326	return error;
327	}	193	}
328		194
329	COMPAT_SYSCALL_DEFINE3(setitimer, int, which,	195	int put_compat_itimerval(struct compat_itimerval __user o, const struct itimerval i)
330	struct compat_itimerval __user *, in,
331	struct compat_itimerval __user *, out)
332	{	196	{
333	struct itimerval kin, kout;	197	struct compat_itimerval v32;
334	int error;
335
336	if (!IS_ENABLED(CONFIG_POSIX_TIMERS))
337	return sys_ni_posix_timers();
338		198
339	if (in) {	199	v32.it_interval.tv_sec = i->it_interval.tv_sec;
340	if (get_compat_itimerval(&kin, in))	200	v32.it_interval.tv_usec = i->it_interval.tv_usec;
341	return -EFAULT;	201	v32.it_value.tv_sec = i->it_value.tv_sec;
342	} else	202	v32.it_value.tv_usec = i->it_value.tv_usec;
343	memset(&kin, 0, sizeof(kin));	203	return copy_to_user(o, &v32, sizeof(struct compat_itimerval)) ? -EFAULT : 0;
344
345	error = do_setitimer(which, &kin, out ? &kout : NULL);
346	if (error \|\| !out)
347	return error;
348	if (put_compat_itimerval(out, &kout))
349	return -EFAULT;
350	return 0;
351	}	204	}
352		205
353	static compat_clock_t clock_t_to_compat_clock_t(clock_t x)	206	static compat_clock_t clock_t_to_compat_clock_t(clock_t x)
@@ -689,193 +542,6 @@ int put_compat_itimerspec(struct compat_itimerspec __user *dst,
689	return 0;	542	return 0;
690	}	543	}
691		544
692	COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
693	struct compat_sigevent __user *, timer_event_spec,
694	timer_t __user *, created_timer_id)
695	{
696	struct sigevent __user *event = NULL;
697
698	if (timer_event_spec) {
699	struct sigevent kevent;
700
701	event = compat_alloc_user_space(sizeof(*event));
702	if (get_compat_sigevent(&kevent, timer_event_spec) \|\|
703	copy_to_user(event, &kevent, sizeof(*event)))
704	return -EFAULT;
705	}
706
707	return sys_timer_create(which_clock, event, created_timer_id);
708	}
709
710	COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
711	struct compat_itimerspec __user *, new,
712	struct compat_itimerspec __user *, old)
713	{
714	long err;
715	mm_segment_t oldfs;
716	struct itimerspec newts, oldts;
717
718	if (!new)
719	return -EINVAL;
720	if (get_compat_itimerspec(&newts, new))
721	return -EFAULT;
722	oldfs = get_fs();
723	set_fs(KERNEL_DS);
724	err = sys_timer_settime(timer_id, flags,
725	(struct itimerspec __user *) &newts,
726	(struct itimerspec __user *) &oldts);
727	set_fs(oldfs);
728	if (!err && old && put_compat_itimerspec(old, &oldts))
729	return -EFAULT;
730	return err;
731	}
732
733	COMPAT_SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
734	struct compat_itimerspec __user *, setting)
735	{
736	long err;
737	mm_segment_t oldfs;
738	struct itimerspec ts;
739
740	oldfs = get_fs();
741	set_fs(KERNEL_DS);
742	err = sys_timer_gettime(timer_id,
743	(struct itimerspec __user *) &ts);
744	set_fs(oldfs);
745	if (!err && put_compat_itimerspec(setting, &ts))
746	return -EFAULT;
747	return err;
748	}
749
750	COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
751	struct compat_timespec __user *, tp)
752	{
753	long err;
754	mm_segment_t oldfs;
755	struct timespec ts;
756
757	if (compat_get_timespec(&ts, tp))
758	return -EFAULT;
759	oldfs = get_fs();
760	set_fs(KERNEL_DS);
761	err = sys_clock_settime(which_clock,
762	(struct timespec __user *) &ts);
763	set_fs(oldfs);
764	return err;
765	}
766
767	COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
768	struct compat_timespec __user *, tp)
769	{
770	long err;
771	mm_segment_t oldfs;
772	struct timespec ts;
773
774	oldfs = get_fs();
775	set_fs(KERNEL_DS);
776	err = sys_clock_gettime(which_clock,
777	(struct timespec __user *) &ts);
778	set_fs(oldfs);
779	if (!err && compat_put_timespec(&ts, tp))
780	return -EFAULT;
781	return err;
782	}
783
784	COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
785	struct compat_timex __user *, utp)
786	{
787	struct timex txc;
788	mm_segment_t oldfs;
789	int err, ret;
790
791	err = compat_get_timex(&txc, utp);
792	if (err)
793	return err;
794
795	oldfs = get_fs();
796	set_fs(KERNEL_DS);
797	ret = sys_clock_adjtime(which_clock, (struct timex __user *) &txc);
798	set_fs(oldfs);
799
800	err = compat_put_timex(utp, &txc);
801	if (err)
802	return err;
803
804	return ret;
805	}
806
807	COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
808	struct compat_timespec __user *, tp)
809	{
810	long err;
811	mm_segment_t oldfs;
812	struct timespec ts;
813
814	oldfs = get_fs();
815	set_fs(KERNEL_DS);
816	err = sys_clock_getres(which_clock,
817	(struct timespec __user *) &ts);
818	set_fs(oldfs);
819	if (!err && tp && compat_put_timespec(&ts, tp))
820	return -EFAULT;
821	return err;
822	}
823
824	static long compat_clock_nanosleep_restart(struct restart_block *restart)
825	{
826	long err;
827	mm_segment_t oldfs;
828	struct timespec tu;
829	struct compat_timespec __user *rmtp = restart->nanosleep.compat_rmtp;
830
831	restart->nanosleep.rmtp = (struct timespec __user *) &tu;
832	oldfs = get_fs();
833	set_fs(KERNEL_DS);
834	err = clock_nanosleep_restart(restart);
835	set_fs(oldfs);
836
837	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
838	compat_put_timespec(&tu, rmtp))
839	return -EFAULT;
840
841	if (err == -ERESTART_RESTARTBLOCK) {
842	restart->fn = compat_clock_nanosleep_restart;
843	restart->nanosleep.compat_rmtp = rmtp;
844	}
845	return err;
846	}
847
848	COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
849	struct compat_timespec __user *, rqtp,
850	struct compat_timespec __user *, rmtp)
851	{
852	long err;
853	mm_segment_t oldfs;
854	struct timespec in, out;
855	struct restart_block *restart;
856
857	if (compat_get_timespec(&in, rqtp))
858	return -EFAULT;
859
860	oldfs = get_fs();
861	set_fs(KERNEL_DS);
862	err = sys_clock_nanosleep(which_clock, flags,
863	(struct timespec __user *) &in,
864	(struct timespec __user *) &out);
865	set_fs(oldfs);
866
867	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
868	compat_put_timespec(&out, rmtp))
869	return -EFAULT;
870
871	if (err == -ERESTART_RESTARTBLOCK) {
872	restart = &current->restart_block;
873	restart->fn = compat_clock_nanosleep_restart;
874	restart->nanosleep.compat_rmtp = rmtp;
875	}
876	return err;
877	}
878
879	/*	545	/*
880	* We currently only need the following fields from the sigevent	546	* We currently only need the following fields from the sigevent
881	* structure: sigev_value, sigev_signo, sig_notify and (sometimes	547	* structure: sigev_value, sigev_signo, sig_notify and (sometimes
@@ -1035,64 +701,6 @@ COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
1035	return ret;	701	return ret;
1036	}	702	}
1037		703
1038	#ifdef __ARCH_WANT_COMPAT_SYS_TIME
1039
1040	/* compat_time_t is a 32 bit "long" and needs to get converted. */
1041
1042	COMPAT_SYSCALL_DEFINE1(time, compat_time_t __user *, tloc)
1043	{
1044	compat_time_t i;
1045	struct timeval tv;
1046
1047	do_gettimeofday(&tv);
1048	i = tv.tv_sec;
1049
1050	if (tloc) {
1051	if (put_user(i,tloc))
1052	return -EFAULT;
1053	}
1054	force_successful_syscall_return();
1055	return i;
1056	}
1057
1058	COMPAT_SYSCALL_DEFINE1(stime, compat_time_t __user *, tptr)
1059	{
1060	struct timespec tv;
1061	int err;
1062
1063	if (get_user(tv.tv_sec, tptr))
1064	return -EFAULT;
1065
1066	tv.tv_nsec = 0;
1067
1068	err = security_settime(&tv, NULL);
1069	if (err)
1070	return err;
1071
1072	do_settimeofday(&tv);
1073	return 0;
1074	}
1075
1076	#endif /* __ARCH_WANT_COMPAT_SYS_TIME */
1077
1078	COMPAT_SYSCALL_DEFINE1(adjtimex, struct compat_timex __user *, utp)
1079	{
1080	struct timex txc;
1081	int err, ret;
1082
1083	err = compat_get_timex(&txc, utp);
1084	if (err)
1085	return err;
1086
1087	ret = do_adjtimex(&txc);
1088
1089	err = compat_put_timex(utp, &txc);
1090	if (err)
1091	return err;
1092
1093	return ret;
1094	}
1095
1096	#ifdef CONFIG_NUMA	704	#ifdef CONFIG_NUMA
1097	COMPAT_SYSCALL_DEFINE6(move_pages, pid_t, pid, compat_ulong_t, nr_pages,	705	COMPAT_SYSCALL_DEFINE6(move_pages, pid_t, pid, compat_ulong_t, nr_pages,
1098	compat_uptr_t __user *, pages32,	706	compat_uptr_t __user *, pages32,