~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/printk/printk.c

Version: ~ [ linux-4.20-rc6 ] ~ [ linux-4.19.8 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.87 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.144 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.166 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.128 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.61 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp