hrtimer: Provide hrtimer_start_range_ns_user()

Calvin reported an odd NMI watchdog lockup which claims that the CPU locked
up in user space. He provided a reproducer, which set's up a timerfd based
timer and then rearms it in a loop with an absolute expiry time of 1ns.

As the expiry time is in the past, the timer ends up as the first expiring
timer in the per CPU hrtimer base and the clockevent device is programmed
with the minimum delta value. If the machine is fast enough, this ends up
in a endless loop of programming the delta value to the minimum value
defined by the clock event device, before the timer interrupt can fire,
which starves the interrupt and consequently triggers the lockup detector
because the hrtimer callback of the lockup mechanism is never invoked.

The clockevents code already has a last resort mechanism to prevent that,
but it's sensible to catch such issues before trying to reprogram the clock
event device.

Provide a variant of hrtimer_start_range_ns(), which sanity checks the
timer after queueing it. It does not so before because the timer might be
armed and therefore needs to be dequeued. also we optimize for the latest
possible point to check, so that the clock event prevention is avoided as
much as possible.

If the timer is already expired _before_ the clock event is reprogrammed,
remove the timer from the queue and signal to the caller that the operation
failed by returning false.

That allows the caller to take immediate action without going through the
loops and hoops of the hrtimer interrupt.

The queueing code can't invoke the timer callback as the caller might hold
a lock which is taken in the callback.

Add a tracepoint which allows to analyze the expired at start situation.

Reported-by: Calvin Owens <calvin@wbinvd.org>
Signed-off-by: Thomas Gleixner <tglx@kernel.org>
Tested-by: Calvin Owens <calvin@wbinvd.org>
Reviewed-by: Frederic Weisbecker <frederic@kernel.org>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: https://patch.msgid.link/20260408114951.995031895@kernel.org

diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 9ced498fefaa2bd797eeabde945af961c07733ec..66cc98c773cf95fad78cc0adc6e1120e982f924d 100644 (file)
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -206,6 +206,9 @@ static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
 extern void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
                                   u64 range_ns, const enum hrtimer_mode mode);
 
