Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 :
3 : #ifndef _KERNEL_PRINTK_RINGBUFFER_H
4 : #define _KERNEL_PRINTK_RINGBUFFER_H
5 :
6 : #include <linux/atomic.h>
7 : #include <linux/dev_printk.h>
8 :
9 : /*
10 : * Meta information about each stored message.
11 : *
12 : * All fields are set by the printk code except for @seq, which is
13 : * set by the ringbuffer code.
14 : */
15 : struct printk_info {
16 : u64 seq; /* sequence number */
17 : u64 ts_nsec; /* timestamp in nanoseconds */
18 : u16 text_len; /* length of text message */
19 : u8 facility; /* syslog facility */
20 : u8 flags:5; /* internal record flags */
21 : u8 level:3; /* syslog level */
22 : u32 caller_id; /* thread id or processor id */
23 :
24 : struct dev_printk_info dev_info;
25 : };
26 :
27 : /*
28 : * A structure providing the buffers, used by writers and readers.
29 : *
30 : * Writers:
31 : * Using prb_rec_init_wr(), a writer sets @text_buf_size before calling
32 : * prb_reserve(). On success, prb_reserve() sets @info and @text_buf to
33 : * buffers reserved for that writer.
34 : *
35 : * Readers:
36 : * Using prb_rec_init_rd(), a reader sets all fields before calling
37 : * prb_read_valid(). Note that the reader provides the @info and @text_buf,
38 : * buffers. On success, the struct pointed to by @info will be filled and
39 : * the char array pointed to by @text_buf will be filled with text data.
40 : */
41 : struct printk_record {
42 : struct printk_info *info;
43 : char *text_buf;
44 : unsigned int text_buf_size;
45 : };
46 :
47 : /* Specifies the logical position and span of a data block. */
48 : struct prb_data_blk_lpos {
49 : unsigned long begin;
50 : unsigned long next;
51 : };
52 :
53 : /*
54 : * A descriptor: the complete meta-data for a record.
55 : *
56 : * @state_var: A bitwise combination of descriptor ID and descriptor state.
57 : */
58 : struct prb_desc {
59 : atomic_long_t state_var;
60 : struct prb_data_blk_lpos text_blk_lpos;
61 : };
62 :
63 : /* A ringbuffer of "ID + data" elements. */
64 : struct prb_data_ring {
65 : unsigned int size_bits;
66 : char *data;
67 : atomic_long_t head_lpos;
68 : atomic_long_t tail_lpos;
69 : };
70 :
71 : /* A ringbuffer of "struct prb_desc" elements. */
72 : struct prb_desc_ring {
73 : unsigned int count_bits;
74 : struct prb_desc *descs;
75 : struct printk_info *infos;
76 : atomic_long_t head_id;
77 : atomic_long_t tail_id;
78 : atomic_long_t last_finalized_id;
79 : };
80 :
81 : /*
82 : * The high level structure representing the printk ringbuffer.
83 : *
84 : * @fail: Count of failed prb_reserve() calls where not even a data-less
85 : * record was created.
86 : */
87 : struct printk_ringbuffer {
88 : struct prb_desc_ring desc_ring;
89 : struct prb_data_ring text_data_ring;
90 : atomic_long_t fail;
91 : };
92 :
93 : /*
94 : * Used by writers as a reserve/commit handle.
95 : *
96 : * @rb: Ringbuffer where the entry is reserved.
97 : * @irqflags: Saved irq flags to restore on entry commit.
98 : * @id: ID of the reserved descriptor.
99 : * @text_space: Total occupied buffer space in the text data ring, including
100 : * ID, alignment padding, and wrapping data blocks.
101 : *
102 : * This structure is an opaque handle for writers. Its contents are only
103 : * to be used by the ringbuffer implementation.
104 : */
105 : struct prb_reserved_entry {
106 : struct printk_ringbuffer *rb;
107 : unsigned long irqflags;
108 : unsigned long id;
109 : unsigned int text_space;
110 : };
111 :
112 : /* The possible responses of a descriptor state-query. */
113 : enum desc_state {
114 : desc_miss = -1, /* ID mismatch (pseudo state) */
115 : desc_reserved = 0x0, /* reserved, in use by writer */
116 : desc_committed = 0x1, /* committed by writer, could get reopened */
117 : desc_finalized = 0x2, /* committed, no further modification allowed */
118 : desc_reusable = 0x3, /* free, not yet used by any writer */
119 : };
120 :
121 : #define _DATA_SIZE(sz_bits) (1UL << (sz_bits))
122 : #define _DESCS_COUNT(ct_bits) (1U << (ct_bits))
123 : #define DESC_SV_BITS (sizeof(unsigned long) * 8)
124 : #define DESC_FLAGS_SHIFT (DESC_SV_BITS - 2)
125 : #define DESC_FLAGS_MASK (3UL << DESC_FLAGS_SHIFT)
126 : #define DESC_STATE(sv) (3UL & (sv >> DESC_FLAGS_SHIFT))
127 : #define DESC_SV(id, state) (((unsigned long)state << DESC_FLAGS_SHIFT) | id)
128 : #define DESC_ID_MASK (~DESC_FLAGS_MASK)
129 : #define DESC_ID(sv) ((sv) & DESC_ID_MASK)
130 : #define FAILED_LPOS 0x1
131 : #define NO_LPOS 0x3
132 :
133 : #define FAILED_BLK_LPOS \
134 : { \
135 : .begin = FAILED_LPOS, \
136 : .next = FAILED_LPOS, \
137 : }
138 :
139 : /*
140 : * Descriptor Bootstrap
141 : *
142 : * The descriptor array is minimally initialized to allow immediate usage
143 : * by readers and writers. The requirements that the descriptor array
144 : * initialization must satisfy:
145 : *
146 : * Req1
147 : * The tail must point to an existing (committed or reusable) descriptor.
148 : * This is required by the implementation of prb_first_seq().
149 : *
150 : * Req2
151 : * Readers must see that the ringbuffer is initially empty.
152 : *
153 : * Req3
154 : * The first record reserved by a writer is assigned sequence number 0.
155 : *
156 : * To satisfy Req1, the tail initially points to a descriptor that is
157 : * minimally initialized (having no data block, i.e. data-less with the
158 : * data block's lpos @begin and @next values set to FAILED_LPOS).
159 : *
160 : * To satisfy Req2, the initial tail descriptor is initialized to the
161 : * reusable state. Readers recognize reusable descriptors as existing
162 : * records, but skip over them.
163 : *
164 : * To satisfy Req3, the last descriptor in the array is used as the initial
165 : * head (and tail) descriptor. This allows the first record reserved by a
166 : * writer (head + 1) to be the first descriptor in the array. (Only the first
167 : * descriptor in the array could have a valid sequence number of 0.)
168 : *
169 : * The first time a descriptor is reserved, it is assigned a sequence number
170 : * with the value of the array index. A "first time reserved" descriptor can
171 : * be recognized because it has a sequence number of 0 but does not have an
172 : * index of 0. (Only the first descriptor in the array could have a valid
173 : * sequence number of 0.) After the first reservation, all future reservations
174 : * (recycling) simply involve incrementing the sequence number by the array
175 : * count.
176 : *
177 : * Hack #1
178 : * Only the first descriptor in the array is allowed to have the sequence
179 : * number 0. In this case it is not possible to recognize if it is being
180 : * reserved the first time (set to index value) or has been reserved
181 : * previously (increment by the array count). This is handled by _always_
182 : * incrementing the sequence number by the array count when reserving the
183 : * first descriptor in the array. In order to satisfy Req3, the sequence
184 : * number of the first descriptor in the array is initialized to minus
185 : * the array count. Then, upon the first reservation, it is incremented
186 : * to 0, thus satisfying Req3.
187 : *
188 : * Hack #2
189 : * prb_first_seq() can be called at any time by readers to retrieve the
190 : * sequence number of the tail descriptor. However, due to Req2 and Req3,
191 : * initially there are no records to report the sequence number of
192 : * (sequence numbers are u64 and there is nothing less than 0). To handle
193 : * this, the sequence number of the initial tail descriptor is initialized
194 : * to 0. Technically this is incorrect, because there is no record with
195 : * sequence number 0 (yet) and the tail descriptor is not the first
196 : * descriptor in the array. But it allows prb_read_valid() to correctly
197 : * report the existence of a record for _any_ given sequence number at all
198 : * times. Bootstrapping is complete when the tail is pushed the first
199 : * time, thus finally pointing to the first descriptor reserved by a
200 : * writer, which has the assigned sequence number 0.
201 : */
202 :
203 : /*
204 : * Initiating Logical Value Overflows
205 : *
206 : * Both logical position (lpos) and ID values can be mapped to array indexes
207 : * but may experience overflows during the lifetime of the system. To ensure
208 : * that printk_ringbuffer can handle the overflows for these types, initial
209 : * values are chosen that map to the correct initial array indexes, but will
210 : * result in overflows soon.
211 : *
212 : * BLK0_LPOS
213 : * The initial @head_lpos and @tail_lpos for data rings. It is at index
214 : * 0 and the lpos value is such that it will overflow on the first wrap.
215 : *
216 : * DESC0_ID
217 : * The initial @head_id and @tail_id for the desc ring. It is at the last
218 : * index of the descriptor array (see Req3 above) and the ID value is such
219 : * that it will overflow on the second wrap.
220 : */
221 : #define BLK0_LPOS(sz_bits) (-(_DATA_SIZE(sz_bits)))
222 : #define DESC0_ID(ct_bits) DESC_ID(-(_DESCS_COUNT(ct_bits) + 1))
223 : #define DESC0_SV(ct_bits) DESC_SV(DESC0_ID(ct_bits), desc_reusable)
224 :
225 : /*
226 : * Define a ringbuffer with an external text data buffer. The same as
227 : * DEFINE_PRINTKRB() but requires specifying an external buffer for the
228 : * text data.
229 : *
230 : * Note: The specified external buffer must be of the size:
231 : * 2 ^ (descbits + avgtextbits)
232 : */
233 : #define _DEFINE_PRINTKRB(name, descbits, avgtextbits, text_buf) \
234 : static struct prb_desc _##name##_descs[_DESCS_COUNT(descbits)] = { \
235 : /* the initial head and tail */ \
236 : [_DESCS_COUNT(descbits) - 1] = { \
237 : /* reusable */ \
238 : .state_var = ATOMIC_INIT(DESC0_SV(descbits)), \
239 : /* no associated data block */ \
240 : .text_blk_lpos = FAILED_BLK_LPOS, \
241 : }, \
242 : }; \
243 : static struct printk_info _##name##_infos[_DESCS_COUNT(descbits)] = { \
244 : /* this will be the first record reserved by a writer */ \
245 : [0] = { \
246 : /* will be incremented to 0 on the first reservation */ \
247 : .seq = -(u64)_DESCS_COUNT(descbits), \
248 : }, \
249 : /* the initial head and tail */ \
250 : [_DESCS_COUNT(descbits) - 1] = { \
251 : /* reports the first seq value during the bootstrap phase */ \
252 : .seq = 0, \
253 : }, \
254 : }; \
255 : static struct printk_ringbuffer name = { \
256 : .desc_ring = { \
257 : .count_bits = descbits, \
258 : .descs = &_##name##_descs[0], \
259 : .infos = &_##name##_infos[0], \
260 : .head_id = ATOMIC_INIT(DESC0_ID(descbits)), \
261 : .tail_id = ATOMIC_INIT(DESC0_ID(descbits)), \
262 : .last_finalized_id = ATOMIC_INIT(DESC0_ID(descbits)), \
263 : }, \
264 : .text_data_ring = { \
265 : .size_bits = (avgtextbits) + (descbits), \
266 : .data = text_buf, \
267 : .head_lpos = ATOMIC_LONG_INIT(BLK0_LPOS((avgtextbits) + (descbits))), \
268 : .tail_lpos = ATOMIC_LONG_INIT(BLK0_LPOS((avgtextbits) + (descbits))), \
269 : }, \
270 : .fail = ATOMIC_LONG_INIT(0), \
271 : }
272 :
273 : /**
274 : * DEFINE_PRINTKRB() - Define a ringbuffer.
275 : *
276 : * @name: The name of the ringbuffer variable.
277 : * @descbits: The number of descriptors as a power-of-2 value.
278 : * @avgtextbits: The average text data size per record as a power-of-2 value.
279 : *
280 : * This is a macro for defining a ringbuffer and all internal structures
281 : * such that it is ready for immediate use. See _DEFINE_PRINTKRB() for a
282 : * variant where the text data buffer can be specified externally.
283 : */
284 : #define DEFINE_PRINTKRB(name, descbits, avgtextbits) \
285 : static char _##name##_text[1U << ((avgtextbits) + (descbits))] \
286 : __aligned(__alignof__(unsigned long)); \
287 : _DEFINE_PRINTKRB(name, descbits, avgtextbits, &_##name##_text[0])
288 :
289 : /* Writer Interface */
290 :
291 : /**
292 : * prb_rec_init_wr() - Initialize a buffer for writing records.
293 : *
294 : * @r: The record to initialize.
295 : * @text_buf_size: The needed text buffer size.
296 : */
297 : static inline void prb_rec_init_wr(struct printk_record *r,
298 : unsigned int text_buf_size)
299 : {
300 979 : r->info = NULL;
301 979 : r->text_buf = NULL;
302 979 : r->text_buf_size = text_buf_size;
303 : }
304 :
305 : bool prb_reserve(struct prb_reserved_entry *e, struct printk_ringbuffer *rb,
306 : struct printk_record *r);
307 : bool prb_reserve_in_last(struct prb_reserved_entry *e, struct printk_ringbuffer *rb,
308 : struct printk_record *r, u32 caller_id, unsigned int max_size);
309 : void prb_commit(struct prb_reserved_entry *e);
310 : void prb_final_commit(struct prb_reserved_entry *e);
311 :
312 : void prb_init(struct printk_ringbuffer *rb,
313 : char *text_buf, unsigned int text_buf_size,
314 : struct prb_desc *descs, unsigned int descs_count_bits,
315 : struct printk_info *infos);
316 : unsigned int prb_record_text_space(struct prb_reserved_entry *e);
317 :
318 : /* Reader Interface */
319 :
320 : /**
321 : * prb_rec_init_rd() - Initialize a buffer for reading records.
322 : *
323 : * @r: The record to initialize.
324 : * @info: A buffer to store record meta-data.
325 : * @text_buf: A buffer to store text data.
326 : * @text_buf_size: The size of @text_buf.
327 : *
328 : * Initialize all the fields that a reader is interested in. All arguments
329 : * (except @r) are optional. Only record data for arguments that are
330 : * non-NULL or non-zero will be read.
331 : */
332 : static inline void prb_rec_init_rd(struct printk_record *r,
333 : struct printk_info *info,
334 : char *text_buf, unsigned int text_buf_size)
335 : {
336 3366 : r->info = info;
337 3366 : r->text_buf = text_buf;
338 3366 : r->text_buf_size = text_buf_size;
339 : }
340 :
341 : /**
342 : * prb_for_each_record() - Iterate over the records of a ringbuffer.
343 : *
344 : * @from: The sequence number to begin with.
345 : * @rb: The ringbuffer to iterate over.
346 : * @s: A u64 to store the sequence number on each iteration.
347 : * @r: A printk_record to store the record on each iteration.
348 : *
349 : * This is a macro for conveniently iterating over a ringbuffer.
350 : * Note that @s may not be the sequence number of the record on each
351 : * iteration. For the sequence number, @r->info->seq should be checked.
352 : *
353 : * Context: Any context.
354 : */
355 : #define prb_for_each_record(from, rb, s, r) \
356 : for ((s) = from; prb_read_valid(rb, s, r); (s) = (r)->info->seq + 1)
357 :
358 : /**
359 : * prb_for_each_info() - Iterate over the meta data of a ringbuffer.
360 : *
361 : * @from: The sequence number to begin with.
362 : * @rb: The ringbuffer to iterate over.
363 : * @s: A u64 to store the sequence number on each iteration.
364 : * @i: A printk_info to store the record meta data on each iteration.
365 : * @lc: An unsigned int to store the text line count of each record.
366 : *
367 : * This is a macro for conveniently iterating over a ringbuffer.
368 : * Note that @s may not be the sequence number of the record on each
369 : * iteration. For the sequence number, @r->info->seq should be checked.
370 : *
371 : * Context: Any context.
372 : */
373 : #define prb_for_each_info(from, rb, s, i, lc) \
374 : for ((s) = from; prb_read_valid_info(rb, s, i, lc); (s) = (i)->seq + 1)
375 :
376 : bool prb_read_valid(struct printk_ringbuffer *rb, u64 seq,
377 : struct printk_record *r);
378 : bool prb_read_valid_info(struct printk_ringbuffer *rb, u64 seq,
379 : struct printk_info *info, unsigned int *line_count);
380 :
381 : u64 prb_first_valid_seq(struct printk_ringbuffer *rb);
382 : u64 prb_next_seq(struct printk_ringbuffer *rb);
383 :
384 : #endif /* _KERNEL_PRINTK_RINGBUFFER_H */
|
