1 files changed, 497 insertions, 262 deletions

diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c
index 4d7b2ce09c27..82d67be7d9d1 100644
--- a/kernel/time/posix-timers.c
+++ b/kernel/time/posix-timers.c
@@ -49,8 +49,10 @@
 #include <linux/workqueue.h>
 #include <linux/export.h>
 #include <linux/hashtable.h>
+#include <linux/compat.h>
 
 #include "timekeeping.h"
+#include "posix-timers.h"
 
 /*
  * Management arrays for POSIX timers. Timers are now kept in static hash table
@@ -69,6 +71,10 @@ static struct kmem_cache *posix_timers_cache;
 static DEFINE_HASHTABLE(posix_timers_hashtable, 9);
 static DEFINE_SPINLOCK(hash_lock);
 
+static const struct k_clock * const posix_clocks[];
+static const struct k_clock *clockid_to_kclock(const clockid_t id);
+static const struct k_clock clock_realtime, clock_monotonic;
+
 /*
  * we assume that the new SIGEV_THREAD_ID shares no bits with the other
  * SIGEV values.  Here we put out an error if this assumption fails.
@@ -124,22 +130,6 @@ static DEFINE_SPINLOCK(hash_lock);
  *          have is CLOCK_REALTIME and its high res counter part, both of
  *          which we beg off on and pass to do_sys_settimeofday().
  */
-
-static struct k_clock posix_clocks[MAX_CLOCKS];
-
-/*
- * These ones are defined below.
- */
-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 *);
-static int common_timer_set(struct k_itimer *, int,
-                            struct itimerspec64 *, struct itimerspec64 *);
-static int common_timer_del(struct k_itimer *timer);
-
-static enum hrtimer_restart posix_timer_fn(struct hrtimer *data);
-
 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags);
 
 #define lock_timer(tid, flags)                                             \
@@ -285,91 +275,23 @@ static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec64 *tp)
  */
 static __init int init_posix_timers(void)
 {
-        struct k_clock clock_realtime = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_clock_realtime_get,
-                .clock_set      = posix_clock_realtime_set,
-                .clock_adj      = posix_clock_realtime_adj,
-                .nsleep         = common_nsleep,
-                .nsleep_restart = hrtimer_nanosleep_restart,
-                .timer_create   = common_timer_create,
-                .timer_set      = common_timer_set,
-                .timer_get      = common_timer_get,
-                .timer_del      = common_timer_del,
-        };
-        struct k_clock clock_monotonic = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_ktime_get_ts,
-                .nsleep         = common_nsleep,
-                .nsleep_restart = hrtimer_nanosleep_restart,
-                .timer_create   = common_timer_create,
-                .timer_set      = common_timer_set,
-                .timer_get      = common_timer_get,
-                .timer_del      = common_timer_del,
-        };
-        struct k_clock clock_monotonic_raw = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_get_monotonic_raw,
-        };
-        struct k_clock clock_realtime_coarse = {
-                .clock_getres   = posix_get_coarse_res,
-                .clock_get      = posix_get_realtime_coarse,
-        };
-        struct k_clock clock_monotonic_coarse = {
-                .clock_getres   = posix_get_coarse_res,
-                .clock_get      = posix_get_monotonic_coarse,
-        };
-        struct k_clock clock_tai = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_get_tai,
-                .nsleep         = common_nsleep,
-                .nsleep_restart = hrtimer_nanosleep_restart,
-                .timer_create   = common_timer_create,
-                .timer_set      = common_timer_set,
-                .timer_get      = common_timer_get,
-                .timer_del      = common_timer_del,
-        };
-        struct k_clock clock_boottime = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_get_boottime,
-                .nsleep         = common_nsleep,
-                .nsleep_restart = hrtimer_nanosleep_restart,
-                .timer_create   = common_timer_create,
-                .timer_set      = common_timer_set,
-                .timer_get      = common_timer_get,
-                .timer_del      = common_timer_del,
-        };
-
-        posix_timers_register_clock(CLOCK_REALTIME, &clock_realtime);
-        posix_timers_register_clock(CLOCK_MONOTONIC, &clock_monotonic);
-        posix_timers_register_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
-        posix_timers_register_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);
-        posix_timers_register_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);
-        posix_timers_register_clock(CLOCK_BOOTTIME, &clock_boottime);
-        posix_timers_register_clock(CLOCK_TAI, &clock_tai);
-
         posix_timers_cache = kmem_cache_create("posix_timers_cache",
                                         sizeof (struct k_itimer), 0, SLAB_PANIC,
                                         NULL);
         return 0;
 }
