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