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 = sizeof(struct printk_log) + text_len + dict_len + pad_len;
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 unsigned long mem;
761
762 mem = memblock_alloc(new_log_buf_len, PAGE_SIZE);
763 if (!mem)
764 return;
765 new_log_buf = __va(mem);
766 } else {
767 new_log_buf = alloc_bootmem_nopanic(new_log_buf_len);
768 }
769
770 if (unlikely(!new_log_buf)) {
771 pr_err("log_buf_len: %ld bytes not available\n",
772 new_log_buf_len);
773 return;
774 }
775
776 raw_spin_lock_irqsave(&logbuf_lock, flags);
777 log_buf_len = new_log_buf_len;
778 log_buf = new_log_buf;
779 new_log_buf_len = 0;
780 free = __LOG_BUF_LEN - log_next_idx;
781 memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
782 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
783
784 pr_info("log_buf_len: %d\n", log_buf_len);
785 pr_info("early log buf free: %d(%d%%)\n",
786 free, (free * 100) / __LOG_BUF_LEN);
787}
788
789static bool __read_mostly ignore_loglevel;
790
791static int __init ignore_loglevel_setup(char *str)
792{
793 ignore_loglevel = 1;
794 printk(KERN_INFO "debug: ignoring loglevel setting.\n");
795
796 return 0;
797}
798
799early_param("ignore_loglevel", ignore_loglevel_setup);
800module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
801MODULE_PARM_DESC(ignore_loglevel, "ignore loglevel setting, to"
802 "print all kernel messages to the console.");
803
804#ifdef CONFIG_BOOT_PRINTK_DELAY
805
806static int boot_delay;
807static unsigned long long loops_per_msec;
808
809static int __init boot_delay_setup(char *str)
810{
811 unsigned long lpj;
812
813 lpj = preset_lpj ? preset_lpj : 1000000;
814 loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
815
816 get_option(&str, &boot_delay);
817 if (boot_delay > 10 * 1000)
818 boot_delay = 0;
819
820 pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
821 "HZ: %d, loops_per_msec: %llu\n",
822 boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
823 return 1;
824}
825__setup("boot_delay=", boot_delay_setup);
826
827static void boot_delay_msec(int level)
828{
829 unsigned long long k;
830 unsigned long timeout;
831
832 if ((boot_delay == 0 || system_state != SYSTEM_BOOTING)
833 || (level >= console_loglevel && !ignore_loglevel)) {
834 return;
835 }
836
837 k = (unsigned long long)loops_per_msec * boot_delay;
838
839 timeout = jiffies + msecs_to_jiffies(boot_delay);
840 while (k) {
841 k--;
842 cpu_relax();
843
844
845
846
847
848 if (time_after(jiffies, timeout))
849 break;
850 touch_nmi_watchdog();
851 }
852}
853#else
854static inline void boot_delay_msec(int level)
855{
856}
857#endif
858
859#if defined(CONFIG_PRINTK_TIME)
860static bool printk_time = 1;
861#else
862static bool printk_time;
863#endif
864module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
865
866static size_t print_time(u64 ts, char *buf)
867{
868 unsigned long rem_nsec;
869
870 if (!printk_time)
871 return 0;
872
873 rem_nsec = do_div(ts, 1000000000);
874
875 if (!buf)
876 return snprintf(NULL, 0, "[%5lu.000000] ", (unsigned long)ts);
877
878 return sprintf(buf, "[%5lu.%06lu] ",
879 (unsigned long)ts, rem_nsec / 1000);
880}
881
882static size_t print_prefix(const struct printk_log *msg, bool syslog, char *buf)
883{
884 size_t len = 0;
885 unsigned int prefix = (msg->facility << 3) | msg->level;
886
887 if (syslog) {
888 if (buf) {
889 len += sprintf(buf, "<%u>", prefix);
890 } else {
891 len += 3;
892 if (prefix > 999)
893 len += 3;
894 else if (prefix > 99)
895 len += 2;
896 else if (prefix > 9)
897 len++;
898 }
899 }
900
901 len += print_time(msg->ts_nsec, buf ? buf + len : NULL);
902 return len;
903}
904
905static size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
906 bool syslog, char *buf, size_t size)
907{
908 const char *text = log_text(msg);
909 size_t text_size = msg->text_len;
910 bool prefix = true;
911 bool newline = true;
912 size_t len = 0;
913
914 if ((prev & LOG_CONT) && !(msg->flags & LOG_PREFIX))
915 prefix = false;
916
917 if (msg->flags & LOG_CONT) {
918 if ((prev & LOG_CONT) && !(prev & LOG_NEWLINE))
919 prefix = false;
920
921 if (!(msg->flags & LOG_NEWLINE))
922 newline = false;
923 }
924
925 do {
926 const char *next = memchr(text, '\n', text_size);
927 size_t text_len;
928
929 if (next) {
930 text_len = next - text;
931 next++;
932 text_size -= next - text;
933 } else {
934 text_len = text_size;
935 }
936
937 if (buf) {
938 if (print_prefix(msg, syslog, NULL) +
939 text_len + 1 >= size - len)
940 break;
941
942 if (prefix)
943 len += print_prefix(msg, syslog, buf + len);
944 memcpy(buf + len, text, text_len);
945 len += text_len;
946 if (next || newline)
947 buf[len++] = '\n';
948 } else {
949
950 if (prefix)
951 len += print_prefix(msg, syslog, NULL);
952 len += text_len;
953 if (next || newline)
954 len++;
955 }
956
957 prefix = true;
958 text = next;
959 } while (text);
960
961 return len;
962}
963
964static int syslog_print(char __user *buf, int size)
965{
966 char *text;
967 struct printk_log *msg;
968 int len = 0;
969
970 text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
971 if (!text)
972 return -ENOMEM;
973
974 while (size > 0) {
975 size_t n;
976 size_t skip;
977
978 raw_spin_lock_irq(&logbuf_lock);
979 if (syslog_seq < log_first_seq) {
980
981 syslog_seq = log_first_seq;
982 syslog_idx = log_first_idx;
983 syslog_prev = 0;
984 syslog_partial = 0;
985 }
986 if (syslog_seq == log_next_seq) {
987 raw_spin_unlock_irq(&logbuf_lock);
988 break;
989 }
990
991 skip = syslog_partial;
992 msg = log_from_idx(syslog_idx);
993 n = msg_print_text(msg, syslog_prev, true, text,
994 LOG_LINE_MAX + PREFIX_MAX);
995 if (n - syslog_partial <= size) {
996
997 syslog_idx = log_next(syslog_idx);
998 syslog_seq++;
999 syslog_prev = msg->flags;
1000 n -= syslog_partial;
1001 syslog_partial = 0;
1002 } else if (!len){
1003
1004 n = size;
1005 syslog_partial += n;
1006 } else
1007 n = 0;
1008 raw_spin_unlock_irq(&logbuf_lock);
1009
1010 if (!n)
1011 break;
1012
1013 if (copy_to_user(buf, text + skip, n)) {
1014 if (!len)
1015 len = -EFAULT;
1016 break;
1017 }
1018
1019 len += n;
1020 size -= n;
1021 buf += n;
1022 }
1023
1024 kfree(text);
1025 return len;
1026}
1027
1028static int syslog_print_all(char __user *buf, int size, bool clear)
1029{
1030 char *text;
1031 int len = 0;
1032
1033 text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
1034 if (!text)
1035 return -ENOMEM;
1036
1037 raw_spin_lock_irq(&logbuf_lock);
1038 if (buf) {
1039 u64 next_seq;
1040 u64 seq;
1041 u32 idx;
1042 enum log_flags prev;
1043
1044 if (clear_seq < log_first_seq) {
1045
1046 clear_seq = log_first_seq;
1047 clear_idx = log_first_idx;
1048 }
1049
1050
1051
1052
1053
1054 seq = clear_seq;
1055 idx = clear_idx;
1056 prev = 0;
1057 while (seq < log_next_seq) {
1058 struct printk_log *msg = log_from_idx(idx);
1059
1060 len += msg_print_text(msg, prev, true, NULL, 0);
1061 prev = msg->flags;
1062 idx = log_next(idx);
1063 seq++;
1064 }
1065
1066
1067 seq = clear_seq;
1068 idx = clear_idx;
1069 prev = 0;
1070 while (len > size && seq < log_next_seq) {
1071 struct printk_log *msg = log_from_idx(idx);
1072
1073 len -= msg_print_text(msg, prev, true, NULL, 0);
1074 prev = msg->flags;
1075 idx = log_next(idx);
1076 seq++;
1077 }
1078
1079
1080 next_seq = log_next_seq;
1081
1082 len = 0;
1083 prev = 0;
1084 while (len >= 0 && seq < next_seq) {
1085 struct printk_log *msg = log_from_idx(idx);
1086 int textlen;
1087
1088 textlen = msg_print_text(msg, prev, true, text,
1089 LOG_LINE_MAX + PREFIX_MAX);
1090 if (textlen < 0) {
1091 len = textlen;
1092 break;
1093 }
1094 idx = log_next(idx);
1095 seq++;
1096 prev = msg->flags;
1097
1098 raw_spin_unlock_irq(&logbuf_lock);
1099 if (copy_to_user(buf + len, text, textlen))
1100 len = -EFAULT;
1101 else
1102 len += textlen;
1103 raw_spin_lock_irq(&logbuf_lock);
1104
1105 if (seq < log_first_seq) {
1106
1107 seq = log_first_seq;
1108 idx = log_first_idx;
1109 prev = 0;
1110 }
1111 }
1112 }
1113
1114 if (clear) {
1115 clear_seq = log_next_seq;
1116 clear_idx = log_next_idx;
1117 }
1118 raw_spin_unlock_irq(&logbuf_lock);
1119
1120 kfree(text);
1121 return len;
1122}
1123
1124int do_syslog(int type, char __user *buf, int len, bool from_file)
1125{
1126 bool clear = false;
1127 static int saved_console_loglevel = -1;
1128 int error;
1129
1130 error = check_syslog_permissions(type, from_file);
1131 if (error)
1132 goto out;
1133
1134 error = security_syslog(type);
1135 if (error)
1136 return error;
1137
1138 switch (type) {
1139 case SYSLOG_ACTION_CLOSE:
1140 break;
1141 case SYSLOG_ACTION_OPEN:
1142 break;
1143 case SYSLOG_ACTION_READ:
1144 error = -EINVAL;
1145 if (!buf || len < 0)
1146 goto out;
1147 error = 0;
1148 if (!len)
1149 goto out;
1150 if (!access_ok(VERIFY_WRITE, buf, len)) {
1151 error = -EFAULT;
1152 goto out;
1153 }
1154 error = wait_event_interruptible(log_wait,
1155 syslog_seq != log_next_seq);
1156 if (error)
1157 goto out;
1158 error = syslog_print(buf, len);
1159 break;
1160
1161 case SYSLOG_ACTION_READ_CLEAR:
1162 clear = true;
1163
1164
1165 case SYSLOG_ACTION_READ_ALL:
1166 error = -EINVAL;
1167 if (!buf || len < 0)
1168 goto out;
1169 error = 0;
1170 if (!len)
1171 goto out;
1172 if (!access_ok(VERIFY_WRITE, buf, len)) {
1173 error = -EFAULT;
1174 goto out;
1175 }
1176 error = syslog_print_all(buf, len, clear);
1177 break;
1178
1179 case SYSLOG_ACTION_CLEAR:
1180 syslog_print_all(NULL, 0, true);
1181 break;
1182
1183 case SYSLOG_ACTION_CONSOLE_OFF:
1184 if (saved_console_loglevel == -1)
1185 saved_console_loglevel = console_loglevel;
1186 console_loglevel = minimum_console_loglevel;
1187 break;
1188
1189 case SYSLOG_ACTION_CONSOLE_ON:
1190 if (saved_console_loglevel != -1) {
1191 console_loglevel = saved_console_loglevel;
1192 saved_console_loglevel = -1;
1193 }
1194 break;
1195
1196 case SYSLOG_ACTION_CONSOLE_LEVEL:
1197 error = -EINVAL;
1198 if (len < 1 || len > 8)
1199 goto out;
1200 if (len < minimum_console_loglevel)
1201 len = minimum_console_loglevel;
1202 console_loglevel = len;
1203
1204 saved_console_loglevel = -1;
1205 error = 0;
1206 break;
1207
1208 case SYSLOG_ACTION_SIZE_UNREAD:
1209 raw_spin_lock_irq(&logbuf_lock);
1210 if (syslog_seq < log_first_seq) {
1211
1212 syslog_seq = log_first_seq;
1213 syslog_idx = log_first_idx;
1214 syslog_prev = 0;
1215 syslog_partial = 0;
1216 }
1217 if (from_file) {
1218
1219
1220
1221
1222
1223 error = log_next_idx - syslog_idx;
1224 } else {
1225 u64 seq = syslog_seq;
1226 u32 idx = syslog_idx;
1227 enum log_flags prev = syslog_prev;
1228
1229 error = 0;
1230 while (seq < log_next_seq) {
1231 struct printk_log *msg = log_from_idx(idx);
1232
1233 error += msg_print_text(msg, prev, true, NULL, 0);
1234 idx = log_next(idx);
1235 seq++;
1236 prev = msg->flags;
1237 }
1238 error -= syslog_partial;
1239 }
1240 raw_spin_unlock_irq(&logbuf_lock);
1241 break;
1242
1243 case SYSLOG_ACTION_SIZE_BUFFER:
1244 error = log_buf_len;
1245 break;
1246 default:
1247 error = -EINVAL;
1248 break;
1249 }
1250out:
1251 return error;
1252}
1253
1254SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
1255{
1256 return do_syslog(type, buf, len, SYSLOG_FROM_READER);
1257}
1258
1259
1260
1261
1262
1263
1264static void call_console_drivers(int level, const char *text, size_t len)
1265{
1266 struct console *con;
1267
1268 trace_console(text, len);
1269
1270 if (level >= console_loglevel && !ignore_loglevel)
1271 return;
1272 if (!console_drivers)
1273 return;
1274
1275 for_each_console(con) {
1276 if (exclusive_console && con != exclusive_console)
1277 continue;
1278 if (!(con->flags & CON_ENABLED))
1279 continue;
1280 if (!con->write)
1281 continue;
1282 if (!cpu_online(smp_processor_id()) &&
1283 !(con->flags & CON_ANYTIME))
1284 continue;
1285 con->write(con, text, len);
1286 }
1287}
1288
1289
1290
1291
1292
1293
1294static void zap_locks(void)
1295{
1296 static unsigned long oops_timestamp;
1297
1298 if (time_after_eq(jiffies, oops_timestamp) &&
1299 !time_after(jiffies, oops_timestamp + 30 * HZ))
1300 return;
1301
1302 oops_timestamp = jiffies;
1303
1304 debug_locks_off();
1305
1306 raw_spin_lock_init(&logbuf_lock);
1307
1308 sema_init(&console_sem, 1);
1309}
1310
1311
1312static int have_callable_console(void)
1313{
1314 struct console *con;
1315
1316 for_each_console(con)
1317 if (con->flags & CON_ANYTIME)
1318 return 1;
1319
1320 return 0;
1321}
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331static inline int can_use_console(unsigned int cpu)
1332{
1333 return cpu_online(cpu) || have_callable_console();
1334}
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346static int console_trylock_for_printk(unsigned int cpu)
1347 __releases(&logbuf_lock)
1348{
1349 int retval = 0, wake = 0;
1350
1351 if (console_trylock()) {
1352 retval = 1;
1353
1354
1355
1356
1357
1358
1359
1360 if (!can_use_console(cpu)) {
1361 console_locked = 0;
1362 wake = 1;
1363 retval = 0;
1364 }
1365 }
1366 logbuf_cpu = UINT_MAX;
1367 raw_spin_unlock(&logbuf_lock);
1368 if (wake)
1369 up(&console_sem);
1370 return retval;
1371}
1372
1373int printk_delay_msec __read_mostly;
1374
1375static inline void printk_delay(void)
1376{
1377 if (unlikely(printk_delay_msec)) {
1378 int m = printk_delay_msec;
1379
1380 while (m--) {
1381 mdelay(1);
1382 touch_nmi_watchdog();
1383 }
1384 }
1385}
1386
1387
1388
1389
1390
1391
1392
1393static struct cont {
1394 char buf[LOG_LINE_MAX];
1395 size_t len;
1396 size_t cons;
1397 struct task_struct *owner;
1398 u64 ts_nsec;
1399 u8 level;
1400 u8 facility;
1401 enum log_flags flags;
1402 bool flushed:1;
1403} cont;
1404
1405static void cont_flush(enum log_flags flags)
1406{
1407 if (cont.flushed)
1408 return;
1409 if (cont.len == 0)
1410 return;
1411
1412 if (cont.cons) {
1413
1414
1415
1416
1417
1418 log_store(cont.facility, cont.level, flags | LOG_NOCONS,
1419 cont.ts_nsec, NULL, 0, cont.buf, cont.len);
1420 cont.flags = flags;
1421 cont.flushed = true;
1422 } else {
1423
1424
1425
1426
1427 log_store(cont.facility, cont.level, flags, 0,
1428 NULL, 0, cont.buf, cont.len);
1429 cont.len = 0;
1430 }
1431}
1432
1433static bool cont_add(int facility, int level, const char *text, size_t len)
1434{
1435 if (cont.len && cont.flushed)
1436 return false;
1437
1438 if (cont.len + len > sizeof(cont.buf)) {
1439
1440 cont_flush(LOG_CONT);
1441 return false;
1442 }
1443
1444 if (!cont.len) {
1445 cont.facility = facility;
1446 cont.level = level;
1447 cont.owner = current;
1448 cont.ts_nsec = local_clock();
1449 cont.flags = 0;
1450 cont.cons = 0;
1451 cont.flushed = false;
1452 }
1453
1454 memcpy(cont.buf + cont.len, text, len);
1455 cont.len += len;
1456
1457 if (cont.len > (sizeof(cont.buf) * 80) / 100)
1458 cont_flush(LOG_CONT);
1459
1460 return true;
1461}
1462
1463static size_t cont_print_text(char *text, size_t size)
1464{
1465 size_t textlen = 0;
1466 size_t len;
1467
1468 if (cont.cons == 0 && (console_prev & LOG_NEWLINE)) {
1469 textlen += print_time(cont.ts_nsec, text);
1470 size -= textlen;
1471 }
1472
1473 len = cont.len - cont.cons;
1474 if (len > 0) {
1475 if (len+1 > size)
1476 len = size-1;
1477 memcpy(text + textlen, cont.buf + cont.cons, len);
1478 textlen += len;
1479 cont.cons = cont.len;
1480 }
1481
1482 if (cont.flushed) {
1483 if (cont.flags & LOG_NEWLINE)
1484 text[textlen++] = '\n';
1485
1486 cont.len = 0;
1487 }
1488 return textlen;
1489}
1490
1491asmlinkage int vprintk_emit(int facility, int level,
1492 const char *dict, size_t dictlen,
1493 const char *fmt, va_list args)
1494{
1495 static int recursion_bug;
1496 static char textbuf[LOG_LINE_MAX];
1497 char *text = textbuf;
1498 size_t text_len;
1499 enum log_flags lflags = 0;
1500 unsigned long flags;
1501 int this_cpu;
1502 int printed_len = 0;
1503
1504 boot_delay_msec(level);
1505 printk_delay();
1506
1507
1508 local_irq_save(flags);
1509 this_cpu = smp_processor_id();
1510
1511
1512
1513
1514 if (unlikely(logbuf_cpu == this_cpu)) {
1515
1516
1517
1518
1519
1520
1521
1522 if (!oops_in_progress && !lockdep_recursing(current)) {
1523 recursion_bug = 1;
1524 goto out_restore_irqs;
1525 }
1526 zap_locks();
1527 }
1528
1529 lockdep_off();
1530 raw_spin_lock(&logbuf_lock);
1531 logbuf_cpu = this_cpu;
1532
1533 if (recursion_bug) {
1534 static const char recursion_msg[] =
1535 "BUG: recent printk recursion!";
1536
1537 recursion_bug = 0;
1538 printed_len += strlen(recursion_msg);
1539
1540 log_store(0, 2, LOG_PREFIX|LOG_NEWLINE, 0,
1541 NULL, 0, recursion_msg, printed_len);
1542 }
1543
1544
1545
1546
1547
1548 text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
1549
1550
1551 if (text_len && text[text_len-1] == '\n') {
1552 text_len--;
1553 lflags |= LOG_NEWLINE;
1554 }
1555
1556
1557 if (facility == 0) {
1558 int kern_level = printk_get_level(text);
1559
1560 if (kern_level) {
1561 const char *end_of_header = printk_skip_level(text);
1562 switch (kern_level) {
1563 case '0' ... '7':
1564 if (level == -1)
1565 level = kern_level - '0';
1566 case 'd':
1567 lflags |= LOG_PREFIX;
1568 case 'c':
1569 break;
1570 }
1571 text_len -= end_of_header - text;
1572 text = (char *)end_of_header;
1573 }
1574 }
1575
1576 if (level == -1)
1577 level = default_message_loglevel;
1578
1579 if (dict)
1580 lflags |= LOG_PREFIX|LOG_NEWLINE;
1581
1582 if (!(lflags & LOG_NEWLINE)) {
1583
1584
1585
1586
1587 if (cont.len && (lflags & LOG_PREFIX || cont.owner != current))
1588 cont_flush(LOG_NEWLINE);
1589
1590
1591 if (!cont_add(facility, level, text, text_len))
1592 log_store(facility, level, lflags | LOG_CONT, 0,
1593 dict, dictlen, text, text_len);
1594 } else {
1595 bool stored = false;
1596
1597
1598
1599
1600
1601
1602
1603 if (cont.len && cont.owner == current) {
1604 if (!(lflags & LOG_PREFIX))
1605 stored = cont_add(facility, level, text, text_len);
1606 cont_flush(LOG_NEWLINE);
1607 }
1608
1609 if (!stored)
1610 log_store(facility, level, lflags, 0,
1611 dict, dictlen, text, text_len);
1612 }
1613 printed_len += text_len;
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623 if (console_trylock_for_printk(this_cpu))
1624 console_unlock();
1625
1626 lockdep_on();
1627out_restore_irqs:
1628 local_irq_restore(flags);
1629
1630 return printed_len;
1631}
1632EXPORT_SYMBOL(vprintk_emit);
1633
1634asmlinkage int vprintk(const char *fmt, va_list args)
1635{
1636 return vprintk_emit(0, -1, NULL, 0, fmt, args);
1637}
1638EXPORT_SYMBOL(vprintk);
1639
1640asmlinkage int printk_emit(int facility, int level,
1641 const char *dict, size_t dictlen,
1642 const char *fmt, ...)
1643{
1644 va_list args;
1645 int r;
1646
1647 va_start(args, fmt);
1648 r = vprintk_emit(facility, level, dict, dictlen, fmt, args);
1649 va_end(args);
1650
1651 return r;
1652}
1653EXPORT_SYMBOL(printk_emit);
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676asmlinkage int printk(const char *fmt, ...)
1677{
1678 va_list args;
1679 int r;
1680
1681#ifdef CONFIG_KGDB_KDB
1682 if (unlikely(kdb_trap_printk)) {
1683 va_start(args, fmt);
1684 r = vkdb_printf(fmt, args);
1685 va_end(args);
1686 return r;
1687 }
1688#endif
1689 va_start(args, fmt);
1690 r = vprintk_emit(0, -1, NULL, 0, fmt, args);
1691 va_end(args);
1692
1693 return r;
1694}
1695EXPORT_SYMBOL(printk);
1696
1697#else
1698
1699#define LOG_LINE_MAX 0
1700#define PREFIX_MAX 0
1701#define LOG_LINE_MAX 0
1702static u64 syslog_seq;
1703static u32 syslog_idx;
1704static u64 console_seq;
1705static u32 console_idx;
1706static enum log_flags syslog_prev;
1707static u64 log_first_seq;
1708static u32 log_first_idx;
1709static u64 log_next_seq;
1710static enum log_flags console_prev;
1711static struct cont {
1712 size_t len;
1713 size_t cons;
1714 u8 level;
1715 bool flushed:1;
1716} cont;
1717static struct printk_log *log_from_idx(u32 idx) { return NULL; }
1718static u32 log_next(u32 idx) { return 0; }
1719static void call_console_drivers(int level, const char *text, size_t len) {}
1720static size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
1721 bool syslog, char *buf, size_t size) { return 0; }
1722static size_t cont_print_text(char *text, size_t size) { return 0; }
1723
1724#endif
1725
1726#ifdef CONFIG_EARLY_PRINTK
1727struct console *early_console;
1728
1729void early_vprintk(const char *fmt, va_list ap)
1730{
1731 if (early_console) {
1732 char buf[512];
1733 int n = vscnprintf(buf, sizeof(buf), fmt, ap);
1734
1735 early_console->write(early_console, buf, n);
1736 }
1737}
1738
1739asmlinkage void early_printk(const char *fmt, ...)
1740{
1741 va_list ap;
1742
1743 va_start(ap, fmt);
1744 early_vprintk(fmt, ap);
1745 va_end(ap);
1746}
1747#endif
1748
1749static int __add_preferred_console(char *name, int idx, char *options,
1750 char *brl_options)
1751{
1752 struct console_cmdline *c;
1753 int i;
1754
1755
1756
1757
1758
1759 for (i = 0, c = console_cmdline;
1760 i < MAX_CMDLINECONSOLES && c->name[0];
1761 i++, c++) {
1762 if (strcmp(c->name, name) == 0 && c->index == idx) {
1763 if (!brl_options)
1764 selected_console = i;
1765 return 0;
1766 }
1767 }
1768 if (i == MAX_CMDLINECONSOLES)
1769 return -E2BIG;
1770 if (!brl_options)
1771 selected_console = i;
1772 strlcpy(c->name, name, sizeof(c->name));
1773 c->options = options;
1774 braille_set_options(c, brl_options);
1775
1776 c->index = idx;
1777 return 0;
1778}
1779
1780
1781
1782static int __init console_setup(char *str)
1783{
1784 char buf[sizeof(console_cmdline[0].name) + 4];
1785 char *s, *options, *brl_options = NULL;
1786 int idx;
1787
1788 if (_braille_console_setup(&str, &brl_options))
1789 return 1;
1790
1791
1792
1793
1794 if (str[0] >= '0' && str[0] <= '9') {
1795 strcpy(buf, "ttyS");
1796 strncpy(buf + 4, str, sizeof(buf) - 5);
1797 } else {
1798 strncpy(buf, str, sizeof(buf) - 1);
1799 }
1800 buf[sizeof(buf) - 1] = 0;
1801 if ((options = strchr(str, ',')) != NULL)
1802 *(options++) = 0;
1803#ifdef __sparc__
1804 if (!strcmp(str, "ttya"))
1805 strcpy(buf, "ttyS0");
1806 if (!strcmp(str, "ttyb"))
1807 strcpy(buf, "ttyS1");
1808#endif
1809 for (s = buf; *s; s++)
1810 if ((*s >= '0' && *s <= '9') || *s == ',')
1811 break;
1812 idx = simple_strtoul(s, NULL, 10);
1813 *s = 0;
1814
1815 __add_preferred_console(buf, idx, options, brl_options);
1816 console_set_on_cmdline = 1;
1817 return 1;
1818}
1819__setup("console=", console_setup);
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834int add_preferred_console(char *name, int idx, char *options)
1835{
1836 return __add_preferred_console(name, idx, options, NULL);
1837}
1838
1839int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
1840{
1841 struct console_cmdline *c;
1842 int i;
1843
1844 for (i = 0, c = console_cmdline;
1845 i < MAX_CMDLINECONSOLES && c->name[0];
1846 i++, c++)
1847 if (strcmp(c->name, name) == 0 && c->index == idx) {
1848 strlcpy(c->name, name_new, sizeof(c->name));
1849 c->name[sizeof(c->name) - 1] = 0;
1850 c->options = options;
1851 c->index = idx_new;
1852 return i;
1853 }
1854
1855 return -1;
1856}
1857
1858bool console_suspend_enabled = 1;
1859EXPORT_SYMBOL(console_suspend_enabled);
1860
1861static int __init console_suspend_disable(char *str)
1862{
1863 console_suspend_enabled = 0;
1864 return 1;
1865}
1866__setup("no_console_suspend", console_suspend_disable);
1867module_param_named(console_suspend, console_suspend_enabled,
1868 bool, S_IRUGO | S_IWUSR);
1869MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
1870 " and hibernate operations");
1871
1872
1873
1874
1875
1876
1877void suspend_console(void)
1878{
1879 if (!console_suspend_enabled)
1880 return;
1881 printk("Suspending console(s) (use no_console_suspend to debug)\n");
1882 console_lock();
1883 console_suspended = 1;
1884 up(&console_sem);
1885}
1886
1887void resume_console(void)
1888{
1889 if (!console_suspend_enabled)
1890 return;
1891 down(&console_sem);
1892 console_suspended = 0;
1893 console_unlock();
1894}
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907static int console_cpu_notify(struct notifier_block *self,
1908 unsigned long action, void *hcpu)
1909{
1910 switch (action) {
1911 case CPU_ONLINE:
1912 case CPU_DEAD:
1913 case CPU_DOWN_FAILED:
1914 case CPU_UP_CANCELED:
1915 console_lock();
1916 console_unlock();
1917 }
1918 return NOTIFY_OK;
1919}
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929void console_lock(void)
1930{
1931 might_sleep();
1932
1933 down(&console_sem);
1934 if (console_suspended)
1935 return;
1936 console_locked = 1;
1937 console_may_schedule = 1;
1938 mutex_acquire(&console_lock_dep_map, 0, 0, _RET_IP_);
1939}
1940EXPORT_SYMBOL(console_lock);
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950int console_trylock(void)
1951{
1952 if (down_trylock(&console_sem))
1953 return 0;
1954 if (console_suspended) {
1955 up(&console_sem);
1956 return 0;
1957 }
1958 console_locked = 1;
1959 console_may_schedule = 0;
1960 mutex_acquire(&console_lock_dep_map, 0, 1, _RET_IP_);
1961 return 1;
1962}
1963EXPORT_SYMBOL(console_trylock);
1964
1965int is_console_locked(void)
1966{
1967 return console_locked;
1968}
1969
1970static void console_cont_flush(char *text, size_t size)
1971{
1972 unsigned long flags;
1973 size_t len;
1974
1975 raw_spin_lock_irqsave(&logbuf_lock, flags);
1976
1977 if (!cont.len)
1978 goto out;
1979
1980
1981
1982
1983
1984
1985 if (console_seq < log_next_seq && !cont.cons)
1986 goto out;
1987
1988 len = cont_print_text(text, size);
1989 raw_spin_unlock(&logbuf_lock);
1990 stop_critical_timings();
1991 call_console_drivers(cont.level, text, len);
1992 start_critical_timings();
1993 local_irq_restore(flags);
1994 return;
1995out:
1996 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
1997}
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013void console_unlock(void)
2014{
2015 static char text[LOG_LINE_MAX + PREFIX_MAX];
2016 static u64 seen_seq;
2017 unsigned long flags;
2018 bool wake_klogd = false;
2019 bool retry;
2020
2021 if (console_suspended) {
2022 up(&console_sem);
2023 return;
2024 }
2025
2026 console_may_schedule = 0;
2027
2028
2029 console_cont_flush(text, sizeof(text));
2030again:
2031 for (;;) {
2032 struct printk_log *msg;
2033 size_t len;
2034 int level;
2035
2036 raw_spin_lock_irqsave(&logbuf_lock, flags);
2037 if (seen_seq != log_next_seq) {
2038 wake_klogd = true;
2039 seen_seq = log_next_seq;
2040 }
2041
2042 if (console_seq < log_first_seq) {
2043
2044 console_seq = log_first_seq;
2045 console_idx = log_first_idx;
2046 console_prev = 0;
2047 }
2048skip:
2049 if (console_seq == log_next_seq)
2050 break;
2051
2052 msg = log_from_idx(console_idx);
2053 if (msg->flags & LOG_NOCONS) {
2054
2055
2056
2057
2058 console_idx = log_next(console_idx);
2059 console_seq++;
2060
2061
2062
2063
2064
2065 msg->flags &= ~LOG_NOCONS;
2066 console_prev = msg->flags;
2067 goto skip;
2068 }
2069
2070 level = msg->level;
2071 len = msg_print_text(msg, console_prev, false,
2072 text, sizeof(text));
2073 console_idx = log_next(console_idx);
2074 console_seq++;
2075 console_prev = msg->flags;
2076 raw_spin_unlock(&logbuf_lock);
2077
2078 stop_critical_timings();
2079 call_console_drivers(level, text, len);
2080 start_critical_timings();
2081 local_irq_restore(flags);
2082 }
2083 console_locked = 0;
2084 mutex_release(&console_lock_dep_map, 1, _RET_IP_);
2085
2086
2087 if (unlikely(exclusive_console))
2088 exclusive_console = NULL;
2089
2090 raw_spin_unlock(&logbuf_lock);
2091
2092 up(&console_sem);
2093
2094
2095
2096
2097
2098
2099
2100 raw_spin_lock(&logbuf_lock);
2101 retry = console_seq != log_next_seq;
2102 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2103
2104 if (retry && console_trylock())
2105 goto again;
2106
2107 if (wake_klogd)
2108 wake_up_klogd();
2109}
2110EXPORT_SYMBOL(console_unlock);
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121void __sched console_conditional_schedule(void)
2122{
2123 if (console_may_schedule)
2124 cond_resched();
2125}
2126EXPORT_SYMBOL(console_conditional_schedule);
2127
2128void console_unblank(void)
2129{
2130 struct console *c;
2131
2132
2133
2134
2135
2136 if (oops_in_progress) {
2137 if (down_trylock(&console_sem) != 0)
2138 return;
2139 } else
2140 console_lock();
2141
2142 console_locked = 1;
2143 console_may_schedule = 0;
2144 for_each_console(c)
2145 if ((c->flags & CON_ENABLED) && c->unblank)
2146 c->unblank();
2147 console_unlock();
2148}
2149
2150
2151
2152
2153struct tty_driver *console_device(int *index)
2154{
2155 struct console *c;
2156 struct tty_driver *driver = NULL;
2157
2158 console_lock();
2159 for_each_console(c) {
2160 if (!c->device)
2161 continue;
2162 driver = c->device(c, index);
2163 if (driver)
2164 break;
2165 }
2166 console_unlock();
2167 return driver;
2168}
2169
2170
2171
2172
2173
2174
2175void console_stop(struct console *console)
2176{
2177 console_lock();
2178 console->flags &= ~CON_ENABLED;
2179 console_unlock();
2180}
2181EXPORT_SYMBOL(console_stop);
2182
2183void console_start(struct console *console)
2184{
2185 console_lock();
2186 console->flags |= CON_ENABLED;
2187 console_unlock();
2188}
2189EXPORT_SYMBOL(console_start);
2190
2191static int __read_mostly keep_bootcon;
2192
2193static int __init keep_bootcon_setup(char *str)
2194{
2195 keep_bootcon = 1;
2196 printk(KERN_INFO "debug: skip boot console de-registration.\n");
2197
2198 return 0;
2199}
2200
2201early_param("keep_bootcon", keep_bootcon_setup);
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222void register_console(struct console *newcon)
2223{
2224 int i;
2225 unsigned long flags;
2226 struct console *bcon = NULL;
2227 struct console_cmdline *c;
2228
2229
2230
2231
2232
2233 if (console_drivers && newcon->flags & CON_BOOT) {
2234
2235 for_each_console(bcon) {
2236 if (!(bcon->flags & CON_BOOT)) {
2237 printk(KERN_INFO "Too late to register bootconsole %s%d\n",
2238 newcon->name, newcon->index);
2239 return;
2240 }
2241 }
2242 }
2243
2244 if (console_drivers && console_drivers->flags & CON_BOOT)
2245 bcon = console_drivers;
2246
2247 if (preferred_console < 0 || bcon || !console_drivers)
2248 preferred_console = selected_console;
2249
2250 if (newcon->early_setup)
2251 newcon->early_setup();
2252
2253
2254
2255
2256
2257
2258 if (preferred_console < 0) {
2259 if (newcon->index < 0)
2260 newcon->index = 0;
2261 if (newcon->setup == NULL ||
2262 newcon->setup(newcon, NULL) == 0) {
2263 newcon->flags |= CON_ENABLED;
2264 if (newcon->device) {
2265 newcon->flags |= CON_CONSDEV;
2266 preferred_console = 0;
2267 }
2268 }
2269 }
2270
2271
2272
2273
2274
2275 for (i = 0, c = console_cmdline;
2276 i < MAX_CMDLINECONSOLES && c->name[0];
2277 i++, c++) {
2278 if (strcmp(c->name, newcon->name) != 0)
2279 continue;
2280 if (newcon->index >= 0 &&
2281 newcon->index != c->index)
2282 continue;
2283 if (newcon->index < 0)
2284 newcon->index = c->index;
2285
2286 if (_braille_register_console(newcon, c))
2287 return;
2288
2289 if (newcon->setup &&
2290 newcon->setup(newcon, console_cmdline[i].options) != 0)
2291 break;
2292 newcon->flags |= CON_ENABLED;
2293 newcon->index = c->index;
2294 if (i == selected_console) {
2295 newcon->flags |= CON_CONSDEV;
2296 preferred_console = selected_console;
2297 }
2298 break;
2299 }
2300
2301 if (!(newcon->flags & CON_ENABLED))
2302 return;
2303
2304
2305
2306
2307
2308
2309
2310 if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
2311 newcon->flags &= ~CON_PRINTBUFFER;
2312
2313
2314
2315
2316
2317 console_lock();
2318 if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
2319 newcon->next = console_drivers;
2320 console_drivers = newcon;
2321 if (newcon->next)
2322 newcon->next->flags &= ~CON_CONSDEV;
2323 } else {
2324 newcon->next = console_drivers->next;
2325 console_drivers->next = newcon;
2326 }
2327 if (newcon->flags & CON_PRINTBUFFER) {
2328
2329
2330
2331
2332 raw_spin_lock_irqsave(&logbuf_lock, flags);
2333 console_seq = syslog_seq;
2334 console_idx = syslog_idx;
2335 console_prev = syslog_prev;
2336 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2337
2338
2339
2340
2341
2342 exclusive_console = newcon;
2343 }
2344 console_unlock();
2345 console_sysfs_notify();
2346
2347
2348
2349
2350
2351
2352
2353
2354 if (bcon &&
2355 ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
2356 !keep_bootcon) {
2357
2358
2359
2360 printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
2361 newcon->name, newcon->index);
2362 for_each_console(bcon)
2363 if (bcon->flags & CON_BOOT)
2364 unregister_console(bcon);
2365 } else {
2366 printk(KERN_INFO "%sconsole [%s%d] enabled\n",
2367 (newcon->flags & CON_BOOT) ? "boot" : "" ,
2368 newcon->name, newcon->index);
2369 }
2370}
2371EXPORT_SYMBOL(register_console);
2372
2373int unregister_console(struct console *console)
2374{
2375 struct console *a, *b;
2376 int res;
2377
2378 res = _braille_unregister_console(console);
2379 if (res)
2380 return res;
2381
2382 res = 1;
2383 console_lock();
2384 if (console_drivers == console) {
2385 console_drivers=console->next;
2386 res = 0;
2387 } else if (console_drivers) {
2388 for (a=console_drivers->next, b=console_drivers ;
2389 a; b=a, a=b->next) {
2390 if (a == console) {
2391 b->next = a->next;
2392 res = 0;
2393 break;
2394 }
2395 }
2396 }
2397
2398
2399
2400
2401
2402 if (console_drivers != NULL && console->flags & CON_CONSDEV)
2403 console_drivers->flags |= CON_CONSDEV;
2404
2405 console_unlock();
2406 console_sysfs_notify();
2407 return res;
2408}
2409EXPORT_SYMBOL(unregister_console);
2410
2411static int __init printk_late_init(void)
2412{
2413 struct console *con;
2414
2415 for_each_console(con) {
2416 if (!keep_bootcon && con->flags & CON_BOOT) {
2417 printk(KERN_INFO "turn off boot console %s%d\n",
2418 con->name, con->index);
2419 unregister_console(con);
2420 }
2421 }
2422 hotcpu_notifier(console_cpu_notify, 0);
2423 return 0;
2424}
2425late_initcall(printk_late_init);
2426
2427#if defined CONFIG_PRINTK
2428
2429
2430
2431#define PRINTK_BUF_SIZE 512
2432
2433#define PRINTK_PENDING_WAKEUP 0x01
2434#define PRINTK_PENDING_SCHED 0x02
2435
2436static DEFINE_PER_CPU(int, printk_pending);
2437static DEFINE_PER_CPU(char [PRINTK_BUF_SIZE], printk_sched_buf);
2438
2439static void wake_up_klogd_work_func(struct irq_work *irq_work)
2440{
2441 int pending = __this_cpu_xchg(printk_pending, 0);
2442
2443 if (pending & PRINTK_PENDING_SCHED) {
2444 char *buf = __get_cpu_var(printk_sched_buf);
2445 printk(KERN_WARNING "[sched_delayed] %s", buf);
2446 }
2447
2448 if (pending & PRINTK_PENDING_WAKEUP)
2449 wake_up_interruptible(&log_wait);
2450}
2451
2452static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
2453 .func = wake_up_klogd_work_func,
2454 .flags = IRQ_WORK_LAZY,
2455};
2456
2457void wake_up_klogd(void)
2458{
2459 preempt_disable();
2460 if (waitqueue_active(&log_wait)) {
2461 this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
2462 irq_work_queue(&__get_cpu_var(wake_up_klogd_work));
2463 }
2464 preempt_enable();
2465}
2466
2467int printk_sched(const char *fmt, ...)
2468{
2469 unsigned long flags;
2470 va_list args;
2471 char *buf;
2472 int r;
2473
2474 local_irq_save(flags);
2475 buf = __get_cpu_var(printk_sched_buf);
2476
2477 va_start(args, fmt);
2478 r = vsnprintf(buf, PRINTK_BUF_SIZE, fmt, args);
2479 va_end(args);
2480
2481 __this_cpu_or(printk_pending, PRINTK_PENDING_SCHED);
2482 irq_work_queue(&__get_cpu_var(wake_up_klogd_work));
2483 local_irq_restore(flags);
2484
2485 return r;
2486}
2487
2488
2489
2490
2491
2492
2493
2494DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
2495
2496int __printk_ratelimit(const char *func)
2497{
2498 return ___ratelimit(&printk_ratelimit_state, func);
2499}
2500EXPORT_SYMBOL(__printk_ratelimit);
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511bool printk_timed_ratelimit(unsigned long *caller_jiffies,
2512 unsigned int interval_msecs)
2513{
2514 if (*caller_jiffies == 0
2515 || !time_in_range(jiffies, *caller_jiffies,
2516 *caller_jiffies
2517 + msecs_to_jiffies(interval_msecs))) {
2518 *caller_jiffies = jiffies;
2519 return true;
2520 }
2521 return false;
2522}
2523EXPORT_SYMBOL(printk_timed_ratelimit);
2524
2525static DEFINE_SPINLOCK(dump_list_lock);
2526static LIST_HEAD(dump_list);
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536int kmsg_dump_register(struct kmsg_dumper *dumper)
2537{
2538 unsigned long flags;
2539 int err = -EBUSY;
2540
2541
2542 if (!dumper->dump)
2543 return -EINVAL;
2544
2545 spin_lock_irqsave(&dump_list_lock, flags);
2546
2547 if (!dumper->registered) {
2548 dumper->registered = 1;
2549 list_add_tail_rcu(&dumper->list, &dump_list);
2550 err = 0;
2551 }
2552 spin_unlock_irqrestore(&dump_list_lock, flags);
2553
2554 return err;
2555}
2556EXPORT_SYMBOL_GPL(kmsg_dump_register);
2557
2558
2559
2560
2561
2562
2563
2564
2565int kmsg_dump_unregister(struct kmsg_dumper *dumper)
2566{
2567 unsigned long flags;
2568 int err = -EINVAL;
2569
2570 spin_lock_irqsave(&dump_list_lock, flags);
2571 if (dumper->registered) {
2572 dumper->registered = 0;
2573 list_del_rcu(&dumper->list);
2574 err = 0;
2575 }
2576 spin_unlock_irqrestore(&dump_list_lock, flags);
2577 synchronize_rcu();
2578
2579 return err;
2580}
2581EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
2582
2583static bool always_kmsg_dump;
2584module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594void kmsg_dump(enum kmsg_dump_reason reason)
2595{
2596 struct kmsg_dumper *dumper;
2597 unsigned long flags;
2598
2599 if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
2600 return;
2601
2602 rcu_read_lock();
2603 list_for_each_entry_rcu(dumper, &dump_list, list) {
2604 if (dumper->max_reason && reason > dumper->max_reason)
2605 continue;
2606
2607
2608 dumper->active = true;
2609
2610 raw_spin_lock_irqsave(&logbuf_lock, flags);
2611 dumper->cur_seq = clear_seq;
2612 dumper->cur_idx = clear_idx;
2613 dumper->next_seq = log_next_seq;
2614 dumper->next_idx = log_next_idx;
2615 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2616
2617
2618 dumper->dump(dumper, reason);
2619
2620
2621 dumper->active = false;
2622 }
2623 rcu_read_unlock();
2624}
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
2646 char *line, size_t size, size_t *len)
2647{
2648 struct printk_log *msg;
2649 size_t l = 0;
2650 bool ret = false;
2651
2652 if (!dumper->active)
2653 goto out;
2654
2655 if (dumper->cur_seq < log_first_seq) {
2656
2657 dumper->cur_seq = log_first_seq;
2658 dumper->cur_idx = log_first_idx;
2659 }
2660
2661
2662 if (dumper->cur_seq >= log_next_seq)
2663 goto out;
2664
2665 msg = log_from_idx(dumper->cur_idx);
2666 l = msg_print_text(msg, 0, syslog, line, size);
2667
2668 dumper->cur_idx = log_next(dumper->cur_idx);
2669 dumper->cur_seq++;
2670 ret = true;
2671out:
2672 if (len)
2673 *len = l;
2674 return ret;
2675}
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
2695 char *line, size_t size, size_t *len)
2696{
2697 unsigned long flags;
2698 bool ret;
2699
2700 raw_spin_lock_irqsave(&logbuf_lock, flags);
2701 ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
2702 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2703
2704 return ret;
2705}
2706EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
2728 char *buf, size_t size, size_t *len)
2729{
2730 unsigned long flags;
2731 u64 seq;
2732 u32 idx;
2733 u64 next_seq;
2734 u32 next_idx;
2735 enum log_flags prev;
2736 size_t l = 0;
2737 bool ret = false;
2738
2739 if (!dumper->active)
2740 goto out;
2741
2742 raw_spin_lock_irqsave(&logbuf_lock, flags);
2743 if (dumper->cur_seq < log_first_seq) {
2744
2745 dumper->cur_seq = log_first_seq;
2746 dumper->cur_idx = log_first_idx;
2747 }
2748
2749
2750 if (dumper->cur_seq >= dumper->next_seq) {
2751 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2752 goto out;
2753 }
2754
2755
2756 seq = dumper->cur_seq;
2757 idx = dumper->cur_idx;
2758 prev = 0;
2759 while (seq < dumper->next_seq) {
2760 struct printk_log *msg = log_from_idx(idx);
2761
2762 l += msg_print_text(msg, prev, true, NULL, 0);
2763 idx = log_next(idx);
2764 seq++;
2765 prev = msg->flags;
2766 }
2767
2768
2769 seq = dumper->cur_seq;
2770 idx = dumper->cur_idx;
2771 prev = 0;
2772 while (l > size && seq < dumper->next_seq) {
2773 struct printk_log *msg = log_from_idx(idx);
2774
2775 l -= msg_print_text(msg, prev, true, NULL, 0);
2776 idx = log_next(idx);
2777 seq++;
2778 prev = msg->flags;
2779 }
2780
2781
2782 next_seq = seq;
2783 next_idx = idx;
2784
2785 l = 0;
2786 prev = 0;
2787 while (seq < dumper->next_seq) {
2788 struct printk_log *msg = log_from_idx(idx);
2789
2790 l += msg_print_text(msg, prev, syslog, buf + l, size - l);
2791 idx = log_next(idx);
2792 seq++;
2793 prev = msg->flags;
2794 }
2795
2796 dumper->next_seq = next_seq;
2797 dumper->next_idx = next_idx;
2798 ret = true;
2799 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2800out:
2801 if (len)
2802 *len = l;
2803 return ret;
2804}
2805EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
2818{
2819 dumper->cur_seq = clear_seq;
2820 dumper->cur_idx = clear_idx;
2821 dumper->next_seq = log_next_seq;
2822 dumper->next_idx = log_next_idx;
2823}
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833void kmsg_dump_rewind(struct kmsg_dumper *dumper)
2834{
2835 unsigned long flags;
2836
2837 raw_spin_lock_irqsave(&logbuf_lock, flags);
2838 kmsg_dump_rewind_nolock(dumper);
2839 raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2840}
2841EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
2842
2843static char dump_stack_arch_desc_str[128];
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855void __init dump_stack_set_arch_desc(const char *fmt, ...)
2856{
2857 va_list args;
2858
2859 va_start(args, fmt);
2860 vsnprintf(dump_stack_arch_desc_str, sizeof(dump_stack_arch_desc_str),
2861 fmt, args);
2862 va_end(args);
2863}
2864
2865
2866
2867
2868
2869
2870
2871
2872void dump_stack_print_info(const char *log_lvl)
2873{
2874 printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n",
2875 log_lvl, raw_smp_processor_id(), current->pid, current->comm,
2876 print_tainted(), init_utsname()->release,
2877 (int)strcspn(init_utsname()->version, " "),
2878 init_utsname()->version);
2879
2880 if (dump_stack_arch_desc_str[0] != '\0')
2881 printk("%sHardware name: %s\n",
2882 log_lvl, dump_stack_arch_desc_str);
2883
2884 print_worker_info(log_lvl, current);
2885}
2886
2887
2888
2889
2890
2891
2892
2893
2894void show_regs_print_info(const char *log_lvl)
2895{
2896 dump_stack_print_info(log_lvl);
2897
2898 printk("%stask: %p ti: %p task.ti: %p\n",
2899 log_lvl, current, current_thread_info(),
2900 task_thread_info(current));
2901}
2902
2903#endif
2904