timekeeping: Add a lockdep override in tick_freeze()

tick_freeze() acquires a raw spinlock (tick_freeze_lock). Later in the
callchain (timekeeping_suspend() -> mc146818_avoid_UIP()) the RTC driver
acquires a spinlock which becomes a sleeping lock on PREEMPT_RT.  Lockdep
complains about this lock nesting.

Add a lockdep override for this special case and a comment explaining
why it is okay.

Reported-by: Borislav Petkov <bp@alien8.de>
Reported-by: Chris Bainbridge <chris.bainbridge@gmail.com>
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: https://lore.kernel.org/all/20250404133429.pnAzf-eF@linutronix.de
Closes: https://lore.kernel.org/all/20250330113202.GAZ-krsjAnurOlTcp-@fat_crate.local/
Closes: https://lore.kernel.org/all/CAP-bSRZ0CWyZZsMtx046YV8L28LhY0fson2g4EqcwRAVN1Jk+Q@mail.gmail.com/

diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index a47bcf71defcf5afdf4edae01d27287e73f1d56a..9a3859443c042c14d89afcdb344b983232ed36fb 100644 (file)
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -509,6 +509,7 @@ void tick_resume(void)
 
 #ifdef CONFIG_SUSPEND
 static DEFINE_RAW_SPINLOCK(tick_freeze_lock);
+static DEFINE_WAIT_OVERRIDE_MAP(tick_freeze_map, LD_WAIT_SLEEP);
 static unsigned int tick_freeze_depth;
 
 /**
@@ -528,9 +529,22 @@ void tick_freeze(void)
        if (tick_freeze_depth == num_online_cpus()) {
                trace_suspend_resume(TPS("timekeeping_freeze"),
                                     smp_processor_id(), true);
+               /*
+                * All other CPUs have their interrupts disabled and are
+                * suspended to idle. Other tasks have been frozen so there
+                * is no scheduling happening. This means that there is no
+                * concurrency in the system at this point. Therefore it is
+                * okay to acquire a sleeping lock on PREEMPT_RT, such as a
+                * spinlock, because the lock cannot be held by other CPUs
+                * or threads and acquiring it cannot block.
+                *
+                * Inform lockdep about the situation.
+                */
+               lock_map_acquire_try(&tick_freeze_map);
                system_state = SYSTEM_SUSPEND;
                sched_clock_suspend();
                timekeeping_suspend();
+               lock_map_release(&tick_freeze_map);
        } else {
                tick_suspend_local();
        }
@@ -552,8 +566,16 @@ void tick_unfreeze(void)
        raw_spin_lock(&tick_freeze_lock);
 
        if (tick_freeze_depth == num_online_cpus()) {
+               /*
+                * Similar to tick_freeze(). On resumption the first CPU may
+                * acquire uncontended sleeping locks while other CPUs block on
+                * tick_freeze_lock.
+                */
+               lock_map_acquire_try(&tick_freeze_map);
                timekeeping_resume();
                sched_clock_resume();
+               lock_map_release(&tick_freeze_map);
+
                system_state = SYSTEM_RUNNING;
                trace_suspend_resume(TPS("timekeeping_freeze"),
                                     smp_processor_id(), false);