lockdep: Prepare for noinstr sections

Force inlining and prevent instrumentation of all sorts by marking the
functions which are invoked from low level entry code with 'noinstr'.

Split the irqflags tracking into two parts. One which does the heavy
lifting while RCU is watching and the final one which can be invoked after
RCU is turned off.

Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Alexandre Chartre <alexandre.chartre@oracle.com>
Link: https://lkml.kernel.org/r/20200505134100.484532537@linutronix.de

diff --git a/include/linux/irqflags.h b/include/linux/irqflags.h
index f150e69ab81d25edafea9c8b833a3f8cc29ef06c..d7f7e436c3afc72b3343e049600e61c95ea06194 100644 (file)
--- a/include/linux/irqflags.h
+++ b/include/linux/irqflags.h
@@ -19,11 +19,13 @@
 #ifdef CONFIG_PROVE_LOCKING
   extern void lockdep_softirqs_on(unsigned long ip);
   extern void lockdep_softirqs_off(unsigned long ip);
+  extern void lockdep_hardirqs_on_prepare(unsigned long ip);
   extern void lockdep_hardirqs_on(unsigned long ip);
   extern void lockdep_hardirqs_off(unsigned long ip);
 #else
   static inline void lockdep_softirqs_on(unsigned long ip) { }
   static inline void lockdep_softirqs_off(unsigned long ip) { }