-
 __initcall(init_posix_timers);
 
-static void schedule_next_timer(struct k_itimer *timr)
+static void common_hrtimer_rearm(struct k_itimer *timr)
 {
         struct hrtimer *timer = &timr->it.real.timer;
 
-        if (timr->it.real.interval == 0)
+        if (!timr->it_interval)
                 return;
 
         timr->it_overrun += (unsigned int) hrtimer_forward(timer,
                                                 timer->base->get_time(),
-                                                timr->it.real.interval);
-
-        timr->it_overrun_last = timr->it_overrun;
-        timr->it_overrun = -1;
-        ++timr->it_requeue_pending;
+                                                timr->it_interval);
         hrtimer_restart(timer);
 }
 
@@ -384,24 +306,27 @@ static void schedule_next_timer(struct k_itimer *timr)
  * To protect against the timer going away while the interrupt is queued,
  * we require that the it_requeue_pending flag be set.
  */
-void do_schedule_next_timer(struct siginfo *info)
+void posixtimer_rearm(struct siginfo *info)
 {
         struct k_itimer *timr;
         unsigned long flags;
 
         timr = lock_timer(info->si_tid, &flags);
+        if (!timr)
+                return;
 
-        if (timr && timr->it_requeue_pending == info->si_sys_private) {
-                if (timr->it_clock < 0)
-                        posix_cpu_timer_schedule(timr);
-                else
-                        schedule_next_timer(timr);
+        if (timr->it_requeue_pending == info->si_sys_private) {
+                timr->kclock->timer_rearm(timr);
+
+                timr->it_active = 1;
+                timr->it_overrun_last = timr->it_overrun;
+                timr->it_overrun = -1;
+                ++timr->it_requeue_pending;
 
                 info->si_overrun += timr->it_overrun_last;
         }
 
-        if (timr)
-                unlock_timer(timr, flags);
+        unlock_timer(timr, flags);
 }
 
 int posix_timer_event(struct k_itimer *timr, int si_private)
@@ -410,12 +335,12 @@ int posix_timer_event(struct k_itimer *timr, int si_private)
         int shared, ret = -1;
         /*
          * FIXME: if ->sigq is queued we can race with
-         * dequeue_signal()->do_schedule_next_timer().
+         * dequeue_signal()->posixtimer_rearm().
          *
          * If dequeue_signal() sees the "right" value of
-         * si_sys_private it calls do_schedule_next_timer().
+         * si_sys_private it calls posixtimer_rearm().
          * We re-queue ->sigq and drop ->it_lock().
-         * do_schedule_next_timer() locks the timer
+         * posixtimer_rearm() locks the timer
          * and re-schedules it while ->sigq is pending.
          * Not really bad, but not that we want.
          */
@@ -431,7 +356,6 @@ int posix_timer_event(struct k_itimer *timr, int si_private)
         /* If we failed to send the signal the timer stops. */
         return ret > 0;
 }
-EXPORT_SYMBOL_GPL(posix_timer_event);
 
 /*
  * This function gets called when a POSIX.1b interval timer expires.  It
@@ -450,7 +374,8 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
         timr = container_of(timer, struct k_itimer, it.real.timer);
         spin_lock_irqsave(&timr->it_lock, flags);
 
-        if (timr->it.real.interval != 0)
+        timr->it_active = 0;
+        if (timr->it_interval != 0)
                 si_private = ++timr->it_requeue_pending;
 
         if (posix_timer_event(timr, si_private)) {
@@ -459,7 +384,7 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
                  * we will not get a call back to restart it AND
                  * it should be restarted.
                  */
