LCOV - code coverage report
Current view: top level - kernel/printk - printk.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 651 1285 50.7 %
Date: 2021-04-22 12:43:58 Functions: 48 93 51.6 %

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

Generated by: LCOV version 1.14