time: Change k_clock nsleep() to use timespec64

struct timespec is not y2038 safe on 32 bit machines.  Replace uses of
struct timespec with struct timespec64 in the kernel.

The syscall interfaces themselves will be changed in a separate series.

Note that the restart_block parameter for nanosleep has also been left
unchanged and will be part of syscall series noted above.

Signed-off-by: Deepa Dinamani <deepa.kernel@gmail.com>
Cc: y2038@lists.linaro.org
Cc: john.stultz@linaro.org
Cc: arnd@arndb.de
Link: http://lkml.kernel.org/r/1490555058-4603-8-git-send-email-deepa.kernel@gmail.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 23d58fcd4d9a76713a70620caddc4b9fbba62092..8c5b10eb7265fb221360cc9bb1a4eebf0dde06ca 100644 (file)
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -452,7 +452,7 @@ static inline u64 hrtimer_forward_now(struct hrtimer *timer,
 }
 
 /* Precise sleep: */
-extern long hrtimer_nanosleep(struct timespec *rqtp,
+extern long hrtimer_nanosleep(struct timespec64 *rqtp,
                              struct timespec __user *rmtp,
                              const enum hrtimer_mode mode,
                              const clockid_t clockid);

diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
index ebc4c49453396411777ae3fc0d9fbdd64ebfb401..8c1e43ab14a97e8645b7f981730938cb4e257b70 100644 (file)
--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -94,7 +94,7 @@ 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 timespec *, struct timespec __user *);
+                      struct timespec64 *, struct timespec __user *);
        long (*nsleep_restart) (struct restart_block *restart_block);
        int (*timer_set) (struct k_itimer *timr, int flags,
                          struct itimerspec64 *new_setting,

diff --git a/kernel/compat.c b/kernel/compat.c
index 1eb9e8aad8693f12b5d56e336576303a75395a93..933bcb31ae10d4c1dcaf2c9b5f48861080d9b3df 100644 (file)
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -240,18 +240,20 @@ COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
                       struct compat_timespec __user *, rmtp)
 {
        struct timespec tu, rmt;
+       struct timespec64 tu64;
        mm_segment_t oldfs;
        long ret;
 
        if (compat_get_timespec(&tu, rqtp))
                return -EFAULT;
 
-       if (!timespec_valid(&tu))
+       tu64 = timespec_to_timespec64(tu);
+       if (!timespec64_valid(&tu64))
                return -EINVAL;
 
        oldfs = get_fs();
        set_fs(KERNEL_DS);
-       ret = hrtimer_nanosleep(&tu,
+       ret = hrtimer_nanosleep(&tu64,
                                rmtp ? (struct timespec __user *)&rmt : NULL,
                                HRTIMER_MODE_REL, CLOCK_MONOTONIC);
        set_fs(oldfs);

diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
index e069f94999a80be078067c7678f9745ad802bd51..5cb5b0008d9710c95c1af7ab8312b5e308b2c5d0 100644 (file)
--- a/kernel/time/alarmtimer.c
+++ b/kernel/time/alarmtimer.c
@@ -790,13 +790,14 @@ out:
  * Handles clock_nanosleep calls against _ALARM clockids
  */
 static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
-                    struct timespec *tsreq, struct timespec __user *rmtp)
+                             struct timespec64 *tsreq,
+                             struct timespec __user *rmtp)
 {
        enum  alarmtimer_type type = clock2alarm(which_clock);
+       struct restart_block *restart;
        struct alarm alarm;
        ktime_t exp;
        int ret = 0;
-       struct restart_block *restart;
 
        if (!alarmtimer_get_rtcdev())
                return -ENOTSUPP;
@@ -809,7 +810,7 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
 
        alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
 
-       exp = timespec_to_ktime(*tsreq);
+       exp = timespec64_to_ktime(*tsreq);
        /* Convert (if necessary) to absolute time */
        if (flags != TIMER_ABSTIME) {
                ktime_t now = alarm_bases[type].gettime();

diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index 1ef82cdb61fff15ae825404fa03baa8b4c2b49a6..a7560123617c3717fa45ba8da9ba766a9654774a 100644 (file)
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -1503,7 +1503,7 @@ out:
        return ret;
 }
 
-long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
+long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
                       const enum hrtimer_mode mode, const clockid_t clockid)
 {
        struct restart_block *restart;
@@ -1516,7 +1516,7 @@ long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
                slack = 0;
 
        hrtimer_init_on_stack(&t.timer, clockid, mode);
-       hrtimer_set_expires_range_ns(&t.timer, timespec_to_ktime(*rqtp), slack);
+       hrtimer_set_expires_range_ns(&t.timer, timespec64_to_ktime(*rqtp), slack);
        if (do_nanosleep(&t, mode))
                goto out;
 
@@ -1547,15 +1547,17 @@ out:
 SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
                struct timespec __user *, rmtp)
 {
+       struct timespec64 tu64;
        struct timespec tu;
 
        if (copy_from_user(&tu, rqtp, sizeof(tu)))
                return -EFAULT;
 
-       if (!timespec_valid(&tu))
+       tu64 = timespec_to_timespec64(tu);
+       if (!timespec64_valid(&tu64))
                return -EINVAL;
 
-       return hrtimer_nanosleep(&tu, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
+       return hrtimer_nanosleep(&tu64, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
 }
 
 /*

diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index 441064d1216fff4ce18e5b3ecdbc7a971b084cef..949e434d35362b39b2c18cff54ff94fb57a4c62d 100644 (file)
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -1219,9 +1219,8 @@ void set_process_cpu_timer(struct task_struct *tsk, unsigned int clock_idx,
 }
 
 static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
-                           struct timespec *rqtp, struct itimerspec *it)
+                           struct timespec64 *rqtp, struct itimerspec64 *it)
 {
-       struct itimerspec64 it64;
        struct k_itimer timer;
        int error;
 
@@ -1241,8 +1240,7 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                it->it_value = *rqtp;
 
                spin_lock_irq(&timer.it_lock);
-               it64 = itimerspec_to_itimerspec64(it);
-               error = posix_cpu_timer_set(&timer, flags, &it64, NULL);
+               error = posix_cpu_timer_set(&timer, flags, it, NULL);
                if (error) {
                        spin_unlock_irq(&timer.it_lock);
                        return error;
@@ -1271,10 +1269,8 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                /*
                 * We were interrupted by a signal.
                 */
-               *rqtp = ns_to_timespec(timer.it.cpu.expires);
-               it64 = itimerspec_to_itimerspec64(it);
-               error = posix_cpu_timer_set(&timer, 0, &zero_it, &it64);
-               *it = itimerspec64_to_itimerspec(&it64);
+               *rqtp = ns_to_timespec64(timer.it.cpu.expires);
+               error = posix_cpu_timer_set(&timer, 0, &zero_it, it);
                if (!error) {
                        /*
                         * Timer is now unarmed, deletion can not fail.
@@ -1310,10 +1306,11 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
 static long posix_cpu_nsleep_restart(struct restart_block *restart_block);
 
 static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
-                           struct timespec *rqtp, struct timespec __user *rmtp)
+                           struct timespec64 *rqtp, struct timespec __user *rmtp)
 {
        struct restart_block *restart_block = &current->restart_block;
-       struct itimerspec it;
+       struct itimerspec64 it;
+       struct timespec ts;
        int error;
 
        /*
@@ -1333,13 +1330,14 @@ static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
                /*
                 * Report back to the user the time still remaining.
                 */
-               if (rmtp && copy_to_user(rmtp, &it.it_value, sizeof *rmtp))
+               ts = timespec64_to_timespec(it.it_value);
+               if (rmtp && copy_to_user(rmtp, &ts, sizeof(*rmtp)))
                        return -EFAULT;
 
                restart_block->fn = posix_cpu_nsleep_restart;
                restart_block->nanosleep.clockid = which_clock;
                restart_block->nanosleep.rmtp = rmtp;
-               restart_block->nanosleep.expires = timespec_to_ns(rqtp);
+               restart_block->nanosleep.expires = timespec64_to_ns(rqtp);
        }
        return error;
 }
@@ -1347,11 +1345,12 @@ static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
 static long posix_cpu_nsleep_restart(struct restart_block *restart_block)
 {
        clockid_t which_clock = restart_block->nanosleep.clockid;
-       struct timespec t;
-       struct itimerspec it;
+       struct itimerspec64 it;
+       struct timespec64 t;
+       struct timespec tmp;
        int error;
 
-       t = ns_to_timespec(restart_block->nanosleep.expires);
+       t = ns_to_timespec64(restart_block->nanosleep.expires);
 
        error = do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t, &it);
 
@@ -1360,10 +1359,11 @@ static long posix_cpu_nsleep_restart(struct restart_block *restart_block)
                /*
                 * Report back to the user the time still remaining.
                 */
-               if (rmtp && copy_to_user(rmtp, &it.it_value, sizeof *rmtp))
+                tmp = timespec64_to_timespec(it.it_value);
+               if (rmtp && copy_to_user(rmtp, &tmp, sizeof(*rmtp)))
                        return -EFAULT;
 
-               restart_block->nanosleep.expires = timespec_to_ns(&t);
+               restart_block->nanosleep.expires = timespec64_to_ns(&t);
        }
        return error;
 