+extern bool hrtimer_start_range_ns_user(struct hrtimer *timer, ktime_t tim,
+                                       u64 range_ns, const enum hrtimer_mode mode);
+
 /**
  * hrtimer_start - (re)start an hrtimer
  * @timer:     the timer to be added
@@ -223,17 +226,28 @@ static inline void hrtimer_start(struct hrtimer *timer, ktime_t tim,
 extern int hrtimer_cancel(struct hrtimer *timer);
 extern int hrtimer_try_to_cancel(struct hrtimer *timer);
 
-static inline void hrtimer_start_expires(struct hrtimer *timer,
-                                        enum hrtimer_mode mode)
+static inline void hrtimer_start_expires(struct hrtimer *timer, enum hrtimer_mode mode)
 {
-       u64 delta;
        ktime_t soft, hard;
+       u64 delta;
+
        soft = hrtimer_get_softexpires(timer);
        hard = hrtimer_get_expires(timer);
        delta = ktime_to_ns(ktime_sub(hard, soft));
        hrtimer_start_range_ns(timer, soft, delta, mode);
 }
 
+static inline bool hrtimer_start_expires_user(struct hrtimer *timer, enum hrtimer_mode mode)
+{
+       ktime_t soft, hard;
+       u64 delta;
+
+       soft = hrtimer_get_softexpires(timer);
+       hard = hrtimer_get_expires(timer);
+       delta = ktime_to_ns(ktime_sub(hard, soft));
+       return hrtimer_start_range_ns_user(timer, soft, delta, mode);
+}
+
 void hrtimer_sleeper_start_expires(struct hrtimer_sleeper *sl,
                                   enum hrtimer_mode mode);
 

diff --git a/include/trace/events/timer.h b/include/trace/events/timer.h
index 07cbb9836b91ef1e96c8b25db06b5659e5a5de56..ca82fd62dc30fadef5c4f37a96e956022a7133c7 100644 (file)
--- a/include/trace/events/timer.h
+++ b/include/trace/events/timer.h
@@ -298,6 +298,19 @@ DECLARE_EVENT_CLASS(hrtimer_class,
        TP_printk("hrtimer=%p", __entry->hrtimer)
 );
 
+/**
+ * hrtimer_start_expired - Invoked when a expired timer was started
+ * @hrtimer:   pointer to struct hrtimer
+ *
+ * Preceeded by a hrtimer_start tracepoint.
+ */
+DEFINE_EVENT(hrtimer_class, hrtimer_start_expired,
+
+       TP_PROTO(struct hrtimer *hrtimer),
+
+       TP_ARGS(hrtimer)
+);
+
 /**
  * hrtimer_expire_exit - called immediately after the hrtimer callback returns
  * @hrtimer:   pointer to struct hrtimer

diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index 5bd6efe598f0f03f57b46fe358d57aaa25b2fb30..79aaac4711644940fdbf91abea95b524b4b34405 100644 (file)
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -1352,6 +1352,12 @@ static inline bool hrtimer_keep_base(struct hrtimer *timer, bool is_local, bool
        return hrtimer_prefer_local(is_local, is_first, is_pinned);
 }
 
+enum {
+       HRTIMER_REPROGRAM_NONE,
+       HRTIMER_REPROGRAM,
+       HRTIMER_REPROGRAM_FORCE,
+};
+
 static bool __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, u64 delta_ns,
                                     const enum hrtimer_mode mode, struct hrtimer_clock_base *base)
 {
@@ -1410,7 +1416,7 @@ static bool __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, u64 del
        /* If a deferred rearm is pending skip reprogramming the device */
        if (cpu_base->deferred_rearm) {
                cpu_base->deferred_needs_update = true;
-               return false;
+               return HRTIMER_REPROGRAM_NONE;
        }
 
        if (!was_first || cpu_base != this_cpu_base) {
@@ -1423,7 +1429,7 @@ static bool __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, u64 del
                 * callbacks.
                 */
                if (likely(hrtimer_base_is_online(this_cpu_base)))
-                       return first;
+                       return first ? HRTIMER_REPROGRAM : HRTIMER_REPROGRAM_NONE;
 
                /*
                 * Timer was enqueued remote because the current base is
@@ -1432,7 +1438,7 @@ static bool __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, u64 del
                 */
                if (first)
                        smp_call_function_single_async(cpu_base->cpu, &cpu_base->csd);
-               return false;
+               return HRTIMER_REPROGRAM_NONE;
        }
 
        /*
@@ -1446,7 +1452,7 @@ static bool __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, u64 del
         */
        if (timer->is_lazy) {
                if (cpu_base->expires_next <= hrtimer_get_expires(timer))
-                       return false;
+                       return HRTIMER_REPROGRAM_NONE;
        }
 
        /*
@@ -1455,8 +1461,24 @@ static bool __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, u64 del
         * reprogram the hardware by evaluating the new first expiring
         * timer.
         */
-       hrtimer_force_reprogram(cpu_base, /* skip_equal */ true);
-       return false;
+       return HRTIMER_REPROGRAM_FORCE;
+}
+
+static int hrtimer_start_range_ns_common(struct hrtimer *timer, ktime_t tim,
+                                        u64 delta_ns, const enum hrtimer_mode mode,
+                                        struct hrtimer_clock_base *base)
+{
+       /*
+        * Check whether the HRTIMER_MODE_SOFT bit and hrtimer.is_soft
+        * match on CONFIG_PREEMPT_RT = n. With PREEMPT_RT check the hard
+        * expiry mode because unmarked timers are moved to softirq expiry.
+        */
+       if (!IS_ENABLED(CONFIG_PREEMPT_RT))
+               WARN_ON_ONCE(!(mode & HRTIMER_MODE_SOFT) ^ !timer->is_soft);
+       else
+               WARN_ON_ONCE(!(mode & HRTIMER_MODE_HARD) ^ !timer->is_hard);
+
+       return __hrtimer_start_range_ns(timer, tim, delta_ns, mode, base);
 }
 
 /**
@@ -1476,24 +1498,104 @@ void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, u64 delta_ns,
 
        debug_hrtimer_assert_init(timer);
 
+       base = lock_hrtimer_base(timer, &flags);
+
+       switch (hrtimer_start_range_ns_common(timer, tim, delta_ns, mode, base)) {
+       case HRTIMER_REPROGRAM:
+               hrtimer_reprogram(timer, true);
+               break;
+       case HRTIMER_REPROGRAM_FORCE:
+               hrtimer_force_reprogram(timer->base->cpu_base, 1);
+               break;
+       case HRTIMER_REPROGRAM_NONE:
+               break;
+       }
+
+       unlock_hrtimer_base(timer, &flags);
+}
+EXPORT_SYMBOL_GPL(hrtimer_start_range_ns);
+
+static inline bool hrtimer_check_user_timer(struct hrtimer *timer)
+{
+       struct hrtimer_cpu_base *cpu_base = timer->base->cpu_base;
+       ktime_t expires;
+
        /*
-        * Check whether the HRTIMER_MODE_SOFT bit and hrtimer.is_soft
-        * match on CONFIG_PREEMPT_RT = n. With PREEMPT_RT check the hard
-        * expiry mode because unmarked timers are moved to softirq expiry.
+        * This uses soft expires because that's the user provided
+        * expiry time, while expires can be further in the past
+        * due to a slack value added to the user expiry time.
         */
-       if (!IS_ENABLED(CONFIG_PREEMPT_RT))
-               WARN_ON_ONCE(!(mode & HRTIMER_MODE_SOFT) ^ !timer->is_soft);
-       else
-               WARN_ON_ONCE(!(mode & HRTIMER_MODE_HARD) ^ !timer->is_hard);
+       expires = hrtimer_get_softexpires(timer);
+
+       /* Convert to monotonic */
+       expires = ktime_sub(expires, timer->base->offset);
+
+       /*
+        * Check whether this timer will end up as the first expiring timer in
+        * the CPU base. If not, no further checks required as it's then
+        * guaranteed to expire in the future.
+        */
+       if (expires >= cpu_base->expires_next)
+               return true;
+
+       /* Validate that the expiry time is in the future. */
+       if (expires > ktime_get())
+               return true;
+
+       debug_hrtimer_deactivate(timer);
+       __remove_hrtimer(timer, timer->base, HRTIMER_STATE_INACTIVE, false);
+       trace_hrtimer_start_expired(timer);
+       return false;
+}
+
+/**
+ * hrtimer_start_range_ns_user - (re)start an user controlled hrtimer
+ * @timer:     the timer to be added
+ * @tim:       expiry time
+ * @delta_ns:  "slack" range for the timer
+ * @mode:      timer mode: absolute (HRTIMER_MODE_ABS) or
+ *             relative (HRTIMER_MODE_REL), and pinned (HRTIMER_MODE_PINNED);
+ *             softirq based mode is considered for debug purpose only!
+ *
+ * Returns: True when the timer was queued, false if it was already expired
+ *
+ * This function cannot invoke the timer callback for expired timers as it might
+ * be called under a lock which the timer callback needs to acquire. So the
+ * caller has to handle that case.
+ */
+bool hrtimer_start_range_ns_user(struct hrtimer *timer, ktime_t tim,
+                                u64 delta_ns, const enum hrtimer_mode mode)
+{
+       struct hrtimer_clock_base *base;
+       unsigned long flags;
+       bool ret = true;
+
+       debug_hrtimer_assert_init(timer);
 
        base = lock_hrtimer_base(timer, &flags);
 
-       if (__hrtimer_start_range_ns(timer, tim, delta_ns, mode, base))
-               hrtimer_reprogram(timer, true);
+       switch (hrtimer_start_range_ns_common(timer, tim, delta_ns, mode, base)) {
+       case HRTIMER_REPROGRAM:
+               ret = hrtimer_check_user_timer(timer);
+               if (ret)
+                       hrtimer_reprogram(timer, true);
+               break;
+       case HRTIMER_REPROGRAM_FORCE:
+               ret = hrtimer_check_user_timer(timer);
+               /*
+                * The base must always be reevaluated, independent of the
+                * result above because the timer was the first pending timer.
+                */
+               hrtimer_force_reprogram(timer->base->cpu_base, 1);
+               break;
+       case HRTIMER_REPROGRAM_NONE:
+               break;
+       }
 
        unlock_hrtimer_base(timer, &flags);
+       return ret;
 }
-EXPORT_SYMBOL_GPL(hrtimer_start_range_ns);
+EXPORT_SYMBOL_GPL(hrtimer_start_range_ns_user);
 
 /**
  * hrtimer_try_to_cancel - try to deactivate a timer