root/kernel/printk/printk.c

DEFINITIONS

1. __control_devkmsg
2. control_devkmsg
3. devkmsg_sysctl_set_loglvl
4. __down_trylock_console_sem
5. __up_console_sem
6. printk_percpu_data_ready
7. log_buf_addr_get
8. log_buf_len_get
9. log_text
10. log_dict
11. log_from_idx
12. log_next
13. logbuf_has_space
14. log_make_free_space
15. msg_used_size
16. truncate_msg
17. log_store
18. syslog_action_restricted
19. check_syslog_permissions
20. append_char
21. msg_print_ext_header
22. msg_print_ext_body
23. __printf
24. devkmsg_write
25. devkmsg_read
26. devkmsg_llseek
27. devkmsg_poll
28. devkmsg_open
29. devkmsg_release
30. log_buf_vmcoreinfo_setup
31. log_buf_len_update
32. log_buf_len_setup
33. log_buf_add_cpu
34. log_buf_add_cpu
35. set_percpu_data_ready
36. setup_log_buf
37. ignore_loglevel_setup
38. suppress_message_printing
39. boot_delay_setup
40. boot_delay_msec
41. boot_delay_msec
42. print_syslog
43. print_time
44. print_caller
45. print_prefix
46. msg_print_text
47. syslog_print
48. syslog_print_all
49. syslog_clear
50. do_syslog
51. SYSCALL_DEFINE3
52. console_lock_spinning_enable
53. console_lock_spinning_disable_and_check
54. console_trylock_spinning
55. call_console_drivers
56. printk_delay
57. printk_caller_id
58. cont_flush
59. cont_add
60. log_output
61. vprintk_store
62. vprintk_emit
63. vprintk
64. vprintk_default
65. printk
66. log_text
67. log_dict
68. log_from_idx
69. log_next
70. msg_print_ext_header
71. msg_print_ext_body
72. console_lock_spinning_enable
73. console_lock_spinning_disable_and_check
74. call_console_drivers
75. msg_print_text
76. suppress_message_printing
77. early_printk
78. __add_preferred_console
79. console_msg_format_setup
80. console_setup
81. add_preferred_console
82. console_suspend_disable
83. suspend_console
84. resume_console
85. console_cpu_notify
86. console_lock
87. console_trylock
88. is_console_locked
89. have_callable_console
90. can_use_console
91. console_unlock
92. console_conditional_schedule
93. console_unblank
94. console_flush_on_panic
95. console_device
96. console_stop
97. console_start
98. keep_bootcon_setup
99. register_console
100. unregister_console
101. console_init
102. printk_late_init
103. wake_up_klogd_work_func
104. wake_up_klogd
105. defer_console_output
106. vprintk_deferred
107. printk_deferred
108. __printk_ratelimit
109. printk_timed_ratelimit
110. kmsg_dump_register
111. kmsg_dump_unregister
112. kmsg_dump
113. kmsg_dump_get_line_nolock
114. kmsg_dump_get_line
115. kmsg_dump_get_buffer
116. kmsg_dump_rewind_nolock
117. kmsg_dump_rewind

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/kernel/printk.c
   4  *
   5  *  Copyright (C) 1991, 1992  Linus Torvalds
   6  *
   7  * Modified to make sys_syslog() more flexible: added commands to
   8  * return the last 4k of kernel messages, regardless of whether
   9  * they've been read or not.  Added option to suppress kernel printk's
  10  * to the console.  Added hook for sending the console messages
  11  * elsewhere, in preparation for a serial line console (someday).
  12  * Ted Ts'o, 2/11/93.
  13  * Modified for sysctl support, 1/8/97, Chris Horn.
  14  * Fixed SMP synchronization, 08/08/99, Manfred Spraul
  15  *     manfred@colorfullife.com
  16  * Rewrote bits to get rid of console_lock
  17  *      01Mar01 Andrew Morton
  18  */
  19 
  20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21 
  22 #include <linux/kernel.h>
  23 #include <linux/mm.h>
  24 #include <linux/tty.h>
  25 #include <linux/tty_driver.h>
  26 #include <linux/console.h>
  27 #include <linux/init.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/nmi.h>
  30 #include <linux/module.h>
  31 #include <linux/moduleparam.h>
  32 #include <linux/delay.h>
  33 #include <linux/smp.h>
  34 #include <linux/security.h>
  35 #include <linux/memblock.h>
  36 #include <linux/syscalls.h>
  37 #include <linux/crash_core.h>
  38 #include <linux/kdb.h>
  39 #include <linux/ratelimit.h>
  40 #include <linux/kmsg_dump.h>
  41 #include <linux/syslog.h>
  42 #include <linux/cpu.h>
  43 #include <linux/rculist.h>
  44 #include <linux/poll.h>
  45 #include <linux/irq_work.h>
  46 #include <linux/ctype.h>
  47 #include <linux/uio.h>
  48 #include <linux/sched/clock.h>
  49 #include <linux/sched/debug.h>
  50 #include <linux/sched/task_stack.h>
  51 
  52 #include <linux/uaccess.h>
  53 #include <asm/sections.h>
  54 
  55 #include <trace/events/initcall.h>
  56 #define CREATE_TRACE_POINTS
  57 #include <trace/events/printk.h>
  58 
  59 #include "console_cmdline.h"
  60 #include "braille.h"
  61 #include "internal.h"
  62 
  63 int console_printk[4] = {
  64         CONSOLE_LOGLEVEL_DEFAULT,       /* console_loglevel */
  65         MESSAGE_LOGLEVEL_DEFAULT,       /* default_message_loglevel */
  66         CONSOLE_LOGLEVEL_MIN,           /* minimum_console_loglevel */
  67         CONSOLE_LOGLEVEL_DEFAULT,       /* default_console_loglevel */
  68 };
  69 EXPORT_SYMBOL_GPL(console_printk);
  70 
  71 atomic_t ignore_console_lock_warning __read_mostly = ATOMIC_INIT(0);
  72 EXPORT_SYMBOL(ignore_console_lock_warning);
  73 
  74 /*
  75  * Low level drivers may need that to know if they can schedule in
  76  * their unblank() callback or not. So let's export it.
  77  */
  78 int oops_in_progress;
  79 EXPORT_SYMBOL(oops_in_progress);
  80 
  81 /*
  82  * console_sem protects the console_drivers list, and also
  83  * provides serialisation for access to the entire console
  84  * driver system.
  85  */
  86 static DEFINE_SEMAPHORE(console_sem);
  87 struct console *console_drivers;
  88 EXPORT_SYMBOL_GPL(console_drivers);
  89 
  90 /*
  91  * System may need to suppress printk message under certain
  92  * circumstances, like after kernel panic happens.
  93  */
  94 int __read_mostly suppress_printk;
  95 
  96 #ifdef CONFIG_LOCKDEP
  97 static struct lockdep_map console_lock_dep_map = {
  98         .name = "console_lock"
  99 };
 100 #endif
 101 
 102 enum devkmsg_log_bits {
 103         __DEVKMSG_LOG_BIT_ON = 0,
 104         __DEVKMSG_LOG_BIT_OFF,
 105         __DEVKMSG_LOG_BIT_LOCK,
 106 };
 107 
 108 enum devkmsg_log_masks {
 109         DEVKMSG_LOG_MASK_ON             = BIT(__DEVKMSG_LOG_BIT_ON),
 110         DEVKMSG_LOG_MASK_OFF            = BIT(__DEVKMSG_LOG_BIT_OFF),
 111         DEVKMSG_LOG_MASK_LOCK           = BIT(__DEVKMSG_LOG_BIT_LOCK),
 112 };
 113 
 114 /* Keep both the 'on' and 'off' bits clear, i.e. ratelimit by default: */
 115 #define DEVKMSG_LOG_MASK_DEFAULT        0
 116 
 117 static unsigned int __read_mostly devkmsg_log = DEVKMSG_LOG_MASK_DEFAULT;
 118 
 119 static int __control_devkmsg(char *str)
 120 {
 121         size_t len;
 122 
 123         if (!str)
 124                 return -EINVAL;
 125 
 126         len = str_has_prefix(str, "on");
 127         if (len) {
 128                 devkmsg_log = DEVKMSG_LOG_MASK_ON;
 129                 return len;
 130         }
 131 
 132         len = str_has_prefix(str, "off");
 133         if (len) {
 134                 devkmsg_log = DEVKMSG_LOG_MASK_OFF;
 135                 return len;
 136         }
 137 
 138         len = str_has_prefix(str, "ratelimit");
 139         if (len) {
 140                 devkmsg_log = DEVKMSG_LOG_MASK_DEFAULT;
 141                 return len;
 142         }
 143 
 144         return -EINVAL;
 145 }
 146 
 147 static int __init control_devkmsg(char *str)
 148 {
 149         if (__control_devkmsg(str) < 0)
 150                 return 1;
 151 
 152         /*
 153          * Set sysctl string accordingly:
 154          */
 155         if (devkmsg_log == DEVKMSG_LOG_MASK_ON)
 156                 strcpy(devkmsg_log_str, "on");
 157         else if (devkmsg_log == DEVKMSG_LOG_MASK_OFF)
 158                 strcpy(devkmsg_log_str, "off");
 159         /* else "ratelimit" which is set by default. */
 160 
 161         /*
 162          * Sysctl cannot change it anymore. The kernel command line setting of
 163          * this parameter is to force the setting to be permanent throughout the
 164          * runtime of the system. This is a precation measure against userspace
 165          * trying to be a smarta** and attempting to change it up on us.
 166          */
 167         devkmsg_log |= DEVKMSG_LOG_MASK_LOCK;
 168 
 169         return 0;
 170 }
 171 __setup("printk.devkmsg=", control_devkmsg);
 172 
 173 char devkmsg_log_str[DEVKMSG_STR_MAX_SIZE] = "ratelimit";
 174 
 175 int devkmsg_sysctl_set_loglvl(struct ctl_table *table, int write,
 176                               void __user *buffer, size_t *lenp, loff_t *ppos)
 177 {
 178         char old_str[DEVKMSG_STR_MAX_SIZE];
 179         unsigned int old;
 180         int err;
 181 
 182         if (write) {
 183                 if (devkmsg_log & DEVKMSG_LOG_MASK_LOCK)
 184                         return -EINVAL;
 185 
 186                 old = devkmsg_log;
 187                 strncpy(old_str, devkmsg_log_str, DEVKMSG_STR_MAX_SIZE);
 188         }
 189 
 190         err = proc_dostring(table, write, buffer, lenp, ppos);
 191         if (err)
 192                 return err;
 193 
 194         if (write) {
 195                 err = __control_devkmsg(devkmsg_log_str);
 196 
 197                 /*
 198                  * Do not accept an unknown string OR a known string with
 199                  * trailing crap...
 200                  */
 201                 if (err < 0 || (err + 1 != *lenp)) {
 202 
 203                         /* ... and restore old setting. */
 204                         devkmsg_log = old;
 205                         strncpy(devkmsg_log_str, old_str, DEVKMSG_STR_MAX_SIZE);
 206 
 207                         return -EINVAL;
 208                 }
 209         }
 210 
 211         return 0;
 212 }
 213 
 214 /* Number of registered extended console drivers. */
 215 static int nr_ext_console_drivers;
 216 
 217 /*
 218  * Helper macros to handle lockdep when locking/unlocking console_sem. We use
 219  * macros instead of functions so that _RET_IP_ contains useful information.
 220  */
 221 #define down_console_sem() do { \
 222         down(&console_sem);\
 223         mutex_acquire(&console_lock_dep_map, 0, 0, _RET_IP_);\
 224 } while (0)
 225 
 226 static int __down_trylock_console_sem(unsigned long ip)
 227 {
 228         int lock_failed;
 229         unsigned long flags;
 230 
 231         /*
 232          * Here and in __up_console_sem() we need to be in safe mode,
 233          * because spindump/WARN/etc from under console ->lock will
 234          * deadlock in printk()->down_trylock_console_sem() otherwise.
 235          */
 236         printk_safe_enter_irqsave(flags);
 237         lock_failed = down_trylock(&console_sem);
 238         printk_safe_exit_irqrestore(flags);
 239 
 240         if (lock_failed)
 241                 return 1;
 242         mutex_acquire(&console_lock_dep_map, 0, 1, ip);
 243         return 0;
 244 }
 245 #define down_trylock_console_sem() __down_trylock_console_sem(_RET_IP_)
 246 
 247 static void __up_console_sem(unsigned long ip)
 248 {
 249         unsigned long flags;
 250 
 251         mutex_release(&console_lock_dep_map, 1, ip);
 252 
 253         printk_safe_enter_irqsave(flags);
 254         up(&console_sem);
 255         printk_safe_exit_irqrestore(flags);
 256 }
 257 #define up_console_sem() __up_console_sem(_RET_IP_)
 258 
 259 /*
 260  * This is used for debugging the mess that is the VT code by
 261  * keeping track if we have the console semaphore held. It's
 262  * definitely not the perfect debug tool (we don't know if _WE_
 263  * hold it and are racing, but it helps tracking those weird code
 264  * paths in the console code where we end up in places I want
 265  * locked without the console sempahore held).
 266  */
 267 static int console_locked, console_suspended;
 268 
 269 /*
 270  * If exclusive_console is non-NULL then only this console is to be printed to.
 271  */
 272 static struct console *exclusive_console;
 273 
 274 /*
 275  *      Array of consoles built from command line options (console=)
 276  */
 277 
 278 #define MAX_CMDLINECONSOLES 8
 279 
 280 static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
 281 
 282 static int preferred_console = -1;
 283 int console_set_on_cmdline;
 284 EXPORT_SYMBOL(console_set_on_cmdline);
 285 
 286 /* Flag: console code may call schedule() */
 287 static int console_may_schedule;
 288 
 289 enum con_msg_format_flags {
 290         MSG_FORMAT_DEFAULT      = 0,
 291         MSG_FORMAT_SYSLOG       = (1 << 0),
 292 };
 293 
 294 static int console_msg_format = MSG_FORMAT_DEFAULT;
 295 
 296 /*
 297  * The printk log buffer consists of a chain of concatenated variable
 298  * length records. Every record starts with a record header, containing
 299  * the overall length of the record.
 300  *
 301  * The heads to the first and last entry in the buffer, as well as the
 302  * sequence numbers of these entries are maintained when messages are
 303  * stored.
 304  *
 305  * If the heads indicate available messages, the length in the header
 306  * tells the start next message. A length == 0 for the next message
 307  * indicates a wrap-around to the beginning of the buffer.
 308  *
 309  * Every record carries the monotonic timestamp in microseconds, as well as
 310  * the standard userspace syslog level and syslog facility. The usual
 311  * kernel messages use LOG_KERN; userspace-injected messages always carry
 312  * a matching syslog facility, by default LOG_USER. The origin of every
 313  * message can be reliably determined that way.
 314  *
 315  * The human readable log message directly follows the message header. The
 316  * length of the message text is stored in the header, the stored message
 317  * is not terminated.
 318  *
 319  * Optionally, a message can carry a dictionary of properties (key/value pairs),
 320  * to provide userspace with a machine-readable message context.
 321  *
 322  * Examples for well-defined, commonly used property names are:
 323  *   DEVICE=b12:8               device identifier
 324  *                                b12:8         block dev_t
 325  *                                c127:3        char dev_t
 326  *                                n8            netdev ifindex
 327  *                                +sound:card0  subsystem:devname
 328  *   SUBSYSTEM=pci              driver-core subsystem name
 329  *
 330  * Valid characters in property names are [a-zA-Z0-9.-_]. The plain text value
 331  * follows directly after a '=' character. Every property is terminated by
 332  * a '\0' character. The last property is not terminated.
 333  *
 334  * Example of a message structure:
 335  *   0000  ff 8f 00 00 00 00 00 00      monotonic time in nsec
 336  *   0008  34 00                        record is 52 bytes long
 337  *   000a        0b 00                  text is 11 bytes long
 338  *   000c              1f 00            dictionary is 23 bytes long
 339  *   000e                    03 00      LOG_KERN (facility) LOG_ERR (level)
 340  *   0010  69 74 27 73 20 61 20 6c      "it's a l"
 341  *         69 6e 65                     "ine"
 342  *   001b           44 45 56 49 43      "DEVIC"
 343  *         45 3d 62 38 3a 32 00 44      "E=b8:2\0D"
 344  *         52 49 56 45 52 3d 62 75      "RIVER=bu"
 345  *         67                           "g"
 346  *   0032     00 00 00                  padding to next message header
 347  *
 348  * The 'struct printk_log' buffer header must never be directly exported to
 349  * userspace, it is a kernel-private implementation detail that might
 350  * need to be changed in the future, when the requirements change.
 351  *
 352  * /dev/kmsg exports the structured data in the following line format:
 353  *   "<level>,<sequnum>,<timestamp>,<contflag>[,additional_values, ... ];<message text>\n"
 354  *
 355  * Users of the export format should ignore possible additional values
 356  * separated by ',', and find the message after the ';' character.
 357  *
 358  * The optional key/value pairs are attached as continuation lines starting
 359  * with a space character and terminated by a newline. All possible
 360  * non-prinatable characters are escaped in the "\xff" notation.
 361  */
 362 
 363 enum log_flags {
 364         LOG_NEWLINE     = 2,    /* text ended with a newline */
 365         LOG_CONT        = 8,    /* text is a fragment of a continuation line */
 366 };
 367 
 368 struct printk_log {
 369         u64 ts_nsec;            /* timestamp in nanoseconds */
 370         u16 len;                /* length of entire record */
 371         u16 text_len;           /* length of text buffer */
 372         u16 dict_len;           /* length of dictionary buffer */
 373         u8 facility;            /* syslog facility */
 374         u8 flags:5;             /* internal record flags */
 375         u8 level:3;             /* syslog level */
 376 #ifdef CONFIG_PRINTK_CALLER
 377         u32 caller_id;            /* thread id or processor id */
 378 #endif
 379 }
 380 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 381 __packed __aligned(4)
 382 #endif
 383 ;
 384 
 385 /*
 386  * The logbuf_lock protects kmsg buffer, indices, counters.  This can be taken
 387  * within the scheduler's rq lock. It must be released before calling
 388  * console_unlock() or anything else that might wake up a process.
 389  */
 390 DEFINE_RAW_SPINLOCK(logbuf_lock);
 391 
 392 /*
 393  * Helper macros to lock/unlock logbuf_lock and switch between
 394  * printk-safe/unsafe modes.
 395  */
 396 #define logbuf_lock_irq()                               \
 397         do {                                            \
 398                 printk_safe_enter_irq();                \
 399                 raw_spin_lock(&logbuf_lock);            \
 400         } while (0)
 401 
 402 #define logbuf_unlock_irq()                             \
 403         do {                                            \
 404                 raw_spin_unlock(&logbuf_lock);          \
 405                 printk_safe_exit_irq();                 \
 406         } while (0)
 407 
 408 #define logbuf_lock_irqsave(flags)                      \
 409         do {                                            \
 410                 printk_safe_enter_irqsave(flags);       \
 411                 raw_spin_lock(&logbuf_lock);            \
 412         } while (0)
 413 
 414 #define logbuf_unlock_irqrestore(flags)         \
 415         do {                                            \
 416                 raw_spin_unlock(&logbuf_lock);          \
 417                 printk_safe_exit_irqrestore(flags);     \
 418         } while (0)
 419 
 420 #ifdef CONFIG_PRINTK
 421 DECLARE_WAIT_QUEUE_HEAD(log_wait);
 422 /* the next printk record to read by syslog(READ) or /proc/kmsg */
 423 static u64 syslog_seq;
 424 static u32 syslog_idx;
 425 static size_t syslog_partial;
 426 static bool syslog_time;
 427 
 428 /* index and sequence number of the first record stored in the buffer */
 429 static u64 log_first_seq;
 430 static u32 log_first_idx;
 431 
 432 /* index and sequence number of the next record to store in the buffer */
 433 static u64 log_next_seq;
 434 static u32 log_next_idx;
 435 
 436 /* the next printk record to write to the console */
 437 static u64 console_seq;
 438 static u32 console_idx;
 439 static u64 exclusive_console_stop_seq;
 440 
 441 /* the next printk record to read after the last 'clear' command */
 442 static u64 clear_seq;
 443 static u32 clear_idx;
 444 
 445 #ifdef CONFIG_PRINTK_CALLER
 446 #define PREFIX_MAX              48
 447 #else
 448 #define PREFIX_MAX              32
 449 #endif
 450 #define LOG_LINE_MAX            (1024 - PREFIX_MAX)
 451 
 452 #define LOG_LEVEL(v)            ((v) & 0x07)
 453 #define LOG_FACILITY(v)         ((v) >> 3 & 0xff)
 454 
 455 /* record buffer */
 456 #define LOG_ALIGN __alignof__(struct printk_log)
 457 #define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
 458 #define LOG_BUF_LEN_MAX (u32)(1 << 31)
 459 static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
 460 static char *log_buf = __log_buf;
 461 static u32 log_buf_len = __LOG_BUF_LEN;
 462 
 463 /*
 464  * We cannot access per-CPU data (e.g. per-CPU flush irq_work) before
 465  * per_cpu_areas are initialised. This variable is set to true when
 466  * it's safe to access per-CPU data.
 467  */
 468 static bool __printk_percpu_data_ready __read_mostly;
 469 
 470 bool printk_percpu_data_ready(void)
 471 {
 472         return __printk_percpu_data_ready;
 473 }
 474 
 475 /* Return log buffer address */
 476 char *log_buf_addr_get(void)
 477 {
 478         return log_buf;
 479 }
 480 
 481 /* Return log buffer size */
 482 u32 log_buf_len_get(void)
 483 {
 484         return log_buf_len;
 485 }
 486 
 487 /* human readable text of the record */
 488 static char *log_text(const struct printk_log *msg)
 489 {
 490         return (char *)msg + sizeof(struct printk_log);
 491 }
 492 
 493 /* optional key/value pair dictionary attached to the record */
 494 static char *log_dict(const struct printk_log *msg)
 495 {
 496         return (char *)msg + sizeof(struct printk_log) + msg->text_len;
 497 }
 498 
 499 /* get record by index; idx must point to valid msg */
 500 static struct printk_log *log_from_idx(u32 idx)
 501 {
 502         struct printk_log *msg = (struct printk_log *)(log_buf + idx);
 503 
 504         /*
 505          * A length == 0 record is the end of buffer marker. Wrap around and
 506          * read the message at the start of the buffer.
 507          */
 508         if (!msg->len)
 509                 return (struct printk_log *)log_buf;
 510         return msg;
 511 }
 512 
 513 /* get next record; idx must point to valid msg */
 514 static u32 log_next(u32 idx)
 515 {
 516         struct printk_log *msg = (struct printk_log *)(log_buf + idx);
 517 
 518         /* length == 0 indicates the end of the buffer; wrap */
 519         /*
 520          * A length == 0 record is the end of buffer marker. Wrap around and
 521          * read the message at the start of the buffer as *this* one, and
 522          * return the one after that.
 523          */
 524         if (!msg->len) {
 525                 msg = (struct printk_log *)log_buf;
 526                 return msg->len;
 527         }
 528         return idx + msg->len;
 529 }
 530 
 531 /*
 532  * Check whether there is enough free space for the given message.
 533  *
 534  * The same values of first_idx and next_idx mean that the buffer
 535  * is either empty or full.
 536  *
 537  * If the buffer is empty, we must respect the position of the indexes.
 538  * They cannot be reset to the beginning of the buffer.
 539  */
 540 static int logbuf_has_space(u32 msg_size, bool empty)
 541 {
 542         u32 free;
 543 
 544         if (log_next_idx > log_first_idx || empty)
 545                 free = max(log_buf_len - log_next_idx, log_first_idx);
 546         else
 547                 free = log_first_idx - log_next_idx;
 548 
 549         /*
 550          * We need space also for an empty header that signalizes wrapping
 551          * of the buffer.
 552          */
 553         return free >= msg_size + sizeof(struct printk_log);
 554 }
 555 
 556 static int log_make_free_space(u32 msg_size)
 557 {
 558         while (log_first_seq < log_next_seq &&
 559                !logbuf_has_space(msg_size, false)) {
 560                 /* drop old messages until we have enough contiguous space */
 561                 log_first_idx = log_next(log_first_idx);
 562                 log_first_seq++;
 563         }
 564 
 565         if (clear_seq < log_first_seq) {
 566                 clear_seq = log_first_seq;
 567                 clear_idx = log_first_idx;
 568         }
 569 
 570         /* sequence numbers are equal, so the log buffer is empty */
 571         if (logbuf_has_space(msg_size, log_first_seq == log_next_seq))
 572                 return 0;
 573 
 574         return -ENOMEM;
 575 }
 576 
 577 /* compute the message size including the padding bytes */
 578 static u32 msg_used_size(u16 text_len, u16 dict_len, u32 *pad_len)
 579 {
 580         u32 size;
 581 
 582         size = sizeof(struct printk_log) + text_len + dict_len;
 583         *pad_len = (-size) & (LOG_ALIGN - 1);
 584         size += *pad_len;
 585 
 586         return size;
 587 }
 588 
 589 /*
 590  * Define how much of the log buffer we could take at maximum. The value
 591  * must be greater than two. Note that only half of the buffer is available
 592  * when the index points to the middle.
 593  */
 594 #define MAX_LOG_TAKE_PART 4
 595 static const char trunc_msg[] = "<truncated>";
 596 
 597 static u32 truncate_msg(u16 *text_len, u16 *trunc_msg_len,
 598                         u16 *dict_len, u32 *pad_len)
 599 {
 600         /*
 601          * The message should not take the whole buffer. Otherwise, it might
 602          * get removed too soon.
 603          */
 604         u32 max_text_len = log_buf_len / MAX_LOG_TAKE_PART;
 605         if (*text_len > max_text_len)
 606                 *text_len = max_text_len;
 607         /* enable the warning message */
 608         *trunc_msg_len = strlen(trunc_msg);
 609         /* disable the "dict" completely */
 610         *dict_len = 0;
 611         /* compute the size again, count also the warning message */
 612         return msg_used_size(*text_len + *trunc_msg_len, 0, pad_len);
 613 }
 614 
 615 /* insert record into the buffer, discard old ones, update heads */
 616 static int log_store(u32 caller_id, int facility, int level,
 617                      enum log_flags flags, u64 ts_nsec,
 618                      const char *dict, u16 dict_len,
 619                      const char *text, u16 text_len)
 620 {
 621         struct printk_log *msg;
 622         u32 size, pad_len;
 623         u16 trunc_msg_len = 0;
 624 
 625         /* number of '\0' padding bytes to next message */
 626         size = msg_used_size(text_len, dict_len, &pad_len);
 627 
 628         if (log_make_free_space(size)) {
 629                 /* truncate the message if it is too long for empty buffer */
 630                 size = truncate_msg(&text_len, &trunc_msg_len,
 631                                     &dict_len, &pad_len);
 632                 /* survive when the log buffer is too small for trunc_msg */
 633                 if (log_make_free_space(size))
 634                         return 0;
 635         }
 636 
 637         if (log_next_idx + size + sizeof(struct printk_log) > log_buf_len) {
 638                 /*
 639                  * This message + an additional empty header does not fit
 640                  * at the end of the buffer. Add an empty header with len == 0
 641                  * to signify a wrap around.
 642                  */
 643                 memset(log_buf + log_next_idx, 0, sizeof(struct printk_log));
 644                 log_next_idx = 0;
 645         }
 646 
 647         /* fill message */
 648         msg = (struct printk_log *)(log_buf + log_next_idx);
 649         memcpy(log_text(msg), text, text_len);
 650         msg->text_len = text_len;
 651         if (trunc_msg_len) {
 652                 memcpy(log_text(msg) + text_len, trunc_msg, trunc_msg_len);
 653                 msg->text_len += trunc_msg_len;
 654         }
 655         memcpy(log_dict(msg), dict, dict_len);
 656         msg->dict_len = dict_len;
 657         msg->facility = facility;
 658         msg->level = level & 7;
 659         msg->flags = flags & 0x1f;
 660         if (ts_nsec > 0)
 661                 msg->ts_nsec = ts_nsec;
 662         else
 663                 msg->ts_nsec = local_clock();
 664 #ifdef CONFIG_PRINTK_CALLER
 665         msg->caller_id = caller_id;
 666 #endif
 667         memset(log_dict(msg) + dict_len, 0, pad_len);
 668         msg->len = size;
 669 
 670         /* insert message */
 671         log_next_idx += msg->len;
 672         log_next_seq++;
 673 
 674         return msg->text_len;
 675 }
 676 
 677 int dmesg_restrict = IS_ENABLED(CONFIG_SECURITY_DMESG_RESTRICT);
 678 
 679 static int syslog_action_restricted(int type)
 680 {
 681         if (dmesg_restrict)
 682                 return 1;
 683         /*
 684          * Unless restricted, we allow "read all" and "get buffer size"
 685          * for everybody.
 686          */
 687         return type != SYSLOG_ACTION_READ_ALL &&
 688                type != SYSLOG_ACTION_SIZE_BUFFER;
 689 }
 690 
 691 static int check_syslog_permissions(int type, int source)
 692 {
 693         /*
 694          * If this is from /proc/kmsg and we've already opened it, then we've
 695          * already done the capabilities checks at open time.
 696          */
 697         if (source == SYSLOG_FROM_PROC && type != SYSLOG_ACTION_OPEN)
 698                 goto ok;
 699 
 700         if (syslog_action_restricted(type)) {
 701                 if (capable(CAP_SYSLOG))
 702                         goto ok;
 703                 /*
 704                  * For historical reasons, accept CAP_SYS_ADMIN too, with
 705                  * a warning.
 706                  */
 707                 if (capable(CAP_SYS_ADMIN)) {
 708                         pr_warn_once("%s (%d): Attempt to access syslog with "
 709                                      "CAP_SYS_ADMIN but no CAP_SYSLOG "
 710                                      "(deprecated).\n",
 711                                  current->comm, task_pid_nr(current));
 712                         goto ok;
 713                 }
 714                 return -EPERM;
 715         }
 716 ok:
 717         return security_syslog(type);
 718 }
 719 
 720 static void append_char(char **pp, char *e, char c)
 721 {
 722         if (*pp < e)
 723                 *(*pp)++ = c;
 724 }
 725 
 726 static ssize_t msg_print_ext_header(char *buf, size_t size,
 727                                     struct printk_log *msg, u64 seq)
 728 {
 729         u64 ts_usec = msg->ts_nsec;
 730         char caller[20];
 731 #ifdef CONFIG_PRINTK_CALLER
 732         u32 id = msg->caller_id;
 733 
 734         snprintf(caller, sizeof(caller), ",caller=%c%u",
 735                  id & 0x80000000 ? 'C' : 'T', id & ~0x80000000);
 736 #else
 737         caller[0] = '\0';
 738 #endif
 739 
 740         do_div(ts_usec, 1000);
 741 
 742         return scnprintf(buf, size, "%u,%llu,%llu,%c%s;",
 743                          (msg->facility << 3) | msg->level, seq, ts_usec,
 744                          msg->flags & LOG_CONT ? 'c' : '-', caller);
 745 }
 746 
 747 static ssize_t msg_print_ext_body(char *buf, size_t size,
 748                                   char *dict, size_t dict_len,
 749                                   char *text, size_t text_len)
 750 {
 751         char *p = buf, *e = buf + size;
 752         size_t i;
 753 
 754         /* escape non-printable characters */
 755         for (i = 0; i < text_len; i++) {
 756                 unsigned char c = text[i];
 757 
 758                 if (c < ' ' || c >= 127 || c == '\\')
 759                         p += scnprintf(p, e - p, "\\x%02x", c);
 760                 else
 761                         append_char(&p, e, c);
 762         }
 763         append_char(&p, e, '\n');
 764 
 765         if (dict_len) {
 766                 bool line = true;
 767 
 768                 for (i = 0; i < dict_len; i++) {
 769                         unsigned char c = dict[i];
 770 
 771                         if (line) {
 772                                 append_char(&p, e, ' ');
 773                                 line = false;
 774                         }
 775 
 776                         if (c == '\0') {
 777                                 append_char(&p, e, '\n');
 778                                 line = true;
 779                                 continue;
 780                         }
 781 
 782                         if (c < ' ' || c >= 127 || c == '\\') {
 783                                 p += scnprintf(p, e - p, "\\x%02x", c);
 784                                 continue;
 785                         }
 786 
 787                         append_char(&p, e, c);
 788                 }
 789                 append_char(&p, e, '\n');
 790         }
 791 
 792         return p - buf;
 793 }
 794 
 795 /* /dev/kmsg - userspace message inject/listen interface */
 796 struct devkmsg_user {
 797         u64 seq;
 798         u32 idx;
 799         struct ratelimit_state rs;
 800         struct mutex lock;
 801         char buf[CONSOLE_EXT_LOG_MAX];
 802 };
 803 
 804 static __printf(3, 4) __cold
 805 int devkmsg_emit(int facility, int level, const char *fmt, ...)
 806 {
 807         va_list args;
 808         int r;
 809 
 810         va_start(args, fmt);
 811         r = vprintk_emit(facility, level, NULL, 0, fmt, args);
 812         va_end(args);
 813 
 814         return r;
 815 }
 816 
 817 static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
 818 {
 819         char *buf, *line;
 820         int level = default_message_loglevel;
 821         int facility = 1;       /* LOG_USER */
 822         struct file *file = iocb->ki_filp;
 823         struct devkmsg_user *user = file->private_data;
 824         size_t len = iov_iter_count(from);
 825         ssize_t ret = len;
 826 
 827         if (!user || len > LOG_LINE_MAX)
 828                 return -EINVAL;
 829 
 830         /* Ignore when user logging is disabled. */
 831         if (devkmsg_log & DEVKMSG_LOG_MASK_OFF)
 832                 return len;
 833 
 834         /* Ratelimit when not explicitly enabled. */
 835         if (!(devkmsg_log & DEVKMSG_LOG_MASK_ON)) {
 836                 if (!___ratelimit(&user->rs, current->comm))
 837                         return ret;
 838         }
 839 
 840         buf = kmalloc(len+1, GFP_KERNEL);
 841         if (buf == NULL)
 842                 return -ENOMEM;
 843 
 844         buf[len] = '\0';
 845         if (!copy_from_iter_full(buf, len, from)) {
 846                 kfree(buf);
 847                 return -EFAULT;
 848         }
 849 
 850         /*
 851          * Extract and skip the syslog prefix <[0-9]*>. Coming from userspace
 852          * the decimal value represents 32bit, the lower 3 bit are the log
 853          * level, the rest are the log facility.
 854          *
 855          * If no prefix or no userspace facility is specified, we
 856          * enforce LOG_USER, to be able to reliably distinguish
 857          * kernel-generated messages from userspace-injected ones.
 858          */
 859         line = buf;
 860         if (line[0] == '<') {
 861                 char *endp = NULL;
 862                 unsigned int u;
 863 
 864                 u = simple_strtoul(line + 1, &endp, 10);
 865                 if (endp && endp[0] == '>') {
 866                         level = LOG_LEVEL(u);
 867                         if (LOG_FACILITY(u) != 0)
 868                                 facility = LOG_FACILITY(u);
 869                         endp++;
 870                         len -= endp - line;
 871                         line = endp;
 872                 }
 873         }
 874 
 875         devkmsg_emit(facility, level, "%s", line);
 876         kfree(buf);
 877         return ret;
 878 }
 879 
 880 static ssize_t devkmsg_read(struct file *file, char __user *buf,
 881                             size_t count, loff_t *ppos)
 882 {
 883         struct devkmsg_user *user = file->private_data;
 884         struct printk_log *msg;
 885         size_t len;
 886         ssize_t ret;
 887 
 888         if (!user)
 889                 return -EBADF;
 890 
 891         ret = mutex_lock_interruptible(&user->lock);
 892         if (ret)
 893                 return ret;
 894 
 895         logbuf_lock_irq();
 896         while (user->seq == log_next_seq) {
 897                 if (file->f_flags & O_NONBLOCK) {
 898                         ret = -EAGAIN;
 899                         logbuf_unlock_irq();
 900                         goto out;
 901                 }
 902 
 903                 logbuf_unlock_irq();
 904                 ret = wait_event_interruptible(log_wait,
 905                                                user->seq != log_next_seq);
 906                 if (ret)
 907                         goto out;
 908                 logbuf_lock_irq();
 909         }
 910 
 911         if (user->seq < log_first_seq) {
 912                 /* our last seen message is gone, return error and reset */
 913                 user->idx = log_first_idx;
 914                 user->seq = log_first_seq;
 915                 ret = -EPIPE;
 916                 logbuf_unlock_irq();
 917                 goto out;
 918         }
 919 
 920         msg = log_from_idx(user->idx);
 921         len = msg_print_ext_header(user->buf, sizeof(user->buf),
 922                                    msg, user->seq);
 923         len += msg_print_ext_body(user->buf + len, sizeof(user->buf) - len,
 924                                   log_dict(msg), msg->dict_len,
 925                                   log_text(msg), msg->text_len);
 926 
 927         user->idx = log_next(user->idx);
 928         user->seq++;
 929         logbuf_unlock_irq();
 930 
 931         if (len > count) {
 932                 ret = -EINVAL;
 933                 goto out;
 934         }
 935 
 936         if (copy_to_user(buf, user->buf, len)) {
 937                 ret = -EFAULT;
 938                 goto out;
 939         }
 940         ret = len;
 941 out:
 942         mutex_unlock(&user->lock);
 943         return ret;
 944 }
 945 
 946 static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
 947 {
 948         struct devkmsg_user *user = file->private_data;
 949         loff_t ret = 0;
 950 
 951         if (!user)
 952                 return -EBADF;
 953         if (offset)
 954                 return -ESPIPE;
 955 
 956         logbuf_lock_irq();
 957         switch (whence) {
 958         case SEEK_SET:
 959                 /* the first record */
 960                 user->idx = log_first_idx;
 961                 user->seq = log_first_seq;
 962                 break;
 963         case SEEK_DATA:
 964                 /*
 965                  * The first record after the last SYSLOG_ACTION_CLEAR,
 966                  * like issued by 'dmesg -c'. Reading /dev/kmsg itself
 967                  * changes no global state, and does not clear anything.
 968                  */
 969                 user->idx = clear_idx;
 970                 user->seq = clear_seq;
 971                 break;
 972         case SEEK_END:
 973                 /* after the last record */
 974                 user->idx = log_next_idx;
 975                 user->seq = log_next_seq;
 976                 break;
 977         default:
 978                 ret = -EINVAL;
 979         }
 980         logbuf_unlock_irq();
 981         return ret;
 982 }
 983 
 984 static __poll_t devkmsg_poll(struct file *file, poll_table *wait)
 985 {
 986         struct devkmsg_user *user = file->private_data;
 987         __poll_t ret = 0;
 988 
 989         if (!user)
 990                 return EPOLLERR|EPOLLNVAL;
 991 
 992         poll_wait(file, &log_wait, wait);
 993 
 994         logbuf_lock_irq();
 995         if (user->seq < log_next_seq) {
 996                 /* return error when data has vanished underneath us */
 997                 if (user->seq < log_first_seq)
 998                         ret = EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
 999                 else
1000                         ret = EPOLLIN|EPOLLRDNORM;
1001         }
1002         logbuf_unlock_irq();
1003 
1004         return ret;
1005 }
1006 
1007 static int devkmsg_open(struct inode *inode, struct file *file)
1008 {
1009         struct devkmsg_user *user;
1010         int err;
1011 
1012         if (devkmsg_log & DEVKMSG_LOG_MASK_OFF)
1013                 return -EPERM;
1014 
1015         /* write-only does not need any file context */
1016         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1017                 err = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
1018                                                SYSLOG_FROM_READER);
1019                 if (err)
1020                         return err;
1021         }
1022 
1023         user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
1024         if (!user)
1025                 return -ENOMEM;
1026 
1027         ratelimit_default_init(&user->rs);
1028         ratelimit_set_flags(&user->rs, RATELIMIT_MSG_ON_RELEASE);
1029 
1030         mutex_init(&user->lock);
1031 
1032         logbuf_lock_irq();
1033         user->idx = log_first_idx;
1034         user->seq = log_first_seq;
1035         logbuf_unlock_irq();
1036 
1037         file->private_data = user;
1038         return 0;
1039 }
1040 
1041 static int devkmsg_release(struct inode *inode, struct file *file)
1042 {
1043         struct devkmsg_user *user = file->private_data;
1044 
1045         if (!user)
1046                 return 0;
1047 
1048         ratelimit_state_exit(&user->rs);
1049 
1050         mutex_destroy(&user->lock);
1051         kfree(user);
1052         return 0;
1053 }
1054 
1055 const struct file_operations kmsg_fops = {
1056         .open = devkmsg_open,
1057         .read = devkmsg_read,
1058         .write_iter = devkmsg_write,
1059         .llseek = devkmsg_llseek,
1060         .poll = devkmsg_poll,
1061         .release = devkmsg_release,
1062 };
1063 
1064 #ifdef CONFIG_CRASH_CORE
1065 /*
1066  * This appends the listed symbols to /proc/vmcore
1067  *
1068  * /proc/vmcore is used by various utilities, like crash and makedumpfile to
1069  * obtain access to symbols that are otherwise very difficult to locate.  These
1070  * symbols are specifically used so that utilities can access and extract the
1071  * dmesg log from a vmcore file after a crash.
1072  */
1073 void log_buf_vmcoreinfo_setup(void)
1074 {
1075         VMCOREINFO_SYMBOL(log_buf);
1076         VMCOREINFO_SYMBOL(log_buf_len);
1077         VMCOREINFO_SYMBOL(log_first_idx);
1078         VMCOREINFO_SYMBOL(clear_idx);
1079         VMCOREINFO_SYMBOL(log_next_idx);
1080         /*
1081          * Export struct printk_log size and field offsets. User space tools can
1082          * parse it and detect any changes to structure down the line.
1083          */
1084         VMCOREINFO_STRUCT_SIZE(printk_log);
1085         VMCOREINFO_OFFSET(printk_log, ts_nsec);
1086         VMCOREINFO_OFFSET(printk_log, len);
1087         VMCOREINFO_OFFSET(printk_log, text_len);
1088         VMCOREINFO_OFFSET(printk_log, dict_len);
1089 #ifdef CONFIG_PRINTK_CALLER
1090         VMCOREINFO_OFFSET(printk_log, caller_id);
1091 #endif
1092 }
1093 #endif
1094 
1095 /* requested log_buf_len from kernel cmdline */
1096 static unsigned long __initdata new_log_buf_len;
1097 
1098 /* we practice scaling the ring buffer by powers of 2 */
1099 static void __init log_buf_len_update(u64 size)
1100 {
1101         if (size > (u64)LOG_BUF_LEN_MAX) {
1102                 size = (u64)LOG_BUF_LEN_MAX;
1103                 pr_err("log_buf over 2G is not supported.\n");
1104         }
1105 
1106         if (size)
1107                 size = roundup_pow_of_two(size);
1108         if (size > log_buf_len)
1109                 new_log_buf_len = (unsigned long)size;
1110 }
1111 
1112 /* save requested log_buf_len since it's too early to process it */
1113 static int __init log_buf_len_setup(char *str)
1114 {
1115         u64 size;
1116 
1117         if (!str)
1118                 return -EINVAL;
1119 
1120         size = memparse(str, &str);
1121 
1122         log_buf_len_update(size);
1123 
1124         return 0;
1125 }
1126 early_param("log_buf_len", log_buf_len_setup);
1127 
1128 #ifdef CONFIG_SMP
1129 #define __LOG_CPU_MAX_BUF_LEN (1 << CONFIG_LOG_CPU_MAX_BUF_SHIFT)
1130 
1131 static void __init log_buf_add_cpu(void)
1132 {
1133         unsigned int cpu_extra;
1134 
1135         /*
1136          * archs should set up cpu_possible_bits properly with
1137          * set_cpu_possible() after setup_arch() but just in
1138          * case lets ensure this is valid.
1139          */
1140         if (num_possible_cpus() == 1)
1141                 return;
1142 
1143         cpu_extra = (num_possible_cpus() - 1) * __LOG_CPU_MAX_BUF_LEN;
1144 
1145         /* by default this will only continue through for large > 64 CPUs */
1146         if (cpu_extra <= __LOG_BUF_LEN / 2)
1147                 return;
1148 
1149         pr_info("log_buf_len individual max cpu contribution: %d bytes\n",
1150                 __LOG_CPU_MAX_BUF_LEN);
1151         pr_info("log_buf_len total cpu_extra contributions: %d bytes\n",
1152                 cpu_extra);
1153         pr_info("log_buf_len min size: %d bytes\n", __LOG_BUF_LEN);
1154 
1155         log_buf_len_update(cpu_extra + __LOG_BUF_LEN);
1156 }
1157 #else /* !CONFIG_SMP */
1158 static inline void log_buf_add_cpu(void) {}
1159 #endif /* CONFIG_SMP */
1160 
1161 static void __init set_percpu_data_ready(void)
1162 {
1163         printk_safe_init();
1164         /* Make sure we set this flag only after printk_safe() init is done */
1165         barrier();
1166         __printk_percpu_data_ready = true;
1167 }
1168 
1169 void __init setup_log_buf(int early)
1170 {
1171         unsigned long flags;
1172         char *new_log_buf;
1173         unsigned int free;
1174 
1175         /*
1176          * Some archs call setup_log_buf() multiple times - first is very
1177          * early, e.g. from setup_arch(), and second - when percpu_areas
1178          * are initialised.
1179          */
1180         if (!early)
1181                 set_percpu_data_ready();
1182 
1183         if (log_buf != __log_buf)
1184                 return;
1185 
1186         if (!early && !new_log_buf_len)
1187                 log_buf_add_cpu();
1188 
1189         if (!new_log_buf_len)
1190                 return;
1191 
1192         new_log_buf = memblock_alloc(new_log_buf_len, LOG_ALIGN);
1193         if (unlikely(!new_log_buf)) {
1194                 pr_err("log_buf_len: %lu bytes not available\n",
1195                         new_log_buf_len);
1196                 return;
1197         }
1198 
1199         logbuf_lock_irqsave(flags);
1200         log_buf_len = new_log_buf_len;
1201         log_buf = new_log_buf;
1202         new_log_buf_len = 0;
1203         free = __LOG_BUF_LEN - log_next_idx;
1204         memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
1205         logbuf_unlock_irqrestore(flags);
1206 
1207         pr_info("log_buf_len: %u bytes\n", log_buf_len);
1208         pr_info("early log buf free: %u(%u%%)\n",
1209                 free, (free * 100) / __LOG_BUF_LEN);
1210 }
1211 
1212 static bool __read_mostly ignore_loglevel;
1213 
1214 static int __init ignore_loglevel_setup(char *str)
1215 {
1216         ignore_loglevel = true;
1217         pr_info("debug: ignoring loglevel setting.\n");
1218 
1219         return 0;
1220 }
1221 
1222 early_param("ignore_loglevel", ignore_loglevel_setup);
1223 module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
1224 MODULE_PARM_DESC(ignore_loglevel,
1225                  "ignore loglevel setting (prints all kernel messages to the console)");
1226 
1227 static bool suppress_message_printing(int level)
1228 {
1229         return (level >= console_loglevel && !ignore_loglevel);
1230 }
1231 
1232 #ifdef CONFIG_BOOT_PRINTK_DELAY
1233 
1234 static int boot_delay; /* msecs delay after each printk during bootup */
1235 static unsigned long long loops_per_msec;       /* based on boot_delay */
1236 
1237 static int __init boot_delay_setup(char *str)
1238 {
1239         unsigned long lpj;
1240 
1241         lpj = preset_lpj ? preset_lpj : 1000000;        /* some guess */
1242         loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
1243 
1244         get_option(&str, &boot_delay);
1245         if (boot_delay > 10 * 1000)
1246                 boot_delay = 0;
1247 
1248         pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
1249                 "HZ: %d, loops_per_msec: %llu\n",
1250                 boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
1251         return 0;
1252 }
1253 early_param("boot_delay", boot_delay_setup);
1254 
1255 static void boot_delay_msec(int level)
1256 {
1257         unsigned long long k;
1258         unsigned long timeout;
1259 
1260         if ((boot_delay == 0 || system_state >= SYSTEM_RUNNING)
1261                 || suppress_message_printing(level)) {
1262                 return;
1263         }
1264 
1265         k = (unsigned long long)loops_per_msec * boot_delay;
1266 
1267         timeout = jiffies + msecs_to_jiffies(boot_delay);
1268         while (k) {
1269                 k--;
1270                 cpu_relax();
1271                 /*
1272                  * use (volatile) jiffies to prevent
1273                  * compiler reduction; loop termination via jiffies
1274                  * is secondary and may or may not happen.
1275                  */
1276                 if (time_after(jiffies, timeout))
1277                         break;
1278                 touch_nmi_watchdog();
1279         }
1280 }
1281 #else
1282 static inline void boot_delay_msec(int level)
1283 {
1284 }
1285 #endif
1286 
1287 static bool printk_time = IS_ENABLED(CONFIG_PRINTK_TIME);
1288 module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
1289 
1290 static size_t print_syslog(unsigned int level, char *buf)
1291 {
1292         return sprintf(buf, "<%u>", level);
1293 }
1294 
1295 static size_t print_time(u64 ts, char *buf)
1296 {
1297         unsigned long rem_nsec = do_div(ts, 1000000000);
1298 
1299         return sprintf(buf, "[%5lu.%06lu]",
1300                        (unsigned long)ts, rem_nsec / 1000);
1301 }
1302 
1303 #ifdef CONFIG_PRINTK_CALLER
1304 static size_t print_caller(u32 id, char *buf)
1305 {
1306         char caller[12];
1307 
1308         snprintf(caller, sizeof(caller), "%c%u",
1309                  id & 0x80000000 ? 'C' : 'T', id & ~0x80000000);
1310         return sprintf(buf, "[%6s]", caller);
1311 }
1312 #else
1313 #define print_caller(id, buf) 0
1314 #endif
1315 
1316 static size_t print_prefix(const struct printk_log *msg, bool syslog,
1317                            bool time, char *buf)
1318 {
1319         size_t len = 0;
1320 
1321         if (syslog)
1322                 len = print_syslog((msg->facility << 3) | msg->level, buf);
1323 
1324         if (time)
1325                 len += print_time(msg->ts_nsec, buf + len);
1326 
1327         len += print_caller(msg->caller_id, buf + len);
1328 
1329         if (IS_ENABLED(CONFIG_PRINTK_CALLER) || time) {
1330                 buf[len++] = ' ';
1331                 buf[len] = '\0';
1332         }
1333 
1334         return len;
1335 }
1336 
1337 static size_t msg_print_text(const struct printk_log *msg, bool syslog,
1338                              bool time, char *buf, size_t size)
1339 {
1340         const char *text = log_text(msg);
1341         size_t text_size = msg->text_len;
1342         size_t len = 0;
1343         char prefix[PREFIX_MAX];
1344         const size_t prefix_len = print_prefix(msg, syslog, time, prefix);
1345 
1346         do {
1347                 const char *next = memchr(text, '\n', text_size);
1348                 size_t text_len;
1349 
1350                 if (next) {
1351                         text_len = next - text;
1352                         next++;
1353                         text_size -= next - text;
1354                 } else {
1355                         text_len = text_size;
1356                 }
1357 
1358                 if (buf) {
1359                         if (prefix_len + text_len + 1 >= size - len)
1360                                 break;
1361 
1362                         memcpy(buf + len, prefix, prefix_len);
1363                         len += prefix_len;
1364                         memcpy(buf + len, text, text_len);
1365                         len += text_len;
1366                         buf[len++] = '\n';
1367                 } else {
1368                         /* SYSLOG_ACTION_* buffer size only calculation */
1369                         len += prefix_len + text_len + 1;
1370                 }
1371 
1372                 text = next;
1373         } while (text);
1374 
1375         return len;
1376 }
1377 
1378 static int syslog_print(char __user *buf, int size)
1379 {
1380         char *text;
1381         struct printk_log *msg;
1382         int len = 0;
1383 
1384         text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
1385         if (!text)
1386                 return -ENOMEM;
1387 
1388         while (size > 0) {
1389                 size_t n;
1390                 size_t skip;
1391 
1392                 logbuf_lock_irq();
1393                 if (syslog_seq < log_first_seq) {
1394                         /* messages are gone, move to first one */
1395                         syslog_seq = log_first_seq;
1396                         syslog_idx = log_first_idx;
1397                         syslog_partial = 0;
1398                 }
1399                 if (syslog_seq == log_next_seq) {
1400                         logbuf_unlock_irq();
1401                         break;
1402                 }
1403 
1404                 /*
1405                  * To keep reading/counting partial line consistent,
1406                  * use printk_time value as of the beginning of a line.
1407                  */
1408                 if (!syslog_partial)
1409                         syslog_time = printk_time;
1410 
1411                 skip = syslog_partial;
1412                 msg = log_from_idx(syslog_idx);
1413                 n = msg_print_text(msg, true, syslog_time, text,
1414                                    LOG_LINE_MAX + PREFIX_MAX);
1415                 if (n - syslog_partial <= size) {
1416                         /* message fits into buffer, move forward */
1417                         syslog_idx = log_next(syslog_idx);
1418                         syslog_seq++;
1419                         n -= syslog_partial;
1420                         syslog_partial = 0;
1421                 } else if (!len){
1422                         /* partial read(), remember position */
1423                         n = size;
1424                         syslog_partial += n;
1425                 } else
1426                         n = 0;
1427                 logbuf_unlock_irq();
1428 
1429                 if (!n)
1430                         break;
1431 
1432                 if (copy_to_user(buf, text + skip, n)) {
1433                         if (!len)
1434                                 len = -EFAULT;
1435                         break;
1436                 }
1437 
1438                 len += n;
1439                 size -= n;
1440                 buf += n;
1441         }
1442 
1443         kfree(text);
1444         return len;
1445 }
1446 
1447 static int syslog_print_all(char __user *buf, int size, bool clear)
1448 {
1449         char *text;
1450         int len = 0;
1451         u64 next_seq;
1452         u64 seq;
1453         u32 idx;
1454         bool time;
1455 
1456         text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
1457         if (!text)
1458                 return -ENOMEM;
1459 
1460         time = printk_time;
1461         logbuf_lock_irq();
1462         /*
1463          * Find first record that fits, including all following records,
1464          * into the user-provided buffer for this dump.
1465          */
1466         seq = clear_seq;
1467         idx = clear_idx;
1468         while (seq < log_next_seq) {
1469                 struct printk_log *msg = log_from_idx(idx);
1470 
1471                 len += msg_print_text(msg, true, time, NULL, 0);
1472                 idx = log_next(idx);
1473                 seq++;
1474         }
1475 
1476         /* move first record forward until length fits into the buffer */
1477         seq = clear_seq;
1478         idx = clear_idx;
1479         while (len > size && seq < log_next_seq) {
1480                 struct printk_log *msg = log_from_idx(idx);
1481 
1482                 len -= msg_print_text(msg, true, time, NULL, 0);
1483                 idx = log_next(idx);
1484                 seq++;
1485         }
1486 
1487         /* last message fitting into this dump */
1488         next_seq = log_next_seq;
1489 
1490         len = 0;
1491         while (len >= 0 && seq < next_seq) {
1492                 struct printk_log *msg = log_from_idx(idx);
1493                 int textlen = msg_print_text(msg, true, time, text,
1494                                              LOG_LINE_MAX + PREFIX_MAX);
1495 
1496                 idx = log_next(idx);
1497                 seq++;
1498 
1499                 logbuf_unlock_irq();
1500                 if (copy_to_user(buf + len, text, textlen))
1501                         len = -EFAULT;
1502                 else
1503                         len += textlen;
1504                 logbuf_lock_irq();
1505 
1506                 if (seq < log_first_seq) {
1507                         /* messages are gone, move to next one */
1508                         seq = log_first_seq;
1509                         idx = log_first_idx;
1510                 }
1511         }
1512 
1513         if (clear) {
1514                 clear_seq = log_next_seq;
1515                 clear_idx = log_next_idx;
1516         }
1517         logbuf_unlock_irq();
1518 
1519         kfree(text);
1520         return len;
1521 }
1522 
1523 static void syslog_clear(void)
1524 {
1525         logbuf_lock_irq();
1526         clear_seq = log_next_seq;
1527         clear_idx = log_next_idx;
1528         logbuf_unlock_irq();
1529 }
1530 
1531 int do_syslog(int type, char __user *buf, int len, int source)
1532 {
1533         bool clear = false;
1534         static int saved_console_loglevel = LOGLEVEL_DEFAULT;
1535         int error;
1536 
1537         error = check_syslog_permissions(type, source);
1538         if (error)
1539                 return error;
1540 
1541         switch (type) {
1542         case SYSLOG_ACTION_CLOSE:       /* Close log */
1543                 break;
1544         case SYSLOG_ACTION_OPEN:        /* Open log */
1545                 break;
1546         case SYSLOG_ACTION_READ:        /* Read from log */
1547                 if (!buf || len < 0)
1548                         return -EINVAL;
1549                 if (!len)
1550                         return 0;
1551                 if (!access_ok(buf, len))
1552                         return -EFAULT;
1553                 error = wait_event_interruptible(log_wait,
1554                                                  syslog_seq != log_next_seq);
1555                 if (error)
1556                         return error;
1557                 error = syslog_print(buf, len);
1558                 break;
1559         /* Read/clear last kernel messages */
1560         case SYSLOG_ACTION_READ_CLEAR:
1561                 clear = true;
1562                 /* FALL THRU */
1563         /* Read last kernel messages */
1564         case SYSLOG_ACTION_READ_ALL:
1565                 if (!buf || len < 0)
1566                         return -EINVAL;
1567                 if (!len)
1568                         return 0;
1569                 if (!access_ok(buf, len))
1570                         return -EFAULT;
1571                 error = syslog_print_all(buf, len, clear);
1572                 break;
1573         /* Clear ring buffer */
1574         case SYSLOG_ACTION_CLEAR:
1575                 syslog_clear();
1576                 break;
1577         /* Disable logging to console */
1578         case SYSLOG_ACTION_CONSOLE_OFF:
1579                 if (saved_console_loglevel == LOGLEVEL_DEFAULT)
1580                         saved_console_loglevel = console_loglevel;
1581                 console_loglevel = minimum_console_loglevel;
1582                 break;
1583         /* Enable logging to console */
1584         case SYSLOG_ACTION_CONSOLE_ON:
1585                 if (saved_console_loglevel != LOGLEVEL_DEFAULT) {
1586                         console_loglevel = saved_console_loglevel;
1587                         saved_console_loglevel = LOGLEVEL_DEFAULT;
1588                 }
1589                 break;
1590         /* Set level of messages printed to console */
1591         case SYSLOG_ACTION_CONSOLE_LEVEL:
1592                 if (len < 1 || len > 8)
1593                         return -EINVAL;
1594                 if (len < minimum_console_loglevel)
1595                         len = minimum_console_loglevel;
1596                 console_loglevel = len;
1597                 /* Implicitly re-enable logging to console */
1598                 saved_console_loglevel = LOGLEVEL_DEFAULT;
1599                 break;
1600         /* Number of chars in the log buffer */
1601         case SYSLOG_ACTION_SIZE_UNREAD:
1602                 logbuf_lock_irq();
1603                 if (syslog_seq < log_first_seq) {
1604                         /* messages are gone, move to first one */
1605                         syslog_seq = log_first_seq;
1606                         syslog_idx = log_first_idx;
1607                         syslog_partial = 0;
1608                 }
1609                 if (source == SYSLOG_FROM_PROC) {
1610                         /*
1611                          * Short-cut for poll(/"proc/kmsg") which simply checks
1612                          * for pending data, not the size; return the count of
1613                          * records, not the length.
1614                          */
1615                         error = log_next_seq - syslog_seq;
1616                 } else {
1617                         u64 seq = syslog_seq;
1618                         u32 idx = syslog_idx;
1619                         bool time = syslog_partial ? syslog_time : printk_time;
1620 
1621                         while (seq < log_next_seq) {
1622                                 struct printk_log *msg = log_from_idx(idx);
1623 
1624                                 error += msg_print_text(msg, true, time, NULL,
1625                                                         0);
1626                                 time = printk_time;
1627                                 idx = log_next(idx);
1628                                 seq++;
1629                         }
1630                         error -= syslog_partial;
1631                 }
1632                 logbuf_unlock_irq();
1633                 break;
1634         /* Size of the log buffer */
1635         case SYSLOG_ACTION_SIZE_BUFFER:
1636                 error = log_buf_len;
1637                 break;
1638         default:
1639                 error = -EINVAL;
1640                 break;
1641         }
1642 
1643         return error;
1644 }
1645 
1646 SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
1647 {
1648         return do_syslog(type, buf, len, SYSLOG_FROM_READER);
1649 }
1650 
1651 /*
1652  * Special console_lock variants that help to reduce the risk of soft-lockups.
1653  * They allow to pass console_lock to another printk() call using a busy wait.
1654  */
1655 
1656 #ifdef CONFIG_LOCKDEP
1657 static struct lockdep_map console_owner_dep_map = {
1658         .name = "console_owner"
1659 };
1660 #endif
1661 
1662 static DEFINE_RAW_SPINLOCK(console_owner_lock);
1663 static struct task_struct *console_owner;
1664 static bool console_waiter;
1665 
1666 /**
1667  * console_lock_spinning_enable - mark beginning of code where another
1668  *      thread might safely busy wait
1669  *
1670  * This basically converts console_lock into a spinlock. This marks
1671  * the section where the console_lock owner can not sleep, because
1672  * there may be a waiter spinning (like a spinlock). Also it must be
1673  * ready to hand over the lock at the end of the section.
1674  */
1675 static void console_lock_spinning_enable(void)
1676 {
1677         raw_spin_lock(&console_owner_lock);
1678         console_owner = current;
1679         raw_spin_unlock(&console_owner_lock);
1680 
1681         /* The waiter may spin on us after setting console_owner */
1682         spin_acquire(&console_owner_dep_map, 0, 0, _THIS_IP_);
1683 }
1684 
1685 /**
1686  * console_lock_spinning_disable_and_check - mark end of code where another
1687  *      thread was able to busy wait and check if there is a waiter
1688  *
1689  * This is called at the end of the section where spinning is allowed.
1690  * It has two functions. First, it is a signal that it is no longer
1691  * safe to start busy waiting for the lock. Second, it checks if
1692  * there is a busy waiter and passes the lock rights to her.
1693  *
1694  * Important: Callers lose the lock if there was a busy waiter.
1695  *      They must not touch items synchronized by console_lock
1696  *      in this case.
1697  *
1698  * Return: 1 if the lock rights were passed, 0 otherwise.
1699  */
1700 static int console_lock_spinning_disable_and_check(void)
1701 {
1702         int waiter;
1703 
1704         raw_spin_lock(&console_owner_lock);
1705         waiter = READ_ONCE(console_waiter);
1706         console_owner = NULL;
1707         raw_spin_unlock(&console_owner_lock);
1708 
1709         if (!waiter) {
1710                 spin_release(&console_owner_dep_map, 1, _THIS_IP_);
1711                 return 0;
1712         }
1713 
1714         /* The waiter is now free to continue */
1715         WRITE_ONCE(console_waiter, false);
1716 
1717         spin_release(&console_owner_dep_map, 1, _THIS_IP_);
1718 
1719         /*
1720          * Hand off console_lock to waiter. The waiter will perform
1721          * the up(). After this, the waiter is the console_lock owner.
1722          */
1723         mutex_release(&console_lock_dep_map, 1, _THIS_IP_);
1724         return 1;
1725 }
1726 
1727 /**
1728  * console_trylock_spinning - try to get console_lock by busy waiting
1729  *
1730  * This allows to busy wait for the console_lock when the current
1731  * owner is running in specially marked sections. It means that
1732  * the current owner is running and cannot reschedule until it
1733  * is ready to lose the lock.
1734  *
1735  * Return: 1 if we got the lock, 0 othrewise
1736  */
1737 static int console_trylock_spinning(void)
1738 {
1739         struct task_struct *owner = NULL;
1740         bool waiter;
1741         bool spin = false;
1742         unsigned long flags;
1743 
1744         if (console_trylock())
1745                 return 1;
1746 
1747         printk_safe_enter_irqsave(flags);
1748 
1749         raw_spin_lock(&console_owner_lock);
1750         owner = READ_ONCE(console_owner);
1751         waiter = READ_ONCE(console_waiter);
1752         if (!waiter && owner && owner != current) {
1753                 WRITE_ONCE(console_waiter, true);
1754                 spin = true;
1755         }
1756         raw_spin_unlock(&console_owner_lock);
1757 
1758         /*
1759          * If there is an active printk() writing to the
1760          * consoles, instead of having it write our data too,
1761          * see if we can offload that load from the active
1762          * printer, and do some printing ourselves.
1763          * Go into a spin only if there isn't already a waiter
1764          * spinning, and there is an active printer, and
1765          * that active printer isn't us (recursive printk?).
1766          */
1767         if (!spin) {
1768                 printk_safe_exit_irqrestore(flags);
1769                 return 0;
1770         }
1771 
1772         /* We spin waiting for the owner to release us */
1773         spin_acquire(&console_owner_dep_map, 0, 0, _THIS_IP_);
1774         /* Owner will clear console_waiter on hand off */
1775         while (READ_ONCE(console_waiter))
1776                 cpu_relax();
1777         spin_release(&console_owner_dep_map, 1, _THIS_IP_);
1778 
1779         printk_safe_exit_irqrestore(flags);
1780         /*
1781          * The owner passed the console lock to us.
1782          * Since we did not spin on console lock, annotate
1783          * this as a trylock. Otherwise lockdep will
1784          * complain.
1785          */
1786         mutex_acquire(&console_lock_dep_map, 0, 1, _THIS_IP_);
1787 
1788         return 1;
1789 }
1790 
1791 /*
1792  * Call the console drivers, asking them to write out
1793  * log_buf[start] to log_buf[end - 1].
1794  * The console_lock must be held.
1795  */
1796 static void call_console_drivers(const char *ext_text, size_t ext_len,
1797                                  const char *text, size_t len)
1798 {
1799         struct console *con;
1800 
1801         trace_console_rcuidle(text, len);
1802 
1803         if (!console_drivers)
1804                 return;
1805 
1806         for_each_console(con) {
1807                 if (exclusive_console && con != exclusive_console)
1808                         continue;
1809                 if (!(con->flags & CON_ENABLED))
1810                         continue;
1811                 if (!con->write)
1812                         continue;
1813                 if (!cpu_online(smp_processor_id()) &&
1814                     !(con->flags & CON_ANYTIME))
1815                         continue;
1816                 if (con->flags & CON_EXTENDED)
1817                         con->write(con, ext_text, ext_len);
1818                 else
1819                         con->write(con, text, len);
1820         }
1821 }
1822 
1823 int printk_delay_msec __read_mostly;
1824 
1825 static inline void printk_delay(void)
1826 {
1827         if (unlikely(printk_delay_msec)) {
1828                 int m = printk_delay_msec;
1829 
1830                 while (m--) {
1831                         mdelay(1);
1832                         touch_nmi_watchdog();
1833                 }
1834         }
1835 }
1836 
1837 static inline u32 printk_caller_id(void)
1838 {
1839         return in_task() ? task_pid_nr(current) :
1840                 0x80000000 + raw_smp_processor_id();
1841 }
1842 
1843 /*
1844  * Continuation lines are buffered, and not committed to the record buffer
1845  * until the line is complete, or a race forces it. The line fragments
1846  * though, are printed immediately to the consoles to ensure everything has
1847  * reached the console in case of a kernel crash.
1848  */
1849 static struct cont {
1850         char buf[LOG_LINE_MAX];
1851         size_t len;                     /* length == 0 means unused buffer */
1852         u32 caller_id;                  /* printk_caller_id() of first print */
1853         u64 ts_nsec;                    /* time of first print */
1854         u8 level;                       /* log level of first message */
1855         u8 facility;                    /* log facility of first message */
1856         enum log_flags flags;           /* prefix, newline flags */
1857 } cont;
1858 
1859 static void cont_flush(void)
1860 {
1861         if (cont.len == 0)
1862                 return;
1863 
1864         log_store(cont.caller_id, cont.facility, cont.level, cont.flags,
1865                   cont.ts_nsec, NULL, 0, cont.buf, cont.len);
1866         cont.len = 0;
1867 }
1868 
1869 static bool cont_add(u32 caller_id, int facility, int level,
1870                      enum log_flags flags, const char *text, size_t len)
1871 {
1872         /* If the line gets too long, split it up in separate records. */
1873         if (cont.len + len > sizeof(cont.buf)) {
1874                 cont_flush();
1875                 return false;
1876         }
1877 
1878         if (!cont.len) {
1879                 cont.facility = facility;
1880                 cont.level = level;
1881                 cont.caller_id = caller_id;
1882                 cont.ts_nsec = local_clock();
1883                 cont.flags = flags;
1884         }
1885 
1886         memcpy(cont.buf + cont.len, text, len);
1887         cont.len += len;
1888 
1889         // The original flags come from the first line,
1890         // but later continuations can add a newline.
1891         if (flags & LOG_NEWLINE) {
1892                 cont.flags |= LOG_NEWLINE;
1893                 cont_flush();
1894         }
1895 
1896         return true;
1897 }
1898 
1899 static size_t log_output(int facility, int level, enum log_flags lflags, const char *dict, size_t dictlen, char *text, size_t text_len)
1900 {
1901         const u32 caller_id = printk_caller_id();
1902 
1903         /*
1904          * If an earlier line was buffered, and we're a continuation
1905          * write from the same context, try to add it to the buffer.
1906          */
1907         if (cont.len) {
1908                 if (cont.caller_id == caller_id && (lflags & LOG_CONT)) {
1909                         if (cont_add(caller_id, facility, level, lflags, text, text_len))
1910                                 return text_len;
1911                 }
1912                 /* Otherwise, make sure it's flushed */
1913                 cont_flush();
1914         }
1915 
1916         /* Skip empty continuation lines that couldn't be added - they just flush */
1917         if (!text_len && (lflags & LOG_CONT))
1918                 return 0;
1919 
1920         /* If it doesn't end in a newline, try to buffer the current line */
1921         if (!(lflags & LOG_NEWLINE)) {
1922                 if (cont_add(caller_id, facility, level, lflags, text, text_len))
1923                         return text_len;
1924         }
1925 
1926         /* Store it in the record log */
1927         return log_store(caller_id, facility, level, lflags, 0,
1928                          dict, dictlen, text, text_len);
1929 }
1930 
1931 /* Must be called under logbuf_lock. */
1932 int vprintk_store(int facility, int level,
1933                   const char *dict, size_t dictlen,
1934                   const char *fmt, va_list args)
1935 {
1936         static char textbuf[LOG_LINE_MAX];
1937         char *text = textbuf;
1938         size_t text_len;
1939         enum log_flags lflags = 0;
1940 
1941         /*
1942          * The printf needs to come first; we need the syslog
1943          * prefix which might be passed-in as a parameter.
1944          */
1945         text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
1946 
1947         /* mark and strip a trailing newline */
1948         if (text_len && text[text_len-1] == '\n') {
1949                 text_len--;
1950                 lflags |= LOG_NEWLINE;
1951         }
1952 
1953         /* strip kernel syslog prefix and extract log level or control flags */
1954         if (facility == 0) {
1955                 int kern_level;
1956 
1957                 while ((kern_level = printk_get_level(text)) != 0) {
1958                         switch (kern_level) {
1959                         case '0' ... '7':
1960                                 if (level == LOGLEVEL_DEFAULT)
1961                                         level = kern_level - '0';
1962                                 break;
1963                         case 'c':       /* KERN_CONT */
1964                                 lflags |= LOG_CONT;
1965                         }
1966 
1967                         text_len -= 2;
1968                         text += 2;
1969                 }
1970         }
1971 
1972         if (level == LOGLEVEL_DEFAULT)
1973                 level = default_message_loglevel;
1974 
1975         if (dict)
1976                 lflags |= LOG_NEWLINE;
1977 
1978         return log_output(facility, level, lflags,
1979                           dict, dictlen, text, text_len);
1980 }
1981 
1982 asmlinkage int vprintk_emit(int facility, int level,
1983                             const char *dict, size_t dictlen,
1984                             const char *fmt, va_list args)
1985 {
1986         int printed_len;
1987         bool in_sched = false, pending_output;
1988         unsigned long flags;
1989         u64 curr_log_seq;
1990 
1991         /* Suppress unimportant messages after panic happens */
1992         if (unlikely(suppress_printk))
1993                 return 0;
1994 
1995         if (level == LOGLEVEL_SCHED) {
1996                 level = LOGLEVEL_DEFAULT;
1997                 in_sched = true;
1998         }
1999 
2000         boot_delay_msec(level);
2001         printk_delay();
2002 
2003         /* This stops the holder of console_sem just where we want him */
2004         logbuf_lock_irqsave(flags);
2005         curr_log_seq = log_next_seq;
2006         printed_len = vprintk_store(facility, level, dict, dictlen, fmt, args);
2007         pending_output = (curr_log_seq != log_next_seq);
2008         logbuf_unlock_irqrestore(flags);
2009 
2010         /* If called from the scheduler, we can not call up(). */
2011         if (!in_sched && pending_output) {
2012                 /*
2013                  * Disable preemption to avoid being preempted while holding
2014                  * console_sem which would prevent anyone from printing to
2015                  * console
2016                  */
2017                 preempt_disable();
2018                 /*
2019                  * Try to acquire and then immediately release the console
2020                  * semaphore.  The release will print out buffers and wake up
2021                  * /dev/kmsg and syslog() users.
2022                  */
2023                 if (console_trylock_spinning())
2024                         console_unlock();
2025                 preempt_enable();
2026         }
2027 
2028         if (pending_output)
2029                 wake_up_klogd();
2030         return printed_len;
2031 }
2032 EXPORT_SYMBOL(vprintk_emit);
2033 
2034 asmlinkage int vprintk(const char *fmt, va_list args)
2035 {
2036         return vprintk_func(fmt, args);
2037 }
2038 EXPORT_SYMBOL(vprintk);
2039 
2040 int vprintk_default(const char *fmt, va_list args)
2041 {
2042         int r;
2043 
2044 #ifdef CONFIG_KGDB_KDB
2045         /* Allow to pass printk() to kdb but avoid a recursion. */
2046         if (unlikely(kdb_trap_printk && kdb_printf_cpu < 0)) {
2047                 r = vkdb_printf(KDB_MSGSRC_PRINTK, fmt, args);
2048                 return r;
2049         }
2050 #endif
2051         r = vprintk_emit(0, LOGLEVEL_DEFAULT, NULL, 0, fmt, args);
2052 
2053         return r;
2054 }
2055 EXPORT_SYMBOL_GPL(vprintk_default);
2056 
2057 /**
2058  * printk - print a kernel message
2059  * @fmt: format string
2060  *
2061  * This is printk(). It can be called from any context. We want it to work.
2062  *
2063  * We try to grab the console_lock. If we succeed, it's easy - we log the
2064  * output and call the console drivers.  If we fail to get the semaphore, we
2065  * place the output into the log buffer and return. The current holder of
2066  * the console_sem will notice the new output in console_unlock(); and will
2067  * send it to the consoles before releasing the lock.
2068  *
2069  * One effect of this deferred printing is that code which calls printk() and
2070  * then changes console_loglevel may break. This is because console_loglevel
2071  * is inspected when the actual printing occurs.
2072  *
2073  * See also:
2074  * printf(3)
2075  *
2076  * See the vsnprintf() documentation for format string extensions over C99.
2077  */
2078 asmlinkage __visible int printk(const char *fmt, ...)
2079 {
2080         va_list args;
2081         int r;
2082 
2083         va_start(args, fmt);
2084         r = vprintk_func(fmt, args);
2085         va_end(args);
2086 
2087         return r;
2088 }
2089 EXPORT_SYMBOL(printk);
2090 
2091 #else /* CONFIG_PRINTK */
2092 
2093 #define LOG_LINE_MAX            0
2094 #define PREFIX_MAX              0
2095 #define printk_time             false
2096 
2097 static u64 syslog_seq;
2098 static u32 syslog_idx;
2099 static u64 console_seq;
2100 static u32 console_idx;
2101 static u64 exclusive_console_stop_seq;
2102 static u64 log_first_seq;
2103 static u32 log_first_idx;
2104 static u64 log_next_seq;
2105 static char *log_text(const struct printk_log *msg) { return NULL; }
2106 static char *log_dict(const struct printk_log *msg) { return NULL; }
2107 static struct printk_log *log_from_idx(u32 idx) { return NULL; }
2108 static u32 log_next(u32 idx) { return 0; }
2109 static ssize_t msg_print_ext_header(char *buf, size_t size,
2110                                     struct printk_log *msg,
2111                                     u64 seq) { return 0; }
2112 static ssize_t msg_print_ext_body(char *buf, size_t size,
2113                                   char *dict, size_t dict_len,
2114                                   char *text, size_t text_len) { return 0; }
2115 static void console_lock_spinning_enable(void) { }
2116 static int console_lock_spinning_disable_and_check(void) { return 0; }
2117 static void call_console_drivers(const char *ext_text, size_t ext_len,
2118                                  const char *text, size_t len) {}
2119 static size_t msg_print_text(const struct printk_log *msg, bool syslog,
2120                              bool time, char *buf, size_t size) { return 0; }
2121 static bool suppress_message_printing(int level) { return false; }
2122 
2123 #endif /* CONFIG_PRINTK */
2124 
2125 #ifdef CONFIG_EARLY_PRINTK
2126 struct console *early_console;
2127 
2128 asmlinkage __visible void early_printk(const char *fmt, ...)
2129 {
2130         va_list ap;
2131         char buf[512];
2132         int n;
2133 
2134         if (!early_console)
2135                 return;
2136 
2137         va_start(ap, fmt);
2138         n = vscnprintf(buf, sizeof(buf), fmt, ap);
2139         va_end(ap);
2140 
2141         early_console->write(early_console, buf, n);
2142 }
2143 #endif
2144 
2145 static int __add_preferred_console(char *name, int idx, char *options,
2146                                    char *brl_options)
2147 {
2148         struct console_cmdline *c;
2149         int i;
2150 
2151         /*
2152          *      See if this tty is not yet registered, and
2153          *      if we have a slot free.
2154          */
2155         for (i = 0, c = console_cmdline;
2156              i < MAX_CMDLINECONSOLES && c->name[0];
2157              i++, c++) {
2158                 if (strcmp(c->name, name) == 0 && c->index == idx) {
2159                         if (!brl_options)
2160                                 preferred_console = i;
2161                         return 0;
2162                 }
2163         }
2164         if (i == MAX_CMDLINECONSOLES)
2165                 return -E2BIG;
2166         if (!brl_options)
2167                 preferred_console = i;
2168         strlcpy(c->name, name, sizeof(c->name));
2169         c->options = options;
2170         braille_set_options(c, brl_options);
2171 
2172         c->index = idx;
2173         return 0;
2174 }
2175 
2176 static int __init console_msg_format_setup(char *str)
2177 {
2178         if (!strcmp(str, "syslog"))
2179                 console_msg_format = MSG_FORMAT_SYSLOG;
2180         if (!strcmp(str, "default"))
2181                 console_msg_format = MSG_FORMAT_DEFAULT;
2182         return 1;
2183 }
2184 __setup("console_msg_format=", console_msg_format_setup);
2185 
2186 /*
2187  * Set up a console.  Called via do_early_param() in init/main.c
2188  * for each "console=" parameter in the boot command line.
2189  */
2190 static int __init console_setup(char *str)
2191 {
2192         char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for "ttyS" */
2193         char *s, *options, *brl_options = NULL;
2194         int idx;
2195 
2196         if (_braille_console_setup(&str, &brl_options))
2197                 return 1;
2198 
2199         /*
2200          * Decode str into name, index, options.
2201          */
2202         if (str[0] >= '0' && str[0] <= '9') {
2203                 strcpy(buf, "ttyS");
2204                 strncpy(buf + 4, str, sizeof(buf) - 5);
2205         } else {
2206                 strncpy(buf, str, sizeof(buf) - 1);
2207         }
2208         buf[sizeof(buf) - 1] = 0;
2209         options = strchr(str, ',');
2210         if (options)
2211                 *(options++) = 0;
2212 #ifdef __sparc__
2213         if (!strcmp(str, "ttya"))
2214                 strcpy(buf, "ttyS0");
2215         if (!strcmp(str, "ttyb"))
2216                 strcpy(buf, "ttyS1");
2217 #endif
2218         for (s = buf; *s; s++)
2219                 if (isdigit(*s) || *s == ',')
2220                         break;
2221         idx = simple_strtoul(s, NULL, 10);
2222         *s = 0;
2223 
2224         __add_preferred_console(buf, idx, options, brl_options);
2225         console_set_on_cmdline = 1;
2226         return 1;
2227 }
2228 __setup("console=", console_setup);
2229 
2230 /**
2231  * add_preferred_console - add a device to the list of preferred consoles.
2232  * @name: device name
2233  * @idx: device index
2234  * @options: options for this console
2235  *
2236  * The last preferred console added will be used for kernel messages
2237  * and stdin/out/err for init.  Normally this is used by console_setup
2238  * above to handle user-supplied console arguments; however it can also
2239  * be used by arch-specific code either to override the user or more
2240  * commonly to provide a default console (ie from PROM variables) when
2241  * the user has not supplied one.
2242  */
2243 int add_preferred_console(char *name, int idx, char *options)
2244 {
2245         return __add_preferred_console(name, idx, options, NULL);
2246 }
2247 
2248 bool console_suspend_enabled = true;
2249 EXPORT_SYMBOL(console_suspend_enabled);
2250 
2251 static int __init console_suspend_disable(char *str)
2252 {
2253         console_suspend_enabled = false;
2254         return 1;
2255 }
2256 __setup("no_console_suspend", console_suspend_disable);
2257 module_param_named(console_suspend, console_suspend_enabled,
2258                 bool, S_IRUGO | S_IWUSR);
2259 MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
2260         " and hibernate operations");
2261 
2262 /**
2263  * suspend_console - suspend the console subsystem
2264  *
2265  * This disables printk() while we go into suspend states
2266  */
2267 void suspend_console(void)
2268 {
2269         if (!console_suspend_enabled)
2270                 return;
2271         pr_info("Suspending console(s) (use no_console_suspend to debug)\n");
2272         console_lock();
2273         console_suspended = 1;
2274         up_console_sem();
2275 }
2276 
2277 void resume_console(void)
2278 {
2279         if (!console_suspend_enabled)
2280                 return;
2281         down_console_sem();
2282         console_suspended = 0;
2283         console_unlock();
2284 }
2285 
2286 /**
2287  * console_cpu_notify - print deferred console messages after CPU hotplug
2288  * @cpu: unused
2289  *
2290  * If printk() is called from a CPU that is not online yet, the messages
2291  * will be printed on the console only if there are CON_ANYTIME consoles.
2292  * This function is called when a new CPU comes online (or fails to come
2293  * up) or goes offline.
2294  */
2295 static int console_cpu_notify(unsigned int cpu)
2296 {
2297         if (!cpuhp_tasks_frozen) {
2298                 /* If trylock fails, someone else is doing the printing */
2299                 if (console_trylock())
2300                         console_unlock();
2301         }
2302         return 0;
2303 }
2304 
2305 /**
2306  * console_lock - lock the console system for exclusive use.
2307  *
2308  * Acquires a lock which guarantees that the caller has
2309  * exclusive access to the console system and the console_drivers list.
2310  *
2311  * Can sleep, returns nothing.
2312  */
2313 void console_lock(void)
2314 {
2315         might_sleep();
2316 
2317         down_console_sem();
2318         if (console_suspended)
2319                 return;
2320         console_locked = 1;
2321         console_may_schedule = 1;
2322 }
2323 EXPORT_SYMBOL(console_lock);
2324 
2325 /**
2326  * console_trylock - try to lock the console system for exclusive use.
2327  *
2328  * Try to acquire a lock which guarantees that the caller has exclusive
2329  * access to the console system and the console_drivers list.
2330  *
2331  * returns 1 on success, and 0 on failure to acquire the lock.
2332  */
2333 int console_trylock(void)
2334 {
2335         if (down_trylock_console_sem())
2336                 return 0;
2337         if (console_suspended) {
2338                 up_console_sem();
2339                 return 0;
2340         }
2341         console_locked = 1;
2342         console_may_schedule = 0;
2343         return 1;
2344 }
2345 EXPORT_SYMBOL(console_trylock);
2346 
2347 int is_console_locked(void)
2348 {
2349         return console_locked;
2350 }
2351 EXPORT_SYMBOL(is_console_locked);
2352 
2353 /*
2354  * Check if we have any console that is capable of printing while cpu is
2355  * booting or shutting down. Requires console_sem.
2356  */
2357 static int have_callable_console(void)
2358 {
2359         struct console *con;
2360 
2361         for_each_console(con)
2362                 if ((con->flags & CON_ENABLED) &&
2363                                 (con->flags & CON_ANYTIME))
2364                         return 1;
2365 
2366         return 0;
2367 }
2368 
2369 /*
2370  * Can we actually use the console at this time on this cpu?
2371  *
2372  * Console drivers may assume that per-cpu resources have been allocated. So
2373  * unless they're explicitly marked as being able to cope (CON_ANYTIME) don't
2374  * call them until this CPU is officially up.
2375  */
2376 static inline int can_use_console(void)
2377 {
2378         return cpu_online(raw_smp_processor_id()) || have_callable_console();
2379 }
2380 
2381 /**
2382  * console_unlock - unlock the console system
2383  *
2384  * Releases the console_lock which the caller holds on the console system
2385  * and the console driver list.
2386  *
2387  * While the console_lock was held, console output may have been buffered
2388  * by printk().  If this is the case, console_unlock(); emits
2389  * the output prior to releasing the lock.
2390  *
2391  * If there is output waiting, we wake /dev/kmsg and syslog() users.
2392  *
2393  * console_unlock(); may be called from any context.
2394  */
2395 void console_unlock(void)
2396 {
2397         static char ext_text[CONSOLE_EXT_LOG_MAX];
2398         static char text[LOG_LINE_MAX + PREFIX_MAX];
2399         unsigned long flags;
2400         bool do_cond_resched, retry;
2401 
2402         if (console_suspended) {
2403                 up_console_sem();
2404                 return;
2405         }
2406 
2407         /*
2408          * Console drivers are called with interrupts disabled, so
2409          * @console_may_schedule should be cleared before; however, we may
2410          * end up dumping a lot of lines, for example, if called from
2411          * console registration path, and should invoke cond_resched()
2412          * between lines if allowable.  Not doing so can cause a very long
2413          * scheduling stall on a slow console leading to RCU stall and
2414          * softlockup warnings which exacerbate the issue with more
2415          * messages practically incapacitating the system.
2416          *
2417          * console_trylock() is not able to detect the preemptive
2418          * context reliably. Therefore the value must be stored before
2419          * and cleared after the the "again" goto label.
2420          */
2421         do_cond_resched = console_may_schedule;
2422 again:
2423         console_may_schedule = 0;
2424 
2425         /*
2426          * We released the console_sem lock, so we need to recheck if
2427          * cpu is online and (if not) is there at least one CON_ANYTIME
2428          * console.
2429          */
2430         if (!can_use_console()) {
2431                 console_locked = 0;
2432                 up_console_sem();
2433                 return;
2434         }
2435 
2436         for (;;) {
2437                 struct printk_log *msg;
2438                 size_t ext_len = 0;
2439                 size_t len;
2440 
2441                 printk_safe_enter_irqsave(flags);
2442                 raw_spin_lock(&logbuf_lock);
2443                 if (console_seq < log_first_seq) {
2444                         len = sprintf(text,
2445                                       "** %llu printk messages dropped **\n",
2446                                       log_first_seq - console_seq);
2447 
2448                         /* messages are gone, move to first one */
2449                         console_seq = log_first_seq;
2450                         console_idx = log_first_idx;
2451                 } else {
2452                         len = 0;
2453                 }
2454 skip:
2455                 if (console_seq == log_next_seq)
2456                         break;
2457 
2458                 msg = log_from_idx(console_idx);
2459                 if (suppress_message_printing(msg->level)) {
2460                         /*
2461                          * Skip record we have buffered and already printed
2462                          * directly to the console when we received it, and
2463                          * record that has level above the console loglevel.
2464                          */
2465                         console_idx = log_next(console_idx);
2466                         console_seq++;
2467                         goto skip;
2468                 }
2469 
2470                 /* Output to all consoles once old messages replayed. */
2471                 if (unlikely(exclusive_console &&
2472                              console_seq >= exclusive_console_stop_seq)) {
2473                         exclusive_console = NULL;
2474                 }
2475 
2476                 len += msg_print_text(msg,
2477                                 console_msg_format & MSG_FORMAT_SYSLOG,
2478                                 printk_time, text + len, sizeof(text) - len);
2479                 if (nr_ext_console_drivers) {
2480                         ext_len = msg_print_ext_header(ext_text,
2481                                                 sizeof(ext_text),
2482                                                 msg, console_seq);
2483                         ext_len += msg_print_ext_body(ext_text + ext_len,
2484                                                 sizeof(ext_text) - ext_len,
2485                                                 log_dict(msg), msg->dict_len,
2486                                                 log_text(msg), msg->text_len);
2487                 }
2488                 console_idx = log_next(console_idx);
2489                 console_seq++;
2490                 raw_spin_unlock(&logbuf_lock);
2491 
2492                 /*
2493                  * While actively printing out messages, if another printk()
2494                  * were to occur on another CPU, it may wait for this one to
2495                  * finish. This task can not be preempted if there is a
2496                  * waiter waiting to take over.
2497                  */
2498                 console_lock_spinning_enable();
2499 
2500                 stop_critical_timings();        /* don't trace print latency */
2501                 call_console_drivers(ext_text, ext_len, text, len);
2502                 start_critical_timings();
2503 
2504                 if (console_lock_spinning_disable_and_check()) {
2505                         printk_safe_exit_irqrestore(flags);
2506                         return;
2507                 }
2508 
2509                 printk_safe_exit_irqrestore(flags);
2510 
2511                 if (do_cond_resched)
2512                         cond_resched();
2513         }
2514 
2515         console_locked = 0;
2516 
2517         raw_spin_unlock(&logbuf_lock);
2518 
2519         up_console_sem();
2520 
2521         /*
2522          * Someone could have filled up the buffer again, so re-check if there's
2523          * something to flush. In case we cannot trylock the console_sem again,
2524          * there's a new owner and the console_unlock() from them will do the
2525          * flush, no worries.
2526          */
2527         raw_spin_lock(&logbuf_lock);
2528         retry = console_seq != log_next_seq;
2529         raw_spin_unlock(&logbuf_lock);
2530         printk_safe_exit_irqrestore(flags);
2531 
2532         if (retry && console_trylock())
2533                 goto again;
2534 }
2535 EXPORT_SYMBOL(console_unlock);
2536 
2537 /**
2538  * console_conditional_schedule - yield the CPU if required
2539  *
2540  * If the console code is currently allowed to sleep, and
2541  * if this CPU should yield the CPU to another task, do
2542  * so here.
2543  *
2544  * Must be called within console_lock();.
2545  */
2546 void __sched console_conditional_schedule(void)
2547 {
2548         if (console_may_schedule)
2549                 cond_resched();
2550 }
2551 EXPORT_SYMBOL(console_conditional_schedule);
2552 
2553 void console_unblank(void)
2554 {
2555         struct console *c;
2556 
2557         /*
2558          * console_unblank can no longer be called in interrupt context unless
2559          * oops_in_progress is set to 1..
2560          */
2561         if (oops_in_progress) {
2562                 if (down_trylock_console_sem() != 0)
2563                         return;
2564         } else
2565                 console_lock();
2566 
2567         console_locked = 1;
2568         console_may_schedule = 0;
2569         for_each_console(c)
2570                 if ((c->flags & CON_ENABLED) && c->unblank)
2571                         c->unblank();
2572         console_unlock();
2573 }
2574 
2575 /**
2576  * console_flush_on_panic - flush console content on panic
2577  * @mode: flush all messages in buffer or just the pending ones
2578  *
2579  * Immediately output all pending messages no matter what.
2580  */
2581 void console_flush_on_panic(enum con_flush_mode mode)
2582 {
2583         /*
2584          * If someone else is holding the console lock, trylock will fail
2585          * and may_schedule may be set.  Ignore and proceed to unlock so
2586          * that messages are flushed out.  As this can be called from any
2587          * context and we don't want to get preempted while flushing,
2588          * ensure may_schedule is cleared.
2589          */
2590         console_trylock();
2591         console_may_schedule = 0;
2592 
2593         if (mode == CONSOLE_REPLAY_ALL) {
2594                 unsigned long flags;
2595 
2596                 logbuf_lock_irqsave(flags);
2597                 console_seq = log_first_seq;
2598                 console_idx = log_first_idx;
2599                 logbuf_unlock_irqrestore(flags);
2600         }
2601         console_unlock();
2602 }
2603 
2604 /*
2605  * Return the console tty driver structure and its associated index
2606  */
2607 struct tty_driver *console_device(int *index)
2608 {
2609         struct console *c;
2610         struct tty_driver *driver = NULL;
2611 
2612         console_lock();
2613         for_each_console(c) {
2614                 if (!c->device)
2615                         continue;
2616                 driver = c->device(c, index);
2617                 if (driver)
2618                         break;
2619         }
2620         console_unlock();
2621         return driver;
2622 }
2623 
2624 /*
2625  * Prevent further output on the passed console device so that (for example)
2626  * serial drivers can disable console output before suspending a port, and can
2627  * re-enable output afterwards.
2628  */
2629 void console_stop(struct console *console)
2630 {
2631         console_lock();
2632         console->flags &= ~CON_ENABLED;
2633         console_unlock();
2634 }
2635 EXPORT_SYMBOL(console_stop);
2636 
2637 void console_start(struct console *console)
2638 {
2639         console_lock();
2640         console->flags |= CON_ENABLED;
2641         console_unlock();
2642 }
2643 EXPORT_SYMBOL(console_start);
2644 
2645 static int __read_mostly keep_bootcon;
2646 
2647 static int __init keep_bootcon_setup(char *str)
2648 {
2649         keep_bootcon = 1;
2650         pr_info("debug: skip boot console de-registration.\n");
2651 
2652         return 0;
2653 }
2654 
2655 early_param("keep_bootcon", keep_bootcon_setup);
2656 
2657 /*
2658  * The console driver calls this routine during kernel initialization
2659  * to register the console printing procedure with printk() and to
2660  * print any messages that were printed by the kernel before the
2661  * console driver was initialized.
2662  *
2663  * This can happen pretty early during the boot process (because of
2664  * early_printk) - sometimes before setup_arch() completes - be careful
2665  * of what kernel features are used - they may not be initialised yet.
2666  *
2667  * There are two types of consoles - bootconsoles (early_printk) and
2668  * "real" consoles (everything which is not a bootconsole) which are
2669  * handled differently.
2670  *  - Any number of bootconsoles can be registered at any time.
2671  *  - As soon as a "real" console is registered, all bootconsoles
2672  *    will be unregistered automatically.
2673  *  - Once a "real" console is registered, any attempt to register a
2674  *    bootconsoles will be rejected
2675  */
2676 void register_console(struct console *newcon)
2677 {
2678         int i;
2679         unsigned long flags;
2680         struct console *bcon = NULL;
2681         struct console_cmdline *c;
2682         static bool has_preferred;
2683 
2684         if (console_drivers)
2685                 for_each_console(bcon)
2686                         if (WARN(bcon == newcon,
2687                                         "console '%s%d' already registered\n",
2688                                         bcon->name, bcon->index))
2689                                 return;
2690 
2691         /*
2692          * before we register a new CON_BOOT console, make sure we don't
2693          * already have a valid console
2694          */
2695         if (console_drivers && newcon->flags & CON_BOOT) {
2696                 /* find the last or real console */
2697                 for_each_console(bcon) {
2698                         if (!(bcon->flags & CON_BOOT)) {
2699                                 pr_info("Too late to register bootconsole %s%d\n",
2700                                         newcon->name, newcon->index);
2701                                 return;
2702                         }
2703                 }
2704         }
2705 
2706         if (console_drivers && console_drivers->flags & CON_BOOT)
2707                 bcon = console_drivers;
2708 
2709         if (!has_preferred || bcon || !console_drivers)
2710                 has_preferred = preferred_console >= 0;
2711 
2712         /*
2713          *      See if we want to use this console driver. If we
2714          *      didn't select a console we take the first one
2715          *      that registers here.
2716          */
2717         if (!has_preferred) {
2718                 if (newcon->index < 0)
2719                         newcon->index = 0;
2720                 if (newcon->setup == NULL ||
2721                     newcon->setup(newcon, NULL) == 0) {
2722                         newcon->flags |= CON_ENABLED;
2723                         if (newcon->device) {
2724                                 newcon->flags |= CON_CONSDEV;
2725                                 has_preferred = true;
2726                         }
2727                 }
2728         }
2729 
2730         /*
2731          *      See if this console matches one we selected on
2732          *      the command line.
2733          */
2734         for (i = 0, c = console_cmdline;
2735              i < MAX_CMDLINECONSOLES && c->name[0];
2736              i++, c++) {
2737                 if (!newcon->match ||
2738                     newcon->match(newcon, c->name, c->index, c->options) != 0) {
2739                         /* default matching */
2740                         BUILD_BUG_ON(sizeof(c->name) != sizeof(newcon->name));
2741                         if (strcmp(c->name, newcon->name) != 0)
2742                                 continue;
2743                         if (newcon->index >= 0 &&
2744                             newcon->index != c->index)
2745                                 continue;
2746                         if (newcon->index < 0)
2747                                 newcon->index = c->index;
2748 
2749                         if (_braille_register_console(newcon, c))
2750                                 return;
2751 
2752                         if (newcon->setup &&
2753                             newcon->setup(newcon, c->options) != 0)
2754                                 break;
2755                 }
2756 
2757                 newcon->flags |= CON_ENABLED;
2758                 if (i == preferred_console) {
2759                         newcon->flags |= CON_CONSDEV;
2760                         has_preferred = true;
2761                 }
2762                 break;
2763         }
2764 
2765         if (!(newcon->flags & CON_ENABLED))
2766                 return;
2767 
2768         /*
2769          * If we have a bootconsole, and are switching to a real console,
2770          * don't print everything out again, since when the boot console, and
2771          * the real console are the same physical device, it's annoying to
2772          * see the beginning boot messages twice
2773          */
2774         if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
2775                 newcon->flags &= ~CON_PRINTBUFFER;
2776 
2777         /*
2778          *      Put this console in the list - keep the
2779          *      preferred driver at the head of the list.
2780          */
2781         console_lock();
2782         if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
2783                 newcon->next = console_drivers;
2784                 console_drivers = newcon;
2785                 if (newcon->next)
2786                         newcon->next->flags &= ~CON_CONSDEV;
2787         } else {
2788                 newcon->next = console_drivers->next;
2789                 console_drivers->next = newcon;
2790         }
2791 
2792         if (newcon->flags & CON_EXTENDED)
2793                 nr_ext_console_drivers++;
2794 
2795         if (newcon->flags & CON_PRINTBUFFER) {
2796                 /*
2797                  * console_unlock(); will print out the buffered messages
2798                  * for us.
2799                  */
2800                 logbuf_lock_irqsave(flags);
2801                 /*
2802                  * We're about to replay the log buffer.  Only do this to the
2803                  * just-registered console to avoid excessive message spam to
2804                  * the already-registered consoles.
2805                  *
2806                  * Set exclusive_console with disabled interrupts to reduce
2807                  * race window with eventual console_flush_on_panic() that
2808                  * ignores console_lock.
2809                  */
2810                 exclusive_console = newcon;
2811                 exclusive_console_stop_seq = console_seq;
2812                 console_seq = syslog_seq;
2813                 console_idx = syslog_idx;
2814                 logbuf_unlock_irqrestore(flags);
2815         }
2816         console_unlock();
2817         console_sysfs_notify();
2818 
2819         /*
2820          * By unregistering the bootconsoles after we enable the real console
2821          * we get the "console xxx enabled" message on all the consoles -
2822          * boot consoles, real consoles, etc - this is to ensure that end
2823          * users know there might be something in the kernel's log buffer that
2824          * went to the bootconsole (that they do not see on the real console)
2825          */
2826         pr_info("%sconsole [%s%d] enabled\n",
2827                 (newcon->flags & CON_BOOT) ? "boot" : "" ,
2828                 newcon->name, newcon->index);
2829         if (bcon &&
2830             ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
2831             !keep_bootcon) {
2832                 /* We need to iterate through all boot consoles, to make
2833                  * sure we print everything out, before we unregister them.
2834                  */
2835                 for_each_console(bcon)
2836                         if (bcon->flags & CON_BOOT)
2837                                 unregister_console(bcon);
2838         }
2839 }
2840 EXPORT_SYMBOL(register_console);
2841 
2842 int unregister_console(struct console *console)
2843 {
2844         struct console *a, *b;
2845         int res;
2846 
2847         pr_info("%sconsole [%s%d] disabled\n",
2848                 (console->flags & CON_BOOT) ? "boot" : "" ,
2849                 console->name, console->index);
2850 
2851         res = _braille_unregister_console(console);
2852         if (res)
2853                 return res;
2854 
2855         res = 1;
2856         console_lock();
2857         if (console_drivers == console) {
2858                 console_drivers=console->next;
2859                 res = 0;
2860         } else if (console_drivers) {
2861                 for (a=console_drivers->next, b=console_drivers ;
2862                      a; b=a, a=b->next) {
2863                         if (a == console) {
2864                                 b->next = a->next;
2865                                 res = 0;
2866                                 break;
2867                         }
2868                 }
2869         }
2870 
2871         if (!res && (console->flags & CON_EXTENDED))
2872                 nr_ext_console_drivers--;
2873 
2874         /*
2875          * If this isn't the last console and it has CON_CONSDEV set, we
2876          * need to set it on the next preferred console.
2877          */
2878         if (console_drivers != NULL && console->flags & CON_CONSDEV)
2879                 console_drivers->flags |= CON_CONSDEV;
2880 
2881         console->flags &= ~CON_ENABLED;
2882         console_unlock();
2883         console_sysfs_notify();
2884         return res;
2885 }
2886 EXPORT_SYMBOL(unregister_console);
2887 
2888 /*
2889  * Initialize the console device. This is called *early*, so
2890  * we can't necessarily depend on lots of kernel help here.
2891  * Just do some early initializations, and do the complex setup
2892  * later.
2893  */
2894 void __init console_init(void)
2895 {
2896         int ret;
2897         initcall_t call;
2898         initcall_entry_t *ce;
2899 
2900         /* Setup the default TTY line discipline. */
2901         n_tty_init();
2902 
2903         /*
2904          * set up the console device so that later boot sequences can
2905          * inform about problems etc..
2906          */
2907         ce = __con_initcall_start;
2908         trace_initcall_level("console");
2909         while (ce < __con_initcall_end) {
2910                 call = initcall_from_entry(ce);
2911                 trace_initcall_start(call);
2912                 ret = call();
2913                 trace_initcall_finish(call, ret);
2914                 ce++;
2915         }
2916 }
2917 
2918 /*
2919  * Some boot consoles access data that is in the init section and which will
2920  * be discarded after the initcalls have been run. To make sure that no code
2921  * will access this data, unregister the boot consoles in a late initcall.
2922  *
2923  * If for some reason, such as deferred probe or the driver being a loadable
2924  * module, the real console hasn't registered yet at this point, there will
2925  * be a brief interval in which no messages are logged to the console, which
2926  * makes it difficult to diagnose problems that occur during this time.
2927  *
2928  * To mitigate this problem somewhat, only unregister consoles whose memory
2929  * intersects with the init section. Note that all other boot consoles will
2930  * get unregistred when the real preferred console is registered.
2931  */
2932 static int __init printk_late_init(void)
2933 {
2934         struct console *con;
2935         int ret;
2936 
2937         for_each_console(con) {
2938                 if (!(con->flags & CON_BOOT))
2939                         continue;
2940 
2941                 /* Check addresses that might be used for enabled consoles. */
2942                 if (init_section_intersects(con, sizeof(*con)) ||
2943                     init_section_contains(con->write, 0) ||
2944                     init_section_contains(con->read, 0) ||
2945                     init_section_contains(con->device, 0) ||
2946                     init_section_contains(con->unblank, 0) ||
2947                     init_section_contains(con->data, 0)) {
2948                         /*
2949                          * Please, consider moving the reported consoles out
2950                          * of the init section.
2951                          */
2952                         pr_warn("bootconsole [%s%d] uses init memory and must be disabled even before the real one is ready\n",
2953                                 con->name, con->index);
2954                         unregister_console(con);
2955                 }
2956         }
2957         ret = cpuhp_setup_state_nocalls(CPUHP_PRINTK_DEAD, "printk:dead", NULL,
2958                                         console_cpu_notify);
2959         WARN_ON(ret < 0);
2960         ret = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN, "printk:online",
2961                                         console_cpu_notify, NULL);
2962         WARN_ON(ret < 0);
2963         return 0;
2964 }
2965 late_initcall(printk_late_init);
2966 
2967 #if defined CONFIG_PRINTK
2968 /*
2969  * Delayed printk version, for scheduler-internal messages:
2970  */
2971 #define PRINTK_PENDING_WAKEUP   0x01
2972 #define PRINTK_PENDING_OUTPUT   0x02
2973 
2974 static DEFINE_PER_CPU(int, printk_pending);
2975 
2976 static void wake_up_klogd_work_func(struct irq_work *irq_work)
2977 {
2978         int pending = __this_cpu_xchg(printk_pending, 0);
2979 
2980         if (pending & PRINTK_PENDING_OUTPUT) {
2981                 /* If trylock fails, someone else is doing the printing */
2982                 if (console_trylock())
2983                         console_unlock();
2984         }
2985 
2986         if (pending & PRINTK_PENDING_WAKEUP)
2987                 wake_up_interruptible(&log_wait);
2988 }
2989 
2990 static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
2991         .func = wake_up_klogd_work_func,
2992         .flags = IRQ_WORK_LAZY,
2993 };
2994 
2995 void wake_up_klogd(void)
2996 {
2997         if (!printk_percpu_data_ready())
2998                 return;
2999 
3000         preempt_disable();
3001         if (waitqueue_active(&log_wait)) {
3002                 this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
3003                 irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
3004         }
3005         preempt_enable();
3006 }
3007 
3008 void defer_console_output(void)
3009 {
3010         if (!printk_percpu_data_ready())
3011                 return;
3012 
3013         preempt_disable();
3014         __this_cpu_or(printk_pending, PRINTK_PENDING_OUTPUT);
3015         irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
3016         preempt_enable();
3017 }
3018 
3019 int vprintk_deferred(const char *fmt, va_list args)
3020 {
3021         int r;
3022 
3023         r = vprintk_emit(0, LOGLEVEL_SCHED, NULL, 0, fmt, args);
3024         defer_console_output();
3025 
3026         return r;
3027 }
3028 
3029 int printk_deferred(const char *fmt, ...)
3030 {
3031         va_list args;
3032         int r;
3033 
3034         va_start(args, fmt);
3035         r = vprintk_deferred(fmt, args);
3036         va_end(args);
3037 
3038         return r;
3039 }
3040 
3041 /*
3042  * printk rate limiting, lifted from the networking subsystem.
3043  *
3044  * This enforces a rate limit: not more than 10 kernel messages
3045  * every 5s to make a denial-of-service attack impossible.
3046  */
3047 DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
3048 
3049 int __printk_ratelimit(const char *func)
3050 {
3051         return ___ratelimit(&printk_ratelimit_state, func);
3052 }
3053 EXPORT_SYMBOL(__printk_ratelimit);
3054 
3055 /**
3056  * printk_timed_ratelimit - caller-controlled printk ratelimiting
3057  * @caller_jiffies: pointer to caller's state
3058  * @interval_msecs: minimum interval between prints
3059  *
3060  * printk_timed_ratelimit() returns true if more than @interval_msecs
3061  * milliseconds have elapsed since the last time printk_timed_ratelimit()
3062  * returned true.
3063  */
3064 bool printk_timed_ratelimit(unsigned long *caller_jiffies,
3065                         unsigned int interval_msecs)
3066 {
3067         unsigned long elapsed = jiffies - *caller_jiffies;
3068 
3069         if (*caller_jiffies && elapsed <= msecs_to_jiffies(interval_msecs))
3070                 return false;
3071 
3072         *caller_jiffies = jiffies;
3073         return true;
3074 }
3075 EXPORT_SYMBOL(printk_timed_ratelimit);
3076 
3077 static DEFINE_SPINLOCK(dump_list_lock);
3078 static LIST_HEAD(dump_list);
3079 
3080 /**
3081  * kmsg_dump_register - register a kernel log dumper.
3082  * @dumper: pointer to the kmsg_dumper structure
3083  *
3084  * Adds a kernel log dumper to the system. The dump callback in the
3085  * structure will be called when the kernel oopses or panics and must be
3086  * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
3087  */
3088 int kmsg_dump_register(struct kmsg_dumper *dumper)
3089 {
3090         unsigned long flags;
3091         int err = -EBUSY;
3092 
3093         /* The dump callback needs to be set */
3094         if (!dumper->dump)
3095                 return -EINVAL;
3096 
3097         spin_lock_irqsave(&dump_list_lock, flags);
3098         /* Don't allow registering multiple times */
3099         if (!dumper->registered) {
3100                 dumper->registered = 1;
3101                 list_add_tail_rcu(&dumper->list, &dump_list);
3102                 err = 0;
3103         }
3104         spin_unlock_irqrestore(&dump_list_lock, flags);
3105 
3106         return err;
3107 }
3108 EXPORT_SYMBOL_GPL(kmsg_dump_register);
3109 
3110 /**
3111  * kmsg_dump_unregister - unregister a kmsg dumper.
3112  * @dumper: pointer to the kmsg_dumper structure
3113  *
3114  * Removes a dump device from the system. Returns zero on success and
3115  * %-EINVAL otherwise.
3116  */
3117 int kmsg_dump_unregister(struct kmsg_dumper *dumper)
3118 {
3119         unsigned long flags;
3120         int err = -EINVAL;
3121 
3122         spin_lock_irqsave(&dump_list_lock, flags);
3123         if (dumper->registered) {
3124                 dumper->registered = 0;
3125                 list_del_rcu(&dumper->list);
3126                 err = 0;
3127         }
3128         spin_unlock_irqrestore(&dump_list_lock, flags);
3129         synchronize_rcu();
3130 
3131         return err;
3132 }
3133 EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
3134 
3135 static bool always_kmsg_dump;
3136 module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
3137 
3138 /**
3139  * kmsg_dump - dump kernel log to kernel message dumpers.
3140  * @reason: the reason (oops, panic etc) for dumping
3141  *
3142  * Call each of the registered dumper's dump() callback, which can
3143  * retrieve the kmsg records with kmsg_dump_get_line() or
3144  * kmsg_dump_get_buffer().
3145  */
3146 void kmsg_dump(enum kmsg_dump_reason reason)
3147 {
3148         struct kmsg_dumper *dumper;
3149         unsigned long flags;
3150 
3151         if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
3152                 return;
3153 
3154         rcu_read_lock();
3155         list_for_each_entry_rcu(dumper, &dump_list, list) {
3156                 if (dumper->max_reason && reason > dumper->max_reason)
3157                         continue;
3158 
3159                 /* initialize iterator with data about the stored records */
3160                 dumper->active = true;
3161 
3162                 logbuf_lock_irqsave(flags);
3163                 dumper->cur_seq = clear_seq;
3164                 dumper->cur_idx = clear_idx;
3165                 dumper->next_seq = log_next_seq;
3166                 dumper->next_idx = log_next_idx;
3167                 logbuf_unlock_irqrestore(flags);
3168 
3169                 /* invoke dumper which will iterate over records */
3170                 dumper->dump(dumper, reason);
3171 
3172                 /* reset iterator */
3173                 dumper->active = false;
3174         }
3175         rcu_read_unlock();
3176 }
3177 
3178 /**
3179  * kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version)
3180  * @dumper: registered kmsg dumper
3181  * @syslog: include the "<4>" prefixes
3182  * @line: buffer to copy the line to
3183  * @size: maximum size of the buffer
3184  * @len: length of line placed into buffer
3185  *
3186  * Start at the beginning of the kmsg buffer, with the oldest kmsg
3187  * record, and copy one record into the provided buffer.
3188  *
3189  * Consecutive calls will return the next available record moving
3190  * towards the end of the buffer with the youngest messages.
3191  *
3192  * A return value of FALSE indicates that there are no more records to
3193  * read.
3194  *
3195  * The function is similar to kmsg_dump_get_line(), but grabs no locks.
3196  */
3197 bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
3198                                char *line, size_t size, size_t *len)
3199 {
3200         struct printk_log *msg;
3201         size_t l = 0;
3202         bool ret = false;
3203 
3204         if (!dumper->active)
3205                 goto out;
3206 
3207         if (dumper->cur_seq < log_first_seq) {
3208                 /* messages are gone, move to first available one */
3209                 dumper->cur_seq = log_first_seq;
3210                 dumper->cur_idx = log_first_idx;
3211         }
3212 
3213         /* last entry */
3214         if (dumper->cur_seq >= log_next_seq)
3215                 goto out;
3216 
3217         msg = log_from_idx(dumper->cur_idx);
3218         l = msg_print_text(msg, syslog, printk_time, line, size);
3219 
3220         dumper->cur_idx = log_next(dumper->cur_idx);
3221         dumper->cur_seq++;
3222         ret = true;
3223 out:
3224         if (len)
3225                 *len = l;
3226         return ret;
3227 }
3228 
3229 /**
3230  * kmsg_dump_get_line - retrieve one kmsg log line
3231  * @dumper: registered kmsg dumper
3232  * @syslog: include the "<4>" prefixes
3233  * @line: buffer to copy the line to
3234  * @size: maximum size of the buffer
3235  * @len: length of line placed into buffer
3236  *
3237  * Start at the beginning of the kmsg buffer, with the oldest kmsg
3238  * record, and copy one record into the provided buffer.
3239  *
3240  * Consecutive calls will return the next available record moving
3241  * towards the end of the buffer with the youngest messages.
3242  *
3243  * A return value of FALSE indicates that there are no more records to
3244  * read.
3245  */
3246 bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
3247                         char *line, size_t size, size_t *len)
3248 {
3249         unsigned long flags;
3250         bool ret;
3251 
3252         logbuf_lock_irqsave(flags);
3253         ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
3254         logbuf_unlock_irqrestore(flags);
3255 
3256         return ret;
3257 }
3258 EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
3259 
3260 /**
3261  * kmsg_dump_get_buffer - copy kmsg log lines
3262  * @dumper: registered kmsg dumper
3263  * @syslog: include the "<4>" prefixes
3264  * @buf: buffer to copy the line to
3265  * @size: maximum size of the buffer
3266  * @len: length of line placed into buffer
3267  *
3268  * Start at the end of the kmsg buffer and fill the provided buffer
3269  * with as many of the the *youngest* kmsg records that fit into it.
3270  * If the buffer is large enough, all available kmsg records will be
3271  * copied with a single call.
3272  *
3273  * Consecutive calls will fill the buffer with the next block of
3274  * available older records, not including the earlier retrieved ones.
3275  *
3276  * A return value of FALSE indicates that there are no more records to
3277  * read.
3278  */
3279 bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
3280                           char *buf, size_t size, size_t *len)
3281 {
3282         unsigned long flags;
3283         u64 seq;
3284         u32 idx;
3285         u64 next_seq;
3286         u32 next_idx;
3287         size_t l = 0;
3288         bool ret = false;
3289         bool time = printk_time;
3290 
3291         if (!dumper->active)
3292                 goto out;
3293 
3294         logbuf_lock_irqsave(flags);
3295         if (dumper->cur_seq < log_first_seq) {
3296                 /* messages are gone, move to first available one */
3297                 dumper->cur_seq = log_first_seq;
3298                 dumper->cur_idx = log_first_idx;
3299         }
3300 
3301         /* last entry */
3302         if (dumper->cur_seq >= dumper->next_seq) {
3303                 logbuf_unlock_irqrestore(flags);
3304                 goto out;
3305         }
3306 
3307         /* calculate length of entire buffer */
3308         seq = dumper->cur_seq;
3309         idx = dumper->cur_idx;
3310         while (seq < dumper->next_seq) {
3311                 struct printk_log *msg = log_from_idx(idx);
3312 
3313                 l += msg_print_text(msg, true, time, NULL, 0);
3314                 idx = log_next(idx);
3315                 seq++;
3316         }
3317 
3318         /* move first record forward until length fits into the buffer */
3319         seq = dumper->cur_seq;
3320         idx = dumper->cur_idx;
3321         while (l >= size && seq < dumper->next_seq) {
3322                 struct printk_log *msg = log_from_idx(idx);
3323 
3324                 l -= msg_print_text(msg, true, time, NULL, 0);
3325                 idx = log_next(idx);
3326                 seq++;
3327         }
3328 
3329         /* last message in next interation */
3330         next_seq = seq;
3331         next_idx = idx;
3332 
3333         l = 0;
3334         while (seq < dumper->next_seq) {
3335                 struct printk_log *msg = log_from_idx(idx);
3336 
3337                 l += msg_print_text(msg, syslog, time, buf + l, size - l);
3338                 idx = log_next(idx);
3339                 seq++;
3340         }
3341 
3342         dumper->next_seq = next_seq;
3343         dumper->next_idx = next_idx;
3344         ret = true;
3345         logbuf_unlock_irqrestore(flags);
3346 out:
3347         if (len)
3348                 *len = l;
3349         return ret;
3350 }
3351 EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
3352 
3353 /**
3354  * kmsg_dump_rewind_nolock - reset the interator (unlocked version)
3355  * @dumper: registered kmsg dumper
3356  *
3357  * Reset the dumper's iterator so that kmsg_dump_get_line() and
3358  * kmsg_dump_get_buffer() can be called again and used multiple
3359  * times within the same dumper.dump() callback.
3360  *
3361  * The function is similar to kmsg_dump_rewind(), but grabs no locks.
3362  */
3363 void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
3364 {
3365         dumper->cur_seq = clear_seq;
3366         dumper->cur_idx = clear_idx;
3367         dumper->next_seq = log_next_seq;
3368         dumper->next_idx = log_next_idx;
3369 }
3370 
3371 /**
3372  * kmsg_dump_rewind - reset the interator
3373  * @dumper: registered kmsg dumper
3374  *
3375  * Reset the dumper's iterator so that kmsg_dump_get_line() and
3376  * kmsg_dump_get_buffer() can be called again and used multiple
3377  * times within the same dumper.dump() callback.
3378  */
3379 void kmsg_dump_rewind(struct kmsg_dumper *dumper)
3380 {
3381         unsigned long flags;
3382 
3383         logbuf_lock_irqsave(flags);
3384         kmsg_dump_rewind_nolock(dumper);
3385         logbuf_unlock_irqrestore(flags);
3386 }
3387 EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
3388 
3389 #endif