1 files changed, 102 insertions, 10 deletions

diff --git a/kernel/time/posix-stubs.c b/kernel/time/posix-stubs.c
index c0cd53eb018a..38f3b20efa29 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)
 {
@@ -27,6 +28,7 @@ asmlinkage long sys_ni_posix_timers(void)
 }
 
 #define SYS_NI(name)  SYSCALL_ALIAS(sys_##name, sys_ni_posix_timers)
+#define COMPAT_SYS_NI(name)  SYSCALL_ALIAS(compat_sys_##name, sys_ni_posix_timers)
 
 SYS_NI(timer_create);
 SYS_NI(timer_gettime);
@@ -39,6 +41,12 @@ SYS_NI(setitimer);
 #ifdef __ARCH_WANT_SYS_ALARM
 SYS_NI(alarm);
 #endif
+COMPAT_SYS_NI(timer_create);
+COMPAT_SYS_NI(clock_adjtime);
+COMPAT_SYS_NI(timer_settime);
+COMPAT_SYS_NI(timer_gettime);
+COMPAT_SYS_NI(getitimer);
+COMPAT_SYS_NI(setitimer);
 
 /*
  * We preserve minimal support for CLOCK_REALTIME and CLOCK_MONOTONIC
@@ -110,22 +118,106 @@ 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;
-                return hrtimer_nanosleep(&t64, rmtp, 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_DEFINE2(clock_settime, const clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        struct timespec64 new_tp64;
+        struct timespec new_tp;
+
+        if (which_clock != CLOCK_REALTIME)
+                return -EINVAL;
+        if (compat_get_timespec(&new_tp, tp))
+                return -EFAULT;
+
+        new_tp64 = timespec_to_timespec64(new_tp);
+        return do_sys_settimeofday64(&new_tp64, NULL);
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
+                       struct compat_timespec __user *,tp)
 {
-        return hrtimer_nanosleep_restart(restart_block);
+        struct timespec64 kernel_tp64;
+        struct timespec kernel_tp;
+
+        switch (which_clock) {
+        case CLOCK_REALTIME: ktime_get_real_ts64(&kernel_tp64); break;
+        case CLOCK_MONOTONIC: ktime_get_ts64(&kernel_tp64); break;
+        case CLOCK_BOOTTIME: get_monotonic_boottime64(&kernel_tp64); break;
+        default: return -EINVAL;
+        }
+
+        kernel_tp = timespec64_to_timespec(kernel_tp64);
+        if (compat_put_timespec(&kernel_tp, tp))
+                return -EFAULT;
+        return 0;
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        struct timespec rtn_tp = {
+                .tv_sec = 0,
+                .tv_nsec = hrtimer_resolution,
+        };
+
+        switch (which_clock) {
+        case CLOCK_REALTIME:
+        case CLOCK_MONOTONIC:
+        case CLOCK_BOOTTIME:
+                if (compat_put_timespec(&rtn_tp, tp))
+                        return -EFAULT;
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
+                       struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
+{
+        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