kernel/printk/internal.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * internal.h - printk internal definitions
   4  */
   5 #include <linux/console.h>
   6 #include <linux/percpu.h>
   7 #include <linux/types.h>
   8
   9 #if defined(CONFIG_PRINTK) && defined(CONFIG_SYSCTL)
  10 struct ctl_table;
  11 void __init printk_sysctl_init(void);
  12 int devkmsg_sysctl_set_loglvl(const struct ctl_table *table, int write,
  13                               void *buffer, size_t *lenp, loff_t *ppos);
  14 #else
  15 #define printk_sysctl_init() do { } while (0)
  16 #endif
  17
  18 #define con_printk(lvl, con, fmt, ...)                          \
  19         printk(lvl pr_fmt("%s%sconsole [%s%d] " fmt),           \
  20                 (con->flags & CON_NBCON) ? "" : "legacy ",      \
  21                 (con->flags & CON_BOOT) ? "boot" : "",          \
  22                 con->name, con->index, ##__VA_ARGS__)
  23
  24 /*
  25  * Identify if legacy printing is forced in a dedicated kthread. If
  26  * true, all printing via console lock occurs within a dedicated
  27  * legacy printer thread. The only exception is on panic, after the
  28  * nbcon consoles have had their chance to print the panic messages
  29  * first.
  30  */
  31 #ifdef CONFIG_PREEMPT_RT
  32 # define force_legacy_kthread() (true)
  33 #else
  34 # define force_legacy_kthread() (false)
  35 #endif
  36
  37 #ifdef CONFIG_PRINTK
  38
  39 #ifdef CONFIG_PRINTK_CALLER
  40 #define PRINTK_PREFIX_MAX       48
  41 #else
  42 #define PRINTK_PREFIX_MAX       32
  43 #endif
  44
  45 /*
  46  * the maximum size of a formatted record (i.e. with prefix added
  47  * per line and dropped messages or in extended message format)
  48  */
  49 #define PRINTK_MESSAGE_MAX      2048
  50
  51 /* the maximum size allowed to be reserved for a record */
  52 #define PRINTKRB_RECORD_MAX     1024
  53
  54 /* Flags for a single printk record. */
  55 enum printk_info_flags {
  56         /* always show on console, ignore console_loglevel */
  57         LOG_FORCE_CON   = 1,
  58         LOG_NEWLINE     = 2,    /* text ended with a newline */
  59         LOG_CONT        = 8,    /* text is a fragment of a continuation line */
  60 };
  61
  62 struct printk_ringbuffer;
  63 struct dev_printk_info;
  64
  65 extern struct printk_ringbuffer *prb;
  66 extern bool printk_kthreads_running;
  67
  68 __printf(4, 0)
  69 int vprintk_store(int facility, int level,
  70                   const struct dev_printk_info *dev_info,
  71                   const char *fmt, va_list args);
  72
  73 __printf(1, 0) int vprintk_default(const char *fmt, va_list args);
  74 __printf(1, 0) int vprintk_deferred(const char *fmt, va_list args);
  75
  76 void __printk_safe_enter(void);
  77 void __printk_safe_exit(void);
  78
  79 bool printk_percpu_data_ready(void);
  80
  81 #define printk_safe_enter_irqsave(flags)        \
  82         do {                                    \
  83                 local_irq_save(flags);          \
  84                 __printk_safe_enter();          \
  85         } while (0)
  86
  87 #define printk_safe_exit_irqrestore(flags)      \
  88         do {                                    \
  89                 __printk_safe_exit();           \
  90                 local_irq_restore(flags);       \
  91         } while (0)
  92
  93 void defer_console_output(void);
  94 bool is_printk_legacy_deferred(void);
  95 bool is_printk_force_console(void);
  96
  97 u16 printk_parse_prefix(const char *text, int *level,
  98                         enum printk_info_flags *flags);
  99 void console_lock_spinning_enable(void);
 100 int console_lock_spinning_disable_and_check(int cookie);
 101
 102 u64 nbcon_seq_read(struct console *con);
 103 void nbcon_seq_force(struct console *con, u64 seq);
 104 bool nbcon_alloc(struct console *con);
 105 void nbcon_free(struct console *con);
 106 enum nbcon_prio nbcon_get_default_prio(void);
 107 void nbcon_atomic_flush_pending(void);
 108 bool nbcon_legacy_emit_next_record(struct console *con, bool *handover,
 109                                    int cookie, bool use_atomic);
 110 bool nbcon_kthread_create(struct console *con);
 111 void nbcon_kthread_stop(struct console *con);
 112 void nbcon_kthreads_wake(void);
 113
 114 /*
 115  * Check if the given console is currently capable and allowed to print
 116  * records. Note that this function does not consider the current context,
 117  * which can also play a role in deciding if @con can be used to print
 118  * records.
 119  */
 120 static inline bool console_is_usable(struct console *con, short flags, bool use_atomic)
 121 {
 122         if (!(flags & CON_ENABLED))
 123                 return false;
 124
 125         if ((flags & CON_SUSPENDED))
 126                 return false;
 127
 128         if (flags & CON_NBCON) {
 129                 /* The write_atomic() callback is optional. */
 130                 if (use_atomic && !con->write_atomic)
 131                         return false;
 132
 133                 /*
 134                  * For the !use_atomic case, @printk_kthreads_running is not
 135                  * checked because the write_thread() callback is also used
 136                  * via the legacy loop when the printer threads are not
 137                  * available.
 138                  */
 139         } else {
 140                 if (!con->write)
 141                         return false;
 142         }
 143
 144         /*
 145          * Console drivers may assume that per-cpu resources have been
 146          * allocated. So unless they're explicitly marked as being able to
 147          * cope (CON_ANYTIME) don't call them until this CPU is officially up.
 148          */
 149         if (!cpu_online(raw_smp_processor_id()) && !(flags & CON_ANYTIME))
 150                 return false;
 151
 152         return true;
 153 }
 154
 155 /**
 156  * nbcon_kthread_wake - Wake up a console printing thread
 157  * @con:        Console to operate on
 158  */
 159 static inline void nbcon_kthread_wake(struct console *con)
 160 {
 161         /*
 162          * Guarantee any new records can be seen by tasks preparing to wait
 163          * before this context checks if the rcuwait is empty.
 164          *
 165          * The full memory barrier in rcuwait_wake_up() pairs with the full
 166          * memory barrier within set_current_state() of
 167          * ___rcuwait_wait_event(), which is called after prepare_to_rcuwait()
 168          * adds the waiter but before it has checked the wait condition.
 169          *
 170          * This pairs with nbcon_kthread_func:A.
 171          */
 172         rcuwait_wake_up(&con->rcuwait); /* LMM(nbcon_kthread_wake:A) */
 173 }
 174
 175 #else
 176
 177 #define PRINTK_PREFIX_MAX       0
 178 #define PRINTK_MESSAGE_MAX      0
 179 #define PRINTKRB_RECORD_MAX     0
 180
 181 #define printk_kthreads_running (false)
 182
 183 /*
 184  * In !PRINTK builds we still export console_sem
 185  * semaphore and some of console functions (console_unlock()/etc.), so
 186  * printk-safe must preserve the existing local IRQ guarantees.
 187  */
 188 #define printk_safe_enter_irqsave(flags) local_irq_save(flags)
 189 #define printk_safe_exit_irqrestore(flags) local_irq_restore(flags)
 190
 191 static inline bool printk_percpu_data_ready(void) { return false; }
 192 static inline void defer_console_output(void) { }
 193 static inline bool is_printk_legacy_deferred(void) { return false; }
 194 static inline u64 nbcon_seq_read(struct console *con) { return 0; }
 195 static inline void nbcon_seq_force(struct console *con, u64 seq) { }
 196 static inline bool nbcon_alloc(struct console *con) { return false; }
 197 static inline void nbcon_free(struct console *con) { }
 198 static inline enum nbcon_prio nbcon_get_default_prio(void) { return NBCON_PRIO_NONE; }
 199 static inline void nbcon_atomic_flush_pending(void) { }
 200 static inline bool nbcon_legacy_emit_next_record(struct console *con, bool *handover,
 201                                                  int cookie, bool use_atomic) { return false; }
 202 static inline void nbcon_kthread_wake(struct console *con) { }
 203 static inline void nbcon_kthreads_wake(void) { }
 204
 205 static inline bool console_is_usable(struct console *con, short flags,
 206                                      bool use_atomic) { return false; }
 207
 208 #endif /* CONFIG_PRINTK */
 209
 210 extern bool have_boot_console;
 211 extern bool have_nbcon_console;
 212 extern bool have_legacy_console;
 213 extern bool legacy_allow_panic_sync;
 214
 215 /**
 216  * struct console_flush_type - Define available console flush methods
 217  * @nbcon_atomic:       Flush directly using nbcon_atomic() callback
 218  * @nbcon_offload:      Offload flush to printer thread
 219  * @legacy_direct:      Call the legacy loop in this context
 220  * @legacy_offload:     Offload the legacy loop into IRQ or legacy thread
 221  *
 222  * Note that the legacy loop also flushes the nbcon consoles.
 223  */
 224 struct console_flush_type {
 225         bool    nbcon_atomic;
 226         bool    nbcon_offload;
 227         bool    legacy_direct;
 228         bool    legacy_offload;
 229 };
 230
 231 /*
 232  * Identify which console flushing methods should be used in the context of
 233  * the caller.
 234  */
 235 static inline void printk_get_console_flush_type(struct console_flush_type *ft)
 236 {
 237         memset(ft, 0, sizeof(*ft));
 238
 239         switch (nbcon_get_default_prio()) {
 240         case NBCON_PRIO_NORMAL:
 241                 if (have_nbcon_console && !have_boot_console) {
 242                         if (printk_kthreads_running)
 243                                 ft->nbcon_offload = true;
 244                         else
 245                                 ft->nbcon_atomic = true;
 246                 }
 247
 248                 /* Legacy consoles are flushed directly when possible. */
 249                 if (have_legacy_console || have_boot_console) {
 250                         if (!is_printk_legacy_deferred())
 251                                 ft->legacy_direct = true;
 252                         else
 253                                 ft->legacy_offload = true;
 254                 }
 255                 break;
 256
 257         case NBCON_PRIO_EMERGENCY:
 258                 if (have_nbcon_console && !have_boot_console)
 259                         ft->nbcon_atomic = true;
 260
 261                 /* Legacy consoles are flushed directly when possible. */
 262                 if (have_legacy_console || have_boot_console) {
 263                         if (!is_printk_legacy_deferred())
 264                                 ft->legacy_direct = true;
 265                         else
 266                                 ft->legacy_offload = true;
 267                 }
 268                 break;
 269
 270         case NBCON_PRIO_PANIC:
 271                 /*
 272                  * In panic, the nbcon consoles will directly print. But
 273                  * only allowed if there are no boot consoles.
 274                  */
 275                 if (have_nbcon_console && !have_boot_console)
 276                         ft->nbcon_atomic = true;
 277
 278                 if (have_legacy_console || have_boot_console) {
 279                         /*
 280                          * This is the same decision as NBCON_PRIO_NORMAL
 281                          * except that offloading never occurs in panic.
 282                          *
 283                          * Note that console_flush_on_panic() will flush
 284                          * legacy consoles anyway, even if unsafe.
 285                          */
 286                         if (!is_printk_legacy_deferred())
 287                                 ft->legacy_direct = true;
 288
 289                         /*
 290                          * In panic, if nbcon atomic printing occurs,
 291                          * the legacy consoles must remain silent until
 292                          * explicitly allowed.
 293                          */
 294                         if (ft->nbcon_atomic && !legacy_allow_panic_sync)
 295                                 ft->legacy_direct = false;
 296                 }
 297                 break;
 298
 299         default:
 300                 WARN_ON_ONCE(1);
 301                 break;
 302         }
 303 }
 304
 305 extern struct printk_buffers printk_shared_pbufs;
 306
 307 /**
 308  * struct printk_buffers - Buffers to read/format/output printk messages.
 309  * @outbuf:     After formatting, contains text to output.
 310  * @scratchbuf: Used as temporary ringbuffer reading and string-print space.
 311  */
 312 struct printk_buffers {
 313         char    outbuf[PRINTK_MESSAGE_MAX];
 314         char    scratchbuf[PRINTKRB_RECORD_MAX];
 315 };
 316
 317 /**
 318  * struct printk_message - Container for a prepared printk message.
 319  * @pbufs:      printk buffers used to prepare the message.
 320  * @outbuf_len: The length of prepared text in @pbufs->outbuf to output. This
 321  *              does not count the terminator. A value of 0 means there is
 322  *              nothing to output and this record should be skipped.
 323  * @seq:        The sequence number of the record used for @pbufs->outbuf.
 324  * @dropped:    The number of dropped records from reading @seq.
 325  */
 326 struct printk_message {
 327         struct printk_buffers   *pbufs;
 328         unsigned int            outbuf_len;
 329         u64                     seq;
 330         unsigned long           dropped;
 331 };
 332
 333 bool other_cpu_in_panic(void);
 334 bool printk_get_next_message(struct printk_message *pmsg, u64 seq,
 335                              bool is_extended, bool may_supress);
 336
 337 #ifdef CONFIG_PRINTK
 338 void console_prepend_dropped(struct printk_message *pmsg, unsigned long dropped);
 339 void console_prepend_replay(struct printk_message *pmsg);
 340 #endif