1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
22#include <linux/kernel.h>
23#include <linux/mm.h>
24#include <linux/tty.h>
25#include <linux/tty_driver.h>
26#include <linux/console.h>
27#include <linux/init.h>
28#include <linux/jiffies.h>
29#include <linux/nmi.h>
30#include <linux/module.h>
31#include <linux/moduleparam.h>
32#include <linux/delay.h>
33#include <linux/smp.h>
34#include <linux/security.h>
35#include <linux/memblock.h>
36#include <linux/syscalls.h>
37#include <linux/crash_core.h>
38#include <linux/ratelimit.h>
39#include <linux/kmsg_dump.h>
40#include <linux/syslog.h>
41#include <linux/cpu.h>
42#include <linux/rculist.h>
43#include <linux/poll.h>
44#include <linux/irq_work.h>
45#include <linux/ctype.h>
46#include <linux/uio.h>
47#include <linux/sched/clock.h>
48#include <linux/sched/debug.h>
49#include <linux/sched/task_stack.h>
50
51#include <linux/uaccess.h>
52#include <asm/sections.h>
53
54#include <trace/events/initcall.h>
55#define CREATE_TRACE_POINTS
56#include <trace/events/printk.h>
57
58#include "console_cmdline.h"
59#include "braille.h"
60#include "internal.h"
61
62int console_printk[4] = {
63 CONSOLE_LOGLEVEL_DEFAULT,
64 MESSAGE_LOGLEVEL_DEFAULT,
65 CONSOLE_LOGLEVEL_MIN,
66 CONSOLE_LOGLEVEL_DEFAULT,
67};
68EXPORT_SYMBOL_GPL(console_printk);
69
70atomic_t ignore_console_lock_warning __read_mostly = ATOMIC_INIT(0);
71EXPORT_SYMBOL(ignore_console_lock_warning);
72
73
74
75
76
77int oops_in_progress;
78EXPORT_SYMBOL(oops_in_progress);
79
80
81
82
83
84
85static DEFINE_SEMAPHORE(console_sem);
86struct console *console_drivers;
87EXPORT_SYMBOL_GPL(console_drivers);
88
89
90
91
92
93int __read_mostly suppress_printk;
94
95#ifdef CONFIG_LOCKDEP
96static struct lockdep_map console_lock_dep_map = {
97 .name = "console_lock"
98};
99#endif
100
101enum devkmsg_log_bits {
102 __DEVKMSG_LOG_BIT_ON = 0,
103 __DEVKMSG_LOG_BIT_OFF,
104 __DEVKMSG_LOG_BIT_LOCK,
105};
106
107enum devkmsg_log_masks {
108 DEVKMSG_LOG_MASK_ON = BIT(__DEVKMSG_LOG_BIT_ON),
109 DEVKMSG_LOG_MASK_OFF = BIT(__DEVKMSG_LOG_BIT_OFF),
110 DEVKMSG_LOG_MASK_LOCK = BIT(__DEVKMSG_LOG_BIT_LOCK),
111};
112
113
114#define DEVKMSG_LOG_MASK_DEFAULT 0
115
116static unsigned int __read_mostly devkmsg_log = DEVKMSG_LOG_MASK_DEFAULT;
117
118static int __control_devkmsg(char *str)
119{
120 size_t len;
121
122 if (!str)
123 return -EINVAL;
124
125 len = str_has_prefix(str, "on");
126 if (len) {
127 devkmsg_log = DEVKMSG_LOG_MASK_ON;
128 return len;
129 }
130
131 len = str_has_prefix(str, "off");
132 if (len) {
133 devkmsg_log = DEVKMSG_LOG_MASK_OFF;
134 return len;
135 }
136
137 len = str_has_prefix(str, "ratelimit");
138 if (len) {
139 devkmsg_log = DEVKMSG_LOG_MASK_DEFAULT;
140 return len;
141 }
142
143 return -EINVAL;
144}
145
146static int __init control_devkmsg(char *str)
147{
148 if (__control_devkmsg(str) < 0)
149 return 1;
150
151
152
153
154 if (devkmsg_log == DEVKMSG_LOG_MASK_ON)
155 strcpy(devkmsg_log_str, "on");
156 else if (devkmsg_log == DEVKMSG_LOG_MASK_OFF)
157 strcpy(devkmsg_log_str, "off");
158
159
160
161
162
163
164
165
166 devkmsg_log |= DEVKMSG_LOG_MASK_LOCK;
167
168 return 0;
169}
170__setup("printk.devkmsg=", control_devkmsg);
171
172char devkmsg_log_str[DEVKMSG_STR_MAX_SIZE] = "ratelimit";
173
174int devkmsg_sysctl_set_loglvl(struct ctl_table *table, int write,
175 void *buffer, size_t *lenp, loff_t *ppos)
176{
177 char old_str[DEVKMSG_STR_MAX_SIZE];
178 unsigned int old;
179 int err;
180
181 if (write) {
182 if (devkmsg_log & DEVKMSG_LOG_MASK_LOCK)
183 return -EINVAL;
184
185 old = devkmsg_log;
186 strncpy(old_str, devkmsg_log_str, DEVKMSG_STR_MAX_SIZE);
187 }
188
189 err = proc_dostring(table, write, buffer, lenp, ppos);
190 if (err)
191 return err;
192
193 if (write) {
194 err = __control_devkmsg(devkmsg_log_str);
195
196
197
198
199
200 if (err < 0 || (err + 1 != *lenp)) {
201
202
203 devkmsg_log = old;
204 strncpy(devkmsg_log_str, old_str, DEVKMSG_STR_MAX_SIZE);
205
206 return -EINVAL;
207 }
208 }
209
210 return 0;
211}
212
213
214static int nr_ext_console_drivers;
215
216
217
218
219
220#define down_console_sem() do { \
221 down(&console_sem);\
222 mutex_acquire(&console_lock_dep_map, 0, 0, _RET_IP_);\
223} while (0)
224
225static int __down_trylock_console_sem(unsigned long ip)
226{
227 int lock_failed;
228 unsigned long flags;
229
230
231
232
233
234
235 printk_safe_enter_irqsave(flags);
236 lock_failed = down_trylock(&console_sem);
237 printk_safe_exit_irqrestore(flags);
238
239 if (lock_failed)
240 return 1;
241 mutex_acquire(&console_lock_dep_map, 0, 1, ip);
242 return 0;
243}
244#define down_trylock_console_sem() __down_trylock_console_sem(_RET_IP_)
245
246static void __up_console_sem(unsigned long ip)
247{
248 unsigned long flags;
249
250 mutex_release(&console_lock_dep_map, ip);
251
252 printk_safe_enter_irqsave(flags);
253 up(&console_sem);
254 printk_safe_exit_irqrestore(flags);
255}
256#define up_console_sem() __up_console_sem(_RET_IP_)
257
258
259
260
261
262
263
264
265
266static int console_locked, console_suspended;
267
268
269
270
271static struct console *exclusive_console;
272
273
274
275
276
277#define MAX_CMDLINECONSOLES 8
278
279static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
280
281static int preferred_console = -1;
282static bool has_preferred_console;
283int console_set_on_cmdline;
284EXPORT_SYMBOL(console_set_on_cmdline);
285
286
287static int console_may_schedule;
288
289enum con_msg_format_flags {
290 MSG_FORMAT_DEFAULT = 0,
291 MSG_FORMAT_SYSLOG = (1 << 0),
292};
293
294static int console_msg_format = MSG_FORMAT_DEFAULT;
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363enum log_flags {
364 LOG_NEWLINE = 2,
365 LOG_CONT = 8,
366};
367
368struct printk_log {
369 u64 ts_nsec;
370 u16 len;
371 u16 text_len;
372 u16 dict_len;
373 u8 facility;
374 u8 flags:5;
375 u8 level:3;
376#ifdef CONFIG_PRINTK_CALLER
377 u32 caller_id;
378#endif
379}
380#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
381__packed __aligned(4)
382#endif
383;
384
385
386
387
388
389
390DEFINE_RAW_SPINLOCK(logbuf_lock);
391
392
393
394
395
396#define logbuf_lock_irq() \
397 do { \
398 printk_safe_enter_irq(); \
399 raw_spin_lock(&logbuf_lock); \
400 } while (0)
401
402#define logbuf_unlock_irq() \
403 do { \
404 raw_spin_unlock(&logbuf_lock); \
405 printk_safe_exit_irq(); \
406 } while (0)
407
408#define logbuf_lock_irqsave(flags) \
409 do { \
410 printk_safe_enter_irqsave(flags); \
411 raw_spin_lock(&logbuf_lock); \
412 } while (0)
413
414#define logbuf_unlock_irqrestore(flags) \
415 do { \
416 raw_spin_unlock(&logbuf_lock); \
417 printk_safe_exit_irqrestore(flags); \
418 } while (0)
419
420#ifdef CONFIG_PRINTK
421DECLARE_WAIT_QUEUE_HEAD(log_wait);
422
423static u64 syslog_seq;
424static u32 syslog_idx;
425static size_t syslog_partial;
426static bool syslog_time;
427
428
429static u64 log_first_seq;
430static u32 log_first_idx;
431
432
433static u64 log_next_seq;
434static u32 log_next_idx;
435
436
437static u64 console_seq;
438static u32 console_idx;
439static u64 exclusive_console_stop_seq;
440
441
442static u64 clear_seq;
443static u32 clear_idx;
444
445#ifdef CONFIG_PRINTK_CALLER
446#define PREFIX_MAX 48
447#else
448#define PREFIX_MAX 32
449#endif
450#define LOG_LINE_MAX (1024 - PREFIX_MAX)
451
452#define LOG_LEVEL(v) ((v) & 0x07)
453#define LOG_FACILITY(v) ((v) >> 3 & 0xff)
454
455
456#define LOG_ALIGN __alignof__(struct printk_log)
457#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
458#define LOG_BUF_LEN_MAX (u32)(1 << 31)
459static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
460static char *log_buf = __log_buf;
461static u32 log_buf_len = __LOG_BUF_LEN;
462
463
464
465
466
467
468static bool __printk_percpu_data_ready __read_mostly;
469
470bool printk_percpu_data_ready(void)
471{
472 return __printk_percpu_data_ready;
473}
474
475
476char *log_buf_addr_get(void)
477{
478 return log_buf;
479}
480
481
482u32 log_buf_len_get(void)
483{
484 return log_buf_len;
485}
486
487
488static char *log_text(const struct printk_log *msg)
489{
490 return (char *)msg + sizeof(struct printk_log);
491}
492
493
494static char *log_dict(const struct printk_log *msg)
495{
496 return (char *)msg + sizeof(struct printk_log) + msg->text_len;
497}
498
499
500static struct printk_log *log_from_idx(u32 idx)
501{
502 struct printk_log *msg = (struct printk_log *)(log_buf + idx);
503
504
505
506
507
508 if (!msg->len)
509 return (struct printk_log *)log_buf;
510 return msg;
511}
512
513
514static u32 log_next(u32 idx)
515{
516 struct printk_log *msg = (struct printk_log *)(log_buf + idx);
517
518
519
520
521
522
523
524 if (!msg->len) {
525 msg = (struct printk_log *)log_buf;
526 return msg->len;
527 }
528 return idx + msg->len;
529}
530
531
532
533
534
535
536
537
538
539
540static int logbuf_has_space(u32 msg_size, bool empty)
541{
542 u32 free;
543
544 if (log_next_idx > log_first_idx || empty)
545 free = max(log_buf_len - log_next_idx, log_first_idx);
546 else
547 free = log_first_idx - log_next_idx;
548
549
550
551
552
553 return free >= msg_size + sizeof(struct printk_log);
554}
555
556static int log_make_free_space(u32 msg_size)
557{
558 while (log_first_seq < log_next_seq &&
559 !logbuf_has_space(msg_size, false)) {
560
561 log_first_idx = log_next(log_first_idx);
562 log_first_seq++;
563 }
564
565 if (clear_seq < log_first_seq) {
566 clear_seq = log_first_seq;
567 clear_idx = log_first_idx;
568 }
569
570
571 if (logbuf_has_space(msg_size, log_first_seq == log_next_seq))
572 return 0;
573
574 return -ENOMEM;
575}
576
577
578static u32 msg_used_size(u16 text_len, u16 dict_len, u32 *pad_len)
579{
580 u32 size;
581
582 size = sizeof(struct printk_log) + text_len + dict_len;
583 *pad_len = (-size) & (LOG_ALIGN - 1);
584 size += *pad_len;
585
586 return size;
587}
588
589
590
591
592
593
594#define MAX_LOG_TAKE_PART 4
595static const char trunc_msg[] = "<truncated>";
596
597static u32 truncate_msg(u16 *text_len, u16 *trunc_msg_len,
598 u16 *dict_len, u32 *pad_len)
599{
600
601
602
603
604 u32 max_text_len = log_buf_len / MAX_LOG_TAKE_PART;
605 if (*text_len > max_text_len)
606 *text_len = max_text_len;
607
608 *trunc_msg_len = strlen(trunc_msg);
609
610 *dict_len = 0;
611
612 return msg_used_size(*text_len + *trunc_msg_len, 0, pad_len);
613}
614
615
616static int log_store(u32 caller_id, int facility, int level,
617 enum log_flags flags, u64 ts_nsec,
618 const char *dict, u16 dict_len,
619 const char *text, u16 text_len)
620{
621 struct printk_log *msg;
622 u32 size, pad_len;
623 u16 trunc_msg_len = 0;
624
625
626 size = msg_used_size(text_len, dict_len, &pad_len);
627
628 if (log_make_free_space(size)) {
629
630 size = truncate_msg(&text_len, &trunc_msg_len,
631 &dict_len, &pad_len);
632
633 if (log_make_free_space(size))
634 return 0;
635 }
636
637 if (log_next_idx + size + sizeof(struct printk_log) > log_buf_len) {
638
639
640
641
642
643 memset(log_buf + log_next_idx, 0, sizeof(struct printk_log));
644 log_next_idx = 0;
645 }
646
647
648 msg = (struct printk_log *)(log_buf + log_next_idx);
649 memcpy(log_text(msg), text, text_len);
650 msg->text_len = text_len;
651 if (trunc_msg_len) {
652 memcpy(log_text(msg) + text_len, trunc_msg, trunc_msg_len);
653 msg->text_len += trunc_msg_len;
654 }
655 memcpy(log_dict(msg), dict, dict_len);
656 msg->dict_len = dict_len;
657 msg->facility = facility;
658 msg->level = level & 7;
659 msg->flags = flags & 0x1f;
660 if (ts_nsec > 0)
661 msg->ts_nsec = ts_nsec;
662 else
663 msg->ts_nsec = local_clock();
664#ifdef CONFIG_PRINTK_CALLER
665 msg->caller_id = caller_id;
666#endif
667 memset(log_dict(msg) + dict_len, 0, pad_len);
668 msg->len = size;
669
670
671 log_next_idx += msg->len;
672 log_next_seq++;
673
674 return msg->text_len;
675}
676
677int dmesg_restrict = IS_ENABLED(CONFIG_SECURITY_DMESG_RESTRICT);
678
679static int syslog_action_restricted(int type)
680{
681 if (dmesg_restrict)
682 return 1;
683
684
685
686
687 return type != SYSLOG_ACTION_READ_ALL &&
688 type != SYSLOG_ACTION_SIZE_BUFFER;
689}
690
691static int check_syslog_permissions(int type, int source)
692{
693
694
695
696
697 if (source == SYSLOG_FROM_PROC && type != SYSLOG_ACTION_OPEN)
698 goto ok;
699
700 if (syslog_action_restricted(type)) {
701 if (capable(CAP_SYSLOG))
702 goto ok;
703
704
705
706
707 if (capable(CAP_SYS_ADMIN)) {
708 pr_warn_once("%s (%d): Attempt to access syslog with "
709 "CAP_SYS_ADMIN but no CAP_SYSLOG "
710 "(deprecated).\n",
711 current->comm, task_pid_nr(current));
712 goto ok;
713 }
714 return -EPERM;
715 }
716ok:
717 return security_syslog(type);
718}
719
720static void append_char(char **pp, char *e, char c)
721{
722 if (*pp < e)
723 *(*pp)++ = c;
724}
725
726static ssize_t msg_print_ext_header(char *buf, size_t size,
727 struct printk_log *msg, u64 seq)
728{
729 u64 ts_usec = msg->ts_nsec;
730 char caller[20];
731#ifdef CONFIG_PRINTK_CALLER
732 u32 id = msg->caller_id;
733
734 snprintf(caller, sizeof(caller), ",caller=%c%u",
735 id & 0x80000000 ? 'C' : 'T', id & ~0x80000000);
736#else
737 caller[0] = '\0';
738#endif
739
740 do_div(ts_usec, 1000);
741
742 return scnprintf(buf, size, "%u,%llu,%llu,%c%s;",
743 (msg->facility << 3) | msg->level, seq, ts_usec,
744 msg->flags & LOG_CONT ? 'c' : '-', caller);
745}
746
747static ssize_t msg_print_ext_body(char *buf, size_t size,
748 char *dict, size_t dict_len,
749 char *text, size_t text_len)
750{
751 char *p = buf, *e = buf + size;
752 size_t i;
753
754
755 for (i = 0; i < text_len; i++) {
756 unsigned char c = text[i];
757
758 if (c < ' ' || c >= 127 || c == '\\')
759 p += scnprintf(p, e - p, "\\x%02x", c);
760 else
761 append_char(&p, e, c);
762 }
763 append_char(&p, e, '\n');
764
765 if (dict_len) {
766 bool line = true;
767
768 for (i = 0; i < dict_len; i++) {
769 unsigned char c = dict[i];
770
771 if (line) {
772 append_char(&p, e, ' ');
773 line = false;
774 }
775
776 if (c == '\0') {
777 append_char(&p, e, '\n');
778 line = true;
779 continue;
780 }
781
782 if (c < ' ' || c >= 127 || c == '\\') {
783 p += scnprintf(p, e - p, "\\x%02x", c);
784 continue;
785 }
786
787 append_char(&p, e, c);
788 }
789 append_char(&p, e, '\n');
790 }
791
792 return p - buf;
793}
794
795
796struct devkmsg_user {
797 u64 seq;
798 u32 idx;
799 struct ratelimit_state rs;
800 struct mutex lock;
801 char buf[CONSOLE_EXT_LOG_MAX];
802};
803
804static __printf(3, 4) __cold
805int devkmsg_emit(int facility, int level, const char *fmt, ...)
806{
807 va_list args;
808 int r;
809
810 va_start(args, fmt);
811 r = vprintk_emit(facility, level, NULL, 0, fmt, args);
812 va_end(args);
813
814 return r;
815}
816
817static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
818{
819 char *buf, *line;
820 int level = default_message_loglevel;
821 int facility = 1;
822 struct file *file = iocb->ki_filp;
823 struct devkmsg_user *user = file->private_data;
824 size_t len = iov_iter_count(from);
825 ssize_t ret = len;
826
827 if (!user || len > LOG_LINE_MAX)
828 return -EINVAL;
829
830
831 if (devkmsg_log & DEVKMSG_LOG_MASK_OFF)
832 return len;
833
834
835 if (!(devkmsg_log & DEVKMSG_LOG_MASK_ON)) {
836 if (!___ratelimit(&user->rs, current->comm))
837 return ret;
838 }
839
840 buf = kmalloc(len+1, GFP_KERNEL);
841 if (buf == NULL)
842 return -ENOMEM;
843
844 buf[len] = '\0';
845 if (!copy_from_iter_full(buf, len, from)) {
846 kfree(buf);
847 return -EFAULT;
848 }
849
850
851
852
853
854
855
856
857
858
859 line = buf;
860 if (line[0] == '<') {
861 char *endp = NULL;
862 unsigned int u;
863
864 u = simple_strtoul(line + 1, &endp, 10);
865 if (endp && endp[0] == '>') {
866 level = LOG_LEVEL(u);
867 if (LOG_FACILITY(u) != 0)
868 facility = LOG_FACILITY(u);
869 endp++;
870 len -= endp - line;
871 line = endp;
872 }
873 }
874
875 devkmsg_emit(facility, level, "%s", line);
876 kfree(buf);
877 return ret;
878}
879
880static ssize_t devkmsg_read(struct file *file, char __user *buf,
881 size_t count, loff_t *ppos)
882{
883 struct devkmsg_user *user = file->private_data;
884 struct printk_log *msg;
885 size_t len;
886 ssize_t ret;
887
888 if (!user)
889 return -EBADF;
890
891 ret = mutex_lock_interruptible(&user->lock);
892 if (ret)
893 return ret;
894
895 logbuf_lock_irq();
896 while (user->seq == log_next_seq) {
897 if (file->f_flags & O_NONBLOCK) {
898 ret = -EAGAIN;
899 logbuf_unlock_irq();
900 goto out;
901 }
902
903 logbuf_unlock_irq();
904 ret = wait_event_interruptible(log_wait,
905 user->seq != log_next_seq);
906 if (ret)
907 goto out;
908 logbuf_lock_irq();
909 }
910
911 if (user->seq < log_first_seq) {
912
913 user->idx = log_first_idx;
914 user->seq = log_first_seq;
915 ret = -EPIPE;
916 logbuf_unlock_irq();
917 goto out;
918 }
919
920 msg = log_from_idx(user->idx);
921 len = msg_print_ext_header(user->buf, sizeof(user->buf),
922 msg, user->seq);
923 len += msg_print_ext_body(user->buf + len, sizeof(user->buf) - len,
924 log_dict(msg), msg->dict_len,
925 log_text(msg), msg->text_len);
926
927 user->idx = log_next(user->idx);
928 user->seq++;
929 logbuf_unlock_irq();
930
931 if (len > count) {
932 ret = -EINVAL;
933 goto out;
934 }
935
936 if (copy_to_user(buf, user->buf, len)) {
937 ret = -EFAULT;
938 goto out;
939 }
940 ret = len;
941out:
942 mutex_unlock(&user->lock);
943 return ret;
944}
945
946
947
948
949
950
951
952
953
954static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
955{
956 struct devkmsg_user *user = file->private_data;
957 loff_t ret = 0;
958
959 if (!user)
960 return -EBADF;
961 if (offset)
962 return -ESPIPE;
963
964 logbuf_lock_irq();
965 switch (whence) {
966 case SEEK_SET:
967
968 user->idx = log_first_idx;
969 user->seq = log_first_seq;
970 break;
971 case SEEK_DATA:
972
973
974
975
976
977 user->idx = clear_idx;
978 user->seq = clear_seq;
979 break;
980 case SEEK_END:
981
982 user->idx = log_next_idx;
983 user->seq = log_next_seq;
984 break;
985 default:
986 ret = -EINVAL;
987 }
988 logbuf_unlock_irq();
989 return ret;
990}
991
992static __poll_t devkmsg_poll(struct file *file, poll_table *wait)
993{
994 struct devkmsg_user *user = file->private_data;
995 __poll_t ret = 0;
996
997 if (!user)
998 return EPOLLERR|EPOLLNVAL;
999
1000 poll_wait(file, &log_wait, wait);
1001
1002 logbuf_lock_irq();
1003 if (user->seq < log_next_seq) {
1004
1005 if (user->seq < log_first_seq)
1006 ret = EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
1007 else
1008 ret = EPOLLIN|EPOLLRDNORM;
1009 }
1010 logbuf_unlock_irq();
1011
1012 return ret;
1013}
1014
1015static int devkmsg_open(struct inode *inode, struct file *file)
1016{
1017 struct devkmsg_user *user;
1018 int err;
1019
1020 if (devkmsg_log & DEVKMSG_LOG_MASK_OFF)
1021 return -EPERM;
1022
1023
1024 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1025 err = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
1026 SYSLOG_FROM_READER);
1027 if (err)
1028 return err;
1029 }
1030
1031 user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
1032 if (!user)
1033 return -ENOMEM;
1034
1035 ratelimit_default_init(&user->rs);
1036 ratelimit_set_flags(&user->rs, RATELIMIT_MSG_ON_RELEASE);
1037
1038 mutex_init(&user->lock);
1039
1040 logbuf_lock_irq();
1041 user->idx = log_first_idx;
1042 user->seq = log_first_seq;
1043 logbuf_unlock_irq();
1044
1045 file->private_data = user;
1046 return 0;
1047}
1048
1049static int devkmsg_release(struct inode *inode, struct file *file)
1050{
1051 struct devkmsg_user *user = file->private_data;
1052
1053 if (!user)
1054 return 0;
1055
1056 ratelimit_state_exit(&user->rs);
1057
1058 mutex_destroy(&user->lock);
1059 kfree(user);
1060 return 0;
1061}
1062
1063const struct file_operations kmsg_fops = {
1064 .open = devkmsg_open,
1065 .read = devkmsg_read,
1066 .write_iter = devkmsg_write,
1067 .llseek = devkmsg_llseek,
1068 .poll = devkmsg_poll,
1069 .release = devkmsg_release,
1070};
1071
1072#ifdef CONFIG_CRASH_CORE
1073
1074
1075
1076
1077
1078
1079
1080
1081void log_buf_vmcoreinfo_setup(void)
1082{
1083 VMCOREINFO_SYMBOL(log_buf);
1084 VMCOREINFO_SYMBOL(log_buf_len);
1085 VMCOREINFO_SYMBOL(log_first_idx);
1086 VMCOREINFO_SYMBOL(clear_idx);
1087 VMCOREINFO_SYMBOL(log_next_idx);
1088
1089
1090
1091
1092 VMCOREINFO_STRUCT_SIZE(printk_log);
1093 VMCOREINFO_OFFSET(printk_log, ts_nsec);
1094 VMCOREINFO_OFFSET(printk_log, len);
1095 VMCOREINFO_OFFSET(printk_log, text_len);
1096 VMCOREINFO_OFFSET(printk_log, dict_len);
1097#ifdef CONFIG_PRINTK_CALLER
1098 VMCOREINFO_OFFSET(printk_log, caller_id);
1099#endif
1100}
1101#endif
1102
1103
1104static unsigned long __initdata new_log_buf_len;
1105
1106
1107static void __init log_buf_len_update(u64 size)
1108{
1109 if (size > (u64)LOG_BUF_LEN_MAX) {
1110 size = (u64)LOG_BUF_LEN_MAX;
1111 pr_err("log_buf over 2G is not supported.\n");
1112 }
1113
1114 if (size)
1115 size = roundup_pow_of_two(size);
1116 if (size > log_buf_len)
1117 new_log_buf_len = (unsigned long)size;
1118}
1119
1120
1121static int __init log_buf_len_setup(char *str)
1122{
1123 u64 size;
1124
1125 if (!str)
1126 return -EINVAL;
1127
1128 size = memparse(str, &str);
1129
1130 log_buf_len_update(size);
1131
1132 return 0;
1133}
1134early_param("log_buf_len", log_buf_len_setup);
1135
1136#ifdef CONFIG_SMP
1137#define __LOG_CPU_MAX_BUF_LEN (1 << CONFIG_LOG_CPU_MAX_BUF_SHIFT)
1138
1139static void __init log_buf_add_cpu(void)
1140{
1141 unsigned int cpu_extra;
1142
1143
1144
1145
1146
1147
1148 if (num_possible_cpus() == 1)
1149 return;
1150
1151 cpu_extra = (num_possible_cpus() - 1) * __LOG_CPU_MAX_BUF_LEN;
1152
1153
1154 if (cpu_extra <= __LOG_BUF_LEN / 2)
1155 return;
1156
1157 pr_info("log_buf_len individual max cpu contribution: %d bytes\n",
1158 __LOG_CPU_MAX_BUF_LEN);
1159 pr_info("log_buf_len total cpu_extra contributions: %d bytes\n",
1160 cpu_extra);
1161 pr_info("log_buf_len min size: %d bytes\n", __LOG_BUF_LEN);
1162
1163 log_buf_len_update(cpu_extra + __LOG_BUF_LEN);
1164}
1165#else
1166static inline void log_buf_add_cpu(void) {}
1167#endif
1168
1169static void __init set_percpu_data_ready(void)
1170{
1171 printk_safe_init();
1172
1173 barrier();
1174 __printk_percpu_data_ready = true;
1175}
1176
1177void __init setup_log_buf(int early)
1178{
1179 unsigned long flags;
1180 char *new_log_buf;
1181 unsigned int free;
1182
1183
1184
1185
1186
1187
1188 if (!early)
1189 set_percpu_data_ready();
1190
1191 if (log_buf != __log_buf)
1192 return;
1193
1194 if (!early && !new_log_buf_len)
1195 log_buf_add_cpu();
1196
1197 if (!new_log_buf_len)
1198 return;
1199
1200 new_log_buf = memblock_alloc(new_log_buf_len, LOG_ALIGN);
1201 if (unlikely(!new_log_buf)) {
1202 pr_err("log_buf_len: %lu bytes not available\n",
1203 new_log_buf_len);
1204 return;
1205 }
1206
1207 logbuf_lock_irqsave(flags);
1208 log_buf_len = new_log_buf_len;
1209 log_buf = new_log_buf;
1210 new_log_buf_len = 0;
1211 free = __LOG_BUF_LEN - log_next_idx;
1212 memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
1213 logbuf_unlock_irqrestore(flags);
1214
1215 pr_info("log_buf_len: %u bytes\n", log_buf_len);
1216 pr_info("early log buf free: %u(%u%%)\n",
1217 free, (free * 100) / __LOG_BUF_LEN);
1218}
1219
1220static bool __read_mostly ignore_loglevel;
1221
1222static int __init ignore_loglevel_setup(char *str)
1223{
1224 ignore_loglevel = true;
1225 pr_info("debug: ignoring loglevel setting.\n");
1226
1227 return 0;
1228}
1229
1230early_param("ignore_loglevel", ignore_loglevel_setup);
1231module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
1232MODULE_PARM_DESC(ignore_loglevel,
1233 "ignore loglevel setting (prints all kernel messages to the console)");
1234
1235static bool suppress_message_printing(int level)
1236{
1237 return (level >= console_loglevel && !ignore_loglevel);
1238}
1239
1240#ifdef CONFIG_BOOT_PRINTK_DELAY
1241
1242static int boot_delay;
1243static unsigned long long loops_per_msec;
1244
1245static int __init boot_delay_setup(char *str)
1246{
1247 unsigned long lpj;
1248
1249 lpj = preset_lpj ? preset_lpj : 1000000;
1250 loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
1251
1252 get_option(&str, &boot_delay);
1253 if (boot_delay > 10 * 1000)
1254 boot_delay = 0;
1255
1256 pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
1257 "HZ: %d, loops_per_msec: %llu\n",
1258 boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
1259 return 0;
1260}
1261early_param("boot_delay", boot_delay_setup);
1262
1263static void boot_delay_msec(int level)
1264{
1265 unsigned long long k;
1266 unsigned long timeout;
1267
1268 if ((boot_delay == 0 || system_state >= SYSTEM_RUNNING)
1269 || suppress_message_printing(level)) {
1270 return;
1271 }
1272
1273 k = (unsigned long long)loops_per_msec * boot_delay;
1274
1275 timeout = jiffies + msecs_to_jiffies(boot_delay);
1276 while (k) {
1277 k--;
1278 cpu_relax();
1279
1280
1281
1282
1283
1284 if (time_after(jiffies, timeout))
1285 break;
1286 touch_nmi_watchdog();
1287 }
1288}
1289#else
1290static inline void boot_delay_msec(int level)
1291{
1292}
1293#endif
1294
1295static bool printk_time = IS_ENABLED(CONFIG_PRINTK_TIME);
1296module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
1297
1298static size_t print_syslog(unsigned int level, char *buf)
1299{
1300 return sprintf(buf, "<%u>", level);
1301}
1302
1303static size_t print_time(u64 ts, char *buf)
1304{
1305 unsigned long rem_nsec = do_div(ts, 1000000000);
1306
1307 return sprintf(buf, "[%5lu.%06lu]",
1308 (unsigned long)ts, rem_nsec / 1000);
1309}
1310
1311#ifdef CONFIG_PRINTK_CALLER
1312static size_t print_caller(u32 id, char *buf)
1313{
1314 char caller[12];
1315
1316 snprintf(caller, sizeof(caller), "%c%u",
1317 id & 0x80000000 ? 'C' : 'T', id & ~0x80000000);
1318 return sprintf(buf, "[%6s]", caller);
1319}
1320#else
1321#define print_caller(id, buf) 0
1322#endif
1323
1324static size_t print_prefix(const struct printk_log *msg, bool syslog,
1325 bool time, char *buf)
1326{
1327 size_t len = 0;
1328
1329 if (syslog)
1330 len = print_syslog((msg->facility << 3) | msg->level, buf);
1331
1332 if (time)
1333 len += print_time(msg->ts_nsec, buf + len);
1334
1335 len += print_caller(msg->caller_id, buf + len);
1336
1337 if (IS_ENABLED(CONFIG_PRINTK_CALLER) || time) {
1338 buf[len++] = ' ';
1339 buf[len] = '\0';
1340 }
1341
1342 return len;
1343}
1344
1345static size_t msg_print_text(const struct printk_log *msg, bool syslog,
1346 bool time, char *buf, size_t size)
1347{
1348 const char *text = log_text(msg);
1349 size_t text_size = msg->text_len;
1350 size_t len = 0;
1351 char prefix[PREFIX_MAX];
1352 const size_t prefix_len = print_prefix(msg, syslog, time, prefix);
1353
1354 do {
1355 const char *next = memchr(text, '\n', text_size);
1356 size_t text_len;
1357
1358 if (next) {
1359 text_len = next - text;
1360 next++;
1361 text_size -= next - text;
1362 } else {
1363 text_len = text_size;
1364 }
1365
1366 if (buf) {
1367 if (prefix_len + text_len + 1 >= size - len)
1368 break;
1369
1370 memcpy(buf + len, prefix, prefix_len);
1371 len += prefix_len;
1372 memcpy(buf + len, text, text_len);
1373 len += text_len;
1374 buf[len++] = '\n';
1375 } else {
1376
1377 len += prefix_len + text_len + 1;
1378 }
1379
1380 text = next;
1381 } while (text);
1382
1383 return len;
1384}
1385
1386static int syslog_print(char __user *buf, int size)
1387{
1388 char *text;
1389 struct printk_log *msg;
1390 int len = 0;
1391
1392 text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
1393 if (!text)
1394 return -ENOMEM;
1395
1396 while (size > 0) {
1397 size_t n;
1398 size_t skip;
1399
1400 logbuf_lock_irq();
1401 if (syslog_seq < log_first_seq) {
1402
1403 syslog_seq = log_first_seq;
1404 syslog_idx = log_first_idx;
1405 syslog_partial = 0;
1406 }
1407 if (syslog_seq == log_next_seq) {
1408 logbuf_unlock_irq();
1409 break;
1410 }
1411
1412
1413
1414
1415
1416 if (!syslog_partial)
1417 syslog_time = printk_time;
1418
1419 skip = syslog_partial;
1420 msg = log_from_idx(syslog_idx);
1421 n = msg_print_text(msg, true, syslog_time, text,
1422 LOG_LINE_MAX + PREFIX_MAX);
1423 if (n - syslog_partial <= size) {
1424
1425 syslog_idx = log_next(syslog_idx);
1426 syslog_seq++;
1427 n -= syslog_partial;
1428 syslog_partial = 0;
1429 } else if (!len){
1430
1431 n = size;
1432 syslog_partial += n;
1433 } else
1434 n = 0;
1435 logbuf_unlock_irq();
1436
1437 if (!n)
1438 break;
1439
1440 if (copy_to_user(buf, text + skip, n)) {
1441 if (!len)
1442 len = -EFAULT;
1443 break;
1444 }
1445
1446 len += n;
1447 size -= n;
1448 buf += n;
1449 }
1450
1451 kfree(text);
1452 return len;
1453}
1454
1455static int syslog_print_all(char __user *buf, int size, bool clear)
1456{
1457 char *text;
1458 int len = 0;
1459 u64 next_seq;
1460 u64 seq;
1461 u32 idx;
1462 bool time;
1463
1464 text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
1465 if (!text)
1466 return -ENOMEM;
1467
1468 time = printk_time;
1469 logbuf_lock_irq();
1470
1471
1472
1473
1474 seq = clear_seq;
1475 idx = clear_idx;
1476 while (seq < log_next_seq) {
1477 struct printk_log *msg = log_from_idx(idx);
1478
1479 len += msg_print_text(msg, true, time, NULL, 0);
1480 idx = log_next(idx);
1481 seq++;
1482 }
1483
1484
1485 seq = clear_seq;
1486 idx = clear_idx;
1487 while (len > size && seq < log_next_seq) {
1488 struct printk_log *msg = log_from_idx(idx);
1489
1490 len -= msg_print_text(msg, true, time, NULL, 0);
1491 idx = log_next(idx);
1492 seq++;
1493 }
1494
1495
1496 next_seq = log_next_seq;
1497
1498 len = 0;
1499 while (len >= 0 && seq < next_seq) {
1500 struct printk_log *msg = log_from_idx(idx);
1501 int textlen = msg_print_text(msg, true, time, text,
1502 LOG_LINE_MAX + PREFIX_MAX);
1503
1504 idx = log_next(idx);
1505 seq++;
1506
1507 logbuf_unlock_irq();
1508 if (copy_to_user(buf + len, text, textlen))
1509 len = -EFAULT;
1510 else
1511 len += textlen;
1512 logbuf_lock_irq();
1513
1514 if (seq < log_first_seq) {
1515
1516 seq = log_first_seq;
1517 idx = log_first_idx;
1518 }
1519 }
1520
1521 if (clear) {
1522 clear_seq = log_next_seq;
1523 clear_idx = log_next_idx;
1524 }
1525 logbuf_unlock_irq();
1526
1527 kfree(text);
1528 return len;
1529}
1530
1531static void syslog_clear(void)
1532{
1533 logbuf_lock_irq();
1534 clear_seq = log_next_seq;
1535 clear_idx = log_next_idx;
1536 logbuf_unlock_irq();
1537}
1538
1539int do_syslog(int type, char __user *buf, int len, int source)
1540{
1541 bool clear = false;
1542 static int saved_console_loglevel = LOGLEVEL_DEFAULT;
1543 int error;
1544
1545 error = check_syslog_permissions(type, source);
1546 if (error)
1547 return error;
1548
1549 switch (type) {
1550 case SYSLOG_ACTION_CLOSE:
1551 break;
1552 case SYSLOG_ACTION_OPEN:
1553 break;
1554 case SYSLOG_ACTION_READ:
1555 if (!buf || len < 0)
1556 return -EINVAL;
1557 if (!len)
1558 return 0;
1559 if (!access_ok(buf, len))
1560 return -EFAULT;
1561 error = wait_event_interruptible(log_wait,
1562 syslog_seq != log_next_seq);
1563 if (error)
1564 return error;
1565 error = syslog_print(buf, len);
1566 break;
1567
1568 case SYSLOG_ACTION_READ_CLEAR:
1569 clear = true;
1570
1571
1572 case SYSLOG_ACTION_READ_ALL:
1573 if (!buf || len < 0)
1574 return -EINVAL;
1575 if (!len)
1576 return 0;
1577 if (!access_ok(buf, len))
1578 return -EFAULT;
1579 error = syslog_print_all(buf, len, clear);
1580 break;
1581
1582 case SYSLOG_ACTION_CLEAR:
1583 syslog_clear();
1584 break;
1585
1586 case SYSLOG_ACTION_CONSOLE_OFF:
1587 if (saved_console_loglevel == LOGLEVEL_DEFAULT)
1588 saved_console_loglevel = console_loglevel;
1589 console_loglevel = minimum_console_loglevel;
1590 break;
1591
1592 case SYSLOG_ACTION_CONSOLE_ON:
1593 if (saved_console_loglevel != LOGLEVEL_DEFAULT) {
1594 console_loglevel = saved_console_loglevel;
1595 saved_console_loglevel = LOGLEVEL_DEFAULT;
1596 }
1597 break;
1598
1599 case SYSLOG_ACTION_CONSOLE_LEVEL:
1600 if (len < 1 || len > 8)
1601 return -EINVAL;
1602 if (len < minimum_console_loglevel)
1603 len = minimum_console_loglevel;
1604 console_loglevel = len;
1605
1606 saved_console_loglevel = LOGLEVEL_DEFAULT;
1607 break;
1608
1609 case SYSLOG_ACTION_SIZE_UNREAD:
1610 logbuf_lock_irq();
1611 if (syslog_seq < log_first_seq) {
1612
1613 syslog_seq = log_first_seq;
1614 syslog_idx = log_first_idx;
1615 syslog_partial = 0;
1616 }
1617 if (source == SYSLOG_FROM_PROC) {
1618
1619
1620
1621
1622
1623 error = log_next_seq - syslog_seq;
1624 } else {
1625 u64 seq = syslog_seq;
1626 u32 idx = syslog_idx;
1627 bool time = syslog_partial ? syslog_time : printk_time;
1628
1629 while (seq < log_next_seq) {
1630 struct printk_log *msg = log_from_idx(idx);
1631
1632 error += msg_print_text(msg, true, time, NULL,
1633 0);
1634 time = printk_time;
1635 idx = log_next(idx);
1636 seq++;
1637 }
1638 error -= syslog_partial;
1639 }
1640 logbuf_unlock_irq();
1641 break;
1642
1643 case SYSLOG_ACTION_SIZE_BUFFER:
1644 error = log_buf_len;
1645 break;
1646 default:
1647 error = -EINVAL;
1648 break;
1649 }
1650
1651 return error;
1652}
1653
1654SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
1655{
1656 return do_syslog(type, buf, len, SYSLOG_FROM_READER);
1657}
1658
1659
1660
1661
1662
1663
1664#ifdef CONFIG_LOCKDEP
1665static struct lockdep_map console_owner_dep_map = {
1666 .name = "console_owner"
1667};
1668#endif
1669
1670static DEFINE_RAW_SPINLOCK(console_owner_lock);
1671static struct task_struct *console_owner;
1672static bool console_waiter;
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683static void console_lock_spinning_enable(void)
1684{
1685 raw_spin_lock(&console_owner_lock);
1686 console_owner = current;
1687 raw_spin_unlock(&console_owner_lock);
1688
1689
1690 spin_acquire(&console_owner_dep_map, 0, 0, _THIS_IP_);
1691}
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708static int console_lock_spinning_disable_and_check(void)
1709{
1710 int waiter;
1711
1712 raw_spin_lock(&console_owner_lock);
1713 waiter = READ_ONCE(console_waiter);
1714 console_owner = NULL;
1715 raw_spin_unlock(&console_owner_lock);
1716
1717 if (!waiter) {
1718 spin_release(&console_owner_dep_map, _THIS_IP_);
1719 return 0;
1720 }
1721
1722
1723 WRITE_ONCE(console_waiter, false);
1724
1725 spin_release(&console_owner_dep_map, _THIS_IP_);
1726
1727
1728
1729
1730
1731 mutex_release(&console_lock_dep_map, _THIS_IP_);
1732 return 1;
1733}
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745static int console_trylock_spinning(void)
1746{
1747 struct task_struct *owner = NULL;
1748 bool waiter;
1749 bool spin = false;
1750 unsigned long flags;
1751
1752 if (console_trylock())
1753 return 1;
1754
1755 printk_safe_enter_irqsave(flags);
1756
1757 raw_spin_lock(&console_owner_lock);
1758 owner = READ_ONCE(console_owner);
1759 waiter = READ_ONCE(console_waiter);
1760 if (!waiter && owner && owner != current) {
1761 WRITE_ONCE(console_waiter, true);
1762 spin = true;
1763 }
1764 raw_spin_unlock(&console_owner_lock);
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775 if (!spin) {
1776 printk_safe_exit_irqrestore(flags);
1777 return 0;
1778 }
1779
1780
1781 spin_acquire(&console_owner_dep_map, 0, 0, _THIS_IP_);
1782
1783 while (READ_ONCE(console_waiter))
1784 cpu_relax();
1785 spin_release(&console_owner_dep_map, _THIS_IP_);
1786
1787 printk_safe_exit_irqrestore(flags);
1788
1789
1790
1791
1792
1793
1794 mutex_acquire(&console_lock_dep_map, 0, 1, _THIS_IP_);
1795
1796 return 1;
1797}
1798
1799
1800
1801
1802
1803
1804static void call_console_drivers(const char *ext_text, size_t ext_len,
1805 const char *text, size_t len)
1806{
1807 struct console *con;
1808
1809 trace_console_rcuidle(text, len);
1810
1811 for_each_console(con) {
1812 if (exclusive_console && con != exclusive_console)
1813 continue;
1814 if (!(con->flags & CON_ENABLED))
1815 continue;
1816 if (!con->write)
1817 continue;
1818 if (!cpu_online(smp_processor_id()) &&
1819 !(con->flags & CON_ANYTIME))
1820 continue;
1821 if (con->flags & CON_EXTENDED)
1822 con->write(con, ext_text, ext_len);
1823 else
1824 con->write(con, text, len);
1825 }
1826}
1827
1828int printk_delay_msec __read_mostly;
1829
1830static inline void printk_delay(void)
1831{
1832 if (unlikely(printk_delay_msec)) {
1833 int m = printk_delay_msec;
1834
1835 while (m--) {
1836 mdelay(1);
1837 touch_nmi_watchdog();
1838 }
1839 }
1840}
1841
1842static inline u32 printk_caller_id(void)
1843{
1844 return in_task() ? task_pid_nr(current) :
1845 0x80000000 + raw_smp_processor_id();
1846}
1847
1848
1849
1850
1851
1852
1853
1854static struct cont {
1855 char buf[LOG_LINE_MAX];
1856 size_t len;
1857 u32 caller_id;
1858 u64 ts_nsec;
1859 u8 level;
1860 u8 facility;
1861 enum log_flags flags;
1862} cont;
1863
1864static void cont_flush(void)
1865{
1866 if (cont.len == 0)
1867 return;
1868
1869 log_store(cont.caller_id, cont.facility, cont.level, cont.flags,
1870 cont.ts_nsec, NULL, 0, cont.buf, cont.len);
1871 cont.len = 0;
1872}
1873
1874static bool cont_add(u32 caller_id, int facility, int level,
1875 enum log_flags flags, const char *text, size_t len)
1876{
1877
1878 if (cont.len + len > sizeof(cont.buf)) {
1879 cont_flush();
1880 return false;
1881 }
1882
1883 if (!cont.len) {
1884 cont.facility = facility;
1885 cont.level = level;
1886 cont.caller_id = caller_id;
1887 cont.ts_nsec = local_clock();
1888 cont.flags = flags;
1889 }
1890
1891 memcpy(cont.buf + cont.len, text, len);
1892 cont.len += len;
1893
1894
1895
1896 if (flags & LOG_NEWLINE) {
1897 cont.flags |= LOG_NEWLINE;
1898 cont_flush();
1899 }
1900
1901 return true;
1902}
1903
1904static size_t log_output(int facility, int level, enum log_flags lflags, const char *dict, size_t dictlen, char *text, size_t text_len)
1905{
1906 const u32 caller_id = printk_caller_id();
1907
1908
1909
1910
1911
1912 if (cont.len) {
1913 if (cont.caller_id == caller_id && (lflags & LOG_CONT)) {
1914 if (cont_add(caller_id, facility, level, lflags, text, text_len))
1915 return text_len;
1916 }
1917
1918 cont_flush();
1919 }
1920
1921
1922 if (!text_len && (lflags & LOG_CONT))
1923 return 0;
1924
1925
1926 if (!(lflags & LOG_NEWLINE)) {
1927 if (cont_add(caller_id, facility, level, lflags, text, text_len))
1928 return text_len;
1929 }
1930
1931
1932 return log_store(caller_id, facility, level, lflags, 0,
1933 dict, dictlen, text, text_len);
1934}
1935
1936
1937int vprintk_store(int facility, int level,
1938 const char *dict, size_t dictlen,
1939 const char *fmt, va_list args)
1940{
1941 static char textbuf[LOG_LINE_MAX];
1942 char *text = textbuf;
1943 size_t text_len;
1944 enum log_flags lflags = 0;
1945
1946
1947
1948
1949
1950 text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
1951
1952
1953 if (text_len && text[text_len-1] == '\n') {
1954 text_len--;
1955 lflags |= LOG_NEWLINE;
1956 }
1957
1958
1959 if (facility == 0) {
1960 int kern_level;
1961
1962 while ((kern_level = printk_get_level(text)) != 0) {
1963 switch (kern_level) {
1964 case '0' ... '7':
1965 if (level == LOGLEVEL_DEFAULT)
1966 level = kern_level - '0';
1967 break;
1968 case 'c':
1969 lflags |= LOG_CONT;
1970 }
1971
1972 text_len -= 2;
1973 text += 2;
1974 }
1975 }
1976
1977 if (level == LOGLEVEL_DEFAULT)
1978 level = default_message_loglevel;
1979
1980 if (dict)
1981 lflags |= LOG_NEWLINE;
1982
1983 return log_output(facility, level, lflags,
1984 dict, dictlen, text, text_len);
1985}
1986
1987asmlinkage int vprintk_emit(int facility, int level,
1988 const char *dict, size_t dictlen,
1989 const char *fmt, va_list args)
1990{
1991 int printed_len;
1992 bool in_sched = false, pending_output;
1993 unsigned long flags;
1994 u64 curr_log_seq;
1995
1996
1997 if (unlikely(suppress_printk))
1998 return 0;
1999
2000 if (level == LOGLEVEL_SCHED) {
2001 level = LOGLEVEL_DEFAULT;
2002 in_sched = true;
2003 }
2004
2005 boot_delay_msec(level);
2006 printk_delay();
2007
2008
2009 logbuf_lock_irqsave(flags);
2010 curr_log_seq = log_next_seq;
2011 printed_len = vprintk_store(facility, level, dict, dictlen, fmt, args);
2012 pending_output = (curr_log_seq != log_next_seq);
2013 logbuf_unlock_irqrestore(flags);
2014
2015
2016 if (!in_sched && pending_output) {
2017
2018
2019
2020
2021
2022 preempt_disable();
2023
2024
2025
2026
2027
2028 if (console_trylock_spinning())
2029 console_unlock();
2030 preempt_enable();
2031 }
2032
2033 if (pending_output)
2034 wake_up_klogd();
2035 return printed_len;
2036}
2037EXPORT_SYMBOL(vprintk_emit);
2038
2039asmlinkage int vprintk(const char *fmt, va_list args)
2040{
2041 return vprintk_func(fmt, args);
2042}
2043EXPORT_SYMBOL(vprintk);
2044
2045int vprintk_default(const char *fmt, va_list args)
2046{
2047 return vprintk_emit(0, LOGLEVEL_DEFAULT, NULL, 0, fmt, args);
2048}
2049EXPORT_SYMBOL_GPL(vprintk_default);
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072asmlinkage __visible int printk(const char *fmt, ...)
2073{
2074 va_list args;
2075 int r;
2076
2077 va_start(args, fmt);
2078 r = vprintk_func(fmt, args);
2079 va_end(args);
2080
2081 return r;
2082}
2083EXPORT_SYMBOL(printk);
2084
2085#else
2086
2087#define LOG_LINE_MAX 0
2088#define PREFIX_MAX 0
2089#define printk_time false
2090
2091static u64 syslog_seq;
2092static u32 syslog_idx;
2093static u64 console_seq;
2094static u32 console_idx;
2095static u64 exclusive_console_stop_seq;
2096static u64 log_first_seq;
2097static u32 log_first_idx;
2098static u64 log_next_seq;
2099static char *log_text(const struct printk_log *msg) { return NULL; }
2100static char *log_dict(const struct printk_log *msg) { return NULL; }
2101static struct printk_log *log_from_idx(u32 idx) { return NULL; }
2102static u32 log_next(u32 idx) { return 0; }
2103static ssize_t msg_print_ext_header(char *buf, size_t size,
2104 struct printk_log *msg,
2105 u64 seq) { return 0; }
2106static ssize_t msg_print_ext_body(char *buf, size_t size,
2107 char *dict, size_t dict_len,
2108 char *text, size_t text_len) { return 0; }
2109static void console_lock_spinning_enable(void) { }
2110static int console_lock_spinning_disable_and_check(void) { return 0; }
2111static void call_console_drivers(const char *ext_text, size_t ext_len,
2112 const char *text, size_t len) {}
2113static size_t msg_print_text(const struct printk_log *msg, bool syslog,
2114 bool time, char *buf, size_t size) { return 0; }
2115static bool suppress_message_printing(int level) { return false; }
2116
2117#endif
2118
2119#ifdef CONFIG_EARLY_PRINTK
2120struct console *early_console;
2121
2122asmlinkage __visible void early_printk(const char *fmt, ...)
2123{
2124 va_list ap;
2125 char buf[512];
2126 int n;
2127
2128 if (!early_console)
2129 return;
2130
2131 va_start(ap, fmt);
2132 n = vscnprintf(buf, sizeof(buf), fmt, ap);
2133 va_end(ap);
2134
2135 early_console->write(early_console, buf, n);
2136}
2137#endif
2138
2139static int __add_preferred_console(char *name, int idx, char *options,
2140 char *brl_options, bool user_specified)
2141{
2142 struct console_cmdline *c;
2143 int i;
2144
2145
2146
2147
2148
2149 for (i = 0, c = console_cmdline;
2150 i < MAX_CMDLINECONSOLES && c->name[0];
2151 i++, c++) {
2152 if (strcmp(c->name, name) == 0 && c->index == idx) {
2153 if (!brl_options)
2154 preferred_console = i;
2155 if (user_specified)
2156 c->user_specified = true;
2157 return 0;
2158 }
2159 }
2160 if (i == MAX_CMDLINECONSOLES)
2161 return -E2BIG;
2162 if (!brl_options)
2163 preferred_console = i;
2164 strlcpy(c->name, name, sizeof(c->name));
2165 c->options = options;
2166 c->user_specified = user_specified;
2167 braille_set_options(c, brl_options);
2168
2169 c->index = idx;
2170 return 0;
2171}
2172
2173static int __init console_msg_format_setup(char *str)
2174{
2175 if (!strcmp(str, "syslog"))
2176 console_msg_format = MSG_FORMAT_SYSLOG;
2177 if (!strcmp(str, "default"))
2178 console_msg_format = MSG_FORMAT_DEFAULT;
2179 return 1;
2180}
2181__setup("console_msg_format=", console_msg_format_setup);
2182
2183
2184
2185
2186
2187static int __init console_setup(char *str)
2188{
2189 char buf[sizeof(console_cmdline[0].name) + 4];
2190 char *s, *options, *brl_options = NULL;
2191 int idx;
2192
2193 if (str[0] == 0)
2194 return 1;
2195
2196 if (_braille_console_setup(&str, &brl_options))
2197 return 1;
2198
2199
2200
2201
2202 if (str[0] >= '0' && str[0] <= '9') {
2203 strcpy(buf, "ttyS");
2204 strncpy(buf + 4, str, sizeof(buf) - 5);
2205 } else {
2206 strncpy(buf, str, sizeof(buf) - 1);
2207 }
2208 buf[sizeof(buf) - 1] = 0;
2209 options = strchr(str, ',');
2210 if (options)
2211 *(options++) = 0;
2212#ifdef __sparc__
2213 if (!strcmp(str, "ttya"))
2214 strcpy(buf, "ttyS0");
2215 if (!strcmp(str, "ttyb"))
2216 strcpy(buf, "ttyS1");
2217#endif
2218 for (s = buf; *s; s++)
2219 if (isdigit(*s) || *s == ',')
2220 break;
2221 idx = simple_strtoul(s, NULL, 10);
2222 *s = 0;
2223
2224 __add_preferred_console(buf, idx, options, brl_options, true);
2225 console_set_on_cmdline = 1;
2226 return 1;
2227}
2228__setup("console=", console_setup);
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243int add_preferred_console(char *name, int idx, char *options)
2244{
2245 return __add_preferred_console(name, idx, options, NULL, false);
2246}
2247
2248bool console_suspend_enabled = true;
2249EXPORT_SYMBOL(console_suspend_enabled);
2250
2251static int __init console_suspend_disable(char *str)
2252{
2253 console_suspend_enabled = false;
2254 return 1;
2255}
2256__setup("no_console_suspend", console_suspend_disable);
2257module_param_named(console_suspend, console_suspend_enabled,
2258 bool, S_IRUGO | S_IWUSR);
2259MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
2260 " and hibernate operations");
2261
2262
2263
2264
2265
2266
2267void suspend_console(void)
2268{
2269 if (!console_suspend_enabled)
2270 return;
2271 pr_info("Suspending console(s) (use no_console_suspend to debug)\n");
2272 console_lock();
2273 console_suspended = 1;
2274 up_console_sem();
2275}
2276
2277void resume_console(void)
2278{
2279 if (!console_suspend_enabled)
2280 return;
2281 down_console_sem();
2282 console_suspended = 0;
2283 console_unlock();
2284}
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295static int console_cpu_notify(unsigned int cpu)
2296{
2297 if (!cpuhp_tasks_frozen) {
2298
2299 if (console_trylock())
2300 console_unlock();
2301 }
2302 return 0;
2303}
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313void console_lock(void)
2314{
2315 might_sleep();
2316
2317 down_console_sem();
2318 if (console_suspended)
2319 return;
2320 console_locked = 1;
2321 console_may_schedule = 1;
2322}
2323EXPORT_SYMBOL(console_lock);
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333int console_trylock(void)
2334{
2335 if (down_trylock_console_sem())
2336 return 0;
2337 if (console_suspended) {
2338 up_console_sem();
2339 return 0;
2340 }
2341 console_locked = 1;
2342 console_may_schedule = 0;
2343 return 1;
2344}
2345EXPORT_SYMBOL(console_trylock);
2346
2347int is_console_locked(void)
2348{
2349 return console_locked;
2350}
2351EXPORT_SYMBOL(is_console_locked);
2352
2353
2354
2355
2356
2357static int have_callable_console(void)
2358{
2359 struct console *con;
2360
2361 for_each_console(con)
2362 if ((con->flags & CON_ENABLED) &&
2363 (con->flags & CON_ANYTIME))
2364 return 1;
2365
2366 return 0;
2367}
2368
2369
2370
2371
2372
2373
2374
2375
2376static inline int can_use_console(void)
2377{
2378 return cpu_online(raw_smp_processor_id()) || have_callable_console();
2379}
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395void console_unlock(void)
2396{
2397 static char ext_text[CONSOLE_EXT_LOG_MAX];
2398 static char text[LOG_LINE_MAX + PREFIX_MAX];
2399 unsigned long flags;
2400 bool do_cond_resched, retry;
2401
2402 if (console_suspended) {
2403 up_console_sem();
2404 return;
2405 }
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421 do_cond_resched = console_may_schedule;
2422again:
2423 console_may_schedule = 0;
2424
2425
2426
2427
2428
2429
2430 if (!can_use_console()) {
2431 console_locked = 0;
2432 up_console_sem();
2433 return;
2434 }
2435
2436 for (;;) {
2437 struct printk_log *msg;
2438 size_t ext_len = 0;
2439 size_t len;
2440
2441 printk_safe_enter_irqsave(flags);
2442 raw_spin_lock(&logbuf_lock);
2443 if (console_seq < log_first_seq) {
2444 len = snprintf(text, sizeof(text),
2445 "** %llu printk messages dropped **\n",
2446 log_first_seq - console_seq);
2447
2448
2449 console_seq = log_first_seq;
2450 console_idx = log_first_idx;
2451 } else {
2452 len = 0;
2453 }
2454skip:
2455 if (console_seq == log_next_seq)
2456 break;
2457
2458 msg = log_from_idx(console_idx);
2459 if (suppress_message_printing(msg->level)) {
2460
2461
2462
2463
2464
2465 console_idx = log_next(console_idx);
2466 console_seq++;
2467 goto skip;
2468 }
2469
2470
2471 if (unlikely(exclusive_console &&
2472 console_seq >= exclusive_console_stop_seq)) {
2473 exclusive_console = NULL;
2474 }
2475
2476 len += msg_print_text(msg,
2477 console_msg_format & MSG_FORMAT_SYSLOG,
2478 printk_time, text + len, sizeof(text) - len);
2479 if (nr_ext_console_drivers) {
2480 ext_len = msg_print_ext_header(ext_text,
2481 sizeof(ext_text),
2482 msg, console_seq);
2483 ext_len += msg_print_ext_body(ext_text + ext_len,
2484 sizeof(ext_text) - ext_len,
2485 log_dict(msg), msg->dict_len,
2486 log_text(msg), msg->text_len);
2487 }
2488 console_idx = log_next(console_idx);
2489 console_seq++;
2490 raw_spin_unlock(&logbuf_lock);
2491
2492
2493
2494
2495
2496
2497
2498 console_lock_spinning_enable();
2499
2500 stop_critical_timings();
2501 call_console_drivers(ext_text, ext_len, text, len);
2502 start_critical_timings();
2503
2504 if (console_lock_spinning_disable_and_check()) {
2505 printk_safe_exit_irqrestore(flags);
2506 return;
2507 }
2508
2509 printk_safe_exit_irqrestore(flags);
2510
2511 if (do_cond_resched)
2512 cond_resched();
2513 }
2514
2515 console_locked = 0;
2516
2517 raw_spin_unlock(&logbuf_lock);
2518
2519 up_console_sem();
2520
2521
2522
2523
2524
2525
2526
2527 raw_spin_lock(&logbuf_lock);
2528 retry = console_seq != log_next_seq;
2529 raw_spin_unlock(&logbuf_lock);
2530 printk_safe_exit_irqrestore(flags);
2531
2532 if (retry && console_trylock())
2533 goto again;
2534}
2535EXPORT_SYMBOL(console_unlock);
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546void __sched console_conditional_schedule(void)
2547{
2548 if (console_may_schedule)
2549 cond_resched();
2550}
2551EXPORT_SYMBOL(console_conditional_schedule);
2552
2553void console_unblank(void)
2554{
2555 struct console *c;
2556
2557
2558
2559
2560
2561 if (oops_in_progress) {
2562 if (down_trylock_console_sem() != 0)
2563 return;
2564 } else
2565 console_lock();
2566
2567 console_locked = 1;
2568 console_may_schedule = 0;
2569 for_each_console(c)
2570 if ((c->flags & CON_ENABLED) && c->unblank)
2571 c->unblank();
2572 console_unlock();
2573}
2574
2575
2576
2577
2578
2579
2580
2581void console_flush_on_panic(enum con_flush_mode mode)
2582{
2583
2584
2585
2586
2587
2588
2589
2590 console_trylock();
2591 console_may_schedule = 0;
2592
2593 if (mode == CONSOLE_REPLAY_ALL) {
2594 unsigned long flags;
2595
2596 logbuf_lock_irqsave(flags);
2597 console_seq = log_first_seq;
2598 console_idx = log_first_idx;
2599 logbuf_unlock_irqrestore(flags);
2600 }
2601 console_unlock();
2602}
2603
2604
2605
2606
2607struct tty_driver *console_device(int *index)
2608{
2609 struct console *c;
2610 struct tty_driver *driver = NULL;
2611
2612 console_lock();
2613 for_each_console(c) {
2614 if (!c->device)
2615 continue;
2616 driver = c->device(c, index);
2617 if (driver)
2618 break;
2619 }
2620 console_unlock();
2621 return driver;
2622}
2623
2624
2625
2626
2627
2628
2629void console_stop(struct console *console)
2630{
2631 console_lock();
2632 console->flags &= ~CON_ENABLED;
2633 console_unlock();
2634}
2635EXPORT_SYMBOL(console_stop);
2636
2637void console_start(struct console *console)
2638{
2639 console_lock();
2640 console->flags |= CON_ENABLED;
2641 console_unlock();
2642}
2643EXPORT_SYMBOL(console_start);
2644
2645static int __read_mostly keep_bootcon;
2646
2647static int __init keep_bootcon_setup(char *str)
2648{
2649 keep_bootcon = 1;
2650 pr_info("debug: skip boot console de-registration.\n");
2651
2652 return 0;
2653}
2654
2655early_param("keep_bootcon", keep_bootcon_setup);
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666static int try_enable_new_console(struct console *newcon, bool user_specified)
2667{
2668 struct console_cmdline *c;
2669 int i, err;
2670
2671 for (i = 0, c = console_cmdline;
2672 i < MAX_CMDLINECONSOLES && c->name[0];
2673 i++, c++) {
2674 if (c->user_specified != user_specified)
2675 continue;
2676 if (!newcon->match ||
2677 newcon->match(newcon, c->name, c->index, c->options) != 0) {
2678
2679 BUILD_BUG_ON(sizeof(c->name) != sizeof(newcon->name));
2680 if (strcmp(c->name, newcon->name) != 0)
2681 continue;
2682 if (newcon->index >= 0 &&
2683 newcon->index != c->index)
2684 continue;
2685 if (newcon->index < 0)
2686 newcon->index = c->index;
2687
2688 if (_braille_register_console(newcon, c))
2689 return 0;
2690
2691 if (newcon->setup &&
2692 (err = newcon->setup(newcon, c->options)) != 0)
2693 return err;
2694 }
2695 newcon->flags |= CON_ENABLED;
2696 if (i == preferred_console) {
2697 newcon->flags |= CON_CONSDEV;
2698 has_preferred_console = true;
2699 }
2700 return 0;
2701 }
2702
2703
2704
2705
2706
2707
2708 if (newcon->flags & CON_ENABLED && c->user_specified == user_specified)
2709 return 0;
2710
2711 return -ENOENT;
2712}
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733void register_console(struct console *newcon)
2734{
2735 unsigned long flags;
2736 struct console *bcon = NULL;
2737 int err;
2738
2739 for_each_console(bcon) {
2740 if (WARN(bcon == newcon, "console '%s%d' already registered\n",
2741 bcon->name, bcon->index))
2742 return;
2743 }
2744
2745
2746
2747
2748
2749 if (newcon->flags & CON_BOOT) {
2750 for_each_console(bcon) {
2751 if (!(bcon->flags & CON_BOOT)) {
2752 pr_info("Too late to register bootconsole %s%d\n",
2753 newcon->name, newcon->index);
2754 return;
2755 }
2756 }
2757 }
2758
2759 if (console_drivers && console_drivers->flags & CON_BOOT)
2760 bcon = console_drivers;
2761
2762 if (!has_preferred_console || bcon || !console_drivers)
2763 has_preferred_console = preferred_console >= 0;
2764
2765
2766
2767
2768
2769
2770 if (!has_preferred_console) {
2771 if (newcon->index < 0)
2772 newcon->index = 0;
2773 if (newcon->setup == NULL ||
2774 newcon->setup(newcon, NULL) == 0) {
2775 newcon->flags |= CON_ENABLED;
2776 if (newcon->device) {
2777 newcon->flags |= CON_CONSDEV;
2778 has_preferred_console = true;
2779 }
2780 }
2781 }
2782
2783
2784 err = try_enable_new_console(newcon, true);
2785
2786
2787 if (err == -ENOENT)
2788 err = try_enable_new_console(newcon, false);
2789
2790
2791 if (err || newcon->flags & CON_BRL)
2792 return;
2793
2794
2795
2796
2797
2798
2799
2800 if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
2801 newcon->flags &= ~CON_PRINTBUFFER;
2802
2803
2804
2805
2806
2807 console_lock();
2808 if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
2809 newcon->next = console_drivers;
2810 console_drivers = newcon;
2811 if (newcon->next)
2812 newcon->next->flags &= ~CON_CONSDEV;
2813
2814 newcon->flags |= CON_CONSDEV;
2815 } else {
2816 newcon->next = console_drivers->next;
2817 console_drivers->next = newcon;
2818 }
2819
2820 if (newcon->flags & CON_EXTENDED)
2821 nr_ext_console_drivers++;
2822
2823 if (newcon->flags & CON_PRINTBUFFER) {
2824
2825
2826
2827
2828 logbuf_lock_irqsave(flags);
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838 exclusive_console = newcon;
2839 exclusive_console_stop_seq = console_seq;
2840 console_seq = syslog_seq;
2841 console_idx = syslog_idx;
2842 logbuf_unlock_irqrestore(flags);
2843 }
2844 console_unlock();
2845 console_sysfs_notify();
2846
2847
2848
2849
2850
2851
2852
2853
2854 pr_info("%sconsole [%s%d] enabled\n",
2855 (newcon->flags & CON_BOOT) ? "boot" : "" ,
2856 newcon->name, newcon->index);
2857 if (bcon &&
2858 ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
2859 !keep_bootcon) {
2860
2861
2862
2863 for_each_console(bcon)
2864 if (bcon->flags & CON_BOOT)
2865 unregister_console(bcon);
2866 }
2867}
2868EXPORT_SYMBOL(register_console);
2869
2870int unregister_console(struct console *console)
2871{
2872 struct console *con;
2873 int res;
2874
2875 pr_info("%sconsole [%s%d] disabled\n",
2876 (console->flags & CON_BOOT) ? "boot" : "" ,
2877 console->name, console->index);
2878
2879 res = _braille_unregister_console(console);
2880 if (res < 0)
2881 return res;
2882 if (res > 0)
2883 return 0;
2884
2885 res = -ENODEV;
2886 console_lock();
2887 if (console_drivers == console) {
2888 console_drivers=console->next;
2889 res = 0;
2890 } else {
2891 for_each_console(con) {
2892 if (con->next == console) {
2893 con->next = console->next;
2894 res = 0;
2895 break;
2896 }
2897 }
2898 }
2899
2900 if (res)
2901 goto out_disable_unlock;
2902
2903 if (console->flags & CON_EXTENDED)
2904 nr_ext_console_drivers--;
2905
2906
2907
2908
2909
2910 if (console_drivers != NULL && console->flags & CON_CONSDEV)
2911 console_drivers->flags |= CON_CONSDEV;
2912
2913 console->flags &= ~CON_ENABLED;
2914 console_unlock();
2915 console_sysfs_notify();
2916
2917 if (console->exit)
2918 res = console->exit(console);
2919
2920 return res;
2921
2922out_disable_unlock:
2923 console->flags &= ~CON_ENABLED;
2924 console_unlock();
2925
2926 return res;
2927}
2928EXPORT_SYMBOL(unregister_console);
2929
2930
2931
2932
2933
2934
2935
2936void __init console_init(void)
2937{
2938 int ret;
2939 initcall_t call;
2940 initcall_entry_t *ce;
2941
2942
2943 n_tty_init();
2944
2945
2946
2947
2948
2949 ce = __con_initcall_start;
2950 trace_initcall_level("console");
2951 while (ce < __con_initcall_end) {
2952 call = initcall_from_entry(ce);
2953 trace_initcall_start(call);
2954 ret = call();
2955 trace_initcall_finish(call, ret);
2956 ce++;
2957 }
2958}
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974static int __init printk_late_init(void)
2975{
2976 struct console *con;
2977 int ret;
2978
2979 for_each_console(con) {
2980 if (!(con->flags & CON_BOOT))
2981 continue;
2982
2983
2984 if (init_section_intersects(con, sizeof(*con)) ||
2985 init_section_contains(con->write, 0) ||
2986 init_section_contains(con->read, 0) ||
2987 init_section_contains(con->device, 0) ||
2988 init_section_contains(con->unblank, 0) ||
2989 init_section_contains(con->data, 0)) {
2990
2991
2992
2993
2994 pr_warn("bootconsole [%s%d] uses init memory and must be disabled even before the real one is ready\n",
2995 con->name, con->index);
2996 unregister_console(con);
2997 }
2998 }
2999 ret = cpuhp_setup_state_nocalls(CPUHP_PRINTK_DEAD, "printk:dead", NULL,
3000 console_cpu_notify);
3001 WARN_ON(ret < 0);
3002 ret = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN, "printk:online",
3003 console_cpu_notify, NULL);
3004 WARN_ON(ret < 0);
3005 return 0;
3006}
3007late_initcall(printk_late_init);
3008
3009#if defined CONFIG_PRINTK
3010
3011
3012
3013#define PRINTK_PENDING_WAKEUP 0x01
3014#define PRINTK_PENDING_OUTPUT 0x02
3015
3016static DEFINE_PER_CPU(int, printk_pending);
3017
3018static void wake_up_klogd_work_func(struct irq_work *irq_work)
3019{
3020 int pending = __this_cpu_xchg(printk_pending, 0);
3021
3022 if (pending & PRINTK_PENDING_OUTPUT) {
3023
3024 if (console_trylock())
3025 console_unlock();
3026 }
3027
3028 if (pending & PRINTK_PENDING_WAKEUP)
3029 wake_up_interruptible(&log_wait);
3030}
3031
3032static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
3033 .func = wake_up_klogd_work_func,
3034 .flags = ATOMIC_INIT(IRQ_WORK_LAZY),
3035};
3036
3037void wake_up_klogd(void)
3038{
3039 if (!printk_percpu_data_ready())
3040 return;
3041
3042 preempt_disable();
3043 if (waitqueue_active(&log_wait)) {
3044 this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
3045 irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
3046 }
3047 preempt_enable();
3048}
3049
3050void defer_console_output(void)
3051{
3052 if (!printk_percpu_data_ready())
3053 return;
3054
3055 preempt_disable();
3056 __this_cpu_or(printk_pending, PRINTK_PENDING_OUTPUT);
3057 irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
3058 preempt_enable();
3059}
3060
3061int vprintk_deferred(const char *fmt, va_list args)
3062{
3063 int r;
3064
3065 r = vprintk_emit(0, LOGLEVEL_SCHED, NULL, 0, fmt, args);
3066 defer_console_output();
3067
3068 return r;
3069}
3070
3071int printk_deferred(const char *fmt, ...)
3072{
3073 va_list args;
3074 int r;
3075
3076 va_start(args, fmt);
3077 r = vprintk_deferred(fmt, args);
3078 va_end(args);
3079
3080 return r;
3081}
3082
3083
3084
3085
3086
3087
3088
3089DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
3090
3091int __printk_ratelimit(const char *func)
3092{
3093 return ___ratelimit(&printk_ratelimit_state, func);
3094}
3095EXPORT_SYMBOL(__printk_ratelimit);
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106bool printk_timed_ratelimit(unsigned long *caller_jiffies,
3107 unsigned int interval_msecs)
3108{
3109 unsigned long elapsed = jiffies - *caller_jiffies;
3110
3111 if (*caller_jiffies && elapsed <= msecs_to_jiffies(interval_msecs))
3112 return false;
3113
3114 *caller_jiffies = jiffies;
3115 return true;
3116}
3117EXPORT_SYMBOL(printk_timed_ratelimit);
3118
3119static DEFINE_SPINLOCK(dump_list_lock);
3120static LIST_HEAD(dump_list);
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130int kmsg_dump_register(struct kmsg_dumper *dumper)
3131{
3132 unsigned long flags;
3133 int err = -EBUSY;
3134
3135
3136 if (!dumper->dump)
3137 return -EINVAL;
3138
3139 spin_lock_irqsave(&dump_list_lock, flags);
3140
3141 if (!dumper->registered) {
3142 dumper->registered = 1;
3143 list_add_tail_rcu(&dumper->list, &dump_list);
3144 err = 0;
3145 }
3146 spin_unlock_irqrestore(&dump_list_lock, flags);
3147
3148 return err;
3149}
3150EXPORT_SYMBOL_GPL(kmsg_dump_register);
3151
3152
3153
3154
3155
3156
3157
3158
3159int kmsg_dump_unregister(struct kmsg_dumper *dumper)
3160{
3161 unsigned long flags;
3162 int err = -EINVAL;
3163
3164 spin_lock_irqsave(&dump_list_lock, flags);
3165 if (dumper->registered) {
3166 dumper->registered = 0;
3167 list_del_rcu(&dumper->list);
3168 err = 0;
3169 }
3170 spin_unlock_irqrestore(&dump_list_lock, flags);
3171 synchronize_rcu();
3172
3173 return err;
3174}
3175EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
3176
3177static bool always_kmsg_dump;
3178module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
3179
3180const char *kmsg_dump_reason_str(enum kmsg_dump_reason reason)
3181{
3182 switch (reason) {
3183 case KMSG_DUMP_PANIC:
3184 return "Panic";
3185 case KMSG_DUMP_OOPS:
3186 return "Oops";
3187 case KMSG_DUMP_EMERG:
3188 return "Emergency";
3189 case KMSG_DUMP_SHUTDOWN:
3190 return "Shutdown";
3191 default:
3192 return "Unknown";
3193 }
3194}
3195EXPORT_SYMBOL_GPL(kmsg_dump_reason_str);
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205void kmsg_dump(enum kmsg_dump_reason reason)
3206{
3207 struct kmsg_dumper *dumper;
3208 unsigned long flags;
3209
3210 rcu_read_lock();
3211 list_for_each_entry_rcu(dumper, &dump_list, list) {
3212 enum kmsg_dump_reason max_reason = dumper->max_reason;
3213
3214
3215
3216
3217
3218 if (max_reason == KMSG_DUMP_UNDEF) {
3219 max_reason = always_kmsg_dump ? KMSG_DUMP_MAX :
3220 KMSG_DUMP_OOPS;
3221 }
3222 if (reason > max_reason)
3223 continue;
3224
3225
3226 dumper->active = true;
3227
3228 logbuf_lock_irqsave(flags);
3229 dumper->cur_seq = clear_seq;
3230 dumper->cur_idx = clear_idx;
3231 dumper->next_seq = log_next_seq;
3232 dumper->next_idx = log_next_idx;
3233 logbuf_unlock_irqrestore(flags);
3234
3235
3236 dumper->dump(dumper, reason);
3237
3238
3239 dumper->active = false;
3240 }
3241 rcu_read_unlock();
3242}
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
3264 char *line, size_t size, size_t *len)
3265{
3266 struct printk_log *msg;
3267 size_t l = 0;
3268 bool ret = false;
3269
3270 if (!dumper->active)
3271 goto out;
3272
3273 if (dumper->cur_seq < log_first_seq) {
3274
3275 dumper->cur_seq = log_first_seq;
3276 dumper->cur_idx = log_first_idx;
3277 }
3278
3279
3280 if (dumper->cur_seq >= log_next_seq)
3281 goto out;
3282
3283 msg = log_from_idx(dumper->cur_idx);
3284 l = msg_print_text(msg, syslog, printk_time, line, size);
3285
3286 dumper->cur_idx = log_next(dumper->cur_idx);
3287 dumper->cur_seq++;
3288 ret = true;
3289out:
3290 if (len)
3291 *len = l;
3292 return ret;
3293}
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
3313 char *line, size_t size, size_t *len)
3314{
3315 unsigned long flags;
3316 bool ret;
3317
3318 logbuf_lock_irqsave(flags);
3319 ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
3320 logbuf_unlock_irqrestore(flags);
3321
3322 return ret;
3323}
3324EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
3346 char *buf, size_t size, size_t *len)
3347{
3348 unsigned long flags;
3349 u64 seq;
3350 u32 idx;
3351 u64 next_seq;
3352 u32 next_idx;
3353 size_t l = 0;
3354 bool ret = false;
3355 bool time = printk_time;
3356
3357 if (!dumper->active)
3358 goto out;
3359
3360 logbuf_lock_irqsave(flags);
3361 if (dumper->cur_seq < log_first_seq) {
3362
3363 dumper->cur_seq = log_first_seq;
3364 dumper->cur_idx = log_first_idx;
3365 }
3366
3367
3368 if (dumper->cur_seq >= dumper->next_seq) {
3369 logbuf_unlock_irqrestore(flags);
3370 goto out;
3371 }
3372
3373
3374 seq = dumper->cur_seq;
3375 idx = dumper->cur_idx;
3376 while (seq < dumper->next_seq) {
3377 struct printk_log *msg = log_from_idx(idx);
3378
3379 l += msg_print_text(msg, true, time, NULL, 0);
3380 idx = log_next(idx);
3381 seq++;
3382 }
3383
3384
3385 seq = dumper->cur_seq;
3386 idx = dumper->cur_idx;
3387 while (l >= size && seq < dumper->next_seq) {
3388 struct printk_log *msg = log_from_idx(idx);
3389
3390 l -= msg_print_text(msg, true, time, NULL, 0);
3391 idx = log_next(idx);
3392 seq++;
3393 }
3394
3395
3396 next_seq = seq;
3397 next_idx = idx;
3398
3399 l = 0;
3400 while (seq < dumper->next_seq) {
3401 struct printk_log *msg = log_from_idx(idx);
3402
3403 l += msg_print_text(msg, syslog, time, buf + l, size - l);
3404 idx = log_next(idx);
3405 seq++;
3406 }
3407
3408 dumper->next_seq = next_seq;
3409 dumper->next_idx = next_idx;
3410 ret = true;
3411 logbuf_unlock_irqrestore(flags);
3412out:
3413 if (len)
3414 *len = l;
3415 return ret;
3416}
3417EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
3430{
3431 dumper->cur_seq = clear_seq;
3432 dumper->cur_idx = clear_idx;
3433 dumper->next_seq = log_next_seq;
3434 dumper->next_idx = log_next_idx;
3435}
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445void kmsg_dump_rewind(struct kmsg_dumper *dumper)
3446{
3447 unsigned long flags;
3448
3449 logbuf_lock_irqsave(flags);
3450 kmsg_dump_rewind_nolock(dumper);
3451 logbuf_unlock_irqrestore(flags);
3452}
3453EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
3454
3455#endif
3456