Merge branch 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull timer updates from Thomas Gleixner:
 "A rather large update for timers/timekeeping:

   - compat syscall consolidation (Al Viro)

   - Posix timer consolidation (Christoph Helwig / Thomas Gleixner)

   - Cleanup of the device tree based initialization for clockevents and
     clocksources (Daniel Lezcano)

   - Consolidation of the FTTMR010 clocksource/event driver (Linus
     Walleij)

   - The usual set of small fixes and updates all over the place"

* 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (93 commits)
  timers: Make the cpu base lock raw
  clocksource/drivers/mips-gic-timer: Fix an error code in 'gic_clocksource_of_init()'
  clocksource/drivers/fsl_ftm_timer: Unmap region obtained by of_iomap
  clocksource/drivers/tcb_clksrc: Make IO endian agnostic
  clocksource/drivers/sun4i: Switch to the timer-of common init
  clocksource/drivers/timer-of: Fix invalid iomap check
  Revert "ktime: Simplify ktime_compare implementation"
  clocksource/drivers: Fix uninitialized variable use in timer_of_init
  kselftests: timers: Add test for frequency step
  kselftests: timers: Fix inconsistency-check to not ignore first timestamp
  time: Add warning about imminent deprecation of CONFIG_GENERIC_TIME_VSYSCALL_OLD
  time: Clean up CLOCK_MONOTONIC_RAW time handling
  posix-cpu-timers: Make timespec to nsec conversion safe
  itimer: Make timeval to nsec conversion range limited
  timers: Fix parameter description of try_to_del_timer_sync()
  ktime: Simplify ktime_compare implementation
  clocksource/drivers/fttmr010: Factor out clock read code
  clocksource/drivers/fttmr010: Implement delay timer
  clocksource/drivers: Add timer-of common init routine
  clocksource/drivers/tcb_clksrc: Save timer context on suspend/resume
  ...

11 files changed, 1129 insertions, 781 deletions

diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
index ee2f4202d82a..c991cf212c6d 100644
--- a/kernel/time/alarmtimer.c
+++ b/kernel/time/alarmtimer.c
@@ -27,6 +27,9 @@
 #include <linux/posix-timers.h>
 #include <linux/workqueue.h>
 #include <linux/freezer.h>
+#include <linux/compat.h>
+
+#include "posix-timers.h"
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/alarmtimer.h>
@@ -45,11 +48,13 @@ static struct alarm_base {
         clockid_t               base_clockid;
 } alarm_bases[ALARM_NUMTYPE];
 
+#if defined(CONFIG_POSIX_TIMERS) || defined(CONFIG_RTC_CLASS)
 /* freezer information to handle clock_nanosleep triggered wakeups */
 static enum alarmtimer_type freezer_alarmtype;
 static ktime_t freezer_expires;
 static ktime_t freezer_delta;
 static DEFINE_SPINLOCK(freezer_delta_lock);
+#endif
 
 static struct wakeup_source *ws;
 
@@ -307,38 +312,6 @@ static int alarmtimer_resume(struct device *dev)
 }
 #endif
 