-                if (timr->it.real.interval != 0) {
+                if (timr->it_interval != 0) {
                         ktime_t now = hrtimer_cb_get_time(timer);
 
                         /*
@@ -488,15 +413,16 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
                         {
                                 ktime_t kj = NSEC_PER_SEC / HZ;
 
-                                if (timr->it.real.interval < kj)
+                                if (timr->it_interval < kj)
                                         now = ktime_add(now, kj);
                         }
 #endif
                         timr->it_overrun += (unsigned int)
                                 hrtimer_forward(timer, now,
-                                                timr->it.real.interval);
+                                                timr->it_interval);
                         ret = HRTIMER_RESTART;
                         ++timr->it_requeue_pending;
+                        timr->it_active = 1;
                 }
         }
 
@@ -521,30 +447,6 @@ static struct pid *good_sigevent(sigevent_t * event)
         return task_pid(rtn);
 }
 
-void posix_timers_register_clock(const clockid_t clock_id,
-                                 struct k_clock *new_clock)
-{
-        if ((unsigned) clock_id >= MAX_CLOCKS) {
-                printk(KERN_WARNING "POSIX clock register failed for clock_id %d\n",
-                       clock_id);
-                return;
-        }
-
-        if (!new_clock->clock_get) {
-                printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n",
-                       clock_id);
-                return;
-        }
-        if (!new_clock->clock_getres) {
-                printk(KERN_WARNING "POSIX clock id %d lacks clock_getres()\n",
-                       clock_id);
-                return;
-        }
-
-        posix_clocks[clock_id] = *new_clock;
-}
-EXPORT_SYMBOL_GPL(posix_timers_register_clock);
-
 static struct k_itimer * alloc_posix_timer(void)
 {
         struct k_itimer *tmr;
@@ -581,17 +483,6 @@ static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
         call_rcu(&tmr->it.rcu, k_itimer_rcu_free);
 }
 
-static struct k_clock *clockid_to_kclock(const clockid_t id)
-{
-        if (id < 0)
-                return (id & CLOCKFD_MASK) == CLOCKFD ?
-                        &clock_posix_dynamic : &clock_posix_cpu;
-
-        if (id >= MAX_CLOCKS || !posix_clocks[id].clock_getres)
-                return NULL;
-        return &posix_clocks[id];
-}
-
 static int common_timer_create(struct k_itimer *new_timer)
 {
         hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
@@ -599,15 +490,12 @@ static int common_timer_create(struct k_itimer *new_timer)
 }
 
 /* Create a POSIX.1b interval timer. */
-
-SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
-                struct sigevent __user *, timer_event_spec,
-                timer_t __user *, created_timer_id)
+static int do_timer_create(clockid_t which_clock, struct sigevent *event,
+                           timer_t __user *created_timer_id)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
         struct k_itimer *new_timer;
         int error, new_timer_id;
-        sigevent_t event;
         int it_id_set = IT_ID_NOT_SET;
 
         if (!kc)
@@ -629,31 +517,28 @@ SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
         it_id_set = IT_ID_SET;
         new_timer->it_id = (timer_t) new_timer_id;
         new_timer->it_clock = which_clock;
+        new_timer->kclock = kc;
         new_timer->it_overrun = -1;
 
-        if (timer_event_spec) {
-                if (copy_from_user(&event, timer_event_spec, sizeof (event))) {
-                        error = -EFAULT;
-                        goto out;
-                }
+        if (event) {
                 rcu_read_lock();
-                new_timer->it_pid = get_pid(good_sigevent(&event));
+                new_timer->it_pid = get_pid(good_sigevent(event));
                 rcu_read_unlock();
                 if (!new_timer->it_pid) {
                         error = -EINVAL;
                         goto out;
                 }
+                new_timer->it_sigev_notify     = event->sigev_notify;
+                new_timer->sigq->info.si_signo = event->sigev_signo;
+                new_timer->sigq->info.si_value = event->sigev_value;
         } else {
-                memset(&event.sigev_value, 0, sizeof(event.sigev_value));
-                event.sigev_notify = SIGEV_SIGNAL;
-                event.sigev_signo = SIGALRM;
-                event.sigev_value.sival_int = new_timer->it_id;
+                new_timer->it_sigev_notify     = SIGEV_SIGNAL;
+                new_timer->sigq->info.si_signo = SIGALRM;
+                memset(&new_timer->sigq->info.si_value, 0, sizeof(sigval_t));
+                new_timer->sigq->info.si_value.sival_int = new_timer->it_id;
                 new_timer->it_pid = get_pid(task_tgid(current));
         }
 
-        new_timer->it_sigev_notify     = event.sigev_notify;
-        new_timer->sigq->info.si_signo = event.sigev_signo;
-        new_timer->sigq->info.si_value = event.sigev_value;
         new_timer->sigq->info.si_tid   = new_timer->it_id;
         new_timer->sigq->info.si_code  = SI_TIMER;
 
@@ -684,6 +569,36 @@ out:
         return error;
 }
 
+SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
+                struct sigevent __user *, timer_event_spec,
+                timer_t __user *, created_timer_id)
+{
+        if (timer_event_spec) {
+                sigevent_t event;
+
+                if (copy_from_user(&event, timer_event_spec, sizeof (event)))
+                        return -EFAULT;
+                return do_timer_create(which_clock, &event, created_timer_id);
+        }
+        return do_timer_create(which_clock, NULL, created_timer_id);
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
+                       struct compat_sigevent __user *, timer_event_spec,
+                       timer_t __user *, created_timer_id)
+{
+        if (timer_event_spec) {
+                sigevent_t event;
+
+                if (get_compat_sigevent(&event, timer_event_spec))
+                        return -EFAULT;
+                return do_timer_create(which_clock, &event, created_timer_id);
+        }
+        return do_timer_create(which_clock, NULL, created_timer_id);
+}
+#endif
+
 /*
  * Locking issues: We need to protect the result of the id look up until
  * we get the timer locked down so it is not deleted under us.  The
@@ -717,6 +632,20 @@ static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
         return NULL;
 }
 
+static ktime_t common_hrtimer_remaining(struct k_itimer *timr, ktime_t now)
+{
+        struct hrtimer *timer = &timr->it.real.timer;
+
+        return __hrtimer_expires_remaining_adjusted(timer, now);
+}
+
+static int common_hrtimer_forward(struct k_itimer *timr, ktime_t now)
+{
+        struct hrtimer *timer = &timr->it.real.timer;
+
+        return (int)hrtimer_forward(timer, now, timr->it_interval);
+}
+
 /*
  * Get the time remaining on a POSIX.1b interval timer.  This function
  * is ALWAYS called with spin_lock_irq on the timer, thus it must not
@@ -733,55 +662,61 @@ static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
  * it is the same as a requeue pending timer WRT to what we should
  * report.
  */
