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