LCOV - code coverage report
Current view: top level - kernel/printk - printk_ringbuffer.h (source / functions) Hit Total Coverage
Test: landlock.info Lines: 9 9 100.0 %
Date: 2021-04-22 12:43:58 Functions: 0 0 -

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

Generated by: LCOV version 1.14