serial: core: Acquire nbcon context in port->lock wrapper

Currently the port->lock wrappers uart_port_lock(),
uart_port_unlock() (and their variants) only lock/unlock
the spin_lock.

If the port is an nbcon console that has implemented the
write_atomic() callback, the wrappers must also acquire/release
the console context and mark the region as unsafe. This allows
general port->lock synchronization to be synchronized against
the nbcon write_atomic() callback.

Note that __uart_port_using_nbcon() relies on the port->lock
being held while a console is added and removed from the
console list (i.e. all uart nbcon drivers *must* take the
port->lock in their device_lock() callbacks).

Signed-off-by: John Ogness <john.ogness@linutronix.de>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Petr Mladek <pmladek@suse.com>
Link: https://lore.kernel.org/r/20240820063001.36405-15-john.ogness@linutronix.de
Signed-off-by: Petr Mladek <pmladek@suse.com>

diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 2cf03ff2056acba80e774072da2eaa9bfcc5a8e7..4ab65874a850b4402ca3a7d3bdda597d7d5093f9 100644 (file)
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -11,6 +11,8 @@
 #include <linux/compiler.h>
 #include <linux/console.h>
 #include <linux/interrupt.h>
+#include <linux/lockdep.h>
+#include <linux/printk.h>
 #include <linux/spinlock.h>
 #include <linux/sched.h>
 #include <linux/tty.h>
@@ -625,6 +627,60 @@ static inline void uart_port_set_cons(struct uart_port *up, struct console *con)
        up->cons = con;
        __uart_port_unlock_irqrestore(up, flags);
 }
+
+/* Only for internal port lock wrapper usage. */
+static inline bool __uart_port_using_nbcon(struct uart_port *up)
+{
+       lockdep_assert_held_once(&up->lock);
+
+       if (likely(!uart_console(up)))
+               return false;
+
+       /*
+        * @up->cons is only modified under the port lock. Therefore it is
+        * certain that it cannot disappear here.
+        *
+        * @up->cons->node is added/removed from the console list under the
+        * port lock. Therefore it is certain that the registration status
+        * cannot change here, thus @up->cons->flags can be read directly.
+        */
+       if (hlist_unhashed_lockless(&up->cons->node) ||
+           !(up->cons->flags & CON_NBCON) ||
+           !up->cons->write_atomic) {
+               return false;
+       }
+
+       return true;
+}
+
+/* Only for internal port lock wrapper usage. */
+static inline bool __uart_port_nbcon_try_acquire(struct uart_port *up)
+{
+       if (!__uart_port_using_nbcon(up))
+               return true;
+
+       return nbcon_device_try_acquire(up->cons);
+}
+
+/* Only for internal port lock wrapper usage. */
+static inline void __uart_port_nbcon_acquire(struct uart_port *up)
+{
+       if (!__uart_port_using_nbcon(up))
+               return;
+
+       while (!nbcon_device_try_acquire(up->cons))
+               cpu_relax();
+}
+
+/* Only for internal port lock wrapper usage. */
+static inline void __uart_port_nbcon_release(struct uart_port *up)
+{
+       if (!__uart_port_using_nbcon(up))
+               return;
+
+       nbcon_device_release(up->cons);
+}
+
 /**
  * uart_port_lock - Lock the UART port
  * @up:                Pointer to UART port structure
@@ -632,6 +688,7 @@ static inline void uart_port_set_cons(struct uart_port *up, struct console *con)
 static inline void uart_port_lock(struct uart_port *up)
 {
        spin_lock(&up->lock);
+       __uart_port_nbcon_acquire(up);
 }
 
 /**
@@ -641,6 +698,7 @@ static inline void uart_port_lock(struct uart_port *up)
 static inline void uart_port_lock_irq(struct uart_port *up)
 {
        spin_lock_irq(&up->lock);
+       __uart_port_nbcon_acquire(up);
 }
 
 /**
@@ -651,6 +709,7 @@ static inline void uart_port_lock_irq(struct uart_port *up)
 static inline void uart_port_lock_irqsave(struct uart_port *up, unsigned long *flags)
 {
        spin_lock_irqsave(&up->lock, *flags);
+       __uart_port_nbcon_acquire(up);
 }
 
 /**
@@ -661,7 +720,15 @@ static inline void uart_port_lock_irqsave(struct uart_port *up, unsigned long *f
  */
 static inline bool uart_port_trylock(struct uart_port *up)
 {
-       return spin_trylock(&up->lock);
+       if (!spin_trylock(&up->lock))
+               return false;
+
+       if (!__uart_port_nbcon_try_acquire(up)) {
+               spin_unlock(&up->lock);
+               return false;
+       }
+
+       return true;
 }
 
 /**
@@ -673,7 +740,15 @@ static inline bool uart_port_trylock(struct uart_port *up)
  */
 static inline bool uart_port_trylock_irqsave(struct uart_port *up, unsigned long *flags)
 {
-       return spin_trylock_irqsave(&up->lock, *flags);
+       if (!spin_trylock_irqsave(&up->lock, *flags))
+               return false;
+
+       if (!__uart_port_nbcon_try_acquire(up)) {
+               spin_unlock_irqrestore(&up->lock, *flags);
+               return false;
+       }
+
+       return true;
 }
 
 /**
@@ -682,6 +757,7 @@ static inline bool uart_port_trylock_irqsave(struct uart_port *up, unsigned long
  */
 static inline void uart_port_unlock(struct uart_port *up)
 {
+       __uart_port_nbcon_release(up);
        spin_unlock(&up->lock);
 }
 
@@ -691,6 +767,7 @@ static inline void uart_port_unlock(struct uart_port *up)
  */
 static inline void uart_port_unlock_irq(struct uart_port *up)
 {
+       __uart_port_nbcon_release(up);
        spin_unlock_irq(&up->lock);
 }
 
@@ -701,6 +778,7 @@ static inline void uart_port_unlock_irq(struct uart_port *up)
  */
 static inline void uart_port_unlock_irqrestore(struct uart_port *up, unsigned long flags)
 {
+       __uart_port_nbcon_release(up);
        spin_unlock_irqrestore(&up->lock, flags);
 }