/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _KERNEL_PRINTK_RINGBUFFER_H#define _KERNEL_PRINTK_RINGBUFFER_H #include <linux/atomic.h>#include <linux/dev_printk.h> /* * Meta information about each stored message. * * All fields are set by the printk code except for @seq, which is * set by the ringbuffer code. */struct printk_info {	u64	seq;		/* sequence number */	u64	ts_nsec;	/* timestamp in nanoseconds */	u16	text_len;	/* length of text message */	u8	facility;	/* syslog facility */	u8	flags:5;	/* internal record flags */	u8	level:3;	/* syslog level */	u32	caller_id;	/* thread id or processor id */ 	struct dev_printk_info	dev_info;}; /* * A structure providing the buffers, used by writers and readers. * * Writers: * Using prb_rec_init_wr(), a writer sets @text_buf_size before calling * prb_reserve(). On success, prb_reserve() sets @info and @text_buf to * buffers reserved for that writer. * * Readers: * Using prb_rec_init_rd(), a reader sets all fields before calling * prb_read_valid(). Note that the reader provides the @info and @text_buf, * buffers. On success, the struct pointed to by @info will be filled and * the char array pointed to by @text_buf will be filled with text data. */struct printk_record {	struct printk_info	*info;	char			*text_buf;	unsigned int		text_buf_size;}; /* Specifies the logical position and span of a data block. */struct prb_data_blk_lpos {	unsigned long	begin;	unsigned long	next;}; /* * A descriptor: the complete meta-data for a record. * * @state_var: A bitwise combination of descriptor ID and descriptor state. */struct prb_desc {	atomic_long_t			state_var;	struct prb_data_blk_lpos	text_blk_lpos;}; /* A ringbuffer of "ID + data" elements. */struct prb_data_ring {	unsigned int	size_bits;	char		*data;	atomic_long_t	head_lpos;	atomic_long_t	tail_lpos;}; /* A ringbuffer of "struct prb_desc" elements. */struct prb_desc_ring {	unsigned int		count_bits;	struct prb_desc		*descs;	struct printk_info	*infos;	atomic_long_t		head_id;	atomic_long_t		tail_id;}; /* * The high level structure representing the printk ringbuffer. * * @fail: Count of failed prb_reserve() calls where not even a data-less *        record was created. */struct printk_ringbuffer {	struct prb_desc_ring	desc_ring;	struct prb_data_ring	text_data_ring;	atomic_long_t		fail;}; /* * Used by writers as a reserve/commit handle. * * @rb:         Ringbuffer where the entry is reserved. * @irqflags:   Saved irq flags to restore on entry commit. * @id:         ID of the reserved descriptor. * @text_space: Total occupied buffer space in the text data ring, including *              ID, alignment padding, and wrapping data blocks. * * This structure is an opaque handle for writers. Its contents are only * to be used by the ringbuffer implementation. */struct prb_reserved_entry {	struct printk_ringbuffer	*rb;	unsigned long			irqflags;	unsigned long			id;	unsigned int			text_space;}; /* The possible responses of a descriptor state-query. */enum desc_state {	desc_miss	=  -1,	/* ID mismatch (pseudo state) */	desc_reserved	= 0x0,	/* reserved, in use by writer */	desc_committed	= 0x1,	/* committed by writer, could get reopened */	desc_finalized	= 0x2,	/* committed, no further modification allowed */	desc_reusable	= 0x3,	/* free, not yet used by any writer */}; #define _DATA_SIZE(sz_bits)	(1UL << (sz_bits))#define _DESCS_COUNT(ct_bits)	(1U << (ct_bits))#define DESC_SV_BITS		(sizeof(unsigned long) * 8)#define DESC_FLAGS_SHIFT	(DESC_SV_BITS - 2)#define DESC_FLAGS_MASK		(3UL << DESC_FLAGS_SHIFT)#define DESC_STATE(sv)		(3UL & (sv >> DESC_FLAGS_SHIFT))#define DESC_SV(id, state)	(((unsigned long)state << DESC_FLAGS_SHIFT) | id)#define DESC_ID_MASK		(~DESC_FLAGS_MASK)#define DESC_ID(sv)		((sv) & DESC_ID_MASK)#define FAILED_LPOS		0x1#define NO_LPOS			0x3 #define FAILED_BLK_LPOS	\{				\	.begin	= FAILED_LPOS,	\	.next	= FAILED_LPOS,	\} /* * Descriptor Bootstrap * * The descriptor array is minimally initialized to allow immediate usage * by readers and writers. The requirements that the descriptor array * initialization must satisfy: * *   Req1 *     The tail must point to an existing (committed or reusable) descriptor. *     This is required by the implementation of prb_first_seq(). * *   Req2 *     Readers must see that the ringbuffer is initially empty. * *   Req3 *     The first record reserved by a writer is assigned sequence number 0. * * To satisfy Req1, the tail initially points to a descriptor that is * minimally initialized (having no data block, i.e. data-less with the * data block's lpos @begin and @next values set to FAILED_LPOS). * * To satisfy Req2, the initial tail descriptor is initialized to the * reusable state. Readers recognize reusable descriptors as existing * records, but skip over them. * * To satisfy Req3, the last descriptor in the array is used as the initial * head (and tail) descriptor. This allows the first record reserved by a * writer (head + 1) to be the first descriptor in the array. (Only the first * descriptor in the array could have a valid sequence number of 0.) * * The first time a descriptor is reserved, it is assigned a sequence number * with the value of the array index. A "first time reserved" descriptor can * be recognized because it has a sequence number of 0 but does not have an * index of 0. (Only the first descriptor in the array could have a valid * sequence number of 0.) After the first reservation, all future reservations * (recycling) simply involve incrementing the sequence number by the array * count. * *   Hack #1 *     Only the first descriptor in the array is allowed to have the sequence *     number 0. In this case it is not possible to recognize if it is being *     reserved the first time (set to index value) or has been reserved *     previously (increment by the array count). This is handled by _always_ *     incrementing the sequence number by the array count when reserving the *     first descriptor in the array. In order to satisfy Req3, the sequence *     number of the first descriptor in the array is initialized to minus *     the array count. Then, upon the first reservation, it is incremented *     to 0, thus satisfying Req3. * *   Hack #2 *     prb_first_seq() can be called at any time by readers to retrieve the *     sequence number of the tail descriptor. However, due to Req2 and Req3, *     initially there are no records to report the sequence number of *     (sequence numbers are u64 and there is nothing less than 0). To handle *     this, the sequence number of the initial tail descriptor is initialized *     to 0. Technically this is incorrect, because there is no record with *     sequence number 0 (yet) and the tail descriptor is not the first *     descriptor in the array. But it allows prb_read_valid() to correctly *     report the existence of a record for _any_ given sequence number at all *     times. Bootstrapping is complete when the tail is pushed the first *     time, thus finally pointing to the first descriptor reserved by a *     writer, which has the assigned sequence number 0. */ /* * Initiating Logical Value Overflows * * Both logical position (lpos) and ID values can be mapped to array indexes * but may experience overflows during the lifetime of the system. To ensure * that printk_ringbuffer can handle the overflows for these types, initial * values are chosen that map to the correct initial array indexes, but will * result in overflows soon. * *   BLK0_LPOS *     The initial @head_lpos and @tail_lpos for data rings. It is at index *     0 and the lpos value is such that it will overflow on the first wrap. * *   DESC0_ID *     The initial @head_id and @tail_id for the desc ring. It is at the last *     index of the descriptor array (see Req3 above) and the ID value is such *     that it will overflow on the second wrap. */#define BLK0_LPOS(sz_bits)	(-(_DATA_SIZE(sz_bits)))#define DESC0_ID(ct_bits)	DESC_ID(-(_DESCS_COUNT(ct_bits) + 1))#define DESC0_SV(ct_bits)	DESC_SV(DESC0_ID(ct_bits), desc_reusable) /* * Define a ringbuffer with an external text data buffer. The same as * DEFINE_PRINTKRB() but requires specifying an external buffer for the * text data. * * Note: The specified external buffer must be of the size: *       2 ^ (descbits + avgtextbits) */#define _DEFINE_PRINTKRB(name, descbits, avgtextbits, text_buf)			\static struct prb_desc _##name##_descs[_DESCS_COUNT(descbits)] = {				\	/* the initial head and tail */								\	[_DESCS_COUNT(descbits) - 1] = {							\		/* reusable */									\		.state_var	= ATOMIC_INIT(DESC0_SV(descbits)),				\		/* no associated data block */							\		.text_blk_lpos	= FAILED_BLK_LPOS,						\	},											\};												\static struct printk_info _##name##_infos[_DESCS_COUNT(descbits)] = {				\	/* this will be the first record reserved by a writer */				\	[0] = {											\		/* will be incremented to 0 on the first reservation */				\		.seq = -(u64)_DESCS_COUNT(descbits),						\	},											\	/* the initial head and tail */								\	[_DESCS_COUNT(descbits) - 1] = {							\		/* reports the first seq value during the bootstrap phase */			\		.seq = 0,									\	},											\};												\static struct printk_ringbuffer name = {							\	.desc_ring = {										\		.count_bits	= descbits,							\		.descs		= &_##name##_descs[0],						\		.infos		= &_##name##_infos[0],						\		.head_id	= ATOMIC_INIT(DESC0_ID(descbits)),				\		.tail_id	= ATOMIC_INIT(DESC0_ID(descbits)),				\	},											\	.text_data_ring = {									\		.size_bits	= (avgtextbits) + (descbits),					\		.data		= text_buf,							\		.head_lpos	= ATOMIC_LONG_INIT(BLK0_LPOS((avgtextbits) + (descbits))),	\		.tail_lpos	= ATOMIC_LONG_INIT(BLK0_LPOS((avgtextbits) + (descbits))),	\	},											\	.fail			= ATOMIC_LONG_INIT(0),						\} /** * DEFINE_PRINTKRB() - Define a ringbuffer. * * @name:        The name of the ringbuffer variable. * @descbits:    The number of descriptors as a power-of-2 value. * @avgtextbits: The average text data size per record as a power-of-2 value. * * This is a macro for defining a ringbuffer and all internal structures * such that it is ready for immediate use. See _DEFINE_PRINTKRB() for a * variant where the text data buffer can be specified externally. */#define DEFINE_PRINTKRB(name, descbits, avgtextbits)				\static char _##name##_text[1U << ((avgtextbits) + (descbits))]			\			__aligned(__alignof__(unsigned long));			\_DEFINE_PRINTKRB(name, descbits, avgtextbits, &_##name##_text[0]) /* Writer Interface */ /** * prb_rec_init_wr() - Initialize a buffer for writing records. * * @r:             The record to initialize. * @text_buf_size: The needed text buffer size. */static inline void prb_rec_init_wr(struct printk_record *r,				   unsigned int text_buf_size){	r->info = NULL;	r->text_buf = NULL;	r->text_buf_size = text_buf_size;} bool prb_reserve(struct prb_reserved_entry *e, struct printk_ringbuffer *rb,		 struct printk_record *r);bool prb_reserve_in_last(struct prb_reserved_entry *e, struct printk_ringbuffer *rb,			 struct printk_record *r, u32 caller_id, unsigned int max_size);void prb_commit(struct prb_reserved_entry *e);void prb_final_commit(struct prb_reserved_entry *e); void prb_init(struct printk_ringbuffer *rb,	      char *text_buf, unsigned int text_buf_size,	      struct prb_desc *descs, unsigned int descs_count_bits,	      struct printk_info *infos);unsigned int prb_record_text_space(struct prb_reserved_entry *e); /* Reader Interface */ /** * prb_rec_init_rd() - Initialize a buffer for reading records. * * @r:             The record to initialize. * @info:          A buffer to store record meta-data. * @text_buf:      A buffer to store text data. * @text_buf_size: The size of @text_buf. * * Initialize all the fields that a reader is interested in. All arguments * (except @r) are optional. Only record data for arguments that are * non-NULL or non-zero will be read. */static inline void prb_rec_init_rd(struct printk_record *r,				   struct printk_info *info,				   char *text_buf, unsigned int text_buf_size){	r->info = info;	r->text_buf = text_buf;	r->text_buf_size = text_buf_size;} /** * prb_for_each_record() - Iterate over the records of a ringbuffer. * * @from: The sequence number to begin with. * @rb:   The ringbuffer to iterate over. * @s:    A u64 to store the sequence number on each iteration. * @r:    A printk_record to store the record on each iteration. * * This is a macro for conveniently iterating over a ringbuffer. * Note that @s may not be the sequence number of the record on each * iteration. For the sequence number, @r->info->seq should be checked. * * Context: Any context. */#define prb_for_each_record(from, rb, s, r) \for ((s) = from; prb_read_valid(rb, s, r); (s) = (r)->info->seq + 1) /** * prb_for_each_info() - Iterate over the meta data of a ringbuffer. * * @from: The sequence number to begin with. * @rb:   The ringbuffer to iterate over. * @s:    A u64 to store the sequence number on each iteration. * @i:    A printk_info to store the record meta data on each iteration. * @lc:   An unsigned int to store the text line count of each record. * * This is a macro for conveniently iterating over a ringbuffer. * Note that @s may not be the sequence number of the record on each * iteration. For the sequence number, @r->info->seq should be checked. * * Context: Any context. */#define prb_for_each_info(from, rb, s, i, lc) \for ((s) = from; prb_read_valid_info(rb, s, i, lc); (s) = (i)->seq + 1) bool prb_read_valid(struct printk_ringbuffer *rb, u64 seq,		    struct printk_record *r);bool prb_read_valid_info(struct printk_ringbuffer *rb, u64 seq,			 struct printk_info *info, unsigned int *line_count); u64 prb_first_valid_seq(struct printk_ringbuffer *rb);u64 prb_next_seq(struct printk_ringbuffer *rb); #endif /* _KERNEL_PRINTK_RINGBUFFER_H */