-static void
-common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)
+void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)
 {
+        const struct k_clock *kc = timr->kclock;
         ktime_t now, remaining, iv;
-        struct hrtimer *timer = &timr->it.real.timer;
+        struct timespec64 ts64;
+        bool sig_none;
 
-        memset(cur_setting, 0, sizeof(*cur_setting));
-
-        iv = timr->it.real.interval;
+        sig_none = (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE;
+        iv = timr->it_interval;
 
         /* interval timer ? */
-        if (iv)
+        if (iv) {
                 cur_setting->it_interval = ktime_to_timespec64(iv);
-        else if (!hrtimer_active(timer) &&
-                 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
-                return;
+        } else if (!timr->it_active) {
+                /*
+                 * SIGEV_NONE oneshot timers are never queued. Check them
+                 * below.
+                 */
+                if (!sig_none)
+                        return;
+        }
 
-        now = timer->base->get_time();
+        /*
+         * The timespec64 based conversion is suboptimal, but it's not
+         * worth to implement yet another callback.
+         */
+        kc->clock_get(timr->it_clock, &ts64);
+        now = timespec64_to_ktime(ts64);
 
         /*
-         * When a requeue is pending or this is a SIGEV_NONE
-         * timer move the expiry time forward by intervals, so
-         * expiry is > now.
+         * When a requeue is pending or this is a SIGEV_NONE timer move the
+         * expiry time forward by intervals, so expiry is > now.
          */
-        if (iv && (timr->it_requeue_pending & REQUEUE_PENDING ||
-                   (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
-                timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
+        if (iv && (timr->it_requeue_pending & REQUEUE_PENDING || sig_none))
+                timr->it_overrun += kc->timer_forward(timr, now);
 
-        remaining = __hrtimer_expires_remaining_adjusted(timer, now);
+        remaining = kc->timer_remaining(timr, now);
         /* Return 0 only, when the timer is expired and not pending */
         if (remaining <= 0) {
                 /*
                  * A single shot SIGEV_NONE timer must return 0, when
                  * it is expired !
                  */
-                if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
+                if (!sig_none)
                         cur_setting->it_value.tv_nsec = 1;
-        } else
+        } else {
                 cur_setting->it_value = ktime_to_timespec64(remaining);
+        }
 }
 
 /* Get the time remaining on a POSIX.1b interval timer. */
-SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
-                struct itimerspec __user *, setting)
+static int do_timer_gettime(timer_t timer_id,  struct itimerspec64 *setting)
 {
-        struct itimerspec64 cur_setting64;
-        struct itimerspec cur_setting;
         struct k_itimer *timr;
-        struct k_clock *kc;
+        const struct k_clock *kc;
         unsigned long flags;
         int ret = 0;
 
@@ -789,20 +724,49 @@ SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
         if (!timr)
                 return -EINVAL;
 
-        kc = clockid_to_kclock(timr->it_clock);
+        memset(setting, 0, sizeof(*setting));
+        kc = timr->kclock;
         if (WARN_ON_ONCE(!kc || !kc->timer_get))
                 ret = -EINVAL;
         else
-                kc->timer_get(timr, &cur_setting64);
+                kc->timer_get(timr, setting);
 
         unlock_timer(timr, flags);
+        return ret;
+}
 
-        cur_setting = itimerspec64_to_itimerspec(&cur_setting64);
-        if (!ret && copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
-                return -EFAULT;
+/* Get the time remaining on a POSIX.1b interval timer. */
+SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
+                struct itimerspec __user *, setting)
+{
+        struct itimerspec64 cur_setting64;
 
+        int ret = do_timer_gettime(timer_id, &cur_setting64);
+        if (!ret) {
+                struct itimerspec cur_setting;
+                cur_setting = itimerspec64_to_itimerspec(&cur_setting64);
+                if (copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
+                        ret = -EFAULT;
+        }
+        return ret;
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
+                       struct compat_itimerspec __user *, setting)
+{
+        struct itimerspec64 cur_setting64;
+
+        int ret = do_timer_gettime(timer_id, &cur_setting64);
+        if (!ret) {
+                struct itimerspec cur_setting;
+                cur_setting = itimerspec64_to_itimerspec(&cur_setting64);
+                if (put_compat_itimerspec(setting, &cur_setting))
+                        ret = -EFAULT;
+        }
         return ret;
 }
+#endif
 
 /*
  * Get the number of overruns of a POSIX.1b interval timer.  This is to
@@ -810,7 +774,7 @@ SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
  * accumulating overruns on the next timer.  The overrun is frozen when
  * the signal is delivered, either at the notify time (if the info block
  * is not queued) or at the actual delivery time (as we are informed by
- * the call back to do_schedule_next_timer().  So all we need to do is
+ * the call back to posixtimer_rearm().  So all we need to do is
  * to pick up the frozen overrun.
  */
 SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
@@ -829,117 +793,183 @@ SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
         return overrun;
 }
 
-/* Set a POSIX.1b interval timer. */
-/* timr->it_lock is taken. */
-static int
-common_timer_set(struct k_itimer *timr, int flags,
-                 struct itimerspec64 *new_setting, struct itimerspec64 *old_setting)
+static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires,
+                               bool absolute, bool sigev_none)
 {
         struct hrtimer *timer = &timr->it.real.timer;
         enum hrtimer_mode mode;
 
+        mode = absolute ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
+        /*
+         * Posix magic: Relative CLOCK_REALTIME timers are not affected by
+         * clock modifications, so they become CLOCK_MONOTONIC based under the
+         * hood. See hrtimer_init(). Update timr->kclock, so the generic
+         * functions which use timr->kclock->clock_get() work.
+         *
+         * Note: it_clock stays unmodified, because the next timer_set() might
+         * use ABSTIME, so it needs to switch back.
+         */
+        if (timr->it_clock == CLOCK_REALTIME)
+                timr->kclock = absolute ? &clock_realtime : &clock_monotonic;
+
+        hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
+        timr->it.real.timer.function = posix_timer_fn;
+
+        if (!absolute)
+                expires = ktime_add_safe(expires, timer->base->get_time());
+        hrtimer_set_expires(timer, expires);
+
+        if (!sigev_none)
+                hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
+}
+
+static int common_hrtimer_try_to_cancel(struct k_itimer *timr)
+{
+        return hrtimer_try_to_cancel(&timr->it.real.timer);
+}
+
+/* Set a POSIX.1b interval timer. */
+int common_timer_set(struct k_itimer *timr, int flags,
+                     struct itimerspec64 *new_setting,
+                     struct itimerspec64 *old_setting)
+{
+        const struct k_clock *kc = timr->kclock;
+        bool sigev_none;
+        ktime_t expires;
+
         if (old_setting)
                 common_timer_get(timr, old_setting);
 
-        /* disable the timer */
-        timr->it.real.interval = 0;
+        /* Prevent rearming by clearing the interval */
+        timr->it_interval = 0;
         /*
-         * careful here.  If smp we could be in the "fire" routine which will
-         * be spinning as we hold the lock.  But this is ONLY an SMP issue.
+         * Careful here. On SMP systems the timer expiry function could be
+         * active and spinning on timr->it_lock.
          */
-        if (hrtimer_try_to_cancel(timer) < 0)
+        if (kc->timer_try_to_cancel(timr) < 0)
                 return TIMER_RETRY;
 
-        timr->it_requeue_pending = (timr->it_requeue_pending + 2) & 
+        timr->it_active = 0;
+        timr->it_requeue_pending = (timr->it_requeue_pending + 2) &
                 ~REQUEUE_PENDING;
         timr->it_overrun_last = 0;
 
-        /* switch off the timer when it_value is zero */
+        /* Switch off the timer when it_value is zero */
         if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
                 return 0;
 
-        mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
-        hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
-        timr->it.real.timer.function = posix_timer_fn;
-
-        hrtimer_set_expires(timer, timespec64_to_ktime(new_setting->it_value));
-
-        /* Convert interval */
-        timr->it.real.interval = timespec64_to_ktime(new_setting->it_interval);
-
-        /* SIGEV_NONE timers are not queued ! See common_timer_get */
-        if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
-                /* Setup correct expiry time for relative timers */
-                if (mode == HRTIMER_MODE_REL) {
-                        hrtimer_add_expires(timer, timer->base->get_time());
-                }
-                return 0;
-        }
+        timr->it_interval = timespec64_to_ktime(new_setting->it_interval);
+        expires = timespec64_to_ktime(new_setting->it_value);
+        sigev_none = (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE;
 
-        hrtimer_start_expires(timer, mode);
+        kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none);
+        timr->it_active = !sigev_none;
         return 0;
 }
 
-/* Set a POSIX.1b interval timer */
-SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
-                const struct itimerspec __user *, new_setting,
-                struct itimerspec __user *, old_setting)
+static int do_timer_settime(timer_t timer_id, int flags,
+                            struct itimerspec64 *new_spec64,
+                            struct itimerspec64 *old_spec64)
 {
-        struct itimerspec64 new_spec64, old_spec64;
-        struct itimerspec64 *rtn = old_setting ? &old_spec64 : NULL;
-        struct itimerspec new_spec, old_spec;
+        const struct k_clock *kc;
         struct k_itimer *timr;
         unsigned long flag;
-        struct k_clock *kc;
         int error = 0;
 
-        if (!new_setting)
+        if (!timespec64_valid(&new_spec64->it_interval) ||
+            !timespec64_valid(&new_spec64->it_value))
                 return -EINVAL;
 
-        if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
-                return -EFAULT;
-        new_spec64 = itimerspec_to_itimerspec64(&new_spec);
-
-        if (!timespec64_valid(&new_spec64.it_interval) ||
-            !timespec64_valid(&new_spec64.it_value))
-                return -EINVAL;
+        if (old_spec64)
+                memset(old_spec64, 0, sizeof(*old_spec64));
 retry:
         timr = lock_timer(timer_id, &flag);
         if (!timr)
                 return -EINVAL;
 
-        kc = clockid_to_kclock(timr->it_clock);
+        kc = timr->kclock;
         if (WARN_ON_ONCE(!kc || !kc->timer_set))
                 error = -EINVAL;
         else
-                error = kc->timer_set(timr, flags, &new_spec64, rtn);
+                error = kc->timer_set(timr, flags, new_spec64, old_spec64);
 
         unlock_timer(timr, flag);
         if (error == TIMER_RETRY) {
-                rtn = NULL;     // We already got the old time...
+                old_spec64 = NULL;      // We already got the old time...
                 goto retry;
         }
 
-        old_spec = itimerspec64_to_itimerspec(&old_spec64);
-        if (old_setting && !error &&
-            copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
-                error = -EFAULT;
+        return error;
+}
+
+/* Set a POSIX.1b interval timer */
+SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
+                const struct itimerspec __user *, new_setting,
+                struct itimerspec __user *, old_setting)
+{
+        struct itimerspec64 new_spec64, old_spec64;
+        struct itimerspec64 *rtn = old_setting ? &old_spec64 : NULL;
+        struct itimerspec new_spec;
+        int error = 0;
+
+        if (!new_setting)
+                return -EINVAL;
+
+        if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
+                return -EFAULT;
+        new_spec64 = itimerspec_to_itimerspec64(&new_spec);
+
+        error = do_timer_settime(timer_id, flags, &new_spec64, rtn);
+        if (!error && old_setting) {
+                struct itimerspec old_spec;
+                old_spec = itimerspec64_to_itimerspec(&old_spec64);
+                if (copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
+                        error = -EFAULT;
+        }
+        return error;
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
+                       struct compat_itimerspec __user *, new,
+                       struct compat_itimerspec __user *, old)
+{
+        struct itimerspec64 new_spec64, old_spec64;
+        struct itimerspec64 *rtn = old ? &old_spec64 : NULL;
+        struct itimerspec new_spec;
+        int error = 0;
+
+        if (!new)
+                return -EINVAL;
+        if (get_compat_itimerspec(&new_spec, new))
+                return -EFAULT;
 
+        new_spec64 = itimerspec_to_itimerspec64(&new_spec);
+        error = do_timer_settime(timer_id, flags, &new_spec64, rtn);
+        if (!error && old) {
+                struct itimerspec old_spec;
+                old_spec = itimerspec64_to_itimerspec(&old_spec64);
+                if (put_compat_itimerspec(old, &old_spec))
+                        error = -EFAULT;
+        }
         return error;
 }
+#endif
 
-static int common_timer_del(struct k_itimer *timer)
+int common_timer_del(struct k_itimer *timer)
 {
-        timer->it.real.interval = 0;
+        const struct k_clock *kc = timer->kclock;
 
-        if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
+        timer->it_interval = 0;
+        if (kc->timer_try_to_cancel(timer) < 0)
                 return TIMER_RETRY;
+        timer->it_active = 0;
         return 0;
 }
 
 static inline int timer_delete_hook(struct k_itimer *timer)
 {
-        struct k_clock *kc = clockid_to_kclock(timer->it_clock);
+        const struct k_clock *kc = timer->kclock;
 
         if (WARN_ON_ONCE(!kc || !kc->timer_del))
                 return -EINVAL;
@@ -1018,7 +1048,7 @@ void exit_itimers(struct signal_struct *sig)
 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
                 const struct timespec __user *, tp)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
         struct timespec64 new_tp64;
         struct timespec new_tp;
 
@@ -1035,7 +1065,7 @@ SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
                 struct timespec __user *,tp)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
         struct timespec64 kernel_tp64;
         struct timespec kernel_tp;
         int error;
