2 * linux/kernel/printk.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * Modified to make sys_syslog() more flexible: added commands to
7 * return the last 4k of kernel messages, regardless of whether
8 * they've been read or not. Added option to suppress kernel printk's
9 * to the console. Added hook for sending the console messages
10 * elsewhere, in preparation for a serial line console (someday).
12 * Modified for sysctl support, 1/8/97, Chris Horn.
13 * Fixed SMP synchronization, 08/08/99, Manfred Spraul
14 * manfred@colorfullife.com
15 * Rewrote bits to get rid of console_lock
16 * 01Mar01 Andrew Morton
19 #include <linux/kernel.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> /* For in_interrupt() */
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>
43 #include <asm/uaccess.h>
46 * Architectures can override it:
48 void asmlinkage
__attribute__((weak
)) early_printk(const char *fmt
, ...)
52 #define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
54 /* printk's without a loglevel use this.. */
55 #define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
57 /* We show everything that is MORE important than this.. */
58 #define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
59 #define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
61 DECLARE_WAIT_QUEUE_HEAD(log_wait
);
63 int console_printk
[4] = {
64 DEFAULT_CONSOLE_LOGLEVEL
, /* console_loglevel */
65 DEFAULT_MESSAGE_LOGLEVEL
, /* default_message_loglevel */
66 MINIMUM_CONSOLE_LOGLEVEL
, /* minimum_console_loglevel */
67 DEFAULT_CONSOLE_LOGLEVEL
, /* default_console_loglevel */
71 * Low level drivers may need that to know if they can schedule in
72 * their unblank() callback or not. So let's export it.
75 EXPORT_SYMBOL(oops_in_progress
);
78 * console_sem protects the console_drivers list, and also
79 * provides serialisation for access to the entire console
82 static DEFINE_SEMAPHORE(console_sem
);
83 struct console
*console_drivers
;
84 EXPORT_SYMBOL_GPL(console_drivers
);
87 * This is used for debugging the mess that is the VT code by
88 * keeping track if we have the console semaphore held. It's
89 * definitely not the perfect debug tool (we don't know if _WE_
90 * hold it are racing, but it helps tracking those weird code
91 * path in the console code where we end up in places I want
92 * locked without the console sempahore held
94 static int console_locked
, console_suspended
;
97 * logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
98 * It is also used in interesting ways to provide interlocking in
99 * release_console_sem().
101 static DEFINE_SPINLOCK(logbuf_lock
);
103 #define LOG_BUF_MASK (log_buf_len-1)
104 #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
107 * The indices into log_buf are not constrained to log_buf_len - they
108 * must be masked before subscripting
110 static unsigned log_start
; /* Index into log_buf: next char to be read by syslog() */
111 static unsigned con_start
; /* Index into log_buf: next char to be sent to consoles */
112 static unsigned log_end
; /* Index into log_buf: most-recently-written-char + 1 */
115 * Array of consoles built from command line options (console=)
117 struct console_cmdline
119 char name
[8]; /* Name of the driver */
120 int index
; /* Minor dev. to use */
121 char *options
; /* Options for the driver */
122 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
123 char *brl_options
; /* Options for braille driver */
127 #define MAX_CMDLINECONSOLES 8
129 static struct console_cmdline console_cmdline
[MAX_CMDLINECONSOLES
];
130 static int selected_console
= -1;
131 static int preferred_console
= -1;
132 int console_set_on_cmdline
;
133 EXPORT_SYMBOL(console_set_on_cmdline
);
135 /* Flag: console code may call schedule() */
136 static int console_may_schedule
;
140 static char __log_buf
[__LOG_BUF_LEN
];
141 static char *log_buf
= __log_buf
;
142 static int log_buf_len
= __LOG_BUF_LEN
;
143 static unsigned logged_chars
; /* Number of chars produced since last read+clear operation */
144 static int saved_console_loglevel
= -1;
148 * This appends the listed symbols to /proc/vmcoreinfo
150 * /proc/vmcoreinfo is used by various utiilties, like crash and makedumpfile to
151 * obtain access to symbols that are otherwise very difficult to locate. These
152 * symbols are specifically used so that utilities can access and extract the
153 * dmesg log from a vmcore file after a crash.
155 void log_buf_kexec_setup(void)
157 VMCOREINFO_SYMBOL(log_buf
);
158 VMCOREINFO_SYMBOL(log_end
);
159 VMCOREINFO_SYMBOL(log_buf_len
);
160 VMCOREINFO_SYMBOL(logged_chars
);
164 static int __init
log_buf_len_setup(char *str
)
166 unsigned size
= memparse(str
, &str
);
170 size
= roundup_pow_of_two(size
);
171 if (size
> log_buf_len
) {
172 unsigned start
, dest_idx
, offset
;
175 new_log_buf
= alloc_bootmem(size
);
177 printk(KERN_WARNING
"log_buf_len: allocation failed\n");
181 spin_lock_irqsave(&logbuf_lock
, flags
);
183 log_buf
= new_log_buf
;
185 offset
= start
= min(con_start
, log_start
);
187 while (start
!= log_end
) {
188 log_buf
[dest_idx
] = __log_buf
[start
& (__LOG_BUF_LEN
- 1)];
195 spin_unlock_irqrestore(&logbuf_lock
, flags
);
197 printk(KERN_NOTICE
"log_buf_len: %d\n", log_buf_len
);
203 __setup("log_buf_len=", log_buf_len_setup
);
205 #ifdef CONFIG_BOOT_PRINTK_DELAY
207 static int boot_delay
; /* msecs delay after each printk during bootup */
208 static unsigned long long loops_per_msec
; /* based on boot_delay */
210 static int __init
boot_delay_setup(char *str
)
214 lpj
= preset_lpj
? preset_lpj
: 1000000; /* some guess */
215 loops_per_msec
= (unsigned long long)lpj
/ 1000 * HZ
;
217 get_option(&str
, &boot_delay
);
218 if (boot_delay
> 10 * 1000)
221 pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
222 "HZ: %d, loops_per_msec: %llu\n",
223 boot_delay
, preset_lpj
, lpj
, HZ
, loops_per_msec
);
226 __setup("boot_delay=", boot_delay_setup
);
228 static void boot_delay_msec(void)
230 unsigned long long k
;
231 unsigned long timeout
;
233 if (boot_delay
== 0 || system_state
!= SYSTEM_BOOTING
)
236 k
= (unsigned long long)loops_per_msec
* boot_delay
;
238 timeout
= jiffies
+ msecs_to_jiffies(boot_delay
);
243 * use (volatile) jiffies to prevent
244 * compiler reduction; loop termination via jiffies
245 * is secondary and may or may not happen.
247 if (time_after(jiffies
, timeout
))
249 touch_nmi_watchdog();
253 static inline void boot_delay_msec(void)
258 #ifdef CONFIG_SECURITY_DMESG_RESTRICT
259 int dmesg_restrict
= 1;
264 int do_syslog(int type
, char __user
*buf
, int len
, bool from_file
)
266 unsigned i
, j
, limit
, count
;
272 * If this is from /proc/kmsg we only do the capabilities checks
275 if (type
== SYSLOG_ACTION_OPEN
|| !from_file
) {
276 if (dmesg_restrict
&& !capable(CAP_SYSLOG
))
277 goto warn
; /* switch to return -EPERM after 2.6.39 */
278 if ((type
!= SYSLOG_ACTION_READ_ALL
&&
279 type
!= SYSLOG_ACTION_SIZE_BUFFER
) &&
280 !capable(CAP_SYSLOG
))
281 goto warn
; /* switch to return -EPERM after 2.6.39 */
284 error
= security_syslog(type
);
289 case SYSLOG_ACTION_CLOSE
: /* Close log */
291 case SYSLOG_ACTION_OPEN
: /* Open log */
293 case SYSLOG_ACTION_READ
: /* Read from log */
300 if (!access_ok(VERIFY_WRITE
, buf
, len
)) {
304 error
= wait_event_interruptible(log_wait
,
305 (log_start
- log_end
));
309 spin_lock_irq(&logbuf_lock
);
310 while (!error
&& (log_start
!= log_end
) && i
< len
) {
311 c
= LOG_BUF(log_start
);
313 spin_unlock_irq(&logbuf_lock
);
314 error
= __put_user(c
,buf
);
318 spin_lock_irq(&logbuf_lock
);
320 spin_unlock_irq(&logbuf_lock
);
324 /* Read/clear last kernel messages */
325 case SYSLOG_ACTION_READ_CLEAR
:
328 /* Read last kernel messages */
329 case SYSLOG_ACTION_READ_ALL
:
336 if (!access_ok(VERIFY_WRITE
, buf
, len
)) {
341 if (count
> log_buf_len
)
343 spin_lock_irq(&logbuf_lock
);
344 if (count
> logged_chars
)
345 count
= logged_chars
;
350 * __put_user() could sleep, and while we sleep
351 * printk() could overwrite the messages
352 * we try to copy to user space. Therefore
353 * the messages are copied in reverse. <manfreds>
355 for (i
= 0; i
< count
&& !error
; i
++) {
357 if (j
+ log_buf_len
< log_end
)
360 spin_unlock_irq(&logbuf_lock
);
361 error
= __put_user(c
,&buf
[count
-1-i
]);
363 spin_lock_irq(&logbuf_lock
);
365 spin_unlock_irq(&logbuf_lock
);
370 int offset
= count
-error
;
371 /* buffer overflow during copy, correct user buffer. */
372 for (i
= 0; i
< error
; i
++) {
373 if (__get_user(c
,&buf
[i
+offset
]) ||
374 __put_user(c
,&buf
[i
])) {
382 /* Clear ring buffer */
383 case SYSLOG_ACTION_CLEAR
:
386 /* Disable logging to console */
387 case SYSLOG_ACTION_CONSOLE_OFF
:
388 if (saved_console_loglevel
== -1)
389 saved_console_loglevel
= console_loglevel
;
390 console_loglevel
= minimum_console_loglevel
;
392 /* Enable logging to console */
393 case SYSLOG_ACTION_CONSOLE_ON
:
394 if (saved_console_loglevel
!= -1) {
395 console_loglevel
= saved_console_loglevel
;
396 saved_console_loglevel
= -1;
399 /* Set level of messages printed to console */
400 case SYSLOG_ACTION_CONSOLE_LEVEL
:
402 if (len
< 1 || len
> 8)
404 if (len
< minimum_console_loglevel
)
405 len
= minimum_console_loglevel
;
406 console_loglevel
= len
;
407 /* Implicitly re-enable logging to console */
408 saved_console_loglevel
= -1;
411 /* Number of chars in the log buffer */
412 case SYSLOG_ACTION_SIZE_UNREAD
:
413 error
= log_end
- log_start
;
415 /* Size of the log buffer */
416 case SYSLOG_ACTION_SIZE_BUFFER
:
426 /* remove after 2.6.39 */
427 if (capable(CAP_SYS_ADMIN
))
428 WARN_ONCE(1, "Attempt to access syslog with CAP_SYS_ADMIN "
429 "but no CAP_SYSLOG (deprecated and denied).\n");
433 SYSCALL_DEFINE3(syslog
, int, type
, char __user
*, buf
, int, len
)
435 return do_syslog(type
, buf
, len
, SYSLOG_FROM_CALL
);
438 #ifdef CONFIG_KGDB_KDB
439 /* kdb dmesg command needs access to the syslog buffer. do_syslog()
440 * uses locks so it cannot be used during debugging. Just tell kdb
441 * where the start and end of the physical and logical logs are. This
442 * is equivalent to do_syslog(3).
444 void kdb_syslog_data(char *syslog_data
[4])
446 syslog_data
[0] = log_buf
;
447 syslog_data
[1] = log_buf
+ log_buf_len
;
448 syslog_data
[2] = log_buf
+ log_end
-
449 (logged_chars
< log_buf_len
? logged_chars
: log_buf_len
);
450 syslog_data
[3] = log_buf
+ log_end
;
452 #endif /* CONFIG_KGDB_KDB */
455 * Call the console drivers on a range of log_buf
457 static void __call_console_drivers(unsigned start
, unsigned end
)
461 for_each_console(con
) {
462 if ((con
->flags
& CON_ENABLED
) && con
->write
&&
463 (cpu_online(smp_processor_id()) ||
464 (con
->flags
& CON_ANYTIME
)))
465 con
->write(con
, &LOG_BUF(start
), end
- start
);
469 static int __read_mostly ignore_loglevel
;
471 static int __init
ignore_loglevel_setup(char *str
)
474 printk(KERN_INFO
"debug: ignoring loglevel setting.\n");
479 early_param("ignore_loglevel", ignore_loglevel_setup
);
482 * Write out chars from start to end - 1 inclusive
484 static void _call_console_drivers(unsigned start
,
485 unsigned end
, int msg_log_level
)
487 if ((msg_log_level
< console_loglevel
|| ignore_loglevel
) &&
488 console_drivers
&& start
!= end
) {
489 if ((start
& LOG_BUF_MASK
) > (end
& LOG_BUF_MASK
)) {
491 __call_console_drivers(start
& LOG_BUF_MASK
,
493 __call_console_drivers(0, end
& LOG_BUF_MASK
);
495 __call_console_drivers(start
, end
);
501 * Call the console drivers, asking them to write out
502 * log_buf[start] to log_buf[end - 1].
503 * The console_sem must be held.
505 static void call_console_drivers(unsigned start
, unsigned end
)
507 unsigned cur_index
, start_print
;
508 static int msg_level
= -1;
510 BUG_ON(((int)(start
- end
)) > 0);
514 while (cur_index
!= end
) {
515 if (msg_level
< 0 && ((end
- cur_index
) > 2) &&
516 LOG_BUF(cur_index
+ 0) == '<' &&
517 LOG_BUF(cur_index
+ 1) >= '0' &&
518 LOG_BUF(cur_index
+ 1) <= '7' &&
519 LOG_BUF(cur_index
+ 2) == '>') {
520 msg_level
= LOG_BUF(cur_index
+ 1) - '0';
522 start_print
= cur_index
;
524 while (cur_index
!= end
) {
525 char c
= LOG_BUF(cur_index
);
531 * printk() has already given us loglevel tags in
532 * the buffer. This code is here in case the
533 * log buffer has wrapped right round and scribbled
536 msg_level
= default_message_loglevel
;
538 _call_console_drivers(start_print
, cur_index
, msg_level
);
540 start_print
= cur_index
;
545 _call_console_drivers(start_print
, end
, msg_level
);
548 static void emit_log_char(char c
)
550 LOG_BUF(log_end
) = c
;
552 if (log_end
- log_start
> log_buf_len
)
553 log_start
= log_end
- log_buf_len
;
554 if (log_end
- con_start
> log_buf_len
)
555 con_start
= log_end
- log_buf_len
;
556 if (logged_chars
< log_buf_len
)
561 * Zap console related locks when oopsing. Only zap at most once
562 * every 10 seconds, to leave time for slow consoles to print a
565 static void zap_locks(void)
567 static unsigned long oops_timestamp
;
569 if (time_after_eq(jiffies
, oops_timestamp
) &&
570 !time_after(jiffies
, oops_timestamp
+ 30 * HZ
))
573 oops_timestamp
= jiffies
;
575 /* If a crash is occurring, make sure we can't deadlock */
576 spin_lock_init(&logbuf_lock
);
577 /* And make sure that we print immediately */
578 sema_init(&console_sem
, 1);
581 #if defined(CONFIG_PRINTK_TIME)
582 static int printk_time
= 1;
584 static int printk_time
= 0;
586 module_param_named(time
, printk_time
, bool, S_IRUGO
| S_IWUSR
);
588 /* Check if we have any console registered that can be called early in boot. */
589 static int have_callable_console(void)
593 for_each_console(con
)
594 if (con
->flags
& CON_ANYTIME
)
601 * printk - print a kernel message
602 * @fmt: format string
604 * This is printk(). It can be called from any context. We want it to work.
606 * We try to grab the console_sem. If we succeed, it's easy - we log the output and
607 * call the console drivers. If we fail to get the semaphore we place the output
608 * into the log buffer and return. The current holder of the console_sem will
609 * notice the new output in release_console_sem() and will send it to the
610 * consoles before releasing the semaphore.
612 * One effect of this deferred printing is that code which calls printk() and
613 * then changes console_loglevel may break. This is because console_loglevel
614 * is inspected when the actual printing occurs.
619 * See the vsnprintf() documentation for format string extensions over C99.
622 asmlinkage
int printk(const char *fmt
, ...)
627 #ifdef CONFIG_KGDB_KDB
628 if (unlikely(kdb_trap_printk
)) {
630 r
= vkdb_printf(fmt
, args
);
636 r
= vprintk(fmt
, args
);
642 /* cpu currently holding logbuf_lock */
643 static volatile unsigned int printk_cpu
= UINT_MAX
;
646 * Can we actually use the console at this time on this cpu?
648 * Console drivers may assume that per-cpu resources have
649 * been allocated. So unless they're explicitly marked as
650 * being able to cope (CON_ANYTIME) don't call them until
651 * this CPU is officially up.
653 static inline int can_use_console(unsigned int cpu
)
655 return cpu_online(cpu
) || have_callable_console();
659 * Try to get console ownership to actually show the kernel
660 * messages from a 'printk'. Return true (and with the
661 * console_semaphore held, and 'console_locked' set) if it
662 * is successful, false otherwise.
664 * This gets called with the 'logbuf_lock' spinlock held and
665 * interrupts disabled. It should return with 'lockbuf_lock'
666 * released but interrupts still disabled.
668 static int acquire_console_semaphore_for_printk(unsigned int cpu
)
669 __releases(&logbuf_lock
)
673 if (!try_acquire_console_sem()) {
677 * If we can't use the console, we need to release
678 * the console semaphore by hand to avoid flushing
679 * the buffer. We need to hold the console semaphore
680 * in order to do this test safely.
682 if (!can_use_console(cpu
)) {
688 printk_cpu
= UINT_MAX
;
689 spin_unlock(&logbuf_lock
);
692 static const char recursion_bug_msg
[] =
693 KERN_CRIT
"BUG: recent printk recursion!\n";
694 static int recursion_bug
;
695 static int new_text_line
= 1;
696 static char printk_buf
[1024];
698 int printk_delay_msec __read_mostly
;
700 static inline void printk_delay(void)
702 if (unlikely(printk_delay_msec
)) {
703 int m
= printk_delay_msec
;
707 touch_nmi_watchdog();
712 asmlinkage
int vprintk(const char *fmt
, va_list args
)
715 int current_log_level
= default_message_loglevel
;
724 /* This stops the holder of console_sem just where we want him */
725 raw_local_irq_save(flags
);
726 this_cpu
= smp_processor_id();
729 * Ouch, printk recursed into itself!
731 if (unlikely(printk_cpu
== this_cpu
)) {
733 * If a crash is occurring during printk() on this CPU,
734 * then try to get the crash message out but make sure
735 * we can't deadlock. Otherwise just return to avoid the
736 * recursion and return - but flag the recursion so that
737 * it can be printed at the next appropriate moment:
739 if (!oops_in_progress
) {
741 goto out_restore_irqs
;
747 spin_lock(&logbuf_lock
);
748 printk_cpu
= this_cpu
;
752 strcpy(printk_buf
, recursion_bug_msg
);
753 printed_len
= strlen(recursion_bug_msg
);
755 /* Emit the output into the temporary buffer */
756 printed_len
+= vscnprintf(printk_buf
+ printed_len
,
757 sizeof(printk_buf
) - printed_len
, fmt
, args
);
762 /* Do we have a loglevel in the string? */
764 unsigned char c
= p
[1];
765 if (c
&& p
[2] == '>') {
767 case '0' ... '7': /* loglevel */
768 current_log_level
= c
- '0';
769 /* Fallthrough - make sure we're on a new line */
770 case 'd': /* KERN_DEFAULT */
771 if (!new_text_line
) {
775 /* Fallthrough - skip the loglevel */
776 case 'c': /* KERN_CONT */
784 * Copy the output into log_buf. If the caller didn't provide
785 * appropriate log level tags, we insert them here
789 /* Always output the token */
791 emit_log_char(current_log_level
+ '0');
797 /* Follow the token with the time */
800 unsigned long long t
;
801 unsigned long nanosec_rem
;
803 t
= cpu_clock(printk_cpu
);
804 nanosec_rem
= do_div(t
, 1000000000);
805 tlen
= sprintf(tbuf
, "[%5lu.%06lu] ",
809 for (tp
= tbuf
; tp
< tbuf
+ tlen
; tp
++)
824 * Try to acquire and then immediately release the
825 * console semaphore. The release will do all the
826 * actual magic (print out buffers, wake up klogd,
829 * The acquire_console_semaphore_for_printk() function
830 * will release 'logbuf_lock' regardless of whether it
831 * actually gets the semaphore or not.
833 if (acquire_console_semaphore_for_printk(this_cpu
))
834 release_console_sem();
838 raw_local_irq_restore(flags
);
843 EXPORT_SYMBOL(printk
);
844 EXPORT_SYMBOL(vprintk
);
848 static void call_console_drivers(unsigned start
, unsigned end
)
854 static int __add_preferred_console(char *name
, int idx
, char *options
,
857 struct console_cmdline
*c
;
861 * See if this tty is not yet registered, and
862 * if we have a slot free.
864 for (i
= 0; i
< MAX_CMDLINECONSOLES
&& console_cmdline
[i
].name
[0]; i
++)
865 if (strcmp(console_cmdline
[i
].name
, name
) == 0 &&
866 console_cmdline
[i
].index
== idx
) {
868 selected_console
= i
;
871 if (i
== MAX_CMDLINECONSOLES
)
874 selected_console
= i
;
875 c
= &console_cmdline
[i
];
876 strlcpy(c
->name
, name
, sizeof(c
->name
));
877 c
->options
= options
;
878 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
879 c
->brl_options
= brl_options
;
885 * Set up a list of consoles. Called from init/main.c
887 static int __init
console_setup(char *str
)
889 char buf
[sizeof(console_cmdline
[0].name
) + 4]; /* 4 for index */
890 char *s
, *options
, *brl_options
= NULL
;
893 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
894 if (!memcmp(str
, "brl,", 4)) {
897 } else if (!memcmp(str
, "brl=", 4)) {
898 brl_options
= str
+ 4;
899 str
= strchr(brl_options
, ',');
901 printk(KERN_ERR
"need port name after brl=\n");
909 * Decode str into name, index, options.
911 if (str
[0] >= '0' && str
[0] <= '9') {
913 strncpy(buf
+ 4, str
, sizeof(buf
) - 5);
915 strncpy(buf
, str
, sizeof(buf
) - 1);
917 buf
[sizeof(buf
) - 1] = 0;
918 if ((options
= strchr(str
, ',')) != NULL
)
921 if (!strcmp(str
, "ttya"))
922 strcpy(buf
, "ttyS0");
923 if (!strcmp(str
, "ttyb"))
924 strcpy(buf
, "ttyS1");
926 for (s
= buf
; *s
; s
++)
927 if ((*s
>= '0' && *s
<= '9') || *s
== ',')
929 idx
= simple_strtoul(s
, NULL
, 10);
932 __add_preferred_console(buf
, idx
, options
, brl_options
);
933 console_set_on_cmdline
= 1;
936 __setup("console=", console_setup
);
939 * add_preferred_console - add a device to the list of preferred consoles.
942 * @options: options for this console
944 * The last preferred console added will be used for kernel messages
945 * and stdin/out/err for init. Normally this is used by console_setup
946 * above to handle user-supplied console arguments; however it can also
947 * be used by arch-specific code either to override the user or more
948 * commonly to provide a default console (ie from PROM variables) when
949 * the user has not supplied one.
951 int add_preferred_console(char *name
, int idx
, char *options
)
953 return __add_preferred_console(name
, idx
, options
, NULL
);
956 int update_console_cmdline(char *name
, int idx
, char *name_new
, int idx_new
, char *options
)
958 struct console_cmdline
*c
;
961 for (i
= 0; i
< MAX_CMDLINECONSOLES
&& console_cmdline
[i
].name
[0]; i
++)
962 if (strcmp(console_cmdline
[i
].name
, name
) == 0 &&
963 console_cmdline
[i
].index
== idx
) {
964 c
= &console_cmdline
[i
];
965 strlcpy(c
->name
, name_new
, sizeof(c
->name
));
966 c
->name
[sizeof(c
->name
) - 1] = 0;
967 c
->options
= options
;
975 int console_suspend_enabled
= 1;
976 EXPORT_SYMBOL(console_suspend_enabled
);
978 static int __init
console_suspend_disable(char *str
)
980 console_suspend_enabled
= 0;
983 __setup("no_console_suspend", console_suspend_disable
);
986 * suspend_console - suspend the console subsystem
988 * This disables printk() while we go into suspend states
990 void suspend_console(void)
992 if (!console_suspend_enabled
)
994 printk("Suspending console(s) (use no_console_suspend to debug)\n");
995 acquire_console_sem();
996 console_suspended
= 1;
1000 void resume_console(void)
1002 if (!console_suspend_enabled
)
1005 console_suspended
= 0;
1006 release_console_sem();
1010 * console_cpu_notify - print deferred console messages after CPU hotplug
1011 * @self: notifier struct
1012 * @action: CPU hotplug event
1015 * If printk() is called from a CPU that is not online yet, the messages
1016 * will be spooled but will not show up on the console. This function is
1017 * called when a new CPU comes online (or fails to come up), and ensures
1018 * that any such output gets printed.
1020 static int __cpuinit
console_cpu_notify(struct notifier_block
*self
,
1021 unsigned long action
, void *hcpu
)
1027 case CPU_DOWN_FAILED
:
1028 case CPU_UP_CANCELED
:
1029 acquire_console_sem();
1030 release_console_sem();
1036 * acquire_console_sem - lock the console system for exclusive use.
1038 * Acquires a semaphore which guarantees that the caller has
1039 * exclusive access to the console system and the console_drivers list.
1041 * Can sleep, returns nothing.
1043 void acquire_console_sem(void)
1045 BUG_ON(in_interrupt());
1047 if (console_suspended
)
1050 console_may_schedule
= 1;
1052 EXPORT_SYMBOL(acquire_console_sem
);
1054 int try_acquire_console_sem(void)
1056 if (down_trylock(&console_sem
))
1058 if (console_suspended
) {
1063 console_may_schedule
= 0;
1066 EXPORT_SYMBOL(try_acquire_console_sem
);
1068 int is_console_locked(void)
1070 return console_locked
;
1073 static DEFINE_PER_CPU(int, printk_pending
);
1075 void printk_tick(void)
1077 if (__this_cpu_read(printk_pending
)) {
1078 __this_cpu_write(printk_pending
, 0);
1079 wake_up_interruptible(&log_wait
);
1083 int printk_needs_cpu(int cpu
)
1085 if (cpu_is_offline(cpu
))
1087 return __this_cpu_read(printk_pending
);
1090 void wake_up_klogd(void)
1092 if (waitqueue_active(&log_wait
))
1093 this_cpu_write(printk_pending
, 1);
1097 * release_console_sem - unlock the console system
1099 * Releases the semaphore which the caller holds on the console system
1100 * and the console driver list.
1102 * While the semaphore was held, console output may have been buffered
1103 * by printk(). If this is the case, release_console_sem() emits
1104 * the output prior to releasing the semaphore.
1106 * If there is output waiting for klogd, we wake it up.
1108 * release_console_sem() may be called from any context.
1110 void release_console_sem(void)
1112 unsigned long flags
;
1113 unsigned _con_start
, _log_end
;
1114 unsigned wake_klogd
= 0;
1116 if (console_suspended
) {
1121 console_may_schedule
= 0;
1124 spin_lock_irqsave(&logbuf_lock
, flags
);
1125 wake_klogd
|= log_start
- log_end
;
1126 if (con_start
== log_end
)
1127 break; /* Nothing to print */
1128 _con_start
= con_start
;
1130 con_start
= log_end
; /* Flush */
1131 spin_unlock(&logbuf_lock
);
1132 stop_critical_timings(); /* don't trace print latency */
1133 call_console_drivers(_con_start
, _log_end
);
1134 start_critical_timings();
1135 local_irq_restore(flags
);
1139 spin_unlock_irqrestore(&logbuf_lock
, flags
);
1143 EXPORT_SYMBOL(release_console_sem
);
1146 * console_conditional_schedule - yield the CPU if required
1148 * If the console code is currently allowed to sleep, and
1149 * if this CPU should yield the CPU to another task, do
1152 * Must be called within acquire_console_sem().
1154 void __sched
console_conditional_schedule(void)
1156 if (console_may_schedule
)
1159 EXPORT_SYMBOL(console_conditional_schedule
);
1161 void console_unblank(void)
1166 * console_unblank can no longer be called in interrupt context unless
1167 * oops_in_progress is set to 1..
1169 if (oops_in_progress
) {
1170 if (down_trylock(&console_sem
) != 0)
1173 acquire_console_sem();
1176 console_may_schedule
= 0;
1178 if ((c
->flags
& CON_ENABLED
) && c
->unblank
)
1180 release_console_sem();
1184 * Return the console tty driver structure and its associated index
1186 struct tty_driver
*console_device(int *index
)
1189 struct tty_driver
*driver
= NULL
;
1191 acquire_console_sem();
1192 for_each_console(c
) {
1195 driver
= c
->device(c
, index
);
1199 release_console_sem();
1204 * Prevent further output on the passed console device so that (for example)
1205 * serial drivers can disable console output before suspending a port, and can
1206 * re-enable output afterwards.
1208 void console_stop(struct console
*console
)
1210 acquire_console_sem();
1211 console
->flags
&= ~CON_ENABLED
;
1212 release_console_sem();
1214 EXPORT_SYMBOL(console_stop
);
1216 void console_start(struct console
*console
)
1218 acquire_console_sem();
1219 console
->flags
|= CON_ENABLED
;
1220 release_console_sem();
1222 EXPORT_SYMBOL(console_start
);
1225 * The console driver calls this routine during kernel initialization
1226 * to register the console printing procedure with printk() and to
1227 * print any messages that were printed by the kernel before the
1228 * console driver was initialized.
1230 * This can happen pretty early during the boot process (because of
1231 * early_printk) - sometimes before setup_arch() completes - be careful
1232 * of what kernel features are used - they may not be initialised yet.
1234 * There are two types of consoles - bootconsoles (early_printk) and
1235 * "real" consoles (everything which is not a bootconsole) which are
1236 * handled differently.
1237 * - Any number of bootconsoles can be registered at any time.
1238 * - As soon as a "real" console is registered, all bootconsoles
1239 * will be unregistered automatically.
1240 * - Once a "real" console is registered, any attempt to register a
1241 * bootconsoles will be rejected
1243 void register_console(struct console
*newcon
)
1246 unsigned long flags
;
1247 struct console
*bcon
= NULL
;
1250 * before we register a new CON_BOOT console, make sure we don't
1251 * already have a valid console
1253 if (console_drivers
&& newcon
->flags
& CON_BOOT
) {
1254 /* find the last or real console */
1255 for_each_console(bcon
) {
1256 if (!(bcon
->flags
& CON_BOOT
)) {
1257 printk(KERN_INFO
"Too late to register bootconsole %s%d\n",
1258 newcon
->name
, newcon
->index
);
1264 if (console_drivers
&& console_drivers
->flags
& CON_BOOT
)
1265 bcon
= console_drivers
;
1267 if (preferred_console
< 0 || bcon
|| !console_drivers
)
1268 preferred_console
= selected_console
;
1270 if (newcon
->early_setup
)
1271 newcon
->early_setup();
1274 * See if we want to use this console driver. If we
1275 * didn't select a console we take the first one
1276 * that registers here.
1278 if (preferred_console
< 0) {
1279 if (newcon
->index
< 0)
1281 if (newcon
->setup
== NULL
||
1282 newcon
->setup(newcon
, NULL
) == 0) {
1283 newcon
->flags
|= CON_ENABLED
;
1284 if (newcon
->device
) {
1285 newcon
->flags
|= CON_CONSDEV
;
1286 preferred_console
= 0;
1292 * See if this console matches one we selected on
1295 for (i
= 0; i
< MAX_CMDLINECONSOLES
&& console_cmdline
[i
].name
[0];
1297 if (strcmp(console_cmdline
[i
].name
, newcon
->name
) != 0)
1299 if (newcon
->index
>= 0 &&
1300 newcon
->index
!= console_cmdline
[i
].index
)
1302 if (newcon
->index
< 0)
1303 newcon
->index
= console_cmdline
[i
].index
;
1304 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1305 if (console_cmdline
[i
].brl_options
) {
1306 newcon
->flags
|= CON_BRL
;
1307 braille_register_console(newcon
,
1308 console_cmdline
[i
].index
,
1309 console_cmdline
[i
].options
,
1310 console_cmdline
[i
].brl_options
);
1314 if (newcon
->setup
&&
1315 newcon
->setup(newcon
, console_cmdline
[i
].options
) != 0)
1317 newcon
->flags
|= CON_ENABLED
;
1318 newcon
->index
= console_cmdline
[i
].index
;
1319 if (i
== selected_console
) {
1320 newcon
->flags
|= CON_CONSDEV
;
1321 preferred_console
= selected_console
;
1326 if (!(newcon
->flags
& CON_ENABLED
))
1330 * If we have a bootconsole, and are switching to a real console,
1331 * don't print everything out again, since when the boot console, and
1332 * the real console are the same physical device, it's annoying to
1333 * see the beginning boot messages twice
1335 if (bcon
&& ((newcon
->flags
& (CON_CONSDEV
| CON_BOOT
)) == CON_CONSDEV
))
1336 newcon
->flags
&= ~CON_PRINTBUFFER
;
1339 * Put this console in the list - keep the
1340 * preferred driver at the head of the list.
1342 acquire_console_sem();
1343 if ((newcon
->flags
& CON_CONSDEV
) || console_drivers
== NULL
) {
1344 newcon
->next
= console_drivers
;
1345 console_drivers
= newcon
;
1347 newcon
->next
->flags
&= ~CON_CONSDEV
;
1349 newcon
->next
= console_drivers
->next
;
1350 console_drivers
->next
= newcon
;
1352 if (newcon
->flags
& CON_PRINTBUFFER
) {
1354 * release_console_sem() will print out the buffered messages
1357 spin_lock_irqsave(&logbuf_lock
, flags
);
1358 con_start
= log_start
;
1359 spin_unlock_irqrestore(&logbuf_lock
, flags
);
1361 release_console_sem();
1362 console_sysfs_notify();
1365 * By unregistering the bootconsoles after we enable the real console
1366 * we get the "console xxx enabled" message on all the consoles -
1367 * boot consoles, real consoles, etc - this is to ensure that end
1368 * users know there might be something in the kernel's log buffer that
1369 * went to the bootconsole (that they do not see on the real console)
1371 if (bcon
&& ((newcon
->flags
& (CON_CONSDEV
| CON_BOOT
)) == CON_CONSDEV
)) {
1372 /* we need to iterate through twice, to make sure we print
1373 * everything out, before we unregister the console(s)
1375 printk(KERN_INFO
"console [%s%d] enabled, bootconsole disabled\n",
1376 newcon
->name
, newcon
->index
);
1377 for_each_console(bcon
)
1378 if (bcon
->flags
& CON_BOOT
)
1379 unregister_console(bcon
);
1381 printk(KERN_INFO
"%sconsole [%s%d] enabled\n",
1382 (newcon
->flags
& CON_BOOT
) ? "boot" : "" ,
1383 newcon
->name
, newcon
->index
);
1386 EXPORT_SYMBOL(register_console
);
1388 int unregister_console(struct console
*console
)
1390 struct console
*a
, *b
;
1393 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1394 if (console
->flags
& CON_BRL
)
1395 return braille_unregister_console(console
);
1398 acquire_console_sem();
1399 if (console_drivers
== console
) {
1400 console_drivers
=console
->next
;
1402 } else if (console_drivers
) {
1403 for (a
=console_drivers
->next
, b
=console_drivers
;
1404 a
; b
=a
, a
=b
->next
) {
1414 * If this isn't the last console and it has CON_CONSDEV set, we
1415 * need to set it on the next preferred console.
1417 if (console_drivers
!= NULL
&& console
->flags
& CON_CONSDEV
)
1418 console_drivers
->flags
|= CON_CONSDEV
;
1420 release_console_sem();
1421 console_sysfs_notify();
1424 EXPORT_SYMBOL(unregister_console
);
1426 static int __init
printk_late_init(void)
1428 struct console
*con
;
1430 for_each_console(con
) {
1431 if (con
->flags
& CON_BOOT
) {
1432 printk(KERN_INFO
"turn off boot console %s%d\n",
1433 con
->name
, con
->index
);
1434 unregister_console(con
);
1437 hotcpu_notifier(console_cpu_notify
, 0);
1440 late_initcall(printk_late_init
);
1442 #if defined CONFIG_PRINTK
1445 * printk rate limiting, lifted from the networking subsystem.
1447 * This enforces a rate limit: not more than 10 kernel messages
1448 * every 5s to make a denial-of-service attack impossible.
1450 DEFINE_RATELIMIT_STATE(printk_ratelimit_state
, 5 * HZ
, 10);
1452 int __printk_ratelimit(const char *func
)
1454 return ___ratelimit(&printk_ratelimit_state
, func
);
1456 EXPORT_SYMBOL(__printk_ratelimit
);
1459 * printk_timed_ratelimit - caller-controlled printk ratelimiting
1460 * @caller_jiffies: pointer to caller's state
1461 * @interval_msecs: minimum interval between prints
1463 * printk_timed_ratelimit() returns true if more than @interval_msecs
1464 * milliseconds have elapsed since the last time printk_timed_ratelimit()
1467 bool printk_timed_ratelimit(unsigned long *caller_jiffies
,
1468 unsigned int interval_msecs
)
1470 if (*caller_jiffies
== 0
1471 || !time_in_range(jiffies
, *caller_jiffies
,
1473 + msecs_to_jiffies(interval_msecs
))) {
1474 *caller_jiffies
= jiffies
;
1479 EXPORT_SYMBOL(printk_timed_ratelimit
);
1481 static DEFINE_SPINLOCK(dump_list_lock
);
1482 static LIST_HEAD(dump_list
);
1485 * kmsg_dump_register - register a kernel log dumper.
1486 * @dumper: pointer to the kmsg_dumper structure
1488 * Adds a kernel log dumper to the system. The dump callback in the
1489 * structure will be called when the kernel oopses or panics and must be
1490 * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
1492 int kmsg_dump_register(struct kmsg_dumper
*dumper
)
1494 unsigned long flags
;
1497 /* The dump callback needs to be set */
1501 spin_lock_irqsave(&dump_list_lock
, flags
);
1502 /* Don't allow registering multiple times */
1503 if (!dumper
->registered
) {
1504 dumper
->registered
= 1;
1505 list_add_tail(&dumper
->list
, &dump_list
);
1508 spin_unlock_irqrestore(&dump_list_lock
, flags
);
1512 EXPORT_SYMBOL_GPL(kmsg_dump_register
);
1515 * kmsg_dump_unregister - unregister a kmsg dumper.
1516 * @dumper: pointer to the kmsg_dumper structure
1518 * Removes a dump device from the system. Returns zero on success and
1519 * %-EINVAL otherwise.
1521 int kmsg_dump_unregister(struct kmsg_dumper
*dumper
)
1523 unsigned long flags
;
1526 spin_lock_irqsave(&dump_list_lock
, flags
);
1527 if (dumper
->registered
) {
1528 dumper
->registered
= 0;
1529 list_del(&dumper
->list
);
1532 spin_unlock_irqrestore(&dump_list_lock
, flags
);
1536 EXPORT_SYMBOL_GPL(kmsg_dump_unregister
);
1538 static const char * const kmsg_reasons
[] = {
1539 [KMSG_DUMP_OOPS
] = "oops",
1540 [KMSG_DUMP_PANIC
] = "panic",
1541 [KMSG_DUMP_KEXEC
] = "kexec",
1544 static const char *kmsg_to_str(enum kmsg_dump_reason reason
)
1546 if (reason
>= ARRAY_SIZE(kmsg_reasons
) || reason
< 0)
1549 return kmsg_reasons
[reason
];
1553 * kmsg_dump - dump kernel log to kernel message dumpers.
1554 * @reason: the reason (oops, panic etc) for dumping
1556 * Iterate through each of the dump devices and call the oops/panic
1557 * callbacks with the log buffer.
1559 void kmsg_dump(enum kmsg_dump_reason reason
)
1563 struct kmsg_dumper
*dumper
;
1564 const char *s1
, *s2
;
1565 unsigned long l1
, l2
;
1566 unsigned long flags
;
1568 /* Theoretically, the log could move on after we do this, but
1569 there's not a lot we can do about that. The new messages
1570 will overwrite the start of what we dump. */
1571 spin_lock_irqsave(&logbuf_lock
, flags
);
1572 end
= log_end
& LOG_BUF_MASK
;
1573 chars
= logged_chars
;
1574 spin_unlock_irqrestore(&logbuf_lock
, flags
);
1577 s1
= log_buf
+ log_buf_len
- chars
+ end
;
1586 s2
= log_buf
+ end
- chars
;
1590 if (!spin_trylock_irqsave(&dump_list_lock
, flags
)) {
1591 printk(KERN_ERR
"dump_kmsg: dump list lock is held during %s, skipping dump\n",
1592 kmsg_to_str(reason
));
1595 list_for_each_entry(dumper
, &dump_list
, list
)
1596 dumper
->dump(dumper
, reason
, s1
, l1
, s2
, l2
);
1597 spin_unlock_irqrestore(&dump_list_lock
, flags
);