kernel/printk/printk_ringbuffer.h

   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         r->info = NULL;
 301         r->text_buf = NULL;
 302         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         r->info = info;
 337         r->text_buf = text_buf;
 338         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 */