-static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
-{
-        struct alarm_base *base;
-        unsigned long flags;
-        ktime_t delta;
-
-        switch(type) {
-        case ALARM_REALTIME:
-                base = &alarm_bases[ALARM_REALTIME];
-                type = ALARM_REALTIME_FREEZER;
-                break;
-        case ALARM_BOOTTIME:
-                base = &alarm_bases[ALARM_BOOTTIME];
-                type = ALARM_BOOTTIME_FREEZER;
-                break;
-        default:
-                WARN_ONCE(1, "Invalid alarm type: %d\n", type);
-                return;
-        }
-
-        delta = ktime_sub(absexp, base->gettime());
-
-        spin_lock_irqsave(&freezer_delta_lock, flags);
-        if (!freezer_delta || (delta < freezer_delta)) {
-                freezer_delta = delta;
-                freezer_expires = absexp;
-                freezer_alarmtype = type;
-        }
-        spin_unlock_irqrestore(&freezer_delta_lock, flags);
-}
-
-
 /**
  * alarm_init - Initialize an alarm structure
  * @alarm: ptr to alarm to be initialized
@@ -488,6 +461,38 @@ u64 alarm_forward_now(struct alarm *alarm, ktime_t interval)
 }
 EXPORT_SYMBOL_GPL(alarm_forward_now);
 
+#ifdef CONFIG_POSIX_TIMERS
+
+static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
+{
+        struct alarm_base *base;
+        unsigned long flags;
+        ktime_t delta;
+
+        switch(type) {
+        case ALARM_REALTIME:
+                base = &alarm_bases[ALARM_REALTIME];
+                type = ALARM_REALTIME_FREEZER;
+                break;
+        case ALARM_BOOTTIME:
+                base = &alarm_bases[ALARM_BOOTTIME];
+                type = ALARM_BOOTTIME_FREEZER;
+                break;
+        default:
+                WARN_ONCE(1, "Invalid alarm type: %d\n", type);
+                return;
+        }
+
+        delta = ktime_sub(absexp, base->gettime());
+
+        spin_lock_irqsave(&freezer_delta_lock, flags);
+        if (!freezer_delta || (delta < freezer_delta)) {
+                freezer_delta = delta;
+                freezer_expires = absexp;
+                freezer_alarmtype = type;
+        }
+        spin_unlock_irqrestore(&freezer_delta_lock, flags);
+}
 
 /**
  * clock2alarm - helper that converts from clockid to alarmtypes
@@ -511,22 +516,26 @@ static enum alarmtimer_type clock2alarm(clockid_t clockid)
 static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
                                                         ktime_t now)
 {
-        unsigned long flags;
         struct k_itimer *ptr = container_of(alarm, struct k_itimer,
-                                                it.alarm.alarmtimer);
+                                            it.alarm.alarmtimer);
         enum alarmtimer_restart result = ALARMTIMER_NORESTART;
+        unsigned long flags;
+        int si_private = 0;
 
         spin_lock_irqsave(&ptr->it_lock, flags);
-        if ((ptr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) {
-                if (IS_ENABLED(CONFIG_POSIX_TIMERS) &&
-                    posix_timer_event(ptr, 0) != 0)
-                        ptr->it_overrun++;
-        }
 
-        /* Re-add periodic timers */
-        if (ptr->it.alarm.interval) {
-                ptr->it_overrun += alarm_forward(alarm, now,
-                                                ptr->it.alarm.interval);
+        ptr->it_active = 0;
+        if (ptr->it_interval)
+                si_private = ++ptr->it_requeue_pending;
+
+        if (posix_timer_event(ptr, si_private) && ptr->it_interval) {
+                /*
+                 * Handle ignored signals and rearm the timer. This will go
+                 * away once we handle ignored signals proper.
+                 */
+                ptr->it_overrun += alarm_forward_now(alarm, ptr->it_interval);
+                ++ptr->it_requeue_pending;
+                ptr->it_active = 1;
                 result = ALARMTIMER_RESTART;
         }
         spin_unlock_irqrestore(&ptr->it_lock, flags);
@@ -535,6 +544,72 @@ static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
 }
 
 /**
+ * alarm_timer_rearm - Posix timer callback for rearming timer
+ * @timr:       Pointer to the posixtimer data struct
+ */
+static void alarm_timer_rearm(struct k_itimer *timr)
+{
+        struct alarm *alarm = &timr->it.alarm.alarmtimer;
+
+        timr->it_overrun += alarm_forward_now(alarm, timr->it_interval);
+        alarm_start(alarm, alarm->node.expires);
+}
+
+/**
+ * alarm_timer_forward - Posix timer callback for forwarding timer
+ * @timr:       Pointer to the posixtimer data struct
+ * @now:        Current time to forward the timer against
+ */
+static int alarm_timer_forward(struct k_itimer *timr, ktime_t now)
+{
+        struct alarm *alarm = &timr->it.alarm.alarmtimer;
+
+        return (int) alarm_forward(alarm, timr->it_interval, now);
+}
+
+/**
+ * alarm_timer_remaining - Posix timer callback to retrieve remaining time
+ * @timr:       Pointer to the posixtimer data struct
+ * @now:        Current time to calculate against
+ */
+static ktime_t alarm_timer_remaining(struct k_itimer *timr, ktime_t now)
+{
+        struct alarm *alarm = &timr->it.alarm.alarmtimer;
+
+        return ktime_sub(now, alarm->node.expires);
+}
+
+/**
+ * alarm_timer_try_to_cancel - Posix timer callback to cancel a timer
+ * @timr:       Pointer to the posixtimer data struct
+ */
+static int alarm_timer_try_to_cancel(struct k_itimer *timr)
+{
+        return alarm_try_to_cancel(&timr->it.alarm.alarmtimer);
+}
+
+/**
+ * alarm_timer_arm - Posix timer callback to arm a timer
+ * @timr:       Pointer to the posixtimer data struct
+ * @expires:    The new expiry time
+ * @absolute:   Expiry value is absolute time
+ * @sigev_none: Posix timer does not deliver signals
+ */
+static void alarm_timer_arm(struct k_itimer *timr, ktime_t expires,
+                            bool absolute, bool sigev_none)
+{
+        struct alarm *alarm = &timr->it.alarm.alarmtimer;
+        struct alarm_base *base = &alarm_bases[alarm->type];
+
+        if (!absolute)
+                expires = ktime_add_safe(expires, base->gettime());
+        if (sigev_none)
+                alarm->node.expires = expires;
+        else
+                alarm_start(&timr->it.alarm.alarmtimer, expires);
+}
+
+/**
  * alarm_clock_getres - posix getres interface
  * @which_clock: clockid
  * @tp: timespec to fill
@@ -591,97 +666,6 @@ static int alarm_timer_create(struct k_itimer *new_timer)
 }
 
 /**
- * alarm_timer_get - posix timer_get interface
- * @new_timer: k_itimer pointer
- * @cur_setting: itimerspec data to fill
- *
- * Copies out the current itimerspec data
- */
-static void alarm_timer_get(struct k_itimer *timr,
-                            struct itimerspec64 *cur_setting)
-{
-        ktime_t relative_expiry_time =
-                alarm_expires_remaining(&(timr->it.alarm.alarmtimer));
-
-        if (ktime_to_ns(relative_expiry_time) > 0) {
-                cur_setting->it_value = ktime_to_timespec64(relative_expiry_time);
-        } else {
-                cur_setting->it_value.tv_sec = 0;
-                cur_setting->it_value.tv_nsec = 0;
-        }
-
-        cur_setting->it_interval = ktime_to_timespec64(timr->it.alarm.interval);
-}
-
-/**
- * alarm_timer_del - posix timer_del interface
- * @timr: k_itimer pointer to be deleted
- *
- * Cancels any programmed alarms for the given timer.
- */
-static int alarm_timer_del(struct k_itimer *timr)
-{
-        if (!rtcdev)
-                return -ENOTSUPP;
-
-        if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
-                return TIMER_RETRY;
-
-        return 0;
-}
-
-/**
- * alarm_timer_set - posix timer_set interface
- * @timr: k_itimer pointer to be deleted
- * @flags: timer flags
- * @new_setting: itimerspec to be used
- * @old_setting: itimerspec being replaced
- *
- * Sets the timer to new_setting, and starts the timer.
- */
-static int alarm_timer_set(struct k_itimer *timr, int flags,
-                           struct itimerspec64 *new_setting,
-                           struct itimerspec64 *old_setting)
-{
-        ktime_t exp;
-
-        if (!rtcdev)
-                return -ENOTSUPP;
-
-        if (flags & ~TIMER_ABSTIME)
-                return -EINVAL;
-
-        if (old_setting)
-                alarm_timer_get(timr, old_setting);
-
-        /* If the timer was already set, cancel it */
-        if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
-                return TIMER_RETRY;
-
-        /* start the timer */
-        timr->it.alarm.interval = timespec64_to_ktime(new_setting->it_interval);
-
-        /*
-         * Rate limit to the tick as a hot fix to prevent DOS. Will be
-         * mopped up later.
-         */
-        if (timr->it.alarm.interval < TICK_NSEC)
-                timr->it.alarm.interval = TICK_NSEC;
-
-        exp = timespec64_to_ktime(new_setting->it_value);
-        /* Convert (if necessary) to absolute time */
-        if (flags != TIMER_ABSTIME) {
-                ktime_t now;
-
-                now = alarm_bases[timr->it.alarm.alarmtimer.type].gettime();
-                exp = ktime_add_safe(now, exp);
-        }
-
-        alarm_start(&timr->it.alarm.alarmtimer, exp);
-        return 0;
-}
-
-/**
  * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
  * @alarm: ptr to alarm that fired
  *
@@ -705,8 +689,10 @@ static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
  *
  * Sets the alarm timer and sleeps until it is fired or interrupted.
  */
-static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
+static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp,
+                                enum alarmtimer_type type)
 {
+        struct restart_block *restart;
         alarm->data = (void *)current;
         do {
                 set_current_state(TASK_INTERRUPTIBLE);
@@ -719,36 +705,25 @@ static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
 
         __set_current_state(TASK_RUNNING);
 
-        return (alarm->data == NULL);
-}
-
-
-/**
- * update_rmtp - Update remaining timespec value
- * @exp: expiration time
- * @type: timer type
- * @rmtp: user pointer to remaining timepsec value
- *
- * Helper function that fills in rmtp value with time between
- * now and the exp value
- */
-static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
-                        struct timespec __user *rmtp)
-{
-        struct timespec rmt;
-        ktime_t rem;
-
-        rem = ktime_sub(exp, alarm_bases[type].gettime());
-
-        if (rem <= 0)
+        if (!alarm->data)
                 return 0;
-        rmt = ktime_to_timespec(rem);
 
-        if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
-                return -EFAULT;
+        if (freezing(current))
+                alarmtimer_freezerset(absexp, type);
+        restart = &current->restart_block;
+        if (restart->nanosleep.type != TT_NONE) {
+                struct timespec rmt;
+                ktime_t rem;
+
+                rem = ktime_sub(absexp, alarm_bases[type].gettime());
 
-        return 1;
+                if (rem <= 0)
+                        return 0;
+                rmt = ktime_to_timespec(rem);
 
+                return nanosleep_copyout(restart, &rmt);
+        }
+        return -ERESTART_RESTARTBLOCK;
 }
 
 /**
@@ -760,32 +735,12 @@ static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
 static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
 {
         enum  alarmtimer_type type = restart->nanosleep.clockid;
-        ktime_t exp;
-        struct timespec __user  *rmtp;
+        ktime_t exp = restart->nanosleep.expires;
         struct alarm alarm;
-        int ret = 0;
 
-        exp = restart->nanosleep.expires;
         alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
 
-        if (alarmtimer_do_nsleep(&alarm, exp))
-                goto out;
-
-        if (freezing(current))
-                alarmtimer_freezerset(exp, type);
-
-        rmtp = restart->nanosleep.rmtp;
-        if (rmtp) {
-                ret = update_rmtp(exp, type, rmtp);
-                if (ret <= 0)
-                        goto out;
-        }
-
-
-        /* The other values in restart are already filled in */
-        ret = -ERESTART_RESTARTBLOCK;
-out:
-        return ret;
+        return alarmtimer_do_nsleep(&alarm, exp, type);
 }
 
 /**
@@ -798,11 +753,10 @@ out:
  * Handles clock_nanosleep calls against _ALARM clockids
  */
 static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
