printk: nbcon: Relocate 32bit seq macros

The macros __seq_to_nbcon_seq() and __nbcon_seq_to_seq() are
used to provide support for atomic handling of sequence numbers
on 32bit systems. Until now this was only used by nbcon.c,
which is why they were located in nbcon.c and include nbcon in
the name.

In a follow-up commit this functionality is also needed by
printk_ringbuffer. Rather than duplicating the functionality,
relocate the macros to printk_ringbuffer.h.

Also, since the macros will be no longer nbcon-specific, rename
them to __u64seq_to_ulseq() and __ulseq_to_u64seq().

This does not result in any functional change.

Signed-off-by: John Ogness <john.ogness@linutronix.de>
Reviewed-by: Petr Mladek <pmladek@suse.com>
Link: https://lore.kernel.org/r/20240207134103.1357162-2-john.ogness@linutronix.de
Signed-off-by: Petr Mladek <pmladek@suse.com>

diff --git a/kernel/printk/nbcon.c b/kernel/printk/nbcon.c
index b96077152f49dd2a2dc416444538360e1b4db78b..c8093bcc01fe6076358faf925b6c7add80319bba 100644 (file)
--- a/kernel/printk/nbcon.c
+++ b/kernel/printk/nbcon.c
@@ -140,39 +140,6 @@ static inline bool nbcon_state_try_cmpxchg(struct console *con, struct nbcon_sta
        return atomic_try_cmpxchg(&ACCESS_PRIVATE(con, nbcon_state), &cur->atom, new->atom);
 }
 
-#ifdef CONFIG_64BIT
-
-#define __seq_to_nbcon_seq(seq) (seq)
-#define __nbcon_seq_to_seq(seq) (seq)
-
-#else /* CONFIG_64BIT */
-
-#define __seq_to_nbcon_seq(seq) ((u32)seq)
-
-static inline u64 __nbcon_seq_to_seq(u32 nbcon_seq)
-{
-       u64 seq;
-       u64 rb_next_seq;
-
-       /*
-        * The provided sequence is only the lower 32 bits of the ringbuffer
-        * sequence. It needs to be expanded to 64bit. Get the next sequence
-        * number from the ringbuffer and fold it.
-        *
-        * Having a 32bit representation in the console is sufficient.
-        * If a console ever gets more than 2^31 records behind
-        * the ringbuffer then this is the least of the problems.
-        *
-        * Also the access to the ring buffer is always safe.
-        */
-       rb_next_seq = prb_next_seq(prb);
-       seq = rb_next_seq - ((u32)rb_next_seq - nbcon_seq);
-
-       return seq;
-}
-
-#endif /* CONFIG_64BIT */
-
 /**
  * nbcon_seq_read - Read the current console sequence
  * @con:       Console to read the sequence of
@@ -183,7 +150,7 @@ u64 nbcon_seq_read(struct console *con)
 {
        unsigned long nbcon_seq = atomic_long_read(&ACCESS_PRIVATE(con, nbcon_seq));
 
-       return __nbcon_seq_to_seq(nbcon_seq);
+       return __ulseq_to_u64seq(prb, nbcon_seq);
 }
 
 /**
@@ -204,7 +171,7 @@ void nbcon_seq_force(struct console *con, u64 seq)
         */
        u64 valid_seq = max_t(u64, seq, prb_first_valid_seq(prb));
 
-       atomic_long_set(&ACCESS_PRIVATE(con, nbcon_seq), __seq_to_nbcon_seq(valid_seq));
+       atomic_long_set(&ACCESS_PRIVATE(con, nbcon_seq), __u64seq_to_ulseq(valid_seq));
 
        /* Clear con->seq since nbcon consoles use con->nbcon_seq instead. */
        con->seq = 0;
@@ -223,11 +190,11 @@ void nbcon_seq_force(struct console *con, u64 seq)
  */
 static void nbcon_seq_try_update(struct nbcon_context *ctxt, u64 new_seq)
 {
-       unsigned long nbcon_seq = __seq_to_nbcon_seq(ctxt->seq);
+       unsigned long nbcon_seq = __u64seq_to_ulseq(ctxt->seq);
        struct console *con = ctxt->console;
 
        if (atomic_long_try_cmpxchg(&ACCESS_PRIVATE(con, nbcon_seq), &nbcon_seq,
-                                   __seq_to_nbcon_seq(new_seq))) {
+                                   __u64seq_to_ulseq(new_seq))) {
                ctxt->seq = new_seq;
        } else {
                ctxt->seq = nbcon_seq_read(con);

diff --git a/kernel/printk/printk_ringbuffer.h b/kernel/printk/printk_ringbuffer.h
index 18cd25e489b8935225c1ca9292c109af71941eb1..b82a96dc2ea2b818a1884c47158a942902e3e609 100644 (file)
--- a/kernel/printk/printk_ringbuffer.h
+++ b/kernel/printk/printk_ringbuffer.h
@@ -381,4 +381,37 @@ bool prb_read_valid_info(struct printk_ringbuffer *rb, u64 seq,
 u64 prb_first_valid_seq(struct printk_ringbuffer *rb);
 u64 prb_next_seq(struct printk_ringbuffer *rb);
 
+#ifdef CONFIG_64BIT
+
+#define __u64seq_to_ulseq(u64seq) (u64seq)
+#define __ulseq_to_u64seq(rb, ulseq) (ulseq)
+
+#else /* CONFIG_64BIT */
+
+#define __u64seq_to_ulseq(u64seq) ((u32)u64seq)
+
+static inline u64 __ulseq_to_u64seq(struct printk_ringbuffer *rb, u32 ulseq)
+{
+       u64 seq;
+       u64 rb_next_seq;
+
+       /*
+        * The provided sequence is only the lower 32 bits of the ringbuffer
+        * sequence. It needs to be expanded to 64bit. Get the next sequence
+        * number from the ringbuffer and fold it.
+        *
+        * Having a 32bit representation in the console is sufficient.
+        * If a console ever gets more than 2^31 records behind
+        * the ringbuffer then this is the least of the problems.
+        *
+        * Also the access to the ring buffer is always safe.
+        */
+       rb_next_seq = prb_next_seq(rb);
+       seq = rb_next_seq - ((u32)rb_next_seq - ulseq);
+
+       return seq;
+}
+
+#endif /* CONFIG_64BIT */
+
 #endif /* _KERNEL_PRINTK_RINGBUFFER_H */