@@ -1388,7 +1388,7 @@ static int process_cpu_timer_create(struct k_itimer *timer)
        return posix_cpu_timer_create(timer);
 }
 static int process_cpu_nsleep(const clockid_t which_clock, int flags,
-                             struct timespec *rqtp,
+                             struct timespec64 *rqtp,
                              struct timespec __user *rmtp)
 {
        return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp, rmtp);

diff --git a/kernel/time/posix-stubs.c b/kernel/time/posix-stubs.c
index 0fbd0c5b95cad597bcc170779e79b7a8d4296048..c0cd53eb018a249f99a3d120ffde9fbcc2abbdef 100644 (file)
--- a/kernel/time/posix-stubs.c
+++ b/kernel/time/posix-stubs.c
@@ -103,6 +103,7 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
                const struct timespec __user *, rqtp,
                struct timespec __user *, rmtp)
 {
+       struct timespec64 t64;
        struct timespec t;
 
        switch (which_clock) {
@@ -111,9 +112,10 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
        case CLOCK_BOOTTIME:
                if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
                        return -EFAULT;
-               if (!timespec_valid(&t))
+               t64 = timespec_to_timespec64(t);
+               if (!timespec64_valid(&t64))
                        return -EINVAL;
-               return hrtimer_nanosleep(&t, rmtp, flags & TIMER_ABSTIME ?
+               return hrtimer_nanosleep(&t64, rmtp, flags & TIMER_ABSTIME ?
                                         HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
                                         which_clock);
        default:

diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c
index 9da4797d0c63eed2c935244c628cc668fb05d312..4d7b2ce09c27cb6b77b1b2d18e379c4efed48d71 100644 (file)
--- a/kernel/time/posix-timers.c
+++ b/kernel/time/posix-timers.c
@@ -130,7 +130,7 @@ static struct k_clock posix_clocks[MAX_CLOCKS];
 /*
  * These ones are defined below.
  */
-static int common_nsleep(const clockid_t, int flags, struct timespec *t,
+static int common_nsleep(const clockid_t, int flags, struct timespec64 *t,
                         struct timespec __user *rmtp);
 static int common_timer_create(struct k_itimer *new_timer);
 static void common_timer_get(struct k_itimer *, struct itimerspec64 *);
@@ -1099,7 +1099,7 @@ 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 timespec *tsave, struct timespec __user *rmtp)
+                        struct timespec64 *tsave, struct timespec __user *rmtp)
 {
        return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
                                 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
@@ -1111,6 +1111,7 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
                struct timespec __user *, rmtp)
 {
        struct k_clock *kc = clockid_to_kclock(which_clock);
+       struct timespec64 t64;
        struct timespec t;
 
        if (!kc)
@@ -1121,10 +1122,11 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
        if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
                return -EFAULT;
 
-       if (!timespec_valid(&t))
+       t64 = timespec_to_timespec64(t);
+       if (!timespec64_valid(&t64))
                return -EINVAL;
 
-       return kc->nsleep(which_clock, flags, &t, rmtp);
+       return kc->nsleep(which_clock, flags, &t64, rmtp);
 }
 
 /*