-                              struct timespec64 *tsreq,
-                              struct timespec __user *rmtp)
+                              const struct timespec64 *tsreq)
 {
         enum  alarmtimer_type type = clock2alarm(which_clock);
-        struct restart_block *restart;
+        struct restart_block *restart = &current->restart_block;
         struct alarm alarm;
         ktime_t exp;
         int ret = 0;
@@ -825,35 +779,36 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
                 exp = ktime_add(now, exp);
         }
 
-        if (alarmtimer_do_nsleep(&alarm, exp))
-                goto out;
-
-        if (freezing(current))
-                alarmtimer_freezerset(exp, type);
+        ret = alarmtimer_do_nsleep(&alarm, exp, type);
+        if (ret != -ERESTART_RESTARTBLOCK)
+                return ret;
 
         /* abs timers don't set remaining time or restart */
-        if (flags == TIMER_ABSTIME) {
-                ret = -ERESTARTNOHAND;
-                goto out;
-        }
+        if (flags == TIMER_ABSTIME)
+                return -ERESTARTNOHAND;
 
-        if (rmtp) {
-                ret = update_rmtp(exp, type, rmtp);
-                if (ret <= 0)
-                        goto out;
-        }
-
-        restart = &current->restart_block;
         restart->fn = alarm_timer_nsleep_restart;
         restart->nanosleep.clockid = type;
         restart->nanosleep.expires = exp;
-        restart->nanosleep.rmtp = rmtp;
-        ret = -ERESTART_RESTARTBLOCK;
-
-out:
         return ret;
 }
 
+const struct k_clock alarm_clock = {
+        .clock_getres           = alarm_clock_getres,
+        .clock_get              = alarm_clock_get,
+        .timer_create           = alarm_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_del              = common_timer_del,
+        .timer_get              = common_timer_get,
+        .timer_arm              = alarm_timer_arm,
+        .timer_rearm            = alarm_timer_rearm,
+        .timer_forward          = alarm_timer_forward,
+        .timer_remaining        = alarm_timer_remaining,
+        .timer_try_to_cancel    = alarm_timer_try_to_cancel,
+        .nsleep                 = alarm_timer_nsleep,
+};
+#endif /* CONFIG_POSIX_TIMERS */
+
 
 /* Suspend hook structures */
 static const struct dev_pm_ops alarmtimer_pm_ops = {
@@ -879,23 +834,9 @@ static int __init alarmtimer_init(void)
         struct platform_device *pdev;
         int error = 0;
         int i;
-        struct k_clock alarm_clock = {
-                .clock_getres   = alarm_clock_getres,
-                .clock_get      = alarm_clock_get,
-                .timer_create   = alarm_timer_create,
-                .timer_set      = alarm_timer_set,
-                .timer_del      = alarm_timer_del,
-                .timer_get      = alarm_timer_get,
-                .nsleep         = alarm_timer_nsleep,
-        };
 
         alarmtimer_rtc_timer_init();
 
-        if (IS_ENABLED(CONFIG_POSIX_TIMERS)) {
-                posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);
-                posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);
-        }
-
         /* Initialize alarm bases */
         alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
         alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index ac053bb5296e..81da124f1115 100644
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -51,6 +51,7 @@
 #include <linux/sched/debug.h>
 #include <linux/timer.h>
 #include <linux/freezer.h>
+#include <linux/compat.h>
 
 #include <linux/uaccess.h>
 
@@ -1439,8 +1440,29 @@ void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task)
 }
 EXPORT_SYMBOL_GPL(hrtimer_init_sleeper);
 
