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/syscalls.h>
35#include <linux/kexec.h>
36#include <linux/kdb.h>
37#include <linux/ratelimit.h>
38#include <linux/kmsg_dump.h>
39#include <linux/syslog.h>
40#include <linux/cpu.h>
41#include <linux/notifier.h>
42#include <linux/rculist.h>
43
44#include <asm/uaccess.h>
45
46
47
48
49void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
50{
51}
52
53#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
54
55
56#define DEFAULT_MESSAGE_LOGLEVEL 4
57
58
59#define MINIMUM_CONSOLE_LOGLEVEL 1
60#define DEFAULT_CONSOLE_LOGLEVEL 7
61
62DECLARE_WAIT_QUEUE_HEAD(log_wait);
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
88
89
90
91
92
93
94
95static int console_locked, console_suspended;
96
97
98
99
100
101
102static DEFINE_SPINLOCK(logbuf_lock);
103
104#define LOG_BUF_MASK (log_buf_len-1)
105#define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
106
107
108
109
110
111static unsigned log_start;
112static unsigned con_start;
113static unsigned log_end;
114
115
116
117
118struct console_cmdline
119{
120 char name[8];
121 int index;
122 char *options;
123#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
124 char *brl_options;
125#endif
126};
127
128#define MAX_CMDLINECONSOLES 8
129
130static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
131static int selected_console = -1;
132static int preferred_console = -1;
133int console_set_on_cmdline;
134EXPORT_SYMBOL(console_set_on_cmdline);
135
136
137static int console_may_schedule;
138
139#ifdef CONFIG_PRINTK
140
141static char __log_buf[__LOG_BUF_LEN];
142static char *log_buf = __log_buf;
143static int log_buf_len = __LOG_BUF_LEN;
144static unsigned logged_chars;
145static int saved_console_loglevel = -1;
146
147#ifdef CONFIG_KEXEC
148
149
150
151
152
153
154
155
156void log_buf_kexec_setup(void)
157{
158 VMCOREINFO_SYMBOL(log_buf);
159 VMCOREINFO_SYMBOL(log_end);
160 VMCOREINFO_SYMBOL(log_buf_len);
161 VMCOREINFO_SYMBOL(logged_chars);
162}
163#endif
164
165static int __init log_buf_len_setup(char *str)
166{
167 unsigned size = memparse(str, &str);
168 unsigned long flags;
169
170 if (size)
171 size = roundup_pow_of_two(size);
172 if (size > log_buf_len) {
173 unsigned start, dest_idx, offset;
174 char *new_log_buf;
175
176 new_log_buf = alloc_bootmem(size);
177 if (!new_log_buf) {
178 printk(KERN_WARNING "log_buf_len: allocation failed\n");
179 goto out;
180 }
181
182 spin_lock_irqsave(&logbuf_lock, flags);
183 log_buf_len = size;
184 log_buf = new_log_buf;
185
186 offset = start = min(con_start, log_start);
187 dest_idx = 0;
188 while (start != log_end) {
189 log_buf[dest_idx] = __log_buf[start & (__LOG_BUF_LEN - 1)];
190 start++;
191 dest_idx++;
192 }
193 log_start -= offset;
194 con_start -= offset;
195 log_end -= offset;
196 spin_unlock_irqrestore(&logbuf_lock, flags);
197
198 printk(KERN_NOTICE "log_buf_len: %d\n", log_buf_len);
199 }
200out:
201 return 1;
202}
203
204__setup("log_buf_len=", log_buf_len_setup);
205
206#ifdef CONFIG_BOOT_PRINTK_DELAY
207
208static int boot_delay;
209static unsigned long long loops_per_msec;
210
211static int __init boot_delay_setup(char *str)
212{
213 unsigned long lpj;
214
215 lpj = preset_lpj ? preset_lpj : 1000000;
216 loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
217
218 get_option(&str, &boot_delay);
219 if (boot_delay > 10 * 1000)
220 boot_delay = 0;
221
222 pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
223 "HZ: %d, loops_per_msec: %llu\n",
224 boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
225 return 1;
226}
227__setup("boot_delay=", boot_delay_setup);
228
229static void boot_delay_msec(void)
230{
231 unsigned long long k;
232 unsigned long timeout;
233
234 if (boot_delay == 0 || system_state != SYSTEM_BOOTING)
235 return;
236
237 k = (unsigned long long)loops_per_msec * boot_delay;
238
239 timeout = jiffies + msecs_to_jiffies(boot_delay);
240 while (k) {
241 k--;
242 cpu_relax();
243
244
245
246
247
248 if (time_after(jiffies, timeout))
249 break;
250 touch_nmi_watchdog();
251 }
252}
253#else
254static inline void boot_delay_msec(void)
255{
256}
257#endif
258
259#ifdef CONFIG_SECURITY_DMESG_RESTRICT
260int dmesg_restrict = 1;
261#else
262int dmesg_restrict;
263#endif
264
265static int syslog_action_restricted(int type)
266{
267 if (dmesg_restrict)
268 return 1;
269
270 return type != SYSLOG_ACTION_READ_ALL && type != SYSLOG_ACTION_SIZE_BUFFER;
271}
272
273static int check_syslog_permissions(int type, bool from_file)
274{
275
276
277
278
279 if (from_file && type != SYSLOG_ACTION_OPEN)
280 return 0;
281
282 if (syslog_action_restricted(type)) {
283 if (capable(CAP_SYSLOG))
284 return 0;
285
286 if (capable(CAP_SYS_ADMIN)) {
287 WARN_ONCE(1, "Attempt to access syslog with CAP_SYS_ADMIN "
288 "but no CAP_SYSLOG (deprecated).\n");
289 return 0;
290 }
291 return -EPERM;
292 }
293 return 0;
294}
295
296int do_syslog(int type, char __user *buf, int len, bool from_file)
297{
298 unsigned i, j, limit, count;
299 int do_clear = 0;
300 char c;
301 int error;
302
303 error = check_syslog_permissions(type, from_file);
304 if (error)
305 goto out;
306
307 error = security_syslog(type);
308 if (error)
309 return error;
310
311 switch (type) {
312 case SYSLOG_ACTION_CLOSE:
313 break;
314 case SYSLOG_ACTION_OPEN:
315 break;
316 case SYSLOG_ACTION_READ:
317 error = -EINVAL;
318 if (!buf || len < 0)
319 goto out;
320 error = 0;
321 if (!len)
322 goto out;
323 if (!access_ok(VERIFY_WRITE, buf, len)) {
324 error = -EFAULT;
325 goto out;
326 }
327 error = wait_event_interruptible(log_wait,
328 (log_start - log_end));
329 if (error)
330 goto out;
331 i = 0;
332 spin_lock_irq(&logbuf_lock);
333 while (!error && (log_start != log_end) && i < len) {
334 c = LOG_BUF(log_start);
335 log_start++;
336 spin_unlock_irq(&logbuf_lock);
337 error = __put_user(c,buf);
338 buf++;
339 i++;
340 cond_resched();
341 spin_lock_irq(&logbuf_lock);
342 }
343 spin_unlock_irq(&logbuf_lock);
344 if (!error)
345 error = i;
346 break;
347
348 case SYSLOG_ACTION_READ_CLEAR:
349 do_clear = 1;
350
351
352 case SYSLOG_ACTION_READ_ALL:
353 error = -EINVAL;
354 if (!buf || len < 0)
355 goto out;
356 error = 0;
357 if (!len)
358 goto out;
359 if (!access_ok(VERIFY_WRITE, buf, len)) {
360 error = -EFAULT;
361 goto out;
362 }
363 count = len;
364 if (count > log_buf_len)
365 count = log_buf_len;
366 spin_lock_irq(&logbuf_lock);
367 if (count > logged_chars)
368 count = logged_chars;
369 if (do_clear)
370 logged_chars = 0;
371 limit = log_end;
372
373
374
375
376
377
378 for (i = 0; i < count && !error; i++) {
379 j = limit-1-i;
380 if (j + log_buf_len < log_end)
381 break;
382 c = LOG_BUF(j);
383 spin_unlock_irq(&logbuf_lock);
384 error = __put_user(c,&buf[count-1-i]);
385 cond_resched();
386 spin_lock_irq(&logbuf_lock);
387 }
388 spin_unlock_irq(&logbuf_lock);
389 if (error)
390 break;
391 error = i;
392 if (i != count) {
393 int offset = count-error;
394
395 for (i = 0; i < error; i++) {
396 if (__get_user(c,&buf[i+offset]) ||
397 __put_user(c,&buf[i])) {
398 error = -EFAULT;
399 break;
400 }
401 cond_resched();
402 }
403 }
404 break;
405
406 case SYSLOG_ACTION_CLEAR:
407 logged_chars = 0;
408 break;
409
410 case SYSLOG_ACTION_CONSOLE_OFF:
411 if (saved_console_loglevel == -1)
412 saved_console_loglevel = console_loglevel;
413 console_loglevel = minimum_console_loglevel;
414 break;
415
416 case SYSLOG_ACTION_CONSOLE_ON:
417 if (saved_console_loglevel != -1) {
418 console_loglevel = saved_console_loglevel;
419 saved_console_loglevel = -1;
420 }
421 break;
422
423 case SYSLOG_ACTION_CONSOLE_LEVEL:
424 error = -EINVAL;
425 if (len < 1 || len > 8)
426 goto out;
427 if (len < minimum_console_loglevel)
428 len = minimum_console_loglevel;
429 console_loglevel = len;
430
431 saved_console_loglevel = -1;
432 error = 0;
433 break;
434
435 case SYSLOG_ACTION_SIZE_UNREAD:
436 error = log_end - log_start;
437 break;
438
439 case SYSLOG_ACTION_SIZE_BUFFER:
440 error = log_buf_len;
441 break;
442 default:
443 error = -EINVAL;
444 break;
445 }
446out:
447 return error;
448}
449
450SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
451{
452 return do_syslog(type, buf, len, SYSLOG_FROM_CALL);
453}
454
455#ifdef CONFIG_KGDB_KDB
456
457
458
459
460
461void kdb_syslog_data(char *syslog_data[4])
462{
463 syslog_data[0] = log_buf;
464 syslog_data[1] = log_buf + log_buf_len;
465 syslog_data[2] = log_buf + log_end -
466 (logged_chars < log_buf_len ? logged_chars : log_buf_len);
467 syslog_data[3] = log_buf + log_end;
468}
469#endif
470
471
472
473
474static void __call_console_drivers(unsigned start, unsigned end)
475{
476 struct console *con;
477
478 for_each_console(con) {
479 if ((con->flags & CON_ENABLED) && con->write &&
480 (cpu_online(smp_processor_id()) ||
481 (con->flags & CON_ANYTIME)))
482 con->write(con, &LOG_BUF(start), end - start);
483 }
484}
485
486static int __read_mostly ignore_loglevel;
487
488static int __init ignore_loglevel_setup(char *str)
489{
490 ignore_loglevel = 1;
491 printk(KERN_INFO "debug: ignoring loglevel setting.\n");
492
493 return 0;
494}
495
496early_param("ignore_loglevel", ignore_loglevel_setup);
497
498
499
500
501static void _call_console_drivers(unsigned start,
502 unsigned end, int msg_log_level)
503{
504 if ((msg_log_level < console_loglevel || ignore_loglevel) &&
505 console_drivers && start != end) {
506 if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
507
508 __call_console_drivers(start & LOG_BUF_MASK,
509 log_buf_len);
510 __call_console_drivers(0, end & LOG_BUF_MASK);
511 } else {
512 __call_console_drivers(start, end);
513 }
514 }
515}
516
517
518
519
520
521
522static void call_console_drivers(unsigned start, unsigned end)
523{
524 unsigned cur_index, start_print;
525 static int msg_level = -1;
526
527 BUG_ON(((int)(start - end)) > 0);
528
529 cur_index = start;
530 start_print = start;
531 while (cur_index != end) {
532 if (msg_level < 0 && ((end - cur_index) > 2) &&
533 LOG_BUF(cur_index + 0) == '<' &&
534 LOG_BUF(cur_index + 1) >= '0' &&
535 LOG_BUF(cur_index + 1) <= '7' &&
536 LOG_BUF(cur_index + 2) == '>') {
537 msg_level = LOG_BUF(cur_index + 1) - '0';
538 cur_index += 3;
539 start_print = cur_index;
540 }
541 while (cur_index != end) {
542 char c = LOG_BUF(cur_index);
543
544 cur_index++;
545 if (c == '\n') {
546 if (msg_level < 0) {
547
548
549
550
551
552
553 msg_level = default_message_loglevel;
554 }
555 _call_console_drivers(start_print, cur_index, msg_level);
556 msg_level = -1;
557 start_print = cur_index;
558 break;
559 }
560 }
561 }
562 _call_console_drivers(start_print, end, msg_level);
563}
564
565static void emit_log_char(char c)
566{
567 LOG_BUF(log_end) = c;
568 log_end++;
569 if (log_end - log_start > log_buf_len)
570 log_start = log_end - log_buf_len;
571 if (log_end - con_start > log_buf_len)
572 con_start = log_end - log_buf_len;
573 if (logged_chars < log_buf_len)
574 logged_chars++;
575}
576
577
578
579
580
581
582static void zap_locks(void)
583{
584 static unsigned long oops_timestamp;
585
586 if (time_after_eq(jiffies, oops_timestamp) &&
587 !time_after(jiffies, oops_timestamp + 30 * HZ))
588 return;
589
590 oops_timestamp = jiffies;
591
592
593 spin_lock_init(&logbuf_lock);
594
595 sema_init(&console_sem, 1);
596}
597
598#if defined(CONFIG_PRINTK_TIME)
599static int printk_time = 1;
600#else
601static int printk_time = 0;
602#endif
603module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
604
605
606static int have_callable_console(void)
607{
608 struct console *con;
609
610 for_each_console(con)
611 if (con->flags & CON_ANYTIME)
612 return 1;
613
614 return 0;
615}
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639asmlinkage int printk(const char *fmt, ...)
640{
641 va_list args;
642 int r;
643
644#ifdef CONFIG_KGDB_KDB
645 if (unlikely(kdb_trap_printk)) {
646 va_start(args, fmt);
647 r = vkdb_printf(fmt, args);
648 va_end(args);
649 return r;
650 }
651#endif
652 va_start(args, fmt);
653 r = vprintk(fmt, args);
654 va_end(args);
655
656 return r;
657}
658
659
660static volatile unsigned int printk_cpu = UINT_MAX;
661
662
663
664
665
666
667
668
669
670static inline int can_use_console(unsigned int cpu)
671{
672 return cpu_online(cpu) || have_callable_console();
673}
674
675
676
677
678
679
680
681
682
683
684
685static int console_trylock_for_printk(unsigned int cpu)
686 __releases(&logbuf_lock)
687{
688 int retval = 0;
689
690 if (console_trylock()) {
691 retval = 1;
692
693
694
695
696
697
698
699 if (!can_use_console(cpu)) {
700 console_locked = 0;
701 up(&console_sem);
702 retval = 0;
703 }
704 }
705 printk_cpu = UINT_MAX;
706 spin_unlock(&logbuf_lock);
707 return retval;
708}
709static const char recursion_bug_msg [] =
710 KERN_CRIT "BUG: recent printk recursion!\n";
711static int recursion_bug;
712static int new_text_line = 1;
713static char printk_buf[1024];
714
715int printk_delay_msec __read_mostly;
716
717static inline void printk_delay(void)
718{
719 if (unlikely(printk_delay_msec)) {
720 int m = printk_delay_msec;
721
722 while (m--) {
723 mdelay(1);
724 touch_nmi_watchdog();
725 }
726 }
727}
728
729asmlinkage int vprintk(const char *fmt, va_list args)
730{
731 int printed_len = 0;
732 int current_log_level = default_message_loglevel;
733 unsigned long flags;
734 int this_cpu;
735 char *p;
736
737 boot_delay_msec();
738 printk_delay();
739
740 preempt_disable();
741
742 raw_local_irq_save(flags);
743 this_cpu = smp_processor_id();
744
745
746
747
748 if (unlikely(printk_cpu == this_cpu)) {
749
750
751
752
753
754
755
756 if (!oops_in_progress) {
757 recursion_bug = 1;
758 goto out_restore_irqs;
759 }
760 zap_locks();
761 }
762
763 lockdep_off();
764 spin_lock(&logbuf_lock);
765 printk_cpu = this_cpu;
766
767 if (recursion_bug) {
768 recursion_bug = 0;
769 strcpy(printk_buf, recursion_bug_msg);
770 printed_len = strlen(recursion_bug_msg);
771 }
772
773 printed_len += vscnprintf(printk_buf + printed_len,
774 sizeof(printk_buf) - printed_len, fmt, args);
775
776
777 p = printk_buf;
778
779
780 if (p[0] == '<') {
781 unsigned char c = p[1];
782 if (c && p[2] == '>') {
783 switch (c) {
784 case '0' ... '7':
785 current_log_level = c - '0';
786
787 case 'd':
788 if (!new_text_line) {
789 emit_log_char('\n');
790 new_text_line = 1;
791 }
792
793 case 'c':
794 p += 3;
795 break;
796 }
797 }
798 }
799
800
801
802
803
804 for ( ; *p; p++) {
805 if (new_text_line) {
806
807 emit_log_char('<');
808 emit_log_char(current_log_level + '0');
809 emit_log_char('>');
810 printed_len += 3;
811 new_text_line = 0;
812
813 if (printk_time) {
814
815 char tbuf[50], *tp;
816 unsigned tlen;
817 unsigned long long t;
818 unsigned long nanosec_rem;
819
820 t = cpu_clock(printk_cpu);
821 nanosec_rem = do_div(t, 1000000000);
822 tlen = sprintf(tbuf, "[%5lu.%06lu] ",
823 (unsigned long) t,
824 nanosec_rem / 1000);
825
826 for (tp = tbuf; tp < tbuf + tlen; tp++)
827 emit_log_char(*tp);
828 printed_len += tlen;
829 }
830
831 if (!*p)
832 break;
833 }
834
835 emit_log_char(*p);
836 if (*p == '\n')
837 new_text_line = 1;
838 }
839
840
841
842
843
844
845
846
847
848
849
850 if (console_trylock_for_printk(this_cpu))
851 console_unlock();
852
853 lockdep_on();
854out_restore_irqs:
855 raw_local_irq_restore(flags);
856
857 preempt_enable();
858 return printed_len;
859}
860EXPORT_SYMBOL(printk);
861EXPORT_SYMBOL(vprintk);
862
863#else
864
865static void call_console_drivers(unsigned start, unsigned end)
866{
867}
868
869#endif
870
871static int __add_preferred_console(char *name, int idx, char *options,
872 char *brl_options)
873{
874 struct console_cmdline *c;
875 int i;
876
877
878
879
880
881 for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
882 if (strcmp(console_cmdline[i].name, name) == 0 &&
883 console_cmdline[i].index == idx) {
884 if (!brl_options)
885 selected_console = i;
886 return 0;
887 }
888 if (i == MAX_CMDLINECONSOLES)
889 return -E2BIG;
890 if (!brl_options)
891 selected_console = i;
892 c = &console_cmdline[i];
893 strlcpy(c->name, name, sizeof(c->name));
894 c->options = options;
895#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
896 c->brl_options = brl_options;
897#endif
898 c->index = idx;
899 return 0;
900}
901
902
903
904static int __init console_setup(char *str)
905{
906 char buf[sizeof(console_cmdline[0].name) + 4];
907 char *s, *options, *brl_options = NULL;
908 int idx;
909
910#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
911 if (!memcmp(str, "brl,", 4)) {
912 brl_options = "";
913 str += 4;
914 } else if (!memcmp(str, "brl=", 4)) {
915 brl_options = str + 4;
916 str = strchr(brl_options, ',');
917 if (!str) {
918 printk(KERN_ERR "need port name after brl=\n");
919 return 1;
920 }
921 *(str++) = 0;
922 }
923#endif
924
925
926
927
928 if (str[0] >= '0' && str[0] <= '9') {
929 strcpy(buf, "ttyS");
930 strncpy(buf + 4, str, sizeof(buf) - 5);
931 } else {
932 strncpy(buf, str, sizeof(buf) - 1);
933 }
934 buf[sizeof(buf) - 1] = 0;
935 if ((options = strchr(str, ',')) != NULL)
936 *(options++) = 0;
937#ifdef __sparc__
938 if (!strcmp(str, "ttya"))
939 strcpy(buf, "ttyS0");
940 if (!strcmp(str, "ttyb"))
941 strcpy(buf, "ttyS1");
942#endif
943 for (s = buf; *s; s++)
944 if ((*s >= '0' && *s <= '9') || *s == ',')
945 break;
946 idx = simple_strtoul(s, NULL, 10);
947 *s = 0;
948
949 __add_preferred_console(buf, idx, options, brl_options);
950 console_set_on_cmdline = 1;
951 return 1;
952}
953__setup("console=", console_setup);
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968int add_preferred_console(char *name, int idx, char *options)
969{
970 return __add_preferred_console(name, idx, options, NULL);
971}
972
973int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
974{
975 struct console_cmdline *c;
976 int i;
977
978 for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
979 if (strcmp(console_cmdline[i].name, name) == 0 &&
980 console_cmdline[i].index == idx) {
981 c = &console_cmdline[i];
982 strlcpy(c->name, name_new, sizeof(c->name));
983 c->name[sizeof(c->name) - 1] = 0;
984 c->options = options;
985 c->index = idx_new;
986 return i;
987 }
988
989 return -1;
990}
991
992int console_suspend_enabled = 1;
993EXPORT_SYMBOL(console_suspend_enabled);
994
995static int __init console_suspend_disable(char *str)
996{
997 console_suspend_enabled = 0;
998 return 1;
999}
1000__setup("no_console_suspend", console_suspend_disable);
1001
1002
1003
1004
1005
1006
1007void suspend_console(void)
1008{
1009 if (!console_suspend_enabled)
1010 return;
1011 printk("Suspending console(s) (use no_console_suspend to debug)\n");
1012 console_lock();
1013 console_suspended = 1;
1014 up(&console_sem);
1015}
1016
1017void resume_console(void)
1018{
1019 if (!console_suspend_enabled)
1020 return;
1021 down(&console_sem);
1022 console_suspended = 0;
1023 console_unlock();
1024}
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037static int __cpuinit console_cpu_notify(struct notifier_block *self,
1038 unsigned long action, void *hcpu)
1039{
1040 switch (action) {
1041 case CPU_ONLINE:
1042 case CPU_DEAD:
1043 case CPU_DYING:
1044 case CPU_DOWN_FAILED:
1045 case CPU_UP_CANCELED:
1046 console_lock();
1047 console_unlock();
1048 }
1049 return NOTIFY_OK;
1050}
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060void console_lock(void)
1061{
1062 BUG_ON(in_interrupt());
1063 down(&console_sem);
1064 if (console_suspended)
1065 return;
1066 console_locked = 1;
1067 console_may_schedule = 1;
1068}
1069EXPORT_SYMBOL(console_lock);
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079int console_trylock(void)
1080{
1081 if (down_trylock(&console_sem))
1082 return 0;
1083 if (console_suspended) {
1084 up(&console_sem);
1085 return 0;
1086 }
1087 console_locked = 1;
1088 console_may_schedule = 0;
1089 return 1;
1090}
1091EXPORT_SYMBOL(console_trylock);
1092
1093int is_console_locked(void)
1094{
1095 return console_locked;
1096}
1097
1098static DEFINE_PER_CPU(int, printk_pending);
1099
1100void printk_tick(void)
1101{
1102 if (__this_cpu_read(printk_pending)) {
1103 __this_cpu_write(printk_pending, 0);
1104 wake_up_interruptible(&log_wait);
1105 }
1106}
1107
1108int printk_needs_cpu(int cpu)
1109{
1110 if (cpu_is_offline(cpu))
1111 printk_tick();
1112 return __this_cpu_read(printk_pending);
1113}
1114
1115void wake_up_klogd(void)
1116{
1117 if (waitqueue_active(&log_wait))
1118 this_cpu_write(printk_pending, 1);
1119}
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135void console_unlock(void)
1136{
1137 unsigned long flags;
1138 unsigned _con_start, _log_end;
1139 unsigned wake_klogd = 0;
1140
1141 if (console_suspended) {
1142 up(&console_sem);
1143 return;
1144 }
1145
1146 console_may_schedule = 0;
1147
1148 for ( ; ; ) {
1149 spin_lock_irqsave(&logbuf_lock, flags);
1150 wake_klogd |= log_start - log_end;
1151 if (con_start == log_end)
1152 break;
1153 _con_start = con_start;
1154 _log_end = log_end;
1155 con_start = log_end;
1156 spin_unlock(&logbuf_lock);
1157 stop_critical_timings();
1158 call_console_drivers(_con_start, _log_end);
1159 start_critical_timings();
1160 local_irq_restore(flags);
1161 }
1162 console_locked = 0;
1163 up(&console_sem);
1164 spin_unlock_irqrestore(&logbuf_lock, flags);
1165 if (wake_klogd)
1166 wake_up_klogd();
1167}
1168EXPORT_SYMBOL(console_unlock);
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179void __sched console_conditional_schedule(void)
1180{
1181 if (console_may_schedule)
1182 cond_resched();
1183}
1184EXPORT_SYMBOL(console_conditional_schedule);
1185
1186void console_unblank(void)
1187{
1188 struct console *c;
1189
1190
1191
1192
1193
1194 if (oops_in_progress) {
1195 if (down_trylock(&console_sem) != 0)
1196 return;
1197 } else
1198 console_lock();
1199
1200 console_locked = 1;
1201 console_may_schedule = 0;
1202 for_each_console(c)
1203 if ((c->flags & CON_ENABLED) && c->unblank)
1204 c->unblank();
1205 console_unlock();
1206}
1207
1208
1209
1210
1211struct tty_driver *console_device(int *index)
1212{
1213 struct console *c;
1214 struct tty_driver *driver = NULL;
1215
1216 console_lock();
1217 for_each_console(c) {
1218 if (!c->device)
1219 continue;
1220 driver = c->device(c, index);
1221 if (driver)
1222 break;
1223 }
1224 console_unlock();
1225 return driver;
1226}
1227
1228
1229
1230
1231
1232
1233void console_stop(struct console *console)
1234{
1235 console_lock();
1236 console->flags &= ~CON_ENABLED;
1237 console_unlock();
1238}
1239EXPORT_SYMBOL(console_stop);
1240
1241void console_start(struct console *console)
1242{
1243 console_lock();
1244 console->flags |= CON_ENABLED;
1245 console_unlock();
1246}
1247EXPORT_SYMBOL(console_start);
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268void register_console(struct console *newcon)
1269{
1270 int i;
1271 unsigned long flags;
1272 struct console *bcon = NULL;
1273
1274
1275
1276
1277
1278 if (console_drivers && newcon->flags & CON_BOOT) {
1279
1280 for_each_console(bcon) {
1281 if (!(bcon->flags & CON_BOOT)) {
1282 printk(KERN_INFO "Too late to register bootconsole %s%d\n",
1283 newcon->name, newcon->index);
1284 return;
1285 }
1286 }
1287 }
1288
1289 if (console_drivers && console_drivers->flags & CON_BOOT)
1290 bcon = console_drivers;
1291
1292 if (preferred_console < 0 || bcon || !console_drivers)
1293 preferred_console = selected_console;
1294
1295 if (newcon->early_setup)
1296 newcon->early_setup();
1297
1298
1299
1300
1301
1302
1303 if (preferred_console < 0) {
1304 if (newcon->index < 0)
1305 newcon->index = 0;
1306 if (newcon->setup == NULL ||
1307 newcon->setup(newcon, NULL) == 0) {
1308 newcon->flags |= CON_ENABLED;
1309 if (newcon->device) {
1310 newcon->flags |= CON_CONSDEV;
1311 preferred_console = 0;
1312 }
1313 }
1314 }
1315
1316
1317
1318
1319
1320 for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
1321 i++) {
1322 if (strcmp(console_cmdline[i].name, newcon->name) != 0)
1323 continue;
1324 if (newcon->index >= 0 &&
1325 newcon->index != console_cmdline[i].index)
1326 continue;
1327 if (newcon->index < 0)
1328 newcon->index = console_cmdline[i].index;
1329#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1330 if (console_cmdline[i].brl_options) {
1331 newcon->flags |= CON_BRL;
1332 braille_register_console(newcon,
1333 console_cmdline[i].index,
1334 console_cmdline[i].options,
1335 console_cmdline[i].brl_options);
1336 return;
1337 }
1338#endif
1339 if (newcon->setup &&
1340 newcon->setup(newcon, console_cmdline[i].options) != 0)
1341 break;
1342 newcon->flags |= CON_ENABLED;
1343 newcon->index = console_cmdline[i].index;
1344 if (i == selected_console) {
1345 newcon->flags |= CON_CONSDEV;
1346 preferred_console = selected_console;
1347 }
1348 break;
1349 }
1350
1351 if (!(newcon->flags & CON_ENABLED))
1352 return;
1353
1354
1355
1356
1357
1358
1359
1360 if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
1361 newcon->flags &= ~CON_PRINTBUFFER;
1362
1363
1364
1365
1366
1367 console_lock();
1368 if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
1369 newcon->next = console_drivers;
1370 console_drivers = newcon;
1371 if (newcon->next)
1372 newcon->next->flags &= ~CON_CONSDEV;
1373 } else {
1374 newcon->next = console_drivers->next;
1375 console_drivers->next = newcon;
1376 }
1377 if (newcon->flags & CON_PRINTBUFFER) {
1378
1379
1380
1381
1382 spin_lock_irqsave(&logbuf_lock, flags);
1383 con_start = log_start;
1384 spin_unlock_irqrestore(&logbuf_lock, flags);
1385 }
1386 console_unlock();
1387 console_sysfs_notify();
1388
1389
1390
1391
1392
1393
1394
1395
1396 if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV)) {
1397
1398
1399
1400 printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
1401 newcon->name, newcon->index);
1402 for_each_console(bcon)
1403 if (bcon->flags & CON_BOOT)
1404 unregister_console(bcon);
1405 } else {
1406 printk(KERN_INFO "%sconsole [%s%d] enabled\n",
1407 (newcon->flags & CON_BOOT) ? "boot" : "" ,
1408 newcon->name, newcon->index);
1409 }
1410}
1411EXPORT_SYMBOL(register_console);
1412
1413int unregister_console(struct console *console)
1414{
1415 struct console *a, *b;
1416 int res = 1;
1417
1418#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1419 if (console->flags & CON_BRL)
1420 return braille_unregister_console(console);
1421#endif
1422
1423 console_lock();
1424 if (console_drivers == console) {
1425 console_drivers=console->next;
1426 res = 0;
1427 } else if (console_drivers) {
1428 for (a=console_drivers->next, b=console_drivers ;
1429 a; b=a, a=b->next) {
1430 if (a == console) {
1431 b->next = a->next;
1432 res = 0;
1433 break;
1434 }
1435 }
1436 }
1437
1438
1439
1440
1441
1442 if (console_drivers != NULL && console->flags & CON_CONSDEV)
1443 console_drivers->flags |= CON_CONSDEV;
1444
1445 console_unlock();
1446 console_sysfs_notify();
1447 return res;
1448}
1449EXPORT_SYMBOL(unregister_console);
1450
1451static int __init printk_late_init(void)
1452{
1453 struct console *con;
1454
1455 for_each_console(con) {
1456 if (con->flags & CON_BOOT) {
1457 printk(KERN_INFO "turn off boot console %s%d\n",
1458 con->name, con->index);
1459 unregister_console(con);
1460 }
1461 }
1462 hotcpu_notifier(console_cpu_notify, 0);
1463 return 0;
1464}
1465late_initcall(printk_late_init);
1466
1467#if defined CONFIG_PRINTK
1468
1469
1470
1471
1472
1473
1474
1475DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
1476
1477int __printk_ratelimit(const char *func)
1478{
1479 return ___ratelimit(&printk_ratelimit_state, func);
1480}
1481EXPORT_SYMBOL(__printk_ratelimit);
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492bool printk_timed_ratelimit(unsigned long *caller_jiffies,
1493 unsigned int interval_msecs)
1494{
1495 if (*caller_jiffies == 0
1496 || !time_in_range(jiffies, *caller_jiffies,
1497 *caller_jiffies
1498 + msecs_to_jiffies(interval_msecs))) {
1499 *caller_jiffies = jiffies;
1500 return true;
1501 }
1502 return false;
1503}
1504EXPORT_SYMBOL(printk_timed_ratelimit);
1505
1506static DEFINE_SPINLOCK(dump_list_lock);
1507static LIST_HEAD(dump_list);
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517int kmsg_dump_register(struct kmsg_dumper *dumper)
1518{
1519 unsigned long flags;
1520 int err = -EBUSY;
1521
1522
1523 if (!dumper->dump)
1524 return -EINVAL;
1525
1526 spin_lock_irqsave(&dump_list_lock, flags);
1527
1528 if (!dumper->registered) {
1529 dumper->registered = 1;
1530 list_add_tail_rcu(&dumper->list, &dump_list);
1531 err = 0;
1532 }
1533 spin_unlock_irqrestore(&dump_list_lock, flags);
1534
1535 return err;
1536}
1537EXPORT_SYMBOL_GPL(kmsg_dump_register);
1538
1539
1540
1541
1542
1543
1544
1545
1546int kmsg_dump_unregister(struct kmsg_dumper *dumper)
1547{
1548 unsigned long flags;
1549 int err = -EINVAL;
1550
1551 spin_lock_irqsave(&dump_list_lock, flags);
1552 if (dumper->registered) {
1553 dumper->registered = 0;
1554 list_del_rcu(&dumper->list);
1555 err = 0;
1556 }
1557 spin_unlock_irqrestore(&dump_list_lock, flags);
1558 synchronize_rcu();
1559
1560 return err;
1561}
1562EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
1563
1564
1565
1566
1567
1568
1569
1570
1571void kmsg_dump(enum kmsg_dump_reason reason)
1572{
1573 unsigned long end;
1574 unsigned chars;
1575 struct kmsg_dumper *dumper;
1576 const char *s1, *s2;
1577 unsigned long l1, l2;
1578 unsigned long flags;
1579
1580
1581
1582
1583 spin_lock_irqsave(&logbuf_lock, flags);
1584 end = log_end & LOG_BUF_MASK;
1585 chars = logged_chars;
1586 spin_unlock_irqrestore(&logbuf_lock, flags);
1587
1588 if (chars > end) {
1589 s1 = log_buf + log_buf_len - chars + end;
1590 l1 = chars - end;
1591
1592 s2 = log_buf;
1593 l2 = end;
1594 } else {
1595 s1 = "";
1596 l1 = 0;
1597
1598 s2 = log_buf + end - chars;
1599 l2 = chars;
1600 }
1601
1602 rcu_read_lock();
1603 list_for_each_entry_rcu(dumper, &dump_list, list)
1604 dumper->dump(dumper, reason, s1, l1, s2, l2);
1605 rcu_read_unlock();
1606}
1607#endif
1608