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