Merge branch 'master' into upstream

1 files changed, 70 insertions, 31 deletions

diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index d38d9ec3276c..479b16b44f79 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -1393,25 +1393,13 @@ void set_process_cpu_timer(struct task_struct *tsk, unsigned int clock_idx,
         }
 }
 
-static long posix_cpu_clock_nanosleep_restart(struct restart_block *);
-
-int posix_cpu_nsleep(const clockid_t which_clock, int flags,
-                     struct timespec *rqtp, struct timespec __user *rmtp)
+static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
+                            struct timespec *rqtp, struct itimerspec *it)
 {
-        struct restart_block *restart_block =
-            &current_thread_info()->restart_block;
         struct k_itimer timer;
         int error;
 
         /*
-         * Diagnose required errors first.
-         */
-        if (CPUCLOCK_PERTHREAD(which_clock) &&
-            (CPUCLOCK_PID(which_clock) == 0 ||
-             CPUCLOCK_PID(which_clock) == current->pid))
-                return -EINVAL;
-
-        /*
          * Set up a temporary timer and then wait for it to go off.
          */
         memset(&timer, 0, sizeof timer);
@@ -1422,11 +1410,12 @@ int posix_cpu_nsleep(const clockid_t which_clock, int flags,
         timer.it_process = current;
         if (!error) {
                 static struct itimerspec zero_it;
-                struct itimerspec it = { .it_value = *rqtp,
-                                         .it_interval = {} };
+
+                memset(it, 0, sizeof *it);
+                it->it_value = *rqtp;
 
                 spin_lock_irq(&timer.it_lock);
-                error = posix_cpu_timer_set(&timer, flags, &it, NULL);
+                error = posix_cpu_timer_set(&timer, flags, it, NULL);
                 if (error) {
                         spin_unlock_irq(&timer.it_lock);
                         return error;
@@ -1454,49 +1443,89 @@ int posix_cpu_nsleep(const clockid_t which_clock, int flags,
                  * We were interrupted by a signal.
                  */
                 sample_to_timespec(which_clock, timer.it.cpu.expires, rqtp);
-                posix_cpu_timer_set(&timer, 0, &zero_it, &it);
+                posix_cpu_timer_set(&timer, 0, &zero_it, it);
                 spin_unlock_irq(&timer.it_lock);
 
-                if ((it.it_value.tv_sec | it.it_value.tv_nsec) == 0) {
+                if ((it->it_value.tv_sec | it->it_value.tv_nsec) == 0) {
                         /*
                          * It actually did fire already.
                          */
                         return 0;
                 }
 
+                error = -ERESTART_RESTARTBLOCK;
+        }
+
+        return error;
+}
+
+int posix_cpu_nsleep(const clockid_t which_clock, int flags,
+                     struct timespec *rqtp, struct timespec __user *rmtp)
+{
+        struct restart_block *restart_block =
+            &current_thread_info()->restart_block;
+        struct itimerspec it;
+        int error;
+
+        /*
+         * Diagnose required errors first.
+         */
+        if (CPUCLOCK_PERTHREAD(which_clock) &&
+            (CPUCLOCK_PID(which_clock) == 0 ||
+             CPUCLOCK_PID(which_clock) == current->pid))
+                return -EINVAL;
+
+        error = do_cpu_nanosleep(which_clock, flags, rqtp, &it);
+
+        if (error == -ERESTART_RESTARTBLOCK) {
+
+                if (flags & TIMER_ABSTIME)
+                        return -ERESTARTNOHAND;
                 /*
-                 * Report back to the user the time still remaining.
-                 */
-                if (rmtp != NULL && !(flags & TIMER_ABSTIME) &&
-                    copy_to_user(rmtp, &it.it_value, sizeof *rmtp))
+                 * Report back to the user the time still remaining.
+                 */
+                if (rmtp != NULL && copy_to_user(rmtp, &it.it_value, sizeof *rmtp))
                         return -EFAULT;
 
-                restart_block->fn = posix_cpu_clock_nanosleep_restart;
-                /* Caller already set restart_block->arg1 */
+                restart_block->fn = posix_cpu_nsleep_restart;
                 restart_block->arg0 = which_clock;
                 restart_block->arg1 = (unsigned long) rmtp;
                 restart_block->arg2 = rqtp->tv_sec;
                 restart_block->arg3 = rqtp->tv_nsec;
-
-                error = -ERESTART_RESTARTBLOCK;
         }
-
         return error;
 }
 
-static long
-posix_cpu_clock_nanosleep_restart(struct restart_block *restart_block)
+long posix_cpu_nsleep_restart(struct restart_block *restart_block)
 {
         clockid_t which_clock = restart_block->arg0;
         struct timespec __user *rmtp;
         struct timespec t;
+        struct itimerspec it;
+        int error;
 
         rmtp = (struct timespec __user *) restart_block->arg1;
         t.tv_sec = restart_block->arg2;
         t.tv_nsec = restart_block->arg3;
 
         restart_block->fn = do_no_restart_syscall;
-        return posix_cpu_nsleep(which_clock, TIMER_ABSTIME, &t, rmtp);
+        error = do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t, &it);
+
+        if (error == -ERESTART_RESTARTBLOCK) {
+                /*
+                 * Report back to the user the time still remaining.
+                 */
+                if (rmtp != NULL && copy_to_user(rmtp, &it.it_value, sizeof *rmtp))
+                        return -EFAULT;
+
+                restart_block->fn = posix_cpu_nsleep_restart;
+                restart_block->arg0 = which_clock;
+                restart_block->arg1 = (unsigned long) rmtp;
+                restart_block->arg2 = t.tv_sec;
+                restart_block->arg3 = t.tv_nsec;
+        }
+        return error;
+
 }
 
 
@@ -1524,6 +1553,10 @@ static int process_cpu_nsleep(const clockid_t which_clock, int flags,
 {
         return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp, rmtp);
 }
+static long process_cpu_nsleep_restart(struct restart_block *restart_block)
+{
+        return -EINVAL;
+}
 static int thread_cpu_clock_getres(const clockid_t which_clock,
                                    struct timespec *tp)
 {
@@ -1544,6 +1577,10 @@ static int thread_cpu_nsleep(const clockid_t which_clock, int flags,
 {
         return -EINVAL;
 }
+static long thread_cpu_nsleep_restart(struct restart_block *restart_block)
+{
+        return -EINVAL;
+}
 
 static __init int init_posix_cpu_timers(void)
 {
@@ -1553,6 +1590,7 @@ static __init int init_posix_cpu_timers(void)
                 .clock_set = do_posix_clock_nosettime,
                 .timer_create = process_cpu_timer_create,
                 .nsleep = process_cpu_nsleep,
+                .nsleep_restart = process_cpu_nsleep_restart,
         };
         struct k_clock thread = {
                 .clock_getres = thread_cpu_clock_getres,
@@ -1560,6 +1598,7 @@ static __init int init_posix_cpu_timers(void)
                 .clock_set = do_posix_clock_nosettime,
                 .timer_create = thread_cpu_timer_create,
                 .nsleep = thread_cpu_nsleep,
+                .nsleep_restart = thread_cpu_nsleep_restart,
         };
 
         register_posix_clock(CLOCK_PROCESS_CPUTIME_ID, &process);