+int nanosleep_copyout(struct restart_block *restart, struct timespec *ts)
+{
+        switch(restart->nanosleep.type) {
+#ifdef CONFIG_COMPAT
+        case TT_COMPAT:
+                if (compat_put_timespec(ts, restart->nanosleep.compat_rmtp))
+                        return -EFAULT;
+                break;
+#endif
+        case TT_NATIVE:
+                if (copy_to_user(restart->nanosleep.rmtp, ts, sizeof(struct timespec)))
+                        return -EFAULT;
+                break;
+        default:
+                BUG();
+        }
+        return -ERESTART_RESTARTBLOCK;
+}
+
 static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)
 {
+        struct restart_block *restart;
+
         hrtimer_init_sleeper(t, current);
 
         do {
@@ -1457,53 +1479,38 @@ static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mod
 
         __set_current_state(TASK_RUNNING);
 
-        return t->task == NULL;
-}
-
-static int update_rmtp(struct hrtimer *timer, struct timespec __user *rmtp)
-{
-        struct timespec rmt;
-        ktime_t rem;
-
-        rem = hrtimer_expires_remaining(timer);
-        if (rem <= 0)
+        if (!t->task)
                 return 0;
-        rmt = ktime_to_timespec(rem);
 
-        if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
-                return -EFAULT;
+        restart = &current->restart_block;
+        if (restart->nanosleep.type != TT_NONE) {
+                ktime_t rem = hrtimer_expires_remaining(&t->timer);
+                struct timespec rmt;
 
-        return 1;
+                if (rem <= 0)
+                        return 0;
+                rmt = ktime_to_timespec(rem);
+
+                return nanosleep_copyout(restart, &rmt);
+        }
+        return -ERESTART_RESTARTBLOCK;
 }
 
-long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
+static long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
 {
         struct hrtimer_sleeper t;
-        struct timespec __user  *rmtp;
-        int ret = 0;
+        int ret;
 
         hrtimer_init_on_stack(&t.timer, restart->nanosleep.clockid,
                                 HRTIMER_MODE_ABS);
         hrtimer_set_expires_tv64(&t.timer, restart->nanosleep.expires);
 
-        if (do_nanosleep(&t, HRTIMER_MODE_ABS))
-                goto out;
-
-        rmtp = restart->nanosleep.rmtp;
-        if (rmtp) {
-                ret = update_rmtp(&t.timer, rmtp);
-                if (ret <= 0)
-                        goto out;
-        }
-
-        /* The other values in restart are already filled in */
-        ret = -ERESTART_RESTARTBLOCK;
-out:
+        ret = do_nanosleep(&t, HRTIMER_MODE_ABS);
         destroy_hrtimer_on_stack(&t.timer);
         return ret;
 }
 
-long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
+long hrtimer_nanosleep(const struct timespec64 *rqtp,
                        const enum hrtimer_mode mode, const clockid_t clockid)
 {
         struct restart_block *restart;
@@ -1517,7 +1524,8 @@ long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
 
         hrtimer_init_on_stack(&t.timer, clockid, mode);
         hrtimer_set_expires_range_ns(&t.timer, timespec64_to_ktime(*rqtp), slack);
-        if (do_nanosleep(&t, mode))
+        ret = do_nanosleep(&t, mode);
+        if (ret != -ERESTART_RESTARTBLOCK)
                 goto out;
 
         /* Absolute timers do not update the rmtp value and restart: */
@@ -1526,19 +1534,10 @@ long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
                 goto out;
         }
 
-        if (rmtp) {
-                ret = update_rmtp(&t.timer, rmtp);
-                if (ret <= 0)
-                        goto out;
-        }
-
         restart = &current->restart_block;
         restart->fn = hrtimer_nanosleep_restart;
         restart->nanosleep.clockid = t.timer.base->clockid;
-        restart->nanosleep.rmtp = rmtp;
         restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
-
-        ret = -ERESTART_RESTARTBLOCK;
 out:
         destroy_hrtimer_on_stack(&t.timer);
         return ret;
@@ -1557,8 +1556,31 @@ SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
         if (!timespec64_valid(&tu64))
                 return -EINVAL;
 
-        return hrtimer_nanosleep(&tu64, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
+        current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
+        current->restart_block.nanosleep.rmtp = rmtp;
+        return hrtimer_nanosleep(&tu64, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
+}
+
+#ifdef CONFIG_COMPAT
+
+COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
+{
+        struct timespec64 tu64;
+        struct timespec tu;
+
+        if (compat_get_timespec(&tu, rqtp))
+                return -EFAULT;
+
+        tu64 = timespec_to_timespec64(tu);
+        if (!timespec64_valid(&tu64))
+                return -EINVAL;
+
+        current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
+        current->restart_block.nanosleep.compat_rmtp = rmtp;
+        return hrtimer_nanosleep(&tu64, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
 }
+#endif
 
 /*
  * Functions related to boot-time initialization:
diff --git a/kernel/time/itimer.c b/kernel/time/itimer.c
index 087d6a1279b8..2ef98a02376a 100644
--- a/kernel/time/itimer.c
+++ b/kernel/time/itimer.c
@@ -15,6 +15,7 @@
 #include <linux/posix-timers.h>
 #include <linux/hrtimer.h>
 #include <trace/events/timer.h>
+#include <linux/compat.h>
 
 #include <linux/uaccess.h>
 
@@ -116,6 +117,19 @@ SYSCALL_DEFINE2(getitimer, int, which, struct itimerval __user *, value)
         return error;
 }
 
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
+                       struct compat_itimerval __user *, it)
+{
+        struct itimerval kit;
+        int error = do_getitimer(which, &kit);
+
+        if (!error && put_compat_itimerval(it, &kit))
+                error = -EFAULT;
+        return error;
+}
+#endif
+
 
 /*
  * The timer is automagically restarted, when interval != 0
@@ -138,8 +152,12 @@ static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
         u64 oval, nval, ointerval, ninterval;
         struct cpu_itimer *it = &tsk->signal->it[clock_id];
 
-        nval = timeval_to_ns(&value->it_value);
-        ninterval = timeval_to_ns(&value->it_interval);
+        /*
+         * Use the to_ktime conversion because that clamps the maximum
+         * value to KTIME_MAX and avoid multiplication overflows.
+         */
+        nval = ktime_to_ns(timeval_to_ktime(value->it_value));
+        ninterval = ktime_to_ns(timeval_to_ktime(value->it_interval));
 
         spin_lock_irq(&tsk->sighand->siglock);
 
@@ -294,3 +312,27 @@ SYSCALL_DEFINE3(setitimer, int, which, struct itimerval __user *, value,
                 return -EFAULT;
         return 0;
 }
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE3(setitimer, int, which,
+                       struct compat_itimerval __user *, in,
+                       struct compat_itimerval __user *, out)
+{
+        struct itimerval kin, kout;
+        int error;
+
+        if (in) {
+                if (get_compat_itimerval(&kin, in))
+                        return -EFAULT;
+        } else {
+                memset(&kin, 0, sizeof(kin));
+        }
+
+        error = do_setitimer(which, &kin, out ? &kout : NULL);
+        if (error || !out)
+                return error;
+        if (put_compat_itimerval(out, &kout))
+                return -EFAULT;
+        return 0;
+}
+#endif
diff --git a/kernel/time/posix-clock.c b/kernel/time/posix-clock.c
index 31d588d37a17..17cdc554c9fe 100644
--- a/kernel/time/posix-clock.c
+++ b/kernel/time/posix-clock.c
@@ -25,6 +25,8 @@
 #include <linux/syscalls.h>
 #include <linux/uaccess.h>
 
+#include "posix-timers.h"
+
 static void delete_clock(struct kref *kref);
 
 /*
@@ -82,38 +84,6 @@ static unsigned int posix_clock_poll(struct file *fp, poll_table *wait)
         return result;
 }
 
-static int posix_clock_fasync(int fd, struct file *fp, int on)
-{
-        struct posix_clock *clk = get_posix_clock(fp);
-        int err = 0;
-
-        if (!clk)
-                return -ENODEV;
-
-        if (clk->ops.fasync)
-                err = clk->ops.fasync(clk, fd, fp, on);
-
-        put_posix_clock(clk);
-
-        return err;
-}
-
-static int posix_clock_mmap(struct file *fp, struct vm_area_struct *vma)
-{
-        struct posix_clock *clk = get_posix_clock(fp);
-        int err = -ENODEV;
-
-        if (!clk)
-                return -ENODEV;
-
-        if (clk->ops.mmap)
-                err = clk->ops.mmap(clk, vma);
-
-        put_posix_clock(clk);
-
-        return err;
-}
-
 static long posix_clock_ioctl(struct file *fp,
                               unsigned int cmd, unsigned long arg)
 {
@@ -199,8 +169,6 @@ static const struct file_operations posix_clock_file_operations = {
         .unlocked_ioctl = posix_clock_ioctl,
         .open           = posix_clock_open,
         .release        = posix_clock_release,
-        .fasync         = posix_clock_fasync,
-        .mmap           = posix_clock_mmap,
 #ifdef CONFIG_COMPAT
         .compat_ioctl   = posix_clock_compat_ioctl,
 #endif
@@ -359,88 +327,9 @@ out:
         return err;
 }
 
-static int pc_timer_create(struct k_itimer *kit)
-{
-        clockid_t id = kit->it_clock;
-        struct posix_clock_desc cd;
-        int err;
-
-        err = get_clock_desc(id, &cd);
-        if (err)
-                return err;
-
-        if (cd.clk->ops.timer_create)
-                err = cd.clk->ops.timer_create(cd.clk, kit);
-        else
-                err = -EOPNOTSUPP;
-
-        put_clock_desc(&cd);
-
-        return err;
-}
-
-static int pc_timer_delete(struct k_itimer *kit)
-{
-        clockid_t id = kit->it_clock;
-        struct posix_clock_desc cd;
-        int err;
-
-        err = get_clock_desc(id, &cd);
-        if (err)
-                return err;
-
-        if (cd.clk->ops.timer_delete)
-                err = cd.clk->ops.timer_delete(cd.clk, kit);
-        else
-                err = -EOPNOTSUPP;
-
-        put_clock_desc(&cd);
-
-        return err;
-}
-
-static void pc_timer_gettime(struct k_itimer *kit, struct itimerspec64 *ts)
-{
-        clockid_t id = kit->it_clock;
-        struct posix_clock_desc cd;
-
-        if (get_clock_desc(id, &cd))
-                return;
-
-        if (cd.clk->ops.timer_gettime)
-                cd.clk->ops.timer_gettime(cd.clk, kit, ts);
-
-        put_clock_desc(&cd);
-}
-
-static int pc_timer_settime(struct k_itimer *kit, int flags,
-                            struct itimerspec64 *ts, struct itimerspec64 *old)
-{
-        clockid_t id = kit->it_clock;
-        struct posix_clock_desc cd;
-        int err;
-
-        err = get_clock_desc(id, &cd);
-        if (err)
-                return err;
-
-        if (cd.clk->ops.timer_settime)
-                err = cd.clk->ops.timer_settime(cd.clk, kit, flags, ts, old);
-        else
-                err = -EOPNOTSUPP;
-
-        put_clock_desc(&cd);
-
-        return err;
-}
-
-struct k_clock clock_posix_dynamic = {
+const struct k_clock clock_posix_dynamic = {
         .clock_getres   = pc_clock_getres,
         .clock_set      = pc_clock_settime,
         .clock_get      = pc_clock_gettime,
         .clock_adj      = pc_clock_adjtime,
-        .timer_create   = pc_timer_create,
-        .timer_set      = pc_timer_settime,
-        .timer_del      = pc_timer_delete,
-        .timer_get      = pc_timer_gettime,
 };
diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index d2a1e6dd0291..60cb24ac9ebc 100644
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -12,6 +12,11 @@
 #include <trace/events/timer.h>
 #include <linux/tick.h>
 #include <linux/workqueue.h>
+#include <linux/compat.h>
+
+#include "posix-timers.h"
+
+static void posix_cpu_timer_rearm(struct k_itimer *timer);
 
 /*
  * Called after updating RLIMIT_CPU to run cpu timer and update
@@ -322,6 +327,8 @@ static int posix_cpu_timer_create(struct k_itimer *new_timer)
         if (CPUCLOCK_WHICH(new_timer->it_clock) >= CPUCLOCK_MAX)
                 return -EINVAL;
 
+        new_timer->kclock = &clock_posix_cpu;
+
         INIT_LIST_HEAD(&new_timer->it.cpu.entry);
 
         rcu_read_lock();
@@ -524,7 +531,8 @@ static void cpu_timer_fire(struct k_itimer *timer)
                  * reload the timer.  But we need to keep it
                  * ticking in case the signal is deliverable next time.
                  */
-                posix_cpu_timer_schedule(timer);
+                posix_cpu_timer_rearm(timer);
+                ++timer->it_requeue_pending;
         }
 }
 
@@ -572,7 +580,11 @@ static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags,
 
         WARN_ON_ONCE(p == NULL);
 
-        new_expires = timespec64_to_ns(&new->it_value);
+        /*
+         * Use the to_ktime conversion because that clamps the maximum
+         * value to KTIME_MAX and avoid multiplication overflows.
+         */
+        new_expires = ktime_to_ns(timespec64_to_ktime(new->it_value));
 
         /*
          * Protect against sighand release/switch in exit/exec and p->cpu_timers
@@ -712,10 +724,8 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *itp
          */
         itp->it_interval = ns_to_timespec64(timer->it.cpu.incr);
 
-        if (timer->it.cpu.expires == 0) {       /* Timer not armed at all.  */
-                itp->it_value.tv_sec = itp->it_value.tv_nsec = 0;
+        if (!timer->it.cpu.expires)
                 return;
-        }
 
         /*
          * Sample the clock to take the difference with the expiry time.
@@ -739,7 +749,6 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *itp
                          * Call the timer disarmed, nothing else to do.
                          */
                         timer->it.cpu.expires = 0;
-                        itp->it_value = ns_to_timespec64(timer->it.cpu.expires);
                         return;
                 } else {
                         cpu_timer_sample_group(timer->it_clock, p, &now);
@@ -976,10 +985,10 @@ static void check_process_timers(struct task_struct *tsk,
 }
 
 /*
- * This is called from the signal code (via do_schedule_next_timer)
+ * This is called from the signal code (via posixtimer_rearm)
  * when the last timer signal was delivered and we have to reload the timer.
  */
-void posix_cpu_timer_schedule(struct k_itimer *timer)
+static void posix_cpu_timer_rearm(struct k_itimer *timer)
 {
         struct sighand_struct *sighand;
         unsigned long flags;
@@ -995,12 +1004,12 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
                 cpu_clock_sample(timer->it_clock, p, &now);
                 bump_cpu_timer(timer, now);
                 if (unlikely(p->exit_state))
-                        goto out;
+                        return;
 
                 /* Protect timer list r/w in arm_timer() */
                 sighand = lock_task_sighand(p, &flags);
                 if (!sighand)
-                        goto out;
+                        return;
         } else {
                 /*
                  * Protect arm_timer() and timer sampling in case of call to
@@ -1013,11 +1022,10 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
                          * We can't even collect a sample any more.
                          */
                         timer->it.cpu.expires = 0;
-                        goto out;
+                        return;
                 } else if (unlikely(p->exit_state) && thread_group_empty(p)) {
-                        unlock_task_sighand(p, &flags);
-                        /* Optimizations: if the process is dying, no need to rearm */
-                        goto out;
+                        /* If the process is dying, no need to rearm */
+                        goto unlock;
                 }
                 cpu_timer_sample_group(timer->it_clock, p, &now);
                 bump_cpu_timer(timer, now);
@@ -1029,12 +1037,8 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
          */
         WARN_ON_ONCE(!irqs_disabled());
         arm_timer(timer);
+unlock:
         unlock_task_sighand(p, &flags);
-
-out:
-        timer->it_overrun_last = timer->it_overrun;
-        timer->it_overrun = -1;
-        ++timer->it_requeue_pending;
 }
 
 /**
@@ -1227,9 +1231,11 @@ 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 timespec64 *rqtp, struct itimerspec64 *it)
+                            const struct timespec64 *rqtp)
 {
+        struct itimerspec64 it;
         struct k_itimer timer;
+        u64 expires;
         int error;
 
         /*
@@ -1243,12 +1249,13 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
         timer.it_process = current;
         if (!error) {
                 static struct itimerspec64 zero_it;
+                struct restart_block *restart;
 
-                memset(it, 0, sizeof *it);
-                it->it_value = *rqtp;
+                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;
@@ -1277,8 +1284,8 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                 /*
                  * We were interrupted by a signal.
                  */