@@ -1055,7 +1085,7 @@ SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
 SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
                 struct timex __user *, utx)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
         struct timex ktx;
         int err;
 
@@ -1078,7 +1108,7 @@ SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
                 struct timespec __user *, tp)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
         struct timespec64 rtn_tp64;
         struct timespec rtn_tp;
         int error;
@@ -1095,13 +1125,98 @@ SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
         return error;
 }
 
+#ifdef CONFIG_COMPAT
+
+COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 new_tp64;
+        struct timespec new_tp;
+
+        if (!kc || !kc->clock_set)
+                return -EINVAL;
+
+        if (compat_get_timespec(&new_tp, tp))
+                return -EFAULT;
+
+        new_tp64 = timespec_to_timespec64(new_tp);
+
+        return kc->clock_set(which_clock, &new_tp64);
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 kernel_tp64;
+        struct timespec kernel_tp;
+        int error;
+
+        if (!kc)
+                return -EINVAL;
+
+        error = kc->clock_get(which_clock, &kernel_tp64);
+        kernel_tp = timespec64_to_timespec(kernel_tp64);
+
+        if (!error && compat_put_timespec(&kernel_tp, tp))
+                error = -EFAULT;
+
+        return error;
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
+                       struct compat_timex __user *, utp)
+{
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timex ktx;
+        int err;
+
+        if (!kc)
+                return -EINVAL;
+        if (!kc->clock_adj)
+                return -EOPNOTSUPP;
+
+        err = compat_get_timex(&ktx, utp);
+        if (err)
+                return err;
+
+        err = kc->clock_adj(which_clock, &ktx);
+
+        if (err >= 0)
+                err = compat_put_timex(utp, &ktx);
+
+        return err;
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 rtn_tp64;
+        struct timespec rtn_tp;
+        int error;
+
+        if (!kc)
+                return -EINVAL;
+
+        error = kc->clock_getres(which_clock, &rtn_tp64);
+        rtn_tp = timespec64_to_timespec(rtn_tp64);
+
+        if (!error && tp && compat_put_timespec(&rtn_tp, tp))
+                error = -EFAULT;
+
+        return error;
+}
+#endif
+
 /*
  * nanosleep for monotonic and realtime clocks
  */
 static int common_nsleep(const clockid_t which_clock, int flags,
-                         struct timespec64 *tsave, struct timespec __user *rmtp)
+                         const struct timespec64 *rqtp)
 {
-        return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
+        return hrtimer_nanosleep(rqtp, flags & TIMER_ABSTIME ?
                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
                                  which_clock);
 }
