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
37#include <asm/uaccess.h>
38
39
40
41
42#define for_each_console(con) \
43 for (con = console_drivers; con != NULL; con = con->next)
44
45
46
47
48void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
49{
50}
51
52#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
53
54
55#define DEFAULT_MESSAGE_LOGLEVEL 4
56
57
58#define MINIMUM_CONSOLE_LOGLEVEL 1
59#define DEFAULT_CONSOLE_LOGLEVEL 7
60
61DECLARE_WAIT_QUEUE_HEAD(log_wait);
62
63int console_printk[4] = {
64 DEFAULT_CONSOLE_LOGLEVEL,
65 DEFAULT_MESSAGE_LOGLEVEL,
66 MINIMUM_CONSOLE_LOGLEVEL,
67 DEFAULT_CONSOLE_LOGLEVEL,
68};
69
70static int saved_console_loglevel = -1;
71
72
73
74
75
76int oops_in_progress;
77EXPORT_SYMBOL(oops_in_progress);
78
79
80
81
82
83
84static DECLARE_MUTEX(console_sem);
85struct console *console_drivers;
86EXPORT_SYMBOL_GPL(console_drivers);
87
88
89
90
91
92
93
94
95
96static int console_locked, console_suspended;
97
98
99
100
101
102
103static DEFINE_SPINLOCK(logbuf_lock);
104
105#define LOG_BUF_MASK (log_buf_len-1)
106#define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
107
108
109
110
111
112static unsigned log_start;
113static unsigned con_start;
114static unsigned log_end;
115
116
117
118
119struct console_cmdline
120{
121 char name[8];
122 int index;
123 char *options;
124#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
125 char *brl_options;
126#endif
127};
128
129#define MAX_CMDLINECONSOLES 8
130
131static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
132static int selected_console = -1;
133static int preferred_console = -1;
134int console_set_on_cmdline;
135EXPORT_SYMBOL(console_set_on_cmdline);
136
137
138static int console_may_schedule;
139
140#ifdef CONFIG_PRINTK
141
142static char __log_buf[__LOG_BUF_LEN];
143static char *log_buf = __log_buf;
144static int log_buf_len = __LOG_BUF_LEN;
145static unsigned logged_chars;
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 unsigned 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
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274int do_syslog(int type, char __user *buf, int len)
275{
276 unsigned i, j, limit, count;
277 int do_clear = 0;
278 char c;
279 int error = 0;
280
281 error = security_syslog(type);
282 if (error)
283 return error;
284
285 switch (type) {
286 case 0:
287 break;
288 case 1:
289 break;
290 case 2:
291 error = -EINVAL;
292 if (!buf || len < 0)
293 goto out;
294 error = 0;
295 if (!len)
296 goto out;
297 if (!access_ok(VERIFY_WRITE, buf, len)) {
298 error = -EFAULT;
299 goto out;
300 }
301 error = wait_event_interruptible(log_wait,
302 (log_start - log_end));
303 if (error)
304 goto out;
305 i = 0;
306 spin_lock_irq(&logbuf_lock);
307 while (!error && (log_start != log_end) && i < len) {
308 c = LOG_BUF(log_start);
309 log_start++;
310 spin_unlock_irq(&logbuf_lock);
311 error = __put_user(c,buf);
312 buf++;
313 i++;
314 cond_resched();
315 spin_lock_irq(&logbuf_lock);
316 }
317 spin_unlock_irq(&logbuf_lock);
318 if (!error)
319 error = i;
320 break;
321 case 4:
322 do_clear = 1;
323
324 case 3:
325 error = -EINVAL;
326 if (!buf || len < 0)
327 goto out;
328 error = 0;
329 if (!len)
330 goto out;
331 if (!access_ok(VERIFY_WRITE, buf, len)) {
332 error = -EFAULT;
333 goto out;
334 }
335 count = len;
336 if (count > log_buf_len)
337 count = log_buf_len;
338 spin_lock_irq(&logbuf_lock);
339 if (count > logged_chars)
340 count = logged_chars;
341 if (do_clear)
342 logged_chars = 0;
343 limit = log_end;
344
345
346
347
348
349
350 for (i = 0; i < count && !error; i++) {
351 j = limit-1-i;
352 if (j + log_buf_len < log_end)
353 break;
354 c = LOG_BUF(j);
355 spin_unlock_irq(&logbuf_lock);
356 error = __put_user(c,&buf[count-1-i]);
357 cond_resched();
358 spin_lock_irq(&logbuf_lock);
359 }
360 spin_unlock_irq(&logbuf_lock);
361 if (error)
362 break;
363 error = i;
364 if (i != count) {
365 int offset = count-error;
366
367 for (i = 0; i < error; i++) {
368 if (__get_user(c,&buf[i+offset]) ||
369 __put_user(c,&buf[i])) {
370 error = -EFAULT;
371 break;
372 }
373 cond_resched();
374 }
375 }
376 break;
377 case 5:
378 logged_chars = 0;
379 break;
380 case 6:
381 if (saved_console_loglevel == -1)
382 saved_console_loglevel = console_loglevel;
383 console_loglevel = minimum_console_loglevel;
384 break;
385 case 7:
386 if (saved_console_loglevel != -1) {
387 console_loglevel = saved_console_loglevel;
388 saved_console_loglevel = -1;
389 }
390 break;
391 case 8:
392 error = -EINVAL;
393 if (len < 1 || len > 8)
394 goto out;
395 if (len < minimum_console_loglevel)
396 len = minimum_console_loglevel;
397 console_loglevel = len;
398
399 saved_console_loglevel = -1;
400 error = 0;
401 break;
402 case 9:
403 error = log_end - log_start;
404 break;
405 case 10:
406 error = log_buf_len;
407 break;
408 default:
409 error = -EINVAL;
410 break;
411 }
412out:
413 return error;
414}
415
416SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
417{
418 return do_syslog(type, buf, len);
419}
420
421
422
423
424static void __call_console_drivers(unsigned start, unsigned end)
425{
426 struct console *con;
427
428 for_each_console(con) {
429 if ((con->flags & CON_ENABLED) && con->write &&
430 (cpu_online(smp_processor_id()) ||
431 (con->flags & CON_ANYTIME)))
432 con->write(con, &LOG_BUF(start), end - start);
433 }
434}
435
436static int __read_mostly ignore_loglevel;
437
438static int __init ignore_loglevel_setup(char *str)
439{
440 ignore_loglevel = 1;
441 printk(KERN_INFO "debug: ignoring loglevel setting.\n");
442
443 return 0;
444}
445
446early_param("ignore_loglevel", ignore_loglevel_setup);
447
448
449
450
451static void _call_console_drivers(unsigned start,
452 unsigned end, int msg_log_level)
453{
454 if ((msg_log_level < console_loglevel || ignore_loglevel) &&
455 console_drivers && start != end) {
456 if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
457
458 __call_console_drivers(start & LOG_BUF_MASK,
459 log_buf_len);
460 __call_console_drivers(0, end & LOG_BUF_MASK);
461 } else {
462 __call_console_drivers(start, end);
463 }
464 }
465}
466
467
468
469
470
471
472static void call_console_drivers(unsigned start, unsigned end)
473{
474 unsigned cur_index, start_print;
475 static int msg_level = -1;
476
477 BUG_ON(((int)(start - end)) > 0);
478
479 cur_index = start;
480 start_print = start;
481 while (cur_index != end) {
482 if (msg_level < 0 && ((end - cur_index) > 2) &&
483 LOG_BUF(cur_index + 0) == '<' &&
484 LOG_BUF(cur_index + 1) >= '0' &&
485 LOG_BUF(cur_index + 1) <= '7' &&
486 LOG_BUF(cur_index + 2) == '>') {
487 msg_level = LOG_BUF(cur_index + 1) - '0';
488 cur_index += 3;
489 start_print = cur_index;
490 }
491 while (cur_index != end) {
492 char c = LOG_BUF(cur_index);
493
494 cur_index++;
495 if (c == '\n') {
496 if (msg_level < 0) {
497
498
499
500
501
502
503 msg_level = default_message_loglevel;
504 }
505 _call_console_drivers(start_print, cur_index, msg_level);
506 msg_level = -1;
507 start_print = cur_index;
508 break;
509 }
510 }
511 }
512 _call_console_drivers(start_print, end, msg_level);
513}
514
515static void emit_log_char(char c)
516{
517 LOG_BUF(log_end) = c;
518 log_end++;
519 if (log_end - log_start > log_buf_len)
520 log_start = log_end - log_buf_len;
521 if (log_end - con_start > log_buf_len)
522 con_start = log_end - log_buf_len;
523 if (logged_chars < log_buf_len)
524 logged_chars++;
525}
526
527
528
529
530
531
532static void zap_locks(void)
533{
534 static unsigned long oops_timestamp;
535
536 if (time_after_eq(jiffies, oops_timestamp) &&
537 !time_after(jiffies, oops_timestamp + 30 * HZ))
538 return;
539
540 oops_timestamp = jiffies;
541
542
543 spin_lock_init(&logbuf_lock);
544
545 init_MUTEX(&console_sem);
546}
547
548#if defined(CONFIG_PRINTK_TIME)
549static int printk_time = 1;
550#else
551static int printk_time = 0;
552#endif
553module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
554
555
556static int have_callable_console(void)
557{
558 struct console *con;
559
560 for_each_console(con)
561 if (con->flags & CON_ANYTIME)
562 return 1;
563
564 return 0;
565}
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589asmlinkage int printk(const char *fmt, ...)
590{
591 va_list args;
592 int r;
593
594 va_start(args, fmt);
595 r = vprintk(fmt, args);
596 va_end(args);
597
598 return r;
599}
600
601
602static volatile unsigned int printk_cpu = UINT_MAX;
603
604
605
606
607
608
609
610
611
612static inline int can_use_console(unsigned int cpu)
613{
614 return cpu_online(cpu) || have_callable_console();
615}
616
617
618
619
620
621
622
623
624
625
626
627static int acquire_console_semaphore_for_printk(unsigned int cpu)
628{
629 int retval = 0;
630
631 if (!try_acquire_console_sem()) {
632 retval = 1;
633
634
635
636
637
638
639
640 if (!can_use_console(cpu)) {
641 console_locked = 0;
642 up(&console_sem);
643 retval = 0;
644 }
645 }
646 printk_cpu = UINT_MAX;
647 spin_unlock(&logbuf_lock);
648 return retval;
649}
650static const char recursion_bug_msg [] =
651 KERN_CRIT "BUG: recent printk recursion!\n";
652static int recursion_bug;
653static int new_text_line = 1;
654static char printk_buf[1024];
655
656int printk_delay_msec __read_mostly;
657
658static inline void printk_delay(void)
659{
660 if (unlikely(printk_delay_msec)) {
661 int m = printk_delay_msec;
662
663 while (m--) {
664 mdelay(1);
665 touch_nmi_watchdog();
666 }
667 }
668}
669
670asmlinkage int vprintk(const char *fmt, va_list args)
671{
672 int printed_len = 0;
673 int current_log_level = default_message_loglevel;
674 unsigned long flags;
675 int this_cpu;
676 char *p;
677
678 boot_delay_msec();
679 printk_delay();
680
681 preempt_disable();
682
683 raw_local_irq_save(flags);
684 this_cpu = smp_processor_id();
685
686
687
688
689 if (unlikely(printk_cpu == this_cpu)) {
690
691
692
693
694
695
696
697 if (!oops_in_progress) {
698 recursion_bug = 1;
699 goto out_restore_irqs;
700 }
701 zap_locks();
702 }
703
704 lockdep_off();
705 spin_lock(&logbuf_lock);
706 printk_cpu = this_cpu;
707
708 if (recursion_bug) {
709 recursion_bug = 0;
710 strcpy(printk_buf, recursion_bug_msg);
711 printed_len = strlen(recursion_bug_msg);
712 }
713
714 printed_len += vscnprintf(printk_buf + printed_len,
715 sizeof(printk_buf) - printed_len, fmt, args);
716
717
718 p = printk_buf;
719
720
721 if (p[0] == '<') {
722 unsigned char c = p[1];
723 if (c && p[2] == '>') {
724 switch (c) {
725 case '0' ... '7':
726 current_log_level = c - '0';
727
728 case 'd':
729 if (!new_text_line) {
730 emit_log_char('\n');
731 new_text_line = 1;
732 }
733
734 case 'c':
735 p += 3;
736 break;
737 }
738 }
739 }
740
741
742
743
744
745 for ( ; *p; p++) {
746 if (new_text_line) {
747
748 emit_log_char('<');
749 emit_log_char(current_log_level + '0');
750 emit_log_char('>');
751 printed_len += 3;
752 new_text_line = 0;
753
754 if (printk_time) {
755
756 char tbuf[50], *tp;
757 unsigned tlen;
758 unsigned long long t;
759 unsigned long nanosec_rem;
760
761 t = cpu_clock(printk_cpu);
762 nanosec_rem = do_div(t, 1000000000);
763 tlen = sprintf(tbuf, "[%5lu.%06lu] ",
764 (unsigned long) t,
765 nanosec_rem / 1000);
766
767 for (tp = tbuf; tp < tbuf + tlen; tp++)
768 emit_log_char(*tp);
769 printed_len += tlen;
770 }
771
772 if (!*p)
773 break;
774 }
775
776 emit_log_char(*p);
777 if (*p == '\n')
778 new_text_line = 1;
779 }
780
781
782
783
784
785
786
787
788
789
790
791 if (acquire_console_semaphore_for_printk(this_cpu))
792 release_console_sem();
793
794 lockdep_on();
795out_restore_irqs:
796 raw_local_irq_restore(flags);
797
798 preempt_enable();
799 return printed_len;
800}
801EXPORT_SYMBOL(printk);
802EXPORT_SYMBOL(vprintk);
803
804#else
805
806static void call_console_drivers(unsigned start, unsigned end)
807{
808}
809
810#endif
811
812static int __add_preferred_console(char *name, int idx, char *options,
813 char *brl_options)
814{
815 struct console_cmdline *c;
816 int i;
817
818
819
820
821
822 for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
823 if (strcmp(console_cmdline[i].name, name) == 0 &&
824 console_cmdline[i].index == idx) {
825 if (!brl_options)
826 selected_console = i;
827 return 0;
828 }
829 if (i == MAX_CMDLINECONSOLES)
830 return -E2BIG;
831 if (!brl_options)
832 selected_console = i;
833 c = &console_cmdline[i];
834 strlcpy(c->name, name, sizeof(c->name));
835 c->options = options;
836#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
837 c->brl_options = brl_options;
838#endif
839 c->index = idx;
840 return 0;
841}
842
843
844
845static int __init console_setup(char *str)
846{
847 char buf[sizeof(console_cmdline[0].name) + 4];
848 char *s, *options, *brl_options = NULL;
849 int idx;
850
851#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
852 if (!memcmp(str, "brl,", 4)) {
853 brl_options = "";
854 str += 4;
855 } else if (!memcmp(str, "brl=", 4)) {
856 brl_options = str + 4;
857 str = strchr(brl_options, ',');
858 if (!str) {
859 printk(KERN_ERR "need port name after brl=\n");
860 return 1;
861 }
862 *(str++) = 0;
863 }
864#endif
865
866
867
868
869 if (str[0] >= '0' && str[0] <= '9') {
870 strcpy(buf, "ttyS");
871 strncpy(buf + 4, str, sizeof(buf) - 5);
872 } else {
873 strncpy(buf, str, sizeof(buf) - 1);
874 }
875 buf[sizeof(buf) - 1] = 0;
876 if ((options = strchr(str, ',')) != NULL)
877 *(options++) = 0;
878#ifdef __sparc__
879 if (!strcmp(str, "ttya"))
880 strcpy(buf, "ttyS0");
881 if (!strcmp(str, "ttyb"))
882 strcpy(buf, "ttyS1");
883#endif
884 for (s = buf; *s; s++)
885 if ((*s >= '0' && *s <= '9') || *s == ',')
886 break;
887 idx = simple_strtoul(s, NULL, 10);
888 *s = 0;
889
890 __add_preferred_console(buf, idx, options, brl_options);
891 console_set_on_cmdline = 1;
892 return 1;
893}
894__setup("console=", console_setup);
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909int add_preferred_console(char *name, int idx, char *options)
910{
911 return __add_preferred_console(name, idx, options, NULL);
912}
913
914int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
915{
916 struct console_cmdline *c;
917 int i;
918
919 for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
920 if (strcmp(console_cmdline[i].name, name) == 0 &&
921 console_cmdline[i].index == idx) {
922 c = &console_cmdline[i];
923 strlcpy(c->name, name_new, sizeof(c->name));
924 c->name[sizeof(c->name) - 1] = 0;
925 c->options = options;
926 c->index = idx_new;
927 return i;
928 }
929
930 return -1;
931}
932
933int console_suspend_enabled = 1;
934EXPORT_SYMBOL(console_suspend_enabled);
935
936static int __init console_suspend_disable(char *str)
937{
938 console_suspend_enabled = 0;
939 return 1;
940}
941__setup("no_console_suspend", console_suspend_disable);
942
943
944
945
946
947
948void suspend_console(void)
949{
950 if (!console_suspend_enabled)
951 return;
952 printk("Suspending console(s) (use no_console_suspend to debug)\n");
953 acquire_console_sem();
954 console_suspended = 1;
955 up(&console_sem);
956}
957
958void resume_console(void)
959{
960 if (!console_suspend_enabled)
961 return;
962 down(&console_sem);
963 console_suspended = 0;
964 release_console_sem();
965}
966
967
968
969
970
971
972
973
974
975void acquire_console_sem(void)
976{
977 BUG_ON(in_interrupt());
978 down(&console_sem);
979 if (console_suspended)
980 return;
981 console_locked = 1;
982 console_may_schedule = 1;
983}
984EXPORT_SYMBOL(acquire_console_sem);
985
986int try_acquire_console_sem(void)
987{
988 if (down_trylock(&console_sem))
989 return -1;
990 if (console_suspended) {
991 up(&console_sem);
992 return -1;
993 }
994 console_locked = 1;
995 console_may_schedule = 0;
996 return 0;
997}
998EXPORT_SYMBOL(try_acquire_console_sem);
999
1000int is_console_locked(void)
1001{
1002 return console_locked;
1003}
1004
1005static DEFINE_PER_CPU(int, printk_pending);
1006
1007void printk_tick(void)
1008{
1009 if (__get_cpu_var(printk_pending)) {
1010 __get_cpu_var(printk_pending) = 0;
1011 wake_up_interruptible(&log_wait);
1012 }
1013}
1014
1015int printk_needs_cpu(int cpu)
1016{
1017 return per_cpu(printk_pending, cpu);
1018}
1019
1020void wake_up_klogd(void)
1021{
1022 if (waitqueue_active(&log_wait))
1023 __raw_get_cpu_var(printk_pending) = 1;
1024}
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040void release_console_sem(void)
1041{
1042 unsigned long flags;
1043 unsigned _con_start, _log_end;
1044 unsigned wake_klogd = 0;
1045
1046 if (console_suspended) {
1047 up(&console_sem);
1048 return;
1049 }
1050
1051 console_may_schedule = 0;
1052
1053 for ( ; ; ) {
1054 spin_lock_irqsave(&logbuf_lock, flags);
1055 wake_klogd |= log_start - log_end;
1056 if (con_start == log_end)
1057 break;
1058 _con_start = con_start;
1059 _log_end = log_end;
1060 con_start = log_end;
1061 spin_unlock(&logbuf_lock);
1062 stop_critical_timings();
1063 call_console_drivers(_con_start, _log_end);
1064 start_critical_timings();
1065 local_irq_restore(flags);
1066 }
1067 console_locked = 0;
1068 up(&console_sem);
1069 spin_unlock_irqrestore(&logbuf_lock, flags);
1070 if (wake_klogd)
1071 wake_up_klogd();
1072}
1073EXPORT_SYMBOL(release_console_sem);
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084void __sched console_conditional_schedule(void)
1085{
1086 if (console_may_schedule)
1087 cond_resched();
1088}
1089EXPORT_SYMBOL(console_conditional_schedule);
1090
1091void console_unblank(void)
1092{
1093 struct console *c;
1094
1095
1096
1097
1098
1099 if (oops_in_progress) {
1100 if (down_trylock(&console_sem) != 0)
1101 return;
1102 } else
1103 acquire_console_sem();
1104
1105 console_locked = 1;
1106 console_may_schedule = 0;
1107 for_each_console(c)
1108 if ((c->flags & CON_ENABLED) && c->unblank)
1109 c->unblank();
1110 release_console_sem();
1111}
1112
1113
1114
1115
1116struct tty_driver *console_device(int *index)
1117{
1118 struct console *c;
1119 struct tty_driver *driver = NULL;
1120
1121 acquire_console_sem();
1122 for_each_console(c) {
1123 if (!c->device)
1124 continue;
1125 driver = c->device(c, index);
1126 if (driver)
1127 break;
1128 }
1129 release_console_sem();
1130 return driver;
1131}
1132
1133
1134
1135
1136
1137
1138void console_stop(struct console *console)
1139{
1140 acquire_console_sem();
1141 console->flags &= ~CON_ENABLED;
1142 release_console_sem();
1143}
1144EXPORT_SYMBOL(console_stop);
1145
1146void console_start(struct console *console)
1147{
1148 acquire_console_sem();
1149 console->flags |= CON_ENABLED;
1150 release_console_sem();
1151}
1152EXPORT_SYMBOL(console_start);
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173void register_console(struct console *newcon)
1174{
1175 int i;
1176 unsigned long flags;
1177 struct console *bcon = NULL;
1178
1179
1180
1181
1182
1183 if (console_drivers && newcon->flags & CON_BOOT) {
1184
1185 for_each_console(bcon) {
1186 if (!(bcon->flags & CON_BOOT)) {
1187 printk(KERN_INFO "Too late to register bootconsole %s%d\n",
1188 newcon->name, newcon->index);
1189 return;
1190 }
1191 }
1192 }
1193
1194 if (console_drivers && console_drivers->flags & CON_BOOT)
1195 bcon = console_drivers;
1196
1197 if (preferred_console < 0 || bcon || !console_drivers)
1198 preferred_console = selected_console;
1199
1200 if (newcon->early_setup)
1201 newcon->early_setup();
1202
1203
1204
1205
1206
1207
1208 if (preferred_console < 0) {
1209 if (newcon->index < 0)
1210 newcon->index = 0;
1211 if (newcon->setup == NULL ||
1212 newcon->setup(newcon, NULL) == 0) {
1213 newcon->flags |= CON_ENABLED;
1214 if (newcon->device) {
1215 newcon->flags |= CON_CONSDEV;
1216 preferred_console = 0;
1217 }
1218 }
1219 }
1220
1221
1222
1223
1224
1225 for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
1226 i++) {
1227 if (strcmp(console_cmdline[i].name, newcon->name) != 0)
1228 continue;
1229 if (newcon->index >= 0 &&
1230 newcon->index != console_cmdline[i].index)
1231 continue;
1232 if (newcon->index < 0)
1233 newcon->index = console_cmdline[i].index;
1234#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1235 if (console_cmdline[i].brl_options) {
1236 newcon->flags |= CON_BRL;
1237 braille_register_console(newcon,
1238 console_cmdline[i].index,
1239 console_cmdline[i].options,
1240 console_cmdline[i].brl_options);
1241 return;
1242 }
1243#endif
1244 if (newcon->setup &&
1245 newcon->setup(newcon, console_cmdline[i].options) != 0)
1246 break;
1247 newcon->flags |= CON_ENABLED;
1248 newcon->index = console_cmdline[i].index;
1249 if (i == selected_console) {
1250 newcon->flags |= CON_CONSDEV;
1251 preferred_console = selected_console;
1252 }
1253 break;
1254 }
1255
1256 if (!(newcon->flags & CON_ENABLED))
1257 return;
1258
1259
1260
1261
1262
1263
1264
1265 if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
1266 newcon->flags &= ~CON_PRINTBUFFER;
1267
1268
1269
1270
1271
1272 acquire_console_sem();
1273 if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
1274 newcon->next = console_drivers;
1275 console_drivers = newcon;
1276 if (newcon->next)
1277 newcon->next->flags &= ~CON_CONSDEV;
1278 } else {
1279 newcon->next = console_drivers->next;
1280 console_drivers->next = newcon;
1281 }
1282 if (newcon->flags & CON_PRINTBUFFER) {
1283
1284
1285
1286
1287 spin_lock_irqsave(&logbuf_lock, flags);
1288 con_start = log_start;
1289 spin_unlock_irqrestore(&logbuf_lock, flags);
1290 }
1291 release_console_sem();
1292
1293
1294
1295
1296
1297
1298
1299
1300 if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV)) {
1301
1302
1303
1304 printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
1305 newcon->name, newcon->index);
1306 for_each_console(bcon)
1307 if (bcon->flags & CON_BOOT)
1308 unregister_console(bcon);
1309 } else {
1310 printk(KERN_INFO "%sconsole [%s%d] enabled\n",
1311 (newcon->flags & CON_BOOT) ? "boot" : "" ,
1312 newcon->name, newcon->index);
1313 }
1314}
1315EXPORT_SYMBOL(register_console);
1316
1317int unregister_console(struct console *console)
1318{
1319 struct console *a, *b;
1320 int res = 1;
1321
1322#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1323 if (console->flags & CON_BRL)
1324 return braille_unregister_console(console);
1325#endif
1326
1327 acquire_console_sem();
1328 if (console_drivers == console) {
1329 console_drivers=console->next;
1330 res = 0;
1331 } else if (console_drivers) {
1332 for (a=console_drivers->next, b=console_drivers ;
1333 a; b=a, a=b->next) {
1334 if (a == console) {
1335 b->next = a->next;
1336 res = 0;
1337 break;
1338 }
1339 }
1340 }
1341
1342
1343
1344
1345
1346 if (console_drivers != NULL && console->flags & CON_CONSDEV)
1347 console_drivers->flags |= CON_CONSDEV;
1348
1349 release_console_sem();
1350 return res;
1351}
1352EXPORT_SYMBOL(unregister_console);
1353
1354static int __init disable_boot_consoles(void)
1355{
1356 struct console *con;
1357
1358 for_each_console(con) {
1359 if (con->flags & CON_BOOT) {
1360 printk(KERN_INFO "turn off boot console %s%d\n",
1361 con->name, con->index);
1362 unregister_console(con);
1363 }
1364 }
1365 return 0;
1366}
1367late_initcall(disable_boot_consoles);
1368
1369#if defined CONFIG_PRINTK
1370
1371
1372
1373
1374
1375
1376
1377DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
1378
1379int printk_ratelimit(void)
1380{
1381 return __ratelimit(&printk_ratelimit_state);
1382}
1383EXPORT_SYMBOL(printk_ratelimit);
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394bool printk_timed_ratelimit(unsigned long *caller_jiffies,
1395 unsigned int interval_msecs)
1396{
1397 if (*caller_jiffies == 0
1398 || !time_in_range(jiffies, *caller_jiffies,
1399 *caller_jiffies
1400 + msecs_to_jiffies(interval_msecs))) {
1401 *caller_jiffies = jiffies;
1402 return true;
1403 }
1404 return false;
1405}
1406EXPORT_SYMBOL(printk_timed_ratelimit);
1407#endif
1408