-                *rqtp = ns_to_timespec64(timer.it.cpu.expires);
-                error = posix_cpu_timer_set(&timer, 0, &zero_it, it);
+                expires = timer.it.cpu.expires;
+                error = posix_cpu_timer_set(&timer, 0, &zero_it, &it);
                 if (!error) {
                         /*
                          * Timer is now unarmed, deletion can not fail.
@@ -1298,7 +1305,7 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                         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.
                          */
@@ -1306,6 +1313,17 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                 }
 
                 error = -ERESTART_RESTARTBLOCK;
+                /*
+                 * Report back to the user the time still remaining.
+                 */
+                restart = &current->restart_block;
+                restart->nanosleep.expires = expires;
+                if (restart->nanosleep.type != TT_NONE) {
+                        struct timespec ts;
+
+                        ts = timespec64_to_timespec(it.it_value);
+                        error = nanosleep_copyout(restart, &ts);
+                }
         }
 
         return error;
@@ -1314,11 +1332,9 @@ 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 timespec64 *rqtp, struct timespec __user *rmtp)
+                            const struct timespec64 *rqtp)
 {
         struct restart_block *restart_block = &current->restart_block;
-        struct itimerspec64 it;
-        struct timespec ts;
         int error;
 
         /*
@@ -1329,23 +1345,15 @@ static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
              CPUCLOCK_PID(which_clock) == task_pid_vnr(current)))
                 return -EINVAL;
 
-        error = do_cpu_nanosleep(which_clock, flags, rqtp, &it);
+        error = do_cpu_nanosleep(which_clock, flags, rqtp);
 
         if (error == -ERESTART_RESTARTBLOCK) {
 
                 if (flags & TIMER_ABSTIME)
                         return -ERESTARTNOHAND;
-                /*
-                 * Report back to the user the time still remaining.
-                 */
-                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 = timespec64_to_ns(rqtp);
         }
         return error;
 }