@@ -1110,7 +1225,7 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
                 const struct timespec __user *, rqtp,
                 struct timespec __user *, rmtp)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
         struct timespec64 t64;
         struct timespec t;
 
@@ -1125,21 +1240,141 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
         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 kc->nsleep(which_clock, flags, &t64, rmtp);
+        return kc->nsleep(which_clock, flags, &t64);
 }
 
-/*
- * 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)
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
+                       struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
 {
-        clockid_t which_clock = restart_block->nanosleep.clockid;
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 t64;
+        struct timespec t;
 
-        if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
+        if (!kc)
                 return -EINVAL;
+        if (!kc->nsleep)
+                return -ENANOSLEEP_NOTSUP;
 
-        return kc->nsleep_restart(restart_block);
+        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 kc->nsleep(which_clock, flags, &t64);
+}
+#endif
+
+static const struct k_clock clock_realtime = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_clock_realtime_get,
+        .clock_set              = posix_clock_realtime_set,
+        .clock_adj              = posix_clock_realtime_adj,
+        .nsleep                 = common_nsleep,
+        .timer_create           = common_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_get              = common_timer_get,
+        .timer_del              = common_timer_del,
+        .timer_rearm            = common_hrtimer_rearm,
+        .timer_forward          = common_hrtimer_forward,
+        .timer_remaining        = common_hrtimer_remaining,
+        .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
+        .timer_arm              = common_hrtimer_arm,
+};
+
+static const struct k_clock clock_monotonic = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_ktime_get_ts,
+        .nsleep                 = common_nsleep,
+        .timer_create           = common_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_get              = common_timer_get,
+        .timer_del              = common_timer_del,
+        .timer_rearm            = common_hrtimer_rearm,
+        .timer_forward          = common_hrtimer_forward,
+        .timer_remaining        = common_hrtimer_remaining,
+        .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
+        .timer_arm              = common_hrtimer_arm,
+};
+
+static const struct k_clock clock_monotonic_raw = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_get_monotonic_raw,
+};
+
+static const struct k_clock clock_realtime_coarse = {
+        .clock_getres           = posix_get_coarse_res,
+        .clock_get              = posix_get_realtime_coarse,
+};
+
+static const struct k_clock clock_monotonic_coarse = {
+        .clock_getres           = posix_get_coarse_res,
+        .clock_get              = posix_get_monotonic_coarse,
+};
+
+static const struct k_clock clock_tai = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_get_tai,
+        .nsleep                 = common_nsleep,
+        .timer_create           = common_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_get              = common_timer_get,
+        .timer_del              = common_timer_del,
+        .timer_rearm            = common_hrtimer_rearm,
+        .timer_forward          = common_hrtimer_forward,
+        .timer_remaining        = common_hrtimer_remaining,
+        .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
+        .timer_arm              = common_hrtimer_arm,
+};
+
+static const struct k_clock clock_boottime = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_get_boottime,
+        .nsleep                 = common_nsleep,
+        .timer_create           = common_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_get              = common_timer_get,
+        .timer_del              = common_timer_del,
+        .timer_rearm            = common_hrtimer_rearm,
+        .timer_forward          = common_hrtimer_forward,
+        .timer_remaining        = common_hrtimer_remaining,
+        .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
+        .timer_arm              = common_hrtimer_arm,
+};
+
+static const struct k_clock * const posix_clocks[] = {
+        [CLOCK_REALTIME]                = &clock_realtime,
+        [CLOCK_MONOTONIC]               = &clock_monotonic,
+        [CLOCK_PROCESS_CPUTIME_ID]      = &clock_process,
+        [CLOCK_THREAD_CPUTIME_ID]       = &clock_thread,
+        [CLOCK_MONOTONIC_RAW]           = &clock_monotonic_raw,
+        [CLOCK_REALTIME_COARSE]         = &clock_realtime_coarse,
+        [CLOCK_MONOTONIC_COARSE]        = &clock_monotonic_coarse,
+        [CLOCK_BOOTTIME]                = &clock_boottime,
+        [CLOCK_REALTIME_ALARM]          = &alarm_clock,
+        [CLOCK_BOOTTIME_ALARM]          = &alarm_clock,
+        [CLOCK_TAI]                     = &clock_tai,
+};
+
+static const struct k_clock *clockid_to_kclock(const clockid_t id)
+{
+        if (id < 0)
+                return (id & CLOCKFD_MASK) == CLOCKFD ?
+                        &clock_posix_dynamic : &clock_posix_cpu;
+
+        if (id >= ARRAY_SIZE(posix_clocks) || !posix_clocks[id])
+                return NULL;
+        return posix_clocks[id];
 }