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
  ...

1 files changed, 161 insertions, 220 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;