+  static inline void lockdep_hardirqs_on_prepare(unsigned long ip) { }
   static inline void lockdep_hardirqs_on(unsigned long ip) { }
   static inline void lockdep_hardirqs_off(unsigned long ip) { }
 #endif

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 4418f5cb832431519edb88c047522c12a816fa3b..658de6164853b6eecc92575b3a634e455eda674e 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -983,6 +983,7 @@ struct task_struct {
        unsigned int                    hardirq_disable_event;
        int                             hardirqs_enabled;
        int                             hardirq_context;
+       u64                             hardirq_chain_key;
        unsigned long                   softirq_disable_ip;
        unsigned long                   softirq_enable_ip;
        unsigned int                    softirq_disable_event;

diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index ac10db66cc63f4b8f96ad59e89ac3caee18a2b6d..9ccd675a8b5a026be76a54f4c8305239d1ab4985 100644 (file)
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -3635,13 +3635,10 @@ mark_held_locks(struct task_struct *curr, enum lock_usage_bit base_bit)
 /*
  * Hardirqs will be enabled:
  */
-static void __trace_hardirqs_on_caller(unsigned long ip)
+static void __trace_hardirqs_on_caller(void)
 {
        struct task_struct *curr = current;
 
-       /* we'll do an OFF -> ON transition: */
-       curr->hardirqs_enabled = 1;
-
        /*
         * We are going to turn hardirqs on, so set the
         * usage bit for all held locks:
@@ -3654,15 +3651,19 @@ static void __trace_hardirqs_on_caller(unsigned long ip)
         * this bit from being set before)
         */
        if (curr->softirqs_enabled)
-               if (!mark_held_locks(curr, LOCK_ENABLED_SOFTIRQ))
-                       return;
-
-       curr->hardirq_enable_ip = ip;
-       curr->hardirq_enable_event = ++curr->irq_events;
-       debug_atomic_inc(hardirqs_on_events);
+               mark_held_locks(curr, LOCK_ENABLED_SOFTIRQ);
 }
 
-void lockdep_hardirqs_on(unsigned long ip)
+/**
+ * lockdep_hardirqs_on_prepare - Prepare for enabling interrupts
+ * @ip:                Caller address
+ *
+ * Invoked before a possible transition to RCU idle from exit to user or
+ * guest mode. This ensures that all RCU operations are done before RCU
+ * stops watching. After the RCU transition lockdep_hardirqs_on() has to be
+ * invoked to set the final state.
+ */
+void lockdep_hardirqs_on_prepare(unsigned long ip)
 {
        if (unlikely(!debug_locks || current->lockdep_recursion))
                return;
@@ -3698,20 +3699,62 @@ void lockdep_hardirqs_on(unsigned long ip)
        if (DEBUG_LOCKS_WARN_ON(current->hardirq_context))
                return;
 
+       current->hardirq_chain_key = current->curr_chain_key;
+
        current->lockdep_recursion++;
-       __trace_hardirqs_on_caller(ip);
+       __trace_hardirqs_on_caller();
        lockdep_recursion_finish();
 }
-NOKPROBE_SYMBOL(lockdep_hardirqs_on);
+EXPORT_SYMBOL_GPL(lockdep_hardirqs_on_prepare);
+
+void noinstr lockdep_hardirqs_on(unsigned long ip)
+{
+       struct task_struct *curr = current;
+
+       if (unlikely(!debug_locks || curr->lockdep_recursion))
+               return;
+
+       if (curr->hardirqs_enabled) {
+               /*
+                * Neither irq nor preemption are disabled here
+                * so this is racy by nature but losing one hit
+                * in a stat is not a big deal.
+                */
+               __debug_atomic_inc(redundant_hardirqs_on);
+               return;
+       }
+
+       /*
+        * We're enabling irqs and according to our state above irqs weren't
+        * already enabled, yet we find the hardware thinks they are in fact
+        * enabled.. someone messed up their IRQ state tracing.
+        */
+       if (DEBUG_LOCKS_WARN_ON(!irqs_disabled()))
+               return;
+
+       /*
+        * Ensure the lock stack remained unchanged between
+        * lockdep_hardirqs_on_prepare() and lockdep_hardirqs_on().
+        */
+       DEBUG_LOCKS_WARN_ON(current->hardirq_chain_key !=
+                           current->curr_chain_key);
+
+       /* we'll do an OFF -> ON transition: */
+       curr->hardirqs_enabled = 1;
+       curr->hardirq_enable_ip = ip;
+       curr->hardirq_enable_event = ++curr->irq_events;
+       debug_atomic_inc(hardirqs_on_events);
+}
+EXPORT_SYMBOL_GPL(lockdep_hardirqs_on);
 
 /*
  * Hardirqs were disabled:
  */
-void lockdep_hardirqs_off(unsigned long ip)
+void noinstr lockdep_hardirqs_off(unsigned long ip)
 {
        struct task_struct *curr = current;
 
-       if (unlikely(!debug_locks || current->lockdep_recursion))
+       if (unlikely(!debug_locks || curr->lockdep_recursion))
                return;
 
        /*
@@ -3729,10 +3772,11 @@ void lockdep_hardirqs_off(unsigned long ip)
                curr->hardirq_disable_ip = ip;
                curr->hardirq_disable_event = ++curr->irq_events;
                debug_atomic_inc(hardirqs_off_events);
-       } else
+       } else {
                debug_atomic_inc(redundant_hardirqs_off);
+       }
 }
-NOKPROBE_SYMBOL(lockdep_hardirqs_off);
+EXPORT_SYMBOL_GPL(lockdep_hardirqs_off);
 
 /*
  * Softirqs will be enabled:
@@ -4408,8 +4452,8 @@ static void print_unlock_imbalance_bug(struct task_struct *curr,
        dump_stack();
 }
 
-static int match_held_lock(const struct held_lock *hlock,
-                                       const struct lockdep_map *lock)
+static noinstr int match_held_lock(const struct held_lock *hlock,
+                                  const struct lockdep_map *lock)
 {
        if (hlock->instance == lock)
                return 1;
@@ -4696,7 +4740,7 @@ __lock_release(struct lockdep_map *lock, unsigned long ip)
        return 0;
 }
 
-static nokprobe_inline
+static __always_inline
 int __lock_is_held(const struct lockdep_map *lock, int read)
 {
        struct task_struct *curr = current;
@@ -4956,7 +5000,7 @@ void lock_release(struct lockdep_map *lock, unsigned long ip)
 }
 EXPORT_SYMBOL_GPL(lock_release);
 
-int lock_is_held_type(const struct lockdep_map *lock, int read)
+noinstr int lock_is_held_type(const struct lockdep_map *lock, int read)
 {
        unsigned long flags;
        int ret = 0;

diff --git a/kernel/trace/trace_preemptirq.c b/kernel/trace/trace_preemptirq.c
index c00880162b06ad0daff899f7fcc3b9f5781f9fa3..fb0691b8a88de66f678e19b31bc4fdd1dbd84583 100644 (file)
--- a/kernel/trace/trace_preemptirq.c
+++ b/kernel/trace/trace_preemptirq.c
@@ -46,6 +46,7 @@ void trace_hardirqs_on(void)
                this_cpu_write(tracing_irq_cpu, 0);
        }
 
+       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
        lockdep_hardirqs_on(CALLER_ADDR0);
 }
 EXPORT_SYMBOL(trace_hardirqs_on);
@@ -93,6 +94,7 @@ __visible void trace_hardirqs_on_caller(unsigned long caller_addr)
                this_cpu_write(tracing_irq_cpu, 0);
        }
 
+       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
        lockdep_hardirqs_on(CALLER_ADDR0);
 }
 EXPORT_SYMBOL(trace_hardirqs_on_caller);

diff --git a/lib/debug_locks.c b/lib/debug_locks.c
index a75ee30b77cb8dd70d792d36e17ec74b0385852f..06d3135bd184c498ae02a60a9da4b5ba502e442d 100644 (file)
--- a/lib/debug_locks.c
+++ b/lib/debug_locks.c
@@ -36,7 +36,7 @@ EXPORT_SYMBOL_GPL(debug_locks_silent);
 /*
  * Generic 'turn off all lock debugging' function:
  */
-int debug_locks_off(void)
+noinstr int debug_locks_off(void)
 {
        if (debug_locks && __debug_locks_off()) {
                if (!debug_locks_silent) {