@@ -1353,28 +1361,11 @@ 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 itimerspec64 it;
         struct timespec64 t;
-        struct timespec tmp;
-        int error;
 
         t = ns_to_timespec64(restart_block->nanosleep.expires);
 
-        error = do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t, &it);
-
-        if (error == -ERESTART_RESTARTBLOCK) {
-                struct timespec __user *rmtp = restart_block->nanosleep.rmtp;
-                /*
-                 * Report back to the user the time still remaining.
-                 */
-                 tmp = timespec64_to_timespec(it.it_value);
-                if (rmtp && copy_to_user(rmtp, &tmp, sizeof(*rmtp)))
-                        return -EFAULT;
-
-                restart_block->nanosleep.expires = timespec64_to_ns(&t);
-        }
-        return error;
-
+        return do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t);
 }
 
 #define PROCESS_CLOCK   MAKE_PROCESS_CPUCLOCK(0, CPUCLOCK_SCHED)
@@ -1396,14 +1387,9 @@ 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 timespec64 *rqtp,
-                              struct timespec __user *rmtp)
-{
-        return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp, rmtp);
-}
-static long process_cpu_nsleep_restart(struct restart_block *restart_block)
+                              const struct timespec64 *rqtp)
 {
-        return -EINVAL;
+        return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp);
 }
 static int thread_cpu_clock_getres(const clockid_t which_clock,
                                    struct timespec64 *tp)
@@ -1421,36 +1407,27 @@ static int thread_cpu_timer_create(struct k_itimer *timer)
         return posix_cpu_timer_create(timer);
 }
 
-struct k_clock clock_posix_cpu = {
+const struct k_clock clock_posix_cpu = {
         .clock_getres   = posix_cpu_clock_getres,
         .clock_set      = posix_cpu_clock_set,
         .clock_get      = posix_cpu_clock_get,
         .timer_create   = posix_cpu_timer_create,
         .nsleep         = posix_cpu_nsleep,
-        .nsleep_restart = posix_cpu_nsleep_restart,
         .timer_set      = posix_cpu_timer_set,
         .timer_del      = posix_cpu_timer_del,
         .timer_get      = posix_cpu_timer_get,
+        .timer_rearm    = posix_cpu_timer_rearm,
 };
 
-static __init int init_posix_cpu_timers(void)
-{
-        struct k_clock process = {
-                .clock_getres   = process_cpu_clock_getres,
-                .clock_get      = process_cpu_clock_get,
-                .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,
-                .clock_get      = thread_cpu_clock_get,
-                .timer_create   = thread_cpu_timer_create,
-        };
-
-        posix_timers_register_clock(CLOCK_PROCESS_CPUTIME_ID, &process);
-        posix_timers_register_clock(CLOCK_THREAD_CPUTIME_ID, &thread);
+const struct k_clock clock_process = {
+        .clock_getres   = process_cpu_clock_getres,
+        .clock_get      = process_cpu_clock_get,
+        .timer_create   = process_cpu_timer_create,
+        .nsleep         = process_cpu_nsleep,
+};
 
-        return 0;
-}
-__initcall(init_posix_cpu_timers);
+const struct k_clock clock_thread = {
+        .clock_getres   = thread_cpu_clock_getres,
+        .clock_get      = thread_cpu_clock_get,
+        .timer_create   = thread_cpu_timer_create,
+};
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
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];
 }
diff --git a/kernel/time/posix-timers.h b/kernel/time/posix-timers.h
new file mode 100644
index 000000000000..fb303c3be4d3
--- /dev/null
+++ b/kernel/time/posix-timers.h
@@ -0,0 +1,40 @@
+#define TIMER_RETRY 1
+
+struct k_clock {
+        int     (*clock_getres)(const clockid_t which_clock,
+                                struct timespec64 *tp);
+        int     (*clock_set)(const clockid_t which_clock,
+                             const struct timespec64 *tp);
+        int     (*clock_get)(const clockid_t which_clock,
+                             struct timespec64 *tp);
+        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,
+                          const struct timespec64 *);
+        int     (*timer_set)(struct k_itimer *timr, int flags,
+                             struct itimerspec64 *new_setting,
+                             struct itimerspec64 *old_setting);
+        int     (*timer_del)(struct k_itimer *timr);
+        void    (*timer_get)(struct k_itimer *timr,
+                             struct itimerspec64 *cur_setting);
+        void    (*timer_rearm)(struct k_itimer *timr);
+        int     (*timer_forward)(struct k_itimer *timr, ktime_t now);
+        ktime_t (*timer_remaining)(struct k_itimer *timr, ktime_t now);
+        int     (*timer_try_to_cancel)(struct k_itimer *timr);
+        void    (*timer_arm)(struct k_itimer *timr, ktime_t expires,
+                             bool absolute, bool sigev_none);
+};
+
+extern const struct k_clock clock_posix_cpu;
+extern const struct k_clock clock_posix_dynamic;
+extern const struct k_clock clock_process;
+extern const struct k_clock clock_thread;
+extern const struct k_clock alarm_clock;
+
+int posix_timer_event(struct k_itimer *timr, int si_private);
+
+void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting);
+int common_timer_set(struct k_itimer *timr, int flags,
+                     struct itimerspec64 *new_setting,
+                     struct itimerspec64 *old_setting);
+int common_timer_del(struct k_itimer *timer);
diff --git a/kernel/time/time.c b/kernel/time/time.c
index 49c73c6ed648..7c89e437c4d7 100644
--- a/kernel/time/time.c
+++ b/kernel/time/time.c
@@ -39,6 +39,7 @@
 #include <linux/ptrace.h>
 
 #include <linux/uaccess.h>
+#include <linux/compat.h>
 #include <asm/unistd.h>
 
 #include <generated/timeconst.h>
@@ -99,6 +100,47 @@ SYSCALL_DEFINE1(stime, time_t __user *, tptr)
 
 #endif /* __ARCH_WANT_SYS_TIME */
 
+#ifdef CONFIG_COMPAT
+#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)
+{
+        struct timeval tv;
+        compat_time_t i;
+
+        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 */
+#endif
+
 SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
                 struct timezone __user *, tz)
 {
@@ -215,6 +257,47 @@ SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
         return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 }
 
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(gettimeofday, struct compat_timeval __user *, tv,
+                       struct timezone __user *, tz)
+{
+        if (tv) {
+                struct timeval ktv;
+
+                do_gettimeofday(&ktv);
+                if (compat_put_timeval(&ktv, tv))
+                        return -EFAULT;
+        }
+        if (tz) {
+                if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
+                        return -EFAULT;
+        }
+
+        return 0;
+}
+
+COMPAT_SYSCALL_DEFINE2(settimeofday, struct compat_timeval __user *, tv,
+                       struct timezone __user *, tz)
+{
+        struct timespec64 new_ts;
+        struct timeval user_tv;
+        struct timezone new_tz;
+
+        if (tv) {
+                if (compat_get_timeval(&user_tv, tv))
+                        return -EFAULT;
+                new_ts.tv_sec = user_tv.tv_sec;
+                new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
+        }
+        if (tz) {
+                if (copy_from_user(&new_tz, tz, sizeof(*tz)))
+                        return -EFAULT;
+        }
+
+        return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
+}
+#endif
+
 SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
 {
         struct timex txc;               /* Local copy of parameter */
@@ -224,12 +307,33 @@ SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
          * structure. But bear in mind that the structures
          * may change
          */
-        if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
+        if (copy_from_user(&txc, txc_p, sizeof(struct timex)))
                 return -EFAULT;
         ret = do_adjtimex(&txc);
         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
 }
 
+#ifdef CONFIG_COMPAT
+
+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;
+}
+#endif
+
 /*
  * Convert jiffies to milliseconds and back.
  *
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index b602c48cb841..cedafa008de5 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -72,6 +72,10 @@ static inline void tk_normalize_xtime(struct timekeeper *tk)
                 tk->tkr_mono.xtime_nsec -= (u64)NSEC_PER_SEC << tk->tkr_mono.shift;
                 tk->xtime_sec++;
         }
+        while (tk->tkr_raw.xtime_nsec >= ((u64)NSEC_PER_SEC << tk->tkr_raw.shift)) {
+                tk->tkr_raw.xtime_nsec -= (u64)NSEC_PER_SEC << tk->tkr_raw.shift;
+                tk->raw_sec++;
+        }
 }
 
 static inline struct timespec64 tk_xtime(struct timekeeper *tk)
@@ -285,12 +289,14 @@ static void tk_setup_internals(struct timekeeper *tk, struct clocksource *clock)
          /* if changing clocks, convert xtime_nsec shift units */
         if (old_clock) {
                 int shift_change = clock->shift - old_clock->shift;
-                if (shift_change < 0)
+                if (shift_change < 0) {
                         tk->tkr_mono.xtime_nsec >>= -shift_change;
-                else
+                        tk->tkr_raw.xtime_nsec >>= -shift_change;
+                } else {
                         tk->tkr_mono.xtime_nsec <<= shift_change;
+                        tk->tkr_raw.xtime_nsec <<= shift_change;
+                }
         }
-        tk->tkr_raw.xtime_nsec = 0;
 
         tk->tkr_mono.shift = clock->shift;
         tk->tkr_raw.shift = clock->shift;
@@ -510,6 +516,7 @@ static void halt_fast_timekeeper(struct timekeeper *tk)
 }
 
 #ifdef CONFIG_GENERIC_TIME_VSYSCALL_OLD
+#warning Please contact your maintainers, as GENERIC_TIME_VSYSCALL_OLD compatibity will disappear soon.
 
 static inline void update_vsyscall(struct timekeeper *tk)
 {
@@ -619,9 +626,6 @@ static inline void tk_update_ktime_data(struct timekeeper *tk)
         nsec = (u32) tk->wall_to_monotonic.tv_nsec;
         tk->tkr_mono.base = ns_to_ktime(seconds * NSEC_PER_SEC + nsec);
 
-        /* Update the monotonic raw base */
-        tk->tkr_raw.base = timespec64_to_ktime(tk->raw_time);
-
         /*
          * The sum of the nanoseconds portions of xtime and
          * wall_to_monotonic can be greater/equal one second. Take
@@ -631,6 +635,11 @@ static inline void tk_update_ktime_data(struct timekeeper *tk)
         if (nsec >= NSEC_PER_SEC)
                 seconds++;
         tk->ktime_sec = seconds;
+
+        /* Update the monotonic raw base */
+        seconds = tk->raw_sec;
+        nsec = (u32)(tk->tkr_raw.xtime_nsec >> tk->tkr_raw.shift);
+        tk->tkr_raw.base = ns_to_ktime(seconds * NSEC_PER_SEC + nsec);
 }
 
 /* must hold timekeeper_lock */
@@ -672,7 +681,6 @@ static void timekeeping_update(struct timekeeper *tk, unsigned int action)
 static void timekeeping_forward_now(struct timekeeper *tk)
 {
         u64 cycle_now, delta;
-        u64 nsec;
 
         cycle_now = tk_clock_read(&tk->tkr_mono);
         delta = clocksource_delta(cycle_now, tk->tkr_mono.cycle_last, tk->tkr_mono.mask);
@@ -684,10 +692,13 @@ static void timekeeping_forward_now(struct timekeeper *tk)
         /* If arch requires, add in get_arch_timeoffset() */
         tk->tkr_mono.xtime_nsec += (u64)arch_gettimeoffset() << tk->tkr_mono.shift;
 
-        tk_normalize_xtime(tk);
 
-        nsec = clocksource_cyc2ns(delta, tk->tkr_raw.mult, tk->tkr_raw.shift);
-        timespec64_add_ns(&tk->raw_time, nsec);
+        tk->tkr_raw.xtime_nsec += delta * tk->tkr_raw.mult;
+
+        /* If arch requires, add in get_arch_timeoffset() */
+        tk->tkr_raw.xtime_nsec += (u64)arch_gettimeoffset() << tk->tkr_raw.shift;
+
+        tk_normalize_xtime(tk);
 }
 
 /**
@@ -1373,19 +1384,18 @@ int timekeeping_notify(struct clocksource *clock)
 void getrawmonotonic64(struct timespec64 *ts)
 {
         struct timekeeper *tk = &tk_core.timekeeper;
-        struct timespec64 ts64;
         unsigned long seq;
         u64 nsecs;
 
         do {
                 seq = read_seqcount_begin(&tk_core.seq);
+                ts->tv_sec = tk->raw_sec;
                 nsecs = timekeeping_get_ns(&tk->tkr_raw);
-                ts64 = tk->raw_time;
 
         } while (read_seqcount_retry(&tk_core.seq, seq));
 
-        timespec64_add_ns(&ts64, nsecs);
-        *ts = ts64;
+        ts->tv_nsec = 0;
+        timespec64_add_ns(ts, nsecs);
 }
 EXPORT_SYMBOL(getrawmonotonic64);
 
@@ -1509,8 +1519,7 @@ void __init timekeeping_init(void)
         tk_setup_internals(tk, clock);
 
         tk_set_xtime(tk, &now);
-        tk->raw_time.tv_sec = 0;
-        tk->raw_time.tv_nsec = 0;
+        tk->raw_sec = 0;
         if (boot.tv_sec == 0 && boot.tv_nsec == 0)
                 boot = tk_xtime(tk);
 
@@ -2011,15 +2020,12 @@ static u64 logarithmic_accumulation(struct timekeeper *tk, u64 offset,
         *clock_set |= accumulate_nsecs_to_secs(tk);
 
         /* Accumulate raw time */
-        tk->tkr_raw.xtime_nsec += (u64)tk->raw_time.tv_nsec << tk->tkr_raw.shift;
         tk->tkr_raw.xtime_nsec += tk->raw_interval << shift;
         snsec_per_sec = (u64)NSEC_PER_SEC << tk->tkr_raw.shift;
         while (tk->tkr_raw.xtime_nsec >= snsec_per_sec) {
                 tk->tkr_raw.xtime_nsec -= snsec_per_sec;
-                tk->raw_time.tv_sec++;
+                tk->raw_sec++;
         }
-        tk->raw_time.tv_nsec = tk->tkr_raw.xtime_nsec >> tk->tkr_raw.shift;
-        tk->tkr_raw.xtime_nsec -= (u64)tk->raw_time.tv_nsec << tk->tkr_raw.shift;
 
         /* Accumulate error between NTP and clock interval */
         tk->ntp_error += tk->ntp_tick << shift;
diff --git a/kernel/time/timer.c b/kernel/time/timer.c
index 152a706ef8b8..71ce3f4eead3 100644
--- a/kernel/time/timer.c
+++ b/kernel/time/timer.c
@@ -195,7 +195,7 @@ EXPORT_SYMBOL(jiffies_64);
 #endif
 
 struct timer_base {
-        spinlock_t              lock;
+        raw_spinlock_t          lock;
         struct timer_list       *running_timer;
         unsigned long           clk;
         unsigned long           next_expiry;
@@ -913,10 +913,10 @@ static struct timer_base *lock_timer_base(struct timer_list *timer,
 
                 if (!(tf & TIMER_MIGRATING)) {
                         base = get_timer_base(tf);
-                        spin_lock_irqsave(&base->lock, *flags);
+                        raw_spin_lock_irqsave(&base->lock, *flags);
                         if (timer->flags == tf)
                                 return base;
-                        spin_unlock_irqrestore(&base->lock, *flags);
+                        raw_spin_unlock_irqrestore(&base->lock, *flags);
                 }
                 cpu_relax();
         }
@@ -986,9 +986,9 @@ __mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only)
                         /* See the comment in lock_timer_base() */
                         timer->flags |= TIMER_MIGRATING;
 
-                        spin_unlock(&base->lock);
+                        raw_spin_unlock(&base->lock);
                         base = new_base;
-                        spin_lock(&base->lock);
+                        raw_spin_lock(&base->lock);
                         WRITE_ONCE(timer->flags,
                                    (timer->flags & ~TIMER_BASEMASK) | base->cpu);
                 }
@@ -1013,7 +1013,7 @@ __mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only)
         }
 
 out_unlock:
-        spin_unlock_irqrestore(&base->lock, flags);
+        raw_spin_unlock_irqrestore(&base->lock, flags);
 
         return ret;
 }
@@ -1106,16 +1106,16 @@ void add_timer_on(struct timer_list *timer, int cpu)
         if (base != new_base) {
                 timer->flags |= TIMER_MIGRATING;
 
-                spin_unlock(&base->lock);
+                raw_spin_unlock(&base->lock);
                 base = new_base;
-                spin_lock(&base->lock);
+                raw_spin_lock(&base->lock);
                 WRITE_ONCE(timer->flags,
                            (timer->flags & ~TIMER_BASEMASK) | cpu);
         }
 
         debug_activate(timer, timer->expires);
         internal_add_timer(base, timer);
-        spin_unlock_irqrestore(&base->lock, flags);
+        raw_spin_unlock_irqrestore(&base->lock, flags);
 }
 EXPORT_SYMBOL_GPL(add_timer_on);
 
@@ -1141,7 +1141,7 @@ int del_timer(struct timer_list *timer)
         if (timer_pending(timer)) {
                 base = lock_timer_base(timer, &flags);
                 ret = detach_if_pending(timer, base, true);
-                spin_unlock_irqrestore(&base->lock, flags);
+                raw_spin_unlock_irqrestore(&base->lock, flags);
         }
 
         return ret;
@@ -1150,7 +1150,7 @@ EXPORT_SYMBOL(del_timer);
 
 /**
  * try_to_del_timer_sync - Try to deactivate a timer
- * @timer: timer do del
+ * @timer: timer to delete
  *
  * This function tries to deactivate a timer. Upon successful (ret >= 0)
  * exit the timer is not queued and the handler is not running on any CPU.
@@ -1168,7 +1168,7 @@ int try_to_del_timer_sync(struct timer_list *timer)
         if (base->running_timer != timer)
                 ret = detach_if_pending(timer, base, true);
 
-        spin_unlock_irqrestore(&base->lock, flags);
+        raw_spin_unlock_irqrestore(&base->lock, flags);
 
         return ret;
 }
@@ -1299,13 +1299,13 @@ static void expire_timers(struct timer_base *base, struct hlist_head *head)
                 data = timer->data;
 
                 if (timer->flags & TIMER_IRQSAFE) {
-                        spin_unlock(&base->lock);
+                        raw_spin_unlock(&base->lock);
                         call_timer_fn(timer, fn, data);
-                        spin_lock(&base->lock);
+                        raw_spin_lock(&base->lock);
                 } else {
-                        spin_unlock_irq(&base->lock);
+                        raw_spin_unlock_irq(&base->lock);
                         call_timer_fn(timer, fn, data);
-                        spin_lock_irq(&base->lock);
+                        raw_spin_lock_irq(&base->lock);
                 }
         }
 }
@@ -1474,7 +1474,7 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem)
         if (cpu_is_offline(smp_processor_id()))
                 return expires;
 
-        spin_lock(&base->lock);
+        raw_spin_lock(&base->lock);
         nextevt = __next_timer_interrupt(base);
         is_max_delta = (nextevt == base->clk + NEXT_TIMER_MAX_DELTA);
         base->next_expiry = nextevt;
@@ -1502,7 +1502,7 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem)
                 if ((expires - basem) > TICK_NSEC)
                         base->is_idle = true;
         }
-        spin_unlock(&base->lock);
+        raw_spin_unlock(&base->lock);
 
         return cmp_next_hrtimer_event(basem, expires);
 }
@@ -1590,7 +1590,7 @@ static inline void __run_timers(struct timer_base *base)
         if (!time_after_eq(jiffies, base->clk))
                 return;
 
-        spin_lock_irq(&base->lock);
+        raw_spin_lock_irq(&base->lock);
 
         while (time_after_eq(jiffies, base->clk)) {
 
@@ -1601,7 +1601,7 @@ static inline void __run_timers(struct timer_base *base)
                         expire_timers(base, heads + levels);
         }
         base->running_timer = NULL;
-        spin_unlock_irq(&base->lock);
+        raw_spin_unlock_irq(&base->lock);
 }
 
 /*
@@ -1786,16 +1786,16 @@ int timers_dead_cpu(unsigned int cpu)
                  * The caller is globally serialized and nobody else
                  * takes two locks at once, deadlock is not possible.
                  */
-                spin_lock_irq(&new_base->lock);
-                spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
+                raw_spin_lock_irq(&new_base->lock);
+                raw_spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
 
                 BUG_ON(old_base->running_timer);
 
                 for (i = 0; i < WHEEL_SIZE; i++)
                         migrate_timer_list(new_base, old_base->vectors + i);
 
-                spin_unlock(&old_base->lock);
-                spin_unlock_irq(&new_base->lock);
+                raw_spin_unlock(&old_base->lock);
+                raw_spin_unlock_irq(&new_base->lock);
                 put_cpu_ptr(&timer_bases);
         }
         return 0;
@@ -1811,7 +1811,7 @@ static void __init init_timer_cpu(int cpu)
         for (i = 0; i < NR_BASES; i++) {
                 base = per_cpu_ptr(&timer_bases[i], cpu);
                 base->cpu = cpu;
-                spin_lock_init(&base->lock);
+                raw_spin_lock_init(&base->lock);
                 base->clk = jiffies;
         }
 }