diff options
Diffstat (limited to '')
| -rw-r--r-- | debian/patches-rt/0085-printk-nbcon-Relocate-32bit-seq-macros.patch | 141 |
1 files changed, 141 insertions, 0 deletions
diff --git a/debian/patches-rt/0085-printk-nbcon-Relocate-32bit-seq-macros.patch b/debian/patches-rt/0085-printk-nbcon-Relocate-32bit-seq-macros.patch new file mode 100644 index 000000000..6d1cf3686 --- /dev/null +++ b/debian/patches-rt/0085-printk-nbcon-Relocate-32bit-seq-macros.patch @@ -0,0 +1,141 @@ +From: John Ogness <john.ogness@linutronix.de> +Date: Wed, 6 Dec 2023 12:01:56 +0000 +Subject: [PATCH 085/134] printk: nbcon: Relocate 32bit seq macros +Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/6.6/older/patches-6.6.7-rt18.tar.xz + +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> +Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> +--- + kernel/printk/nbcon.c | 41 +++----------------------------------- + kernel/printk/printk_ringbuffer.h | 33 ++++++++++++++++++++++++++++++ + 2 files changed, 37 insertions(+), 37 deletions(-) + +--- a/kernel/printk/nbcon.c ++++ b/kernel/printk/nbcon.c +@@ -140,39 +140,6 @@ static inline bool nbcon_state_try_cmpxc + 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 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 + */ + 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); +--- a/kernel/printk/printk_ringbuffer.h ++++ b/kernel/printk/printk_ringbuffer.h +@@ -381,4 +381,37 @@ bool prb_read_valid_info(struct printk_r + 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 */ |