tick/sched: Reduce seqcount held scope in tick_do_update_jiffies64()

[ Upstream commit a8e09f156967a67b62b5efc53fadf841d5180be0 ]

If jiffies are up to date already (caller lost the race against another
CPU) there is no point to change the sequence count. Doing that just forces
other CPUs into the seqcount retry loop in tick_nohz_next_event() for
nothing.

Just bail out early.

[ tglx: Rewrote most of it ]

Signed-off-by: Yunfeng Ye <yeyunfeng@huawei.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Link: https://lore.kernel.org/r/20201117132006.462195901@linutronix.de
Stable-dep-of: e9523a0d8189 ("tick/common: Align tick period with the HZ tick.")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 1dfa53494164aa2bae749d628d40d41560b72faa..eaeeb4bb1f8ab7ec8913954cd2e56595bb8dfe8d 100644 (file)
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -84,38 +84,35 @@ static void tick_do_update_jiffies64(ktime_t now)
 
        /* Reevaluate with jiffies_lock held */
        raw_spin_lock(&jiffies_lock);
+       if (ktime_before(now, tick_next_period)) {
+               raw_spin_unlock(&jiffies_lock);
+               return;
+       }
+
        write_seqcount_begin(&jiffies_seq);
 
-       delta = ktime_sub(now, last_jiffies_update);
-       if (delta >= tick_period) {
+       last_jiffies_update = ktime_add(last_jiffies_update, tick_period);
 
-               delta = ktime_sub(delta, tick_period);
-               last_jiffies_update = ktime_add(last_jiffies_update,
-                                               tick_period);
+       delta = ktime_sub(now, tick_next_period);
+       if (unlikely(delta >= tick_period)) {
+               /* Slow path for long idle sleep times */
+               s64 incr = ktime_to_ns(tick_period);
 
-               /* Slow path for long timeouts */
-               if (unlikely(delta >= tick_period)) {
-                       s64 incr = ktime_to_ns(tick_period);
+               ticks = ktime_divns(delta, incr);
 
-                       ticks = ktime_divns(delta, incr);
+               last_jiffies_update = ktime_add_ns(last_jiffies_update,
+                                                  incr * ticks);
+       }
 
-                       last_jiffies_update = ktime_add_ns(last_jiffies_update,
-                                                          incr * ticks);
-               }
-               do_timer(++ticks);
+       do_timer(++ticks);
+
+       /*
+        * Keep the tick_next_period variable up to date.  WRITE_ONCE()
+        * pairs with the READ_ONCE() in the lockless quick check above.
+        */
+       WRITE_ONCE(tick_next_period,
+                  ktime_add(last_jiffies_update, tick_period));
 
-               /*
-                * Keep the tick_next_period variable up to date.
-                * WRITE_ONCE() pairs with the READ_ONCE() in the lockless
-                * quick check above.
-                */
-               WRITE_ONCE(tick_next_period,
-                          ktime_add(last_jiffies_update, tick_period));
-       } else {
-               write_seqcount_end(&jiffies_seq);
-               raw_spin_unlock(&jiffies_lock);
-               return;
-       }
        write_seqcount_end(&jiffies_seq);
        raw_spin_unlock(&jiffies_lock);
        update_wall_time();