1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/kernel.h>
20#include <linux/mm.h>
21#include <linux/tty.h>
22#include <linux/tty_driver.h>
23#include <linux/console.h>
24#include <linux/init.h>
25#include <linux/jiffies.h>
26#include <linux/nmi.h>
27#include <linux/module.h>
28#include <linux/moduleparam.h>
29#include <linux/interrupt.h>
30#include <linux/delay.h>
31#include <linux/smp.h>
32#include <linux/security.h>
33#include <linux/bootmem.h>
34#include <linux/memblock.h>
35#include <linux/aio.h>
36#include <linux/syscalls.h>
37#include <linux/kexec.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/notifier.h>
44#include <linux/rculist.h>
45#include <linux/poll.h>
46#include <linux/irq_work.h>
47#include <linux/utsname.h>
48
49#include <asm/uaccess.h>
50
51#define CREATE_TRACE_POINTS
52#include <trace/events/printk.h>
53
54#include "console_cmdline.h"
55#include "braille.h"
56
57
58#define DEFAULT_MESSAGE_LOGLEVEL CONFIG_DEFAULT_MESSAGE_LOGLEVEL
59
60
61#define MINIMUM_CONSOLE_LOGLEVEL 1
62#define DEFAULT_CONSOLE_LOGLEVEL 7
63
64int console_printk[4] = {
65 DEFAULT_CONSOLE_LOGLEVEL,
66 DEFAULT_MESSAGE_LOGLEVEL,
67 MINIMUM_CONSOLE_LOGLEVEL,
68 DEFAULT_CONSOLE_LOGLEVEL,
69};
70
71
72
73
74
75int oops_in_progress;
76EXPORT_SYMBOL(oops_in_progress);
77
78
79
80
81
82
83static DEFINE_SEMAPHORE(console_sem);
84struct console *console_drivers;
85EXPORT_SYMBOL_GPL(console_drivers);
86
87#ifdef CONFIG_LOCKDEP
88static struct lockdep_map console_lock_dep_map = {
89 .name = "console_lock"
90};
91#endif
92
93
94
95
96
97
98
99
100
101static int console_locked, console_suspended;
102
103
104
105
106static struct console *exclusive_console;
107
108
109
110
111
112#define MAX_CMDLINECONSOLES 8
113
114static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
115
116static int selected_console = -1;
117static int preferred_console = -1;
118int console_set_on_cmdline;
119EXPORT_SYMBOL(console_set_on_cmdline);
120
121
122static int console_may_schedule;
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191enum log_flags {
192 LOG_NOCONS = 1,
193 LOG_NEWLINE = 2,
194 LOG_PREFIX = 4,
195 LOG_CONT = 8,
196};
197
198struct printk_log {
199 u64 ts_nsec;
200 u16 len;
201 u16 text_len;
202 u16 dict_len;
203 u8 facility;
204 u8 flags:5;
205 u8 level:3;
206};
207
208
209
210
211
212static DEFINE_RAW_SPINLOCK(logbuf_lock);
213
214#ifdef CONFIG_PRINTK
215DECLARE_WAIT_QUEUE_HEAD(log_wait);
216
217static u64 syslog_seq;
218static u32 syslog_idx;
219static enum log_flags syslog_prev;
220static size_t syslog_partial;
221
222
223static u64 log_first_seq;
224static u32 log_first_idx;
225
226
227static u64 log_next_seq;
228static u32 log_next_idx;
229
230
231static u64 console_seq;
232static u32 console_idx;
233static enum log_flags console_prev;
234
235
236static u64 clear_seq;
237static u32 clear_idx;
238
239#define PREFIX_MAX 32
240#define LOG_LINE_MAX 1024 - PREFIX_MAX
241
242
243#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
244#define LOG_ALIGN 4
245#else
246#define LOG_ALIGN __alignof__(struct printk_log)
247#endif
248#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
249static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
250static char *log_buf = __log_buf;
251static u32 log_buf_len = __LOG_BUF_LEN;
252
253
254static volatile unsigned int logbuf_cpu = UINT_MAX;
255
256
257static char *log_text(const struct printk_log *msg)
258{
259 return (char *)msg + sizeof(struct printk_log);
260}
261
262
263static char *log_dict(const struct printk_log *msg)
264{
265 return (char *)msg + sizeof(struct printk_log) + msg->text_len;
266}
267
268
269static struct printk_log *log_from_idx(u32 idx)
270{
271 struct printk_log *msg = (struct printk_log *)(log_buf + idx);
272
273
274
275
276
277 if (!msg->len)
278 return (struct printk_log *)log_buf;
279 return msg;
280}
281
282
283static u32 log_next(u32 idx)
284{
285 struct printk_log *msg = (struct printk_log *)(log_buf + idx);
286
287
288
289
290
291
292
293 if (!msg->len) {
294 msg = (struct printk_log *)log_buf;
295 return msg->len;
296 }
297 return idx + msg->len;
298}
299
300
301static void log_store(int facility, int level,
302 enum log_flags flags, u64 ts_nsec,
303 const char *dict, u16 dict_len,
304 const char *text, u16 text_len)
305{
306 struct printk_log *msg;
307 u32 size, pad_len;
308
309
310 size = sizeof(struct printk_log) + text_len + dict_len;
311 pad_len = (-size) & (LOG_ALIGN - 1);
312 size += pad_len;
313
314 while (log_first_seq < log_next_seq) {
315 u32 free;
316
317 if (log_next_idx > log_first_idx)
318 free = max(log_buf_len - log_next_idx, log_first_idx);
319 else
320 free = log_first_idx - log_next_idx;
321
322 if (free >= size + sizeof(struct printk_log))
323 break;
324
325
326 log_first_idx = log_next(log_first_idx);
327 log_first_seq++;
328 }
329
330 if (log_next_idx + size + sizeof(struct printk_log) > log_buf_len) {
331
332
333
334
335
336 memset(log_buf + log_next_idx, 0, sizeof(struct printk_log));
337 log_next_idx = 0;
338 }
339
340
341 msg = (struct printk_log *)(log_buf + log_next_idx);
342 memcpy(log_text(msg), text, text_len);
343 msg->text_len = text_len;
344 memcpy(log_dict(msg), dict, dict_len);
345 msg->dict_len = dict_len;
346 msg->facility = facility;
347 msg->level = level & 7;
348 msg->flags = flags & 0x1f;
349 if (ts_nsec > 0)
350 msg->ts_nsec = ts_nsec;
351 else
352 msg->ts_nsec = local_clock();
353 memset(log_dict(msg) + dict_len, 0, pad_len);
354 msg->len = size;
355
356
357 log_next_idx += msg->len;
358 log_next_seq++;
359}
360
361#ifdef CONFIG_SECURITY_DMESG_RESTRICT
362int dmesg_restrict = 1;
363#else
364int dmesg_restrict;
365#endif
366
367static int syslog_action_restricted(int type)
368{
369 if (dmesg_restrict)
370 return 1;
371
372
373
374
375 return type != SYSLOG_ACTION_READ_ALL &&
376 type != SYSLOG_ACTION_SIZE_BUFFER;
377}
378
379static int check_syslog_permissions(int type, bool from_file)
380{
381
382
383
384
385 if (from_file && type != SYSLOG_ACTION_OPEN)
386 return 0;
387
388 if (syslog_action_restricted(type)) {
389 if (capable(CAP_SYSLOG))
390 return 0;
391
392
393
394
395 if (capable(CAP_SYS_ADMIN)) {
396 pr_warn_once("%s (%d): Attempt to access syslog with "
397 "CAP_SYS_ADMIN but no CAP_SYSLOG "
398 "(deprecated).\n",
399 current->comm, task_pid_nr(current));
400 return 0;
401 }
402 return -EPERM;
403 }
404 return security_syslog(type);
405}
406
407
408
409struct devkmsg_user {
410 u64 seq;
411 u32 idx;
412 enum log_flags prev;
413 struct mutex lock;
414 char buf[8192];
415};
416
417static ssize_t devkmsg_writev(struct kiocb *iocb, const struct iovec *iv,
418 unsigned long count, loff_t pos)
419{
420 char *buf, *line;
421 int i;
422 int level = default_message_loglevel;
423 int facility = 1;
424 size_t len = iov_length(iv, count);
425 ssize_t ret = len;
426
427 if (len > LOG_LINE_MAX)
428 return -EINVAL;
429 buf = kmalloc(len+1, GFP_KERNEL);
430 if (buf == NULL)
431 return -ENOMEM;
432
433 line = buf;
434 for (i = 0; i < count; i++) {
435 if (copy_from_user(line, iv[i].iov_base, iv[i].iov_len)) {
436 ret = -EFAULT;
437 goto out;
438 }
439 line += iv[i].iov_len;
440 }
441
442
443
444
445
446
447
448
449
450
451 line = buf;
452 if (line[0] == '<') {
453 char *endp = NULL;
454
455 i = simple_strtoul(line+1, &endp, 10);
456 if (endp && endp[0] == '>') {
457 level = i & 7;
458 if (i >> 3)
459 facility = i >> 3;
460 endp++;
461 len -= endp - line;
462 line = endp;
463 }
464 }
465 line[len] = '\0';
466
467 printk_emit(facility, level, NULL, 0, "%s", line);
468out:
469 kfree(buf);
470 return ret;
471}
472
473static ssize_t devkmsg_read(struct file *file, char __user *buf,
474 size_t count, loff_t *ppos)
475{
476 struct devkmsg_user *user = file->private_data;
477 struct printk_log *msg;
478 u64 ts_usec;
479 size_t i;
480 char cont = '-';
481 size_t len;
482 ssize_t ret;
483
484 if (!user)
485 return -EBADF;
486
487 ret = mutex_lock_interruptible(&user->lock);
488 if (ret)
489 return ret;
490 raw_spin_lock_irq(&logbuf_lock);
491 while (user->seq == log_next_seq) {
492 if (file->f_flags & O_NONBLOCK) {
493 ret = -EAGAIN;
494 raw_spin_unlock_irq(&logbuf_lock);
495 goto out;
496 }
497
498 raw_spin_unlock_irq(&logbuf_lock);
499 ret = wait_event_interruptible(log_wait,
500 user->seq != log_next_seq);
501 if (ret)
502 goto out;
503 raw_spin_lock_irq(&logbuf_lock);
504 }
505
506 if (user->seq < log_first_seq) {
507
508 user->idx = log_first_idx;
509 user->seq = log_first_seq;
510 ret = -EPIPE;
511 raw_spin_unlock_irq(&logbuf_lock);
512 goto out;
513 }
514
515 msg = log_from_idx(user->idx);
516 ts_usec = msg->ts_nsec;
517 do_div(ts_usec, 1000);
518
519
520
521
522
523
524
525
526
527 if (msg->flags & LOG_CONT && !(user->prev & LOG_CONT))
528 cont = 'c';
529 else if ((msg->flags & LOG_CONT) ||
530 ((user->prev & LOG_CONT) && !(msg->flags & LOG_PREFIX)))
531 cont = '+';
532
533 len = sprintf(user->buf, "%u,%llu,%llu,%c;",
534 (msg->facility << 3) | msg->level,
535 user->seq, ts_usec, cont);
536 user->prev = msg->flags;
537
538
539 for (i = 0; i < msg->text_len; i++) {
540 unsigned char c = log_text(msg)[i];
541
542 if (c < ' ' || c >= 127 || c == '\\')
543 len += sprintf(user->buf + len, "\\x%02x", c);
544 else
545 user->buf[len++] = c;
546 }
547 user->buf[len++] = '\n';
548
549 if (msg->dict_len) {
550 bool line = true;
551
552 for (i = 0; i < msg->dict_len; i++) {
553 unsigned char c = log_dict(msg)[i];
554
555 if (line) {
556 user->buf[len++] = ' ';
557 line = false;
558 }
559
560 if (c == '\0') {
561 user->buf[len++] = '\n';
562 line = true;
563 continue;
564 }
565
566 if (c < ' ' || c >= 127 || c == '\\') {
567 len += sprintf(user->buf + len, "\\x%02x", c);
568 continue;
569 }
570
571 user->buf[len++] = c;
572 }
573 user->buf[len++] = '\n';
574 }
575
576 user->idx = log_next(user->idx);
577 user->seq++;
578 raw_spin_unlock_irq(&logbuf_lock);
579
580 if (len > count) {
581 ret = -EINVAL;
582 goto out;
583 }
584
585 if (copy_to_user(buf, user->buf, len)) {
586 ret = -EFAULT;
587 goto out;
588 }
589 ret = len;
590out:
591 mutex_unlock(&user->lock);
592 return ret;
593}
594
595static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
596{
597 struct devkmsg_user *user = file->private_data;
598 loff_t ret = 0;
599
600 if (!user)
601 return -EBADF;
602 if (offset)
603 return -ESPIPE;
604
605 raw_spin_lock_irq(&logbuf_lock);
606 switch (whence) {
607 case SEEK_SET:
608
609 user->idx = log_first_idx;
610 user->seq = log_first_seq;
611 break;
612 case SEEK_DATA:
613
614
615
616
617
618 user->idx = clear_idx;
619 user->seq = clear_seq;
620 break;
621 case SEEK_END:
622
623 user->idx = log_next_idx;
624 user->seq = log_next_seq;
625 break;
626 default:
627 ret = -EINVAL;
628 }
629 raw_spin_unlock_irq(&logbuf_lock);
630 return ret;
631}
632
633static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
634{
635 struct devkmsg_user *user = file->private_data;
636 int ret = 0;
637
638 if (!user)
639 return POLLERR|POLLNVAL;
640
641 poll_wait(file, &log_wait, wait);
642
643 raw_spin_lock_irq(&logbuf_lock);
644 if (user->seq < log_next_seq) {
645
646 if (user->seq < log_first_seq)
647 ret = POLLIN|POLLRDNORM|POLLERR|POLLPRI;
648 else
649 ret = POLLIN|POLLRDNORM;
650 }
651 raw_spin_unlock_irq(&logbuf_lock);
652
653 return ret;
654}
655
656static int devkmsg_open(struct inode *inode, struct file *file)
657{
658 struct devkmsg_user *user;
659 int err;
660
661
662 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
663 return 0;
664
665 err = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
666 SYSLOG_FROM_READER);
667 if (err)
668 return err;
669
670 user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
671 if (!user)
672 return -ENOMEM;
673
674 mutex_init(&user->lock);
675
676 raw_spin_lock_irq(&logbuf_lock);
677 user->idx = log_first_idx;
678 user->seq = log_first_seq;
679 raw_spin_unlock_irq(&logbuf_lock);
680
681 file->private_data = user;
682 return 0;
683}
684
685static int devkmsg_release(struct inode *inode, struct file *file)
686{
687 struct devkmsg_user *user = file->private_data;
688
689 if (!user)
690 return 0;
691
692 mutex_destroy(&user->lock);
693 kfree(user);
694 return 0;
695}
696
697const struct file_operations kmsg_fops = {
698 .open = devkmsg_open,
699 .read = devkmsg_read,
700 .aio_write = devkmsg_writev,
701 .llseek = devkmsg_llseek,
702 .poll = devkmsg_poll,
703 .release = devkmsg_release,
704};
705
706#ifdef CONFIG_KEXEC
707
708
709
710
711
712
713
714
715void log_buf_kexec_setup(void)
716{
717 VMCOREINFO_SYMBOL(log_buf);
718 VMCOREINFO_SYMBOL(log_buf_len);
719 VMCOREINFO_SYMBOL(log_first_idx);
720 VMCOREINFO_SYMBOL(log_next_idx);
721
722
723
724
725 VMCOREINFO_STRUCT_SIZE(printk_log);
726 VMCOREINFO_OFFSET(printk_log, ts_nsec);
727 VMCOREINFO_OFFSET(printk_log, len);
728 VMCOREINFO_OFFSET(printk_log, text_len);
729 VMCOREINFO_OFFSET(printk_log, dict_len);
730}
731#endif
732
733
734static unsigned long __initdata new_log_buf_len;
735
736
737static int __init log_buf_len_setup(char *str)
738{
739 unsigned size = memparse(str, &str);
740
741 if (size)
742 size = roundup_pow_of_two(size);
743 if (size > log_buf_len)
744 new_log_buf_len = size;
745
746 return 0;
747}
748early_param("log_buf_len", log_buf_len_setup);
749
750void __init setup_log_buf(int early)
751{
752 unsigned long flags;
753 char *new_log_buf;
754 int free;
755
756 if (!new_log_buf_len)
757 return;
758
759 if (early) {
760 new_log_buf =
761 memblock_virt_alloc(new_log_buf_len, PAGE_SIZE);
762 } else {
763 new_log_buf = memblock_virt_alloc_nopanic(new_log_buf_len, 0);
764 }
765
766 if (unlikely(!new_log_buf)) {
767 pr_err("log_buf_len: %ld bytes not available\n",
768 new_log_buf_len);
769 return;
770 }
771
772 raw_spin_lock_irqsave(&logbuf_lock, flags);
773 log_buf_len = new_log_buf_len;
774 log_buf = new_log_buf;
775 new_log_buf_len = 0;
776 free = __LOG_BUF_LEN - log_next_idx;
777 memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
778 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
779
780 pr_info("log_buf_len: %d\n", log_buf_len);
781 pr_info("early log buf free: %d(%d%%)\n",
782 free, (free * 100) / __LOG_BUF_LEN);
783}
784
785static bool __read_mostly ignore_loglevel;
786
787static int __init ignore_loglevel_setup(char *str)
788{
789 ignore_loglevel = 1;
790 pr_info("debug: ignoring loglevel setting.\n");
791
792 return 0;
793}
794
795early_param("ignore_loglevel", ignore_loglevel_setup);
796module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
797MODULE_PARM_DESC(ignore_loglevel, "ignore loglevel setting, to"
798 "print all kernel messages to the console.");
799
800#ifdef CONFIG_BOOT_PRINTK_DELAY
801
802static int boot_delay;
803static unsigned long long loops_per_msec;
804
805static int __init boot_delay_setup(char *str)
806{
807 unsigned long lpj;
808
809 lpj = preset_lpj ? preset_lpj : 1000000;
810 loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
811
812 get_option(&str, &boot_delay);
813 if (boot_delay > 10 * 1000)
814 boot_delay = 0;
815
816 pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
817 "HZ: %d, loops_per_msec: %llu\n",
818 boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
819 return 0;
820}
821early_param("boot_delay", boot_delay_setup);
822
823static void boot_delay_msec(int level)
824{
825 unsigned long long k;
826 unsigned long timeout;
827
828 if ((boot_delay == 0 || system_state != SYSTEM_BOOTING)
829 || (level >= console_loglevel && !ignore_loglevel)) {
830 return;
831 }
832
833 k = (unsigned long long)loops_per_msec * boot_delay;
834
835 timeout = jiffies + msecs_to_jiffies(boot_delay);
836 while (k) {
837 k--;
838 cpu_relax();
839
840
841
842
843
844 if (time_after(jiffies, timeout))
845 break;
846 touch_nmi_watchdog();
847 }
848}
849#else
850static inline void boot_delay_msec(int level)
851{
852}
853#endif
854
855#if defined(CONFIG_PRINTK_TIME)
856static bool printk_time = 1;
857#else
858static bool printk_time;
859#endif
860module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
861
862static size_t print_time(u64 ts, char *buf)
863{
864 unsigned long rem_nsec;
865
866 if (!printk_time)
867 return 0;
868
869 rem_nsec = do_div(ts, 1000000000);
870
871 if (!buf)
872 return snprintf(NULL, 0, "[%5lu.000000] ", (unsigned long)ts);
873
874 return sprintf(buf, "[%5lu.%06lu] ",
875 (unsigned long)ts, rem_nsec / 1000);
876}
877
878static size_t print_prefix(const struct printk_log *msg, bool syslog, char *buf)
879{
880 size_t len = 0;
881 unsigned int prefix = (msg->facility << 3) | msg->level;
882
883 if (syslog) {
884 if (buf) {
885 len += sprintf(buf, "<%u>", prefix);
886 } else {
887 len += 3;
888 if (prefix > 999)
889 len += 3;
890 else if (prefix > 99)
891 len += 2;
892 else if (prefix > 9)
893 len++;
894 }
895 }
896
897 len += print_time(msg->ts_nsec, buf ? buf + len : NULL);
898 return len;
899}
900
901static size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
902 bool syslog, char *buf, size_t size)
903{
904 const char *text = log_text(msg);
905 size_t text_size = msg->text_len;
906 bool prefix = true;
907 bool newline = true;
908 size_t len = 0;
909
910 if ((prev & LOG_CONT) && !(msg->flags & LOG_PREFIX))
911 prefix = false;
912
913 if (msg->flags & LOG_CONT) {
914 if ((prev & LOG_CONT) && !(prev & LOG_NEWLINE))
915 prefix = false;
916
917 if (!(msg->flags & LOG_NEWLINE))
918 newline = false;
919 }
920
921 do {
922 const char *next = memchr(text, '\n', text_size);
923 size_t text_len;
924
925 if (next) {
926 text_len = next - text;
927 next++;
928 text_size -= next - text;
929 } else {
930 text_len = text_size;
931 }
932
933 if (buf) {
934 if (print_prefix(msg, syslog, NULL) +
935 text_len + 1 >= size - len)
936 break;
937
938 if (prefix)
939 len += print_prefix(msg, syslog, buf + len);
940 memcpy(buf + len, text, text_len);
941 len += text_len;
942 if (next || newline)
943 buf[len++] = '\n';
944 } else {
945
946 if (prefix)
947 len += print_prefix(msg, syslog, NULL);
948 len += text_len;
949 if (next || newline)
950 len++;
951 }
952
953 prefix = true;
954 text = next;
955 } while (text);
956
957 return len;
958}
959
960static int syslog_print(char __user *buf, int size)
961{
962 char *text;
963 struct printk_log *msg;
964 int len = 0;
965
966 text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
967 if (!text)
968 return -ENOMEM;
969
970 while (size > 0) {
971 size_t n;
972 size_t skip;
973
974 raw_spin_lock_irq(&logbuf_lock);
975 if (syslog_seq < log_first_seq) {
976
977 syslog_seq = log_first_seq;
978 syslog_idx = log_first_idx;
979 syslog_prev = 0;
980 syslog_partial = 0;
981 }
982 if (syslog_seq == log_next_seq) {
983 raw_spin_unlock_irq(&logbuf_lock);
984 break;
985 }
986
987 skip = syslog_partial;
988 msg = log_from_idx(syslog_idx);
989 n = msg_print_text(msg, syslog_prev, true, text,
990 LOG_LINE_MAX + PREFIX_MAX);
991 if (n - syslog_partial <= size) {
992
993 syslog_idx = log_next(syslog_idx);
994 syslog_seq++;
995 syslog_prev = msg->flags;
996 n -= syslog_partial;
997 syslog_partial = 0;
998 } else if (!len){
999
1000 n = size;
1001 syslog_partial += n;
1002 } else
1003 n = 0;
1004 raw_spin_unlock_irq(&logbuf_lock);
1005
1006 if (!n)
1007 break;
1008
1009 if (copy_to_user(buf, text + skip, n)) {
1010 if (!len)
1011 len = -EFAULT;
1012 break;
1013 }
1014
1015 len += n;
1016 size -= n;
1017 buf += n;
1018 }
1019
1020 kfree(text);
1021 return len;
1022}
1023
1024static int syslog_print_all(char __user *buf, int size, bool clear)
1025{
1026 char *text;
1027 int len = 0;
1028
1029 text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
1030 if (!text)
1031 return -ENOMEM;
1032
1033 raw_spin_lock_irq(&logbuf_lock);
1034 if (buf) {
1035 u64 next_seq;
1036 u64 seq;
1037 u32 idx;
1038 enum log_flags prev;
1039
1040 if (clear_seq < log_first_seq) {
1041
1042 clear_seq = log_first_seq;
1043 clear_idx = log_first_idx;
1044 }
1045
1046
1047
1048
1049
1050 seq = clear_seq;
1051 idx = clear_idx;
1052 prev = 0;
1053 while (seq < log_next_seq) {
1054 struct printk_log *msg = log_from_idx(idx);
1055
1056 len += msg_print_text(msg, prev, true, NULL, 0);
1057 prev = msg->flags;
1058 idx = log_next(idx);
1059 seq++;
1060 }
1061
1062
1063 seq = clear_seq;
1064 idx = clear_idx;
1065 prev = 0;
1066 while (len > size && seq < log_next_seq) {
1067 struct printk_log *msg = log_from_idx(idx);
1068
1069 len -= msg_print_text(msg, prev, true, NULL, 0);
1070 prev = msg->flags;
1071 idx = log_next(idx);
1072 seq++;
1073 }
1074
1075
1076 next_seq = log_next_seq;
1077
1078 len = 0;
1079 while (len >= 0 && seq < next_seq) {
1080 struct printk_log *msg = log_from_idx(idx);
1081 int textlen;
1082
1083 textlen = msg_print_text(msg, prev, true, text,
1084 LOG_LINE_MAX + PREFIX_MAX);
1085 if (textlen < 0) {
1086 len = textlen;
1087 break;
1088 }
1089 idx = log_next(idx);
1090 seq++;
1091 prev = msg->flags;
1092
1093 raw_spin_unlock_irq(&logbuf_lock);
1094 if (copy_to_user(buf + len, text, textlen))
1095 len = -EFAULT;
1096 else
1097 len += textlen;
1098 raw_spin_lock_irq(&logbuf_lock);
1099
1100 if (seq < log_first_seq) {
1101
1102 seq = log_first_seq;
1103 idx = log_first_idx;
1104 prev = 0;
1105 }
1106 }
1107 }
1108
1109 if (clear) {
1110 clear_seq = log_next_seq;
1111 clear_idx = log_next_idx;
1112 }
1113 raw_spin_unlock_irq(&logbuf_lock);
1114
1115 kfree(text);
1116 return len;
1117}
1118
1119int do_syslog(int type, char __user *buf, int len, bool from_file)
1120{
1121 bool clear = false;
1122 static int saved_console_loglevel = -1;
1123 int error;
1124
1125 error = check_syslog_permissions(type, from_file);
1126 if (error)
1127 goto out;
1128
1129 error = security_syslog(type);
1130 if (error)
1131 return error;
1132
1133 switch (type) {
1134 case SYSLOG_ACTION_CLOSE:
1135 break;
1136 case SYSLOG_ACTION_OPEN:
1137 break;
1138 case SYSLOG_ACTION_READ:
1139 error = -EINVAL;
1140 if (!buf || len < 0)
1141 goto out;
1142 error = 0;
1143 if (!len)
1144 goto out;
1145 if (!access_ok(VERIFY_WRITE, buf, len)) {
1146 error = -EFAULT;
1147 goto out;
1148 }
1149 error = wait_event_interruptible(log_wait,
1150 syslog_seq != log_next_seq);
1151 if (error)
1152 goto out;
1153 error = syslog_print(buf, len);
1154 break;
1155
1156 case SYSLOG_ACTION_READ_CLEAR:
1157 clear = true;
1158
1159
1160 case SYSLOG_ACTION_READ_ALL:
1161 error = -EINVAL;
1162 if (!buf || len < 0)
1163 goto out;
1164 error = 0;
1165 if (!len)
1166 goto out;
1167 if (!access_ok(VERIFY_WRITE, buf, len)) {
1168 error = -EFAULT;
1169 goto out;
1170 }
1171 error = syslog_print_all(buf, len, clear);
1172 break;
1173
1174 case SYSLOG_ACTION_CLEAR:
1175 syslog_print_all(NULL, 0, true);
1176 break;
1177
1178 case SYSLOG_ACTION_CONSOLE_OFF:
1179 if (saved_console_loglevel == -1)
1180 saved_console_loglevel = console_loglevel;
1181 console_loglevel = minimum_console_loglevel;
1182 break;
1183
1184 case SYSLOG_ACTION_CONSOLE_ON:
1185 if (saved_console_loglevel != -1) {
1186 console_loglevel = saved_console_loglevel;
1187 saved_console_loglevel = -1;
1188 }
1189 break;
1190
1191 case SYSLOG_ACTION_CONSOLE_LEVEL:
1192 error = -EINVAL;
1193 if (len < 1 || len > 8)
1194 goto out;
1195 if (len < minimum_console_loglevel)
1196 len = minimum_console_loglevel;
1197 console_loglevel = len;
1198
1199 saved_console_loglevel = -1;
1200 error = 0;
1201 break;
1202
1203 case SYSLOG_ACTION_SIZE_UNREAD:
1204 raw_spin_lock_irq(&logbuf_lock);
1205 if (syslog_seq < log_first_seq) {
1206
1207 syslog_seq = log_first_seq;
1208 syslog_idx = log_first_idx;
1209 syslog_prev = 0;
1210 syslog_partial = 0;
1211 }
1212 if (from_file) {
1213
1214
1215
1216
1217
1218 error = log_next_idx - syslog_idx;
1219 } else {
1220 u64 seq = syslog_seq;
1221 u32 idx = syslog_idx;
1222 enum log_flags prev = syslog_prev;
1223
1224 error = 0;
1225 while (seq < log_next_seq) {
1226 struct printk_log *msg = log_from_idx(idx);
1227
1228 error += msg_print_text(msg, prev, true, NULL, 0);
1229 idx = log_next(idx);
1230 seq++;
1231 prev = msg->flags;
1232 }
1233 error -= syslog_partial;
1234 }
1235 raw_spin_unlock_irq(&logbuf_lock);
1236 break;
1237
1238 case SYSLOG_ACTION_SIZE_BUFFER:
1239 error = log_buf_len;
1240 break;
1241 default:
1242 error = -EINVAL;
1243 break;
1244 }
1245out:
1246 return error;
1247}
1248
1249SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
1250{
1251 return do_syslog(type, buf, len, SYSLOG_FROM_READER);
1252}
1253
1254
1255
1256
1257
1258
1259static void call_console_drivers(int level, const char *text, size_t len)
1260{
1261 struct console *con;
1262
1263 trace_console(text, len);
1264
1265 if (level >= console_loglevel && !ignore_loglevel)
1266 return;
1267 if (!console_drivers)
1268 return;
1269
1270 for_each_console(con) {
1271 if (exclusive_console && con != exclusive_console)
1272 continue;
1273 if (!(con->flags & CON_ENABLED))
1274 continue;
1275 if (!con->write)
1276 continue;
1277 if (!cpu_online(smp_processor_id()) &&
1278 !(con->flags & CON_ANYTIME))
1279 continue;
1280 con->write(con, text, len);
1281 }
1282}
1283
1284
1285
1286
1287
1288
1289static void zap_locks(void)
1290{
1291 static unsigned long oops_timestamp;
1292
1293 if (time_after_eq(jiffies, oops_timestamp) &&
1294 !time_after(jiffies, oops_timestamp + 30 * HZ))
1295 return;
1296
1297 oops_timestamp = jiffies;
1298
1299 debug_locks_off();
1300
1301 raw_spin_lock_init(&logbuf_lock);
1302
1303 sema_init(&console_sem, 1);
1304}
1305
1306
1307static int have_callable_console(void)
1308{
1309 struct console *con;
1310
1311 for_each_console(con)
1312 if (con->flags & CON_ANYTIME)
1313 return 1;
1314
1315 return 0;
1316}
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326static inline int can_use_console(unsigned int cpu)
1327{
1328 return cpu_online(cpu) || have_callable_console();
1329}
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341static int console_trylock_for_printk(unsigned int cpu)
1342 __releases(&logbuf_lock)
1343{
1344 int retval = 0, wake = 0;
1345
1346 if (console_trylock()) {
1347 retval = 1;
1348
1349
1350
1351
1352
1353
1354
1355 if (!can_use_console(cpu)) {
1356 console_locked = 0;
1357 wake = 1;
1358 retval = 0;
1359 }
1360 }
1361 logbuf_cpu = UINT_MAX;
1362 raw_spin_unlock(&logbuf_lock);
1363 if (wake)
1364 up(&console_sem);
1365 return retval;
1366}
1367
1368int printk_delay_msec __read_mostly;
1369
1370static inline void printk_delay(void)
1371{
1372 if (unlikely(printk_delay_msec)) {
1373 int m = printk_delay_msec;
1374
1375 while (m--) {
1376 mdelay(1);
1377 touch_nmi_watchdog();
1378 }
1379 }
1380}
1381
1382
1383
1384
1385
1386
1387
1388static struct cont {
1389 char buf[LOG_LINE_MAX];
1390 size_t len;
1391 size_t cons;
1392 struct task_struct *owner;
1393 u64 ts_nsec;
1394 u8 level;
1395 u8 facility;
1396 enum log_flags flags;
1397 bool flushed:1;
1398} cont;
1399
1400static void cont_flush(enum log_flags flags)
1401{
1402 if (cont.flushed)
1403 return;
1404 if (cont.len == 0)
1405 return;
1406
1407 if (cont.cons) {
1408
1409
1410
1411
1412
1413 log_store(cont.facility, cont.level, flags | LOG_NOCONS,
1414 cont.ts_nsec, NULL, 0, cont.buf, cont.len);
1415 cont.flags = flags;
1416 cont.flushed = true;
1417 } else {
1418
1419
1420
1421
1422 log_store(cont.facility, cont.level, flags, 0,
1423 NULL, 0, cont.buf, cont.len);
1424 cont.len = 0;
1425 }
1426}
1427
1428static bool cont_add(int facility, int level, const char *text, size_t len)
1429{
1430 if (cont.len && cont.flushed)
1431 return false;
1432
1433 if (cont.len + len > sizeof(cont.buf)) {
1434
1435 cont_flush(LOG_CONT);
1436 return false;
1437 }
1438
1439 if (!cont.len) {
1440 cont.facility = facility;
1441 cont.level = level;
1442 cont.owner = current;
1443 cont.ts_nsec = local_clock();
1444 cont.flags = 0;
1445 cont.cons = 0;
1446 cont.flushed = false;
1447 }
1448
1449 memcpy(cont.buf + cont.len, text, len);
1450 cont.len += len;
1451
1452 if (cont.len > (sizeof(cont.buf) * 80) / 100)
1453 cont_flush(LOG_CONT);
1454
1455 return true;
1456}
1457
1458static size_t cont_print_text(char *text, size_t size)
1459{
1460 size_t textlen = 0;
1461 size_t len;
1462
1463 if (cont.cons == 0 && (console_prev & LOG_NEWLINE)) {
1464 textlen += print_time(cont.ts_nsec, text);
1465 size -= textlen;
1466 }
1467
1468 len = cont.len - cont.cons;
1469 if (len > 0) {
1470 if (len+1 > size)
1471 len = size-1;
1472 memcpy(text + textlen, cont.buf + cont.cons, len);
1473 textlen += len;
1474 cont.cons = cont.len;
1475 }
1476
1477 if (cont.flushed) {
1478 if (cont.flags & LOG_NEWLINE)
1479 text[textlen++] = '\n';
1480
1481 cont.len = 0;
1482 }
1483 return textlen;
1484}
1485
1486asmlinkage int vprintk_emit(int facility, int level,
1487 const char *dict, size_t dictlen,
1488 const char *fmt, va_list args)
1489{
1490 static int recursion_bug;
1491 static char textbuf[LOG_LINE_MAX];
1492 char *text = textbuf;
1493 size_t text_len;
1494 enum log_flags lflags = 0;
1495 unsigned long flags;
1496 int this_cpu;
1497 int printed_len = 0;
1498
1499 boot_delay_msec(level);
1500 printk_delay();
1501
1502
1503 local_irq_save(flags);
1504 this_cpu = smp_processor_id();
1505
1506
1507
1508
1509 if (unlikely(logbuf_cpu == this_cpu)) {
1510
1511
1512
1513
1514
1515
1516
1517 if (!oops_in_progress && !lockdep_recursing(current)) {
1518 recursion_bug = 1;
1519 goto out_restore_irqs;
1520 }
1521 zap_locks();
1522 }
1523
1524 lockdep_off();
1525 raw_spin_lock(&logbuf_lock);
1526 logbuf_cpu = this_cpu;
1527
1528 if (recursion_bug) {
1529 static const char recursion_msg[] =
1530 "BUG: recent printk recursion!";
1531
1532 recursion_bug = 0;
1533 printed_len += strlen(recursion_msg);
1534
1535 log_store(0, 2, LOG_PREFIX|LOG_NEWLINE, 0,
1536 NULL, 0, recursion_msg, printed_len);
1537 }
1538
1539
1540
1541
1542
1543 text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
1544
1545
1546 if (text_len && text[text_len-1] == '\n') {
1547 text_len--;
1548 lflags |= LOG_NEWLINE;
1549 }
1550
1551
1552 if (facility == 0) {
1553 int kern_level = printk_get_level(text);
1554
1555 if (kern_level) {
1556 const char *end_of_header = printk_skip_level(text);
1557 switch (kern_level) {
1558 case '0' ... '7':
1559 if (level == -1)
1560 level = kern_level - '0';
1561 case 'd':
1562 lflags |= LOG_PREFIX;
1563 }
1564
1565
1566
1567
1568
1569 text_len -= end_of_header - text;
1570 text = (char *)end_of_header;
1571 }
1572 }
1573
1574 if (level == -1)
1575 level = default_message_loglevel;
1576
1577 if (dict)
1578 lflags |= LOG_PREFIX|LOG_NEWLINE;
1579
1580 if (!(lflags & LOG_NEWLINE)) {
1581
1582
1583
1584
1585 if (cont.len && (lflags & LOG_PREFIX || cont.owner != current))
1586 cont_flush(LOG_NEWLINE);
1587
1588
1589 if (!cont_add(facility, level, text, text_len))
1590 log_store(facility, level, lflags | LOG_CONT, 0,
1591 dict, dictlen, text, text_len);
1592 } else {
1593 bool stored = false;
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603 if (cont.len) {
1604 if (cont.owner == current && !(lflags & LOG_PREFIX))
1605 stored = cont_add(facility, level, text,
1606 text_len);
1607 cont_flush(LOG_NEWLINE);
1608 }
1609
1610 if (!stored)
1611 log_store(facility, level, lflags, 0,
1612 dict, dictlen, text, text_len);
1613 }
1614 printed_len += text_len;
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624 if (console_trylock_for_printk(this_cpu))
1625 console_unlock();
1626
1627 lockdep_on();
1628out_restore_irqs:
1629 local_irq_restore(flags);
1630
1631 return printed_len;
1632}
1633EXPORT_SYMBOL(vprintk_emit);
1634
1635asmlinkage int vprintk(const char *fmt, va_list args)
1636{
1637 return vprintk_emit(0, -1, NULL, 0, fmt, args);
1638}
1639EXPORT_SYMBOL(vprintk);
1640
1641asmlinkage int printk_emit(int facility, int level,
1642 const char *dict, size_t dictlen,
1643 const char *fmt, ...)
1644{
1645 va_list args;
1646 int r;
1647
1648 va_start(args, fmt);
1649 r = vprintk_emit(facility, level, dict, dictlen, fmt, args);
1650 va_end(args);
1651
1652 return r;
1653}
1654EXPORT_SYMBOL(printk_emit);
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677asmlinkage __visible int printk(const char *fmt, ...)
1678{
1679 va_list args;
1680 int r;
1681
1682#ifdef CONFIG_KGDB_KDB
1683 if (unlikely(kdb_trap_printk)) {
1684 va_start(args, fmt);
1685 r = vkdb_printf(fmt, args);
1686 va_end(args);
1687 return r;
1688 }
1689#endif
1690 va_start(args, fmt);
1691 r = vprintk_emit(0, -1, NULL, 0, fmt, args);
1692 va_end(args);
1693
1694 return r;
1695}
1696EXPORT_SYMBOL(printk);
1697
1698#else
1699
1700#define LOG_LINE_MAX 0
1701#define PREFIX_MAX 0
1702#define LOG_LINE_MAX 0
1703static u64 syslog_seq;
1704static u32 syslog_idx;
1705static u64 console_seq;
1706static u32 console_idx;
1707static enum log_flags syslog_prev;
1708static u64 log_first_seq;
1709static u32 log_first_idx;
1710static u64 log_next_seq;
1711static enum log_flags console_prev;
1712static struct cont {
1713 size_t len;
1714 size_t cons;
1715 u8 level;
1716 bool flushed:1;
1717} cont;
1718static struct printk_log *log_from_idx(u32 idx) { return NULL; }
1719static u32 log_next(u32 idx) { return 0; }
1720static void call_console_drivers(int level, const char *text, size_t len) {}
1721static size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
1722 bool syslog, char *buf, size_t size) { return 0; }
1723static size_t cont_print_text(char *text, size_t size) { return 0; }
1724
1725#endif
1726
1727#ifdef CONFIG_EARLY_PRINTK
1728struct console *early_console;
1729
1730void early_vprintk(const char *fmt, va_list ap)
1731{
1732 if (early_console) {
1733 char buf[512];
1734 int n = vscnprintf(buf, sizeof(buf), fmt, ap);
1735
1736 early_console->write(early_console, buf, n);
1737 }
1738}
1739
1740asmlinkage __visible void early_printk(const char *fmt, ...)
1741{
1742 va_list ap;
1743
1744 va_start(ap, fmt);
1745 early_vprintk(fmt, ap);
1746 va_end(ap);
1747}
1748#endif
1749
1750static int __add_preferred_console(char *name, int idx, char *options,
1751 char *brl_options)
1752{
1753 struct console_cmdline *c;
1754 int i;
1755
1756
1757
1758
1759
1760 for (i = 0, c = console_cmdline;
1761 i < MAX_CMDLINECONSOLES && c->name[0];
1762 i++, c++) {
1763 if (strcmp(c->name, name) == 0 && c->index == idx) {
1764 if (!brl_options)
1765 selected_console = i;
1766 return 0;
1767 }
1768 }
1769 if (i == MAX_CMDLINECONSOLES)
1770 return -E2BIG;
1771 if (!brl_options)
1772 selected_console = i;
1773 strlcpy(c->name, name, sizeof(c->name));
1774 c->options = options;
1775 braille_set_options(c, brl_options);
1776
1777 c->index = idx;
1778 return 0;
1779}
1780
1781
1782
1783static int __init console_setup(char *str)
1784{
1785 char buf[sizeof(console_cmdline[0].name) + 4];
1786 char *s, *options, *brl_options = NULL;
1787 int idx;
1788
1789 if (_braille_console_setup(&str, &brl_options))
1790 return 1;
1791
1792
1793
1794
1795 if (str[0] >= '0' && str[0] <= '9') {
1796 strcpy(buf, "ttyS");
1797 strncpy(buf + 4, str, sizeof(buf) - 5);
1798 } else {
1799 strncpy(buf, str, sizeof(buf) - 1);
1800 }
1801 buf[sizeof(buf) - 1] = 0;
1802 if ((options = strchr(str, ',')) != NULL)
1803 *(options++) = 0;
1804#ifdef __sparc__
1805 if (!strcmp(str, "ttya"))
1806 strcpy(buf, "ttyS0");
1807 if (!strcmp(str, "ttyb"))
1808 strcpy(buf, "ttyS1");
1809#endif
1810 for (s = buf; *s; s++)
1811 if ((*s >= '0' && *s <= '9') || *s == ',')
1812 break;
1813 idx = simple_strtoul(s, NULL, 10);
1814 *s = 0;
1815
1816 __add_preferred_console(buf, idx, options, brl_options);
1817 console_set_on_cmdline = 1;
1818 return 1;
1819}
1820__setup("console=", console_setup);
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835int add_preferred_console(char *name, int idx, char *options)
1836{
1837 return __add_preferred_console(name, idx, options, NULL);
1838}
1839
1840int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
1841{
1842 struct console_cmdline *c;
1843 int i;
1844
1845 for (i = 0, c = console_cmdline;
1846 i < MAX_CMDLINECONSOLES && c->name[0];
1847 i++, c++)
1848 if (strcmp(c->name, name) == 0 && c->index == idx) {
1849 strlcpy(c->name, name_new, sizeof(c->name));
1850 c->name[sizeof(c->name) - 1] = 0;
1851 c->options = options;
1852 c->index = idx_new;
1853 return i;
1854 }
1855
1856 return -1;
1857}
1858
1859bool console_suspend_enabled = 1;
1860EXPORT_SYMBOL(console_suspend_enabled);
1861
1862static int __init console_suspend_disable(char *str)
1863{
1864 console_suspend_enabled = 0;
1865 return 1;
1866}
1867__setup("no_console_suspend", console_suspend_disable);
1868module_param_named(console_suspend, console_suspend_enabled,
1869 bool, S_IRUGO | S_IWUSR);
1870MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
1871 " and hibernate operations");
1872
1873
1874
1875
1876
1877
1878void suspend_console(void)
1879{
1880 if (!console_suspend_enabled)
1881 return;
1882 printk("Suspending console(s) (use no_console_suspend to debug)\n");
1883 console_lock();
1884 console_suspended = 1;
1885 up(&console_sem);
1886 mutex_release(&console_lock_dep_map, 1, _RET_IP_);
1887}
1888
1889void resume_console(void)
1890{
1891 if (!console_suspend_enabled)
1892 return;
1893 down(&console_sem);
1894 mutex_acquire(&console_lock_dep_map, 0, 0, _RET_IP_);
1895 console_suspended = 0;
1896 console_unlock();
1897}
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910static int console_cpu_notify(struct notifier_block *self,
1911 unsigned long action, void *hcpu)
1912{
1913 switch (action) {
1914 case CPU_ONLINE:
1915 case CPU_DEAD:
1916 case CPU_DOWN_FAILED:
1917 case CPU_UP_CANCELED:
1918 console_lock();
1919 console_unlock();
1920 }
1921 return NOTIFY_OK;
1922}
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932void console_lock(void)
1933{
1934 might_sleep();
1935
1936 down(&console_sem);
1937 if (console_suspended)
1938 return;
1939 console_locked = 1;
1940 console_may_schedule = 1;
1941 mutex_acquire(&console_lock_dep_map, 0, 0, _RET_IP_);
1942}
1943EXPORT_SYMBOL(console_lock);
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953int console_trylock(void)
1954{
1955 if (down_trylock(&console_sem))
1956 return 0;
1957 if (console_suspended) {
1958 up(&console_sem);
1959 return 0;
1960 }
1961 console_locked = 1;
1962 console_may_schedule = 0;
1963 mutex_acquire(&console_lock_dep_map, 0, 1, _RET_IP_);
1964 return 1;
1965}
1966EXPORT_SYMBOL(console_trylock);
1967
1968int is_console_locked(void)
1969{
1970 return console_locked;
1971}
1972
1973static void console_cont_flush(char *text, size_t size)
1974{
1975 unsigned long flags;
1976 size_t len;
1977
1978 raw_spin_lock_irqsave(&logbuf_lock, flags);
1979
1980 if (!cont.len)
1981 goto out;
1982
1983
1984
1985
1986
1987
1988 if (console_seq < log_next_seq && !cont.cons)
1989 goto out;
1990
1991 len = cont_print_text(text, size);
1992 raw_spin_unlock(&logbuf_lock);
1993 stop_critical_timings();
1994 call_console_drivers(cont.level, text, len);
1995 start_critical_timings();
1996 local_irq_restore(flags);
1997 return;
1998out:
1999 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2000}
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016void console_unlock(void)
2017{
2018 static char text[LOG_LINE_MAX + PREFIX_MAX];
2019 static u64 seen_seq;
2020 unsigned long flags;
2021 bool wake_klogd = false;
2022 bool retry;
2023
2024 if (console_suspended) {
2025 up(&console_sem);
2026 return;
2027 }
2028
2029 console_may_schedule = 0;
2030
2031
2032 console_cont_flush(text, sizeof(text));
2033again:
2034 for (;;) {
2035 struct printk_log *msg;
2036 size_t len;
2037 int level;
2038
2039 raw_spin_lock_irqsave(&logbuf_lock, flags);
2040 if (seen_seq != log_next_seq) {
2041 wake_klogd = true;
2042 seen_seq = log_next_seq;
2043 }
2044
2045 if (console_seq < log_first_seq) {
2046
2047 console_seq = log_first_seq;
2048 console_idx = log_first_idx;
2049 console_prev = 0;
2050 }
2051skip:
2052 if (console_seq == log_next_seq)
2053 break;
2054
2055 msg = log_from_idx(console_idx);
2056 if (msg->flags & LOG_NOCONS) {
2057
2058
2059
2060
2061 console_idx = log_next(console_idx);
2062 console_seq++;
2063
2064
2065
2066
2067
2068 msg->flags &= ~LOG_NOCONS;
2069 console_prev = msg->flags;
2070 goto skip;
2071 }
2072
2073 level = msg->level;
2074 len = msg_print_text(msg, console_prev, false,
2075 text, sizeof(text));
2076 console_idx = log_next(console_idx);
2077 console_seq++;
2078 console_prev = msg->flags;
2079 raw_spin_unlock(&logbuf_lock);
2080
2081 stop_critical_timings();
2082 call_console_drivers(level, text, len);
2083 start_critical_timings();
2084 local_irq_restore(flags);
2085 }
2086 console_locked = 0;
2087 mutex_release(&console_lock_dep_map, 1, _RET_IP_);
2088
2089
2090 if (unlikely(exclusive_console))
2091 exclusive_console = NULL;
2092
2093 raw_spin_unlock(&logbuf_lock);
2094
2095 up(&console_sem);
2096
2097
2098
2099
2100
2101
2102
2103 raw_spin_lock(&logbuf_lock);
2104 retry = console_seq != log_next_seq;
2105 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2106
2107 if (retry && console_trylock())
2108 goto again;
2109
2110 if (wake_klogd)
2111 wake_up_klogd();
2112}
2113EXPORT_SYMBOL(console_unlock);
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124void __sched console_conditional_schedule(void)
2125{
2126 if (console_may_schedule)
2127 cond_resched();
2128}
2129EXPORT_SYMBOL(console_conditional_schedule);
2130
2131void console_unblank(void)
2132{
2133 struct console *c;
2134
2135
2136
2137
2138
2139 if (oops_in_progress) {
2140 if (down_trylock(&console_sem) != 0)
2141 return;
2142 } else
2143 console_lock();
2144
2145 console_locked = 1;
2146 console_may_schedule = 0;
2147 for_each_console(c)
2148 if ((c->flags & CON_ENABLED) && c->unblank)
2149 c->unblank();
2150 console_unlock();
2151}
2152
2153
2154
2155
2156struct tty_driver *console_device(int *index)
2157{
2158 struct console *c;
2159 struct tty_driver *driver = NULL;
2160
2161 console_lock();
2162 for_each_console(c) {
2163 if (!c->device)
2164 continue;
2165 driver = c->device(c, index);
2166 if (driver)
2167 break;
2168 }
2169 console_unlock();
2170 return driver;
2171}
2172
2173
2174
2175
2176
2177
2178void console_stop(struct console *console)
2179{
2180 console_lock();
2181 console->flags &= ~CON_ENABLED;
2182 console_unlock();
2183}
2184EXPORT_SYMBOL(console_stop);
2185
2186void console_start(struct console *console)
2187{
2188 console_lock();
2189 console->flags |= CON_ENABLED;
2190 console_unlock();
2191}
2192EXPORT_SYMBOL(console_start);
2193
2194static int __read_mostly keep_bootcon;
2195
2196static int __init keep_bootcon_setup(char *str)
2197{
2198 keep_bootcon = 1;
2199 pr_info("debug: skip boot console de-registration.\n");
2200
2201 return 0;
2202}
2203
2204early_param("keep_bootcon", keep_bootcon_setup);
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225void register_console(struct console *newcon)
2226{
2227 int i;
2228 unsigned long flags;
2229 struct console *bcon = NULL;
2230 struct console_cmdline *c;
2231
2232 if (console_drivers)
2233 for_each_console(bcon)
2234 if (WARN(bcon == newcon,
2235 "console '%s%d' already registered\n",
2236 bcon->name, bcon->index))
2237 return;
2238
2239
2240
2241
2242
2243 if (console_drivers && newcon->flags & CON_BOOT) {
2244
2245 for_each_console(bcon) {
2246 if (!(bcon->flags & CON_BOOT)) {
2247 pr_info("Too late to register bootconsole %s%d\n",
2248 newcon->name, newcon->index);
2249 return;
2250 }
2251 }
2252 }
2253
2254 if (console_drivers && console_drivers->flags & CON_BOOT)
2255 bcon = console_drivers;
2256
2257 if (preferred_console < 0 || bcon || !console_drivers)
2258 preferred_console = selected_console;
2259
2260 if (newcon->early_setup)
2261 newcon->early_setup();
2262
2263
2264
2265
2266
2267
2268 if (preferred_console < 0) {
2269 if (newcon->index < 0)
2270 newcon->index = 0;
2271 if (newcon->setup == NULL ||
2272 newcon->setup(newcon, NULL) == 0) {
2273 newcon->flags |= CON_ENABLED;
2274 if (newcon->device) {
2275 newcon->flags |= CON_CONSDEV;
2276 preferred_console = 0;
2277 }
2278 }
2279 }
2280
2281
2282
2283
2284
2285 for (i = 0, c = console_cmdline;
2286 i < MAX_CMDLINECONSOLES && c->name[0];
2287 i++, c++) {
2288 if (strcmp(c->name, newcon->name) != 0)
2289 continue;
2290 if (newcon->index >= 0 &&
2291 newcon->index != c->index)
2292 continue;
2293 if (newcon->index < 0)
2294 newcon->index = c->index;
2295
2296 if (_braille_register_console(newcon, c))
2297 return;
2298
2299 if (newcon->setup &&
2300 newcon->setup(newcon, console_cmdline[i].options) != 0)
2301 break;
2302 newcon->flags |= CON_ENABLED;
2303 newcon->index = c->index;
2304 if (i == selected_console) {
2305 newcon->flags |= CON_CONSDEV;
2306 preferred_console = selected_console;
2307 }
2308 break;
2309 }
2310
2311 if (!(newcon->flags & CON_ENABLED))
2312 return;
2313
2314
2315
2316
2317
2318
2319
2320 if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
2321 newcon->flags &= ~CON_PRINTBUFFER;
2322
2323
2324
2325
2326
2327 console_lock();
2328 if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
2329 newcon->next = console_drivers;
2330 console_drivers = newcon;
2331 if (newcon->next)
2332 newcon->next->flags &= ~CON_CONSDEV;
2333 } else {
2334 newcon->next = console_drivers->next;
2335 console_drivers->next = newcon;
2336 }
2337 if (newcon->flags & CON_PRINTBUFFER) {
2338
2339
2340
2341
2342 raw_spin_lock_irqsave(&logbuf_lock, flags);
2343 console_seq = syslog_seq;
2344 console_idx = syslog_idx;
2345 console_prev = syslog_prev;
2346 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2347
2348
2349
2350
2351
2352 exclusive_console = newcon;
2353 }
2354 console_unlock();
2355 console_sysfs_notify();
2356
2357
2358
2359
2360
2361
2362
2363
2364 pr_info("%sconsole [%s%d] enabled\n",
2365 (newcon->flags & CON_BOOT) ? "boot" : "" ,
2366 newcon->name, newcon->index);
2367 if (bcon &&
2368 ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
2369 !keep_bootcon) {
2370
2371
2372
2373 for_each_console(bcon)
2374 if (bcon->flags & CON_BOOT)
2375 unregister_console(bcon);
2376 }
2377}
2378EXPORT_SYMBOL(register_console);
2379
2380int unregister_console(struct console *console)
2381{
2382 struct console *a, *b;
2383 int res;
2384
2385 pr_info("%sconsole [%s%d] disabled\n",
2386 (console->flags & CON_BOOT) ? "boot" : "" ,
2387 console->name, console->index);
2388
2389 res = _braille_unregister_console(console);
2390 if (res)
2391 return res;
2392
2393 res = 1;
2394 console_lock();
2395 if (console_drivers == console) {
2396 console_drivers=console->next;
2397 res = 0;
2398 } else if (console_drivers) {
2399 for (a=console_drivers->next, b=console_drivers ;
2400 a; b=a, a=b->next) {
2401 if (a == console) {
2402 b->next = a->next;
2403 res = 0;
2404 break;
2405 }
2406 }
2407 }
2408
2409
2410
2411
2412
2413 if (console_drivers != NULL && console->flags & CON_CONSDEV)
2414 console_drivers->flags |= CON_CONSDEV;
2415
2416 console_unlock();
2417 console_sysfs_notify();
2418 return res;
2419}
2420EXPORT_SYMBOL(unregister_console);
2421
2422static int __init printk_late_init(void)
2423{
2424 struct console *con;
2425
2426 for_each_console(con) {
2427 if (!keep_bootcon && con->flags & CON_BOOT) {
2428 unregister_console(con);
2429 }
2430 }
2431 hotcpu_notifier(console_cpu_notify, 0);
2432 return 0;
2433}
2434late_initcall(printk_late_init);
2435
2436#if defined CONFIG_PRINTK
2437
2438
2439
2440#define PRINTK_BUF_SIZE 512
2441
2442#define PRINTK_PENDING_WAKEUP 0x01
2443#define PRINTK_PENDING_SCHED 0x02
2444
2445static DEFINE_PER_CPU(int, printk_pending);
2446static DEFINE_PER_CPU(char [PRINTK_BUF_SIZE], printk_sched_buf);
2447
2448static void wake_up_klogd_work_func(struct irq_work *irq_work)
2449{
2450 int pending = __this_cpu_xchg(printk_pending, 0);
2451
2452 if (pending & PRINTK_PENDING_SCHED) {
2453 char *buf = __get_cpu_var(printk_sched_buf);
2454 pr_warn("[sched_delayed] %s", buf);
2455 }
2456
2457 if (pending & PRINTK_PENDING_WAKEUP)
2458 wake_up_interruptible(&log_wait);
2459}
2460
2461static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
2462 .func = wake_up_klogd_work_func,
2463 .flags = IRQ_WORK_LAZY,
2464};
2465
2466void wake_up_klogd(void)
2467{
2468 preempt_disable();
2469 if (waitqueue_active(&log_wait)) {
2470 this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
2471 irq_work_queue(&__get_cpu_var(wake_up_klogd_work));
2472 }
2473 preempt_enable();
2474}
2475
2476int printk_sched(const char *fmt, ...)
2477{
2478 unsigned long flags;
2479 va_list args;
2480 char *buf;
2481 int r;
2482
2483 local_irq_save(flags);
2484 buf = __get_cpu_var(printk_sched_buf);
2485
2486 va_start(args, fmt);
2487 r = vsnprintf(buf, PRINTK_BUF_SIZE, fmt, args);
2488 va_end(args);
2489
2490 __this_cpu_or(printk_pending, PRINTK_PENDING_SCHED);
2491 irq_work_queue(&__get_cpu_var(wake_up_klogd_work));
2492 local_irq_restore(flags);
2493
2494 return r;
2495}
2496
2497
2498
2499
2500
2501
2502
2503DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
2504
2505int __printk_ratelimit(const char *func)
2506{
2507 return ___ratelimit(&printk_ratelimit_state, func);
2508}
2509EXPORT_SYMBOL(__printk_ratelimit);
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520bool printk_timed_ratelimit(unsigned long *caller_jiffies,
2521 unsigned int interval_msecs)
2522{
2523 if (*caller_jiffies == 0
2524 || !time_in_range(jiffies, *caller_jiffies,
2525 *caller_jiffies
2526 + msecs_to_jiffies(interval_msecs))) {
2527 *caller_jiffies = jiffies;
2528 return true;
2529 }
2530 return false;
2531}
2532EXPORT_SYMBOL(printk_timed_ratelimit);
2533
2534static DEFINE_SPINLOCK(dump_list_lock);
2535static LIST_HEAD(dump_list);
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545int kmsg_dump_register(struct kmsg_dumper *dumper)
2546{
2547 unsigned long flags;
2548 int err = -EBUSY;
2549
2550
2551 if (!dumper->dump)
2552 return -EINVAL;
2553
2554 spin_lock_irqsave(&dump_list_lock, flags);
2555
2556 if (!dumper->registered) {
2557 dumper->registered = 1;
2558 list_add_tail_rcu(&dumper->list, &dump_list);
2559 err = 0;
2560 }
2561 spin_unlock_irqrestore(&dump_list_lock, flags);
2562
2563 return err;
2564}
2565EXPORT_SYMBOL_GPL(kmsg_dump_register);
2566
2567
2568
2569
2570
2571
2572
2573
2574int kmsg_dump_unregister(struct kmsg_dumper *dumper)
2575{
2576 unsigned long flags;
2577 int err = -EINVAL;
2578
2579 spin_lock_irqsave(&dump_list_lock, flags);
2580 if (dumper->registered) {
2581 dumper->registered = 0;
2582 list_del_rcu(&dumper->list);
2583 err = 0;
2584 }
2585 spin_unlock_irqrestore(&dump_list_lock, flags);
2586 synchronize_rcu();
2587
2588 return err;
2589}
2590EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
2591
2592static bool always_kmsg_dump;
2593module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603void kmsg_dump(enum kmsg_dump_reason reason)
2604{
2605 struct kmsg_dumper *dumper;
2606 unsigned long flags;
2607
2608 if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
2609 return;
2610
2611 rcu_read_lock();
2612 list_for_each_entry_rcu(dumper, &dump_list, list) {
2613 if (dumper->max_reason && reason > dumper->max_reason)
2614 continue;
2615
2616
2617 dumper->active = true;
2618
2619 raw_spin_lock_irqsave(&logbuf_lock, flags);
2620 dumper->cur_seq = clear_seq;
2621 dumper->cur_idx = clear_idx;
2622 dumper->next_seq = log_next_seq;
2623 dumper->next_idx = log_next_idx;
2624 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2625
2626
2627 dumper->dump(dumper, reason);
2628
2629
2630 dumper->active = false;
2631 }
2632 rcu_read_unlock();
2633}
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
2655 char *line, size_t size, size_t *len)
2656{
2657 struct printk_log *msg;
2658 size_t l = 0;
2659 bool ret = false;
2660
2661 if (!dumper->active)
2662 goto out;
2663
2664 if (dumper->cur_seq < log_first_seq) {
2665
2666 dumper->cur_seq = log_first_seq;
2667 dumper->cur_idx = log_first_idx;
2668 }
2669
2670
2671 if (dumper->cur_seq >= log_next_seq)
2672 goto out;
2673
2674 msg = log_from_idx(dumper->cur_idx);
2675 l = msg_print_text(msg, 0, syslog, line, size);
2676
2677 dumper->cur_idx = log_next(dumper->cur_idx);
2678 dumper->cur_seq++;
2679 ret = true;
2680out:
2681 if (len)
2682 *len = l;
2683 return ret;
2684}
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
2704 char *line, size_t size, size_t *len)
2705{
2706 unsigned long flags;
2707 bool ret;
2708
2709 raw_spin_lock_irqsave(&logbuf_lock, flags);
2710 ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
2711 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2712
2713 return ret;
2714}
2715EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
2737 char *buf, size_t size, size_t *len)
2738{
2739 unsigned long flags;
2740 u64 seq;
2741 u32 idx;
2742 u64 next_seq;
2743 u32 next_idx;
2744 enum log_flags prev;
2745 size_t l = 0;
2746 bool ret = false;
2747
2748 if (!dumper->active)
2749 goto out;
2750
2751 raw_spin_lock_irqsave(&logbuf_lock, flags);
2752 if (dumper->cur_seq < log_first_seq) {
2753
2754 dumper->cur_seq = log_first_seq;
2755 dumper->cur_idx = log_first_idx;
2756 }
2757
2758
2759 if (dumper->cur_seq >= dumper->next_seq) {
2760 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2761 goto out;
2762 }
2763
2764
2765 seq = dumper->cur_seq;
2766 idx = dumper->cur_idx;
2767 prev = 0;
2768 while (seq < dumper->next_seq) {
2769 struct printk_log *msg = log_from_idx(idx);
2770
2771 l += msg_print_text(msg, prev, true, NULL, 0);
2772 idx = log_next(idx);
2773 seq++;
2774 prev = msg->flags;
2775 }
2776
2777
2778 seq = dumper->cur_seq;
2779 idx = dumper->cur_idx;
2780 prev = 0;
2781 while (l > size && seq < dumper->next_seq) {
2782 struct printk_log *msg = log_from_idx(idx);
2783
2784 l -= msg_print_text(msg, prev, true, NULL, 0);
2785 idx = log_next(idx);
2786 seq++;
2787 prev = msg->flags;
2788 }
2789
2790
2791 next_seq = seq;
2792 next_idx = idx;
2793
2794 l = 0;
2795 while (seq < dumper->next_seq) {
2796 struct printk_log *msg = log_from_idx(idx);
2797
2798 l += msg_print_text(msg, prev, syslog, buf + l, size - l);
2799 idx = log_next(idx);
2800 seq++;
2801 prev = msg->flags;
2802 }
2803
2804 dumper->next_seq = next_seq;
2805 dumper->next_idx = next_idx;
2806 ret = true;
2807 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2808out:
2809 if (len)
2810 *len = l;
2811 return ret;
2812}
2813EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
2826{
2827 dumper->cur_seq = clear_seq;
2828 dumper->cur_idx = clear_idx;
2829 dumper->next_seq = log_next_seq;
2830 dumper->next_idx = log_next_idx;
2831}
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841void kmsg_dump_rewind(struct kmsg_dumper *dumper)
2842{
2843 unsigned long flags;
2844
2845 raw_spin_lock_irqsave(&logbuf_lock, flags);
2846 kmsg_dump_rewind_nolock(dumper);
2847 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2848}
2849EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
2850
2851static char dump_stack_arch_desc_str[128];
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863void __init dump_stack_set_arch_desc(const char *fmt, ...)
2864{
2865 va_list args;
2866
2867 va_start(args, fmt);
2868 vsnprintf(dump_stack_arch_desc_str, sizeof(dump_stack_arch_desc_str),
2869 fmt, args);
2870 va_end(args);
2871}
2872
2873
2874
2875
2876
2877
2878
2879
2880void dump_stack_print_info(const char *log_lvl)
2881{
2882 printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n",
2883 log_lvl, raw_smp_processor_id(), current->pid, current->comm,
2884 print_tainted(), init_utsname()->release,
2885 (int)strcspn(init_utsname()->version, " "),
2886 init_utsname()->version);
2887
2888 if (dump_stack_arch_desc_str[0] != '\0')
2889 printk("%sHardware name: %s\n",
2890 log_lvl, dump_stack_arch_desc_str);
2891
2892 print_worker_info(log_lvl, current);
2893}
2894
2895
2896
2897
2898
2899
2900
2901
2902void show_regs_print_info(const char *log_lvl)
2903{
2904 dump_stack_print_info(log_lvl);
2905
2906 printk("%stask: %p ti: %p task.ti: %p\n",
2907 log_lvl, current, current_thread_info(),
2908 task_thread_info(current));
2909}
2910
2911#endif
2912