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/memblock.h>
35 #include <linux/syscalls.h>
36 #include <linux/kexec.h>
37 #include <linux/kdb.h>
38 #include <linux/ratelimit.h>
39 #include <linux/kmsg_dump.h>
40 #include <linux/syslog.h>
41 #include <linux/cpu.h>
42 #include <linux/notifier.h>
43 #include <linux/rculist.h>
45 #include <asm/uaccess.h>
48 * Architectures can override it:
50 void asmlinkage
__attribute__((weak
)) early_printk(const char *fmt
, ...)
54 #define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
56 /* printk's without a loglevel use this.. */
57 #define DEFAULT_MESSAGE_LOGLEVEL CONFIG_DEFAULT_MESSAGE_LOGLEVEL
59 /* We show everything that is MORE important than this.. */
60 #define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
61 #define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
63 DECLARE_WAIT_QUEUE_HEAD(log_wait
);
65 int console_printk
[4] = {
66 DEFAULT_CONSOLE_LOGLEVEL
, /* console_loglevel */
67 DEFAULT_MESSAGE_LOGLEVEL
, /* default_message_loglevel */
68 MINIMUM_CONSOLE_LOGLEVEL
, /* minimum_console_loglevel */
69 DEFAULT_CONSOLE_LOGLEVEL
, /* default_console_loglevel */
73 * Low level drivers may need that to know if they can schedule in
74 * their unblank() callback or not. So let's export it.
77 EXPORT_SYMBOL(oops_in_progress
);
80 * console_sem protects the console_drivers list, and also
81 * provides serialisation for access to the entire console
84 static DEFINE_SEMAPHORE(console_sem
);
85 struct console
*console_drivers
;
86 EXPORT_SYMBOL_GPL(console_drivers
);
89 * This is used for debugging the mess that is the VT code by
90 * keeping track if we have the console semaphore held. It's
91 * definitely not the perfect debug tool (we don't know if _WE_
92 * hold it are racing, but it helps tracking those weird code
93 * path in the console code where we end up in places I want
94 * locked without the console sempahore held
96 static int console_locked
, console_suspended
;
99 * logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
100 * It is also used in interesting ways to provide interlocking in
103 static DEFINE_SPINLOCK(logbuf_lock
);
105 #define LOG_BUF_MASK (log_buf_len-1)
106 #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
109 * The indices into log_buf are not constrained to log_buf_len - they
110 * must be masked before subscripting
112 static unsigned log_start
; /* Index into log_buf: next char to be read by syslog() */
113 static unsigned con_start
; /* Index into log_buf: next char to be sent to consoles */
114 static unsigned log_end
; /* Index into log_buf: most-recently-written-char + 1 */
117 * If exclusive_console is non-NULL then only this console is to be printed to.
119 static struct console
*exclusive_console
;
122 * Array of consoles built from command line options (console=)
124 struct console_cmdline
126 char name
[8]; /* Name of the driver */
127 int index
; /* Minor dev. to use */
128 char *options
; /* Options for the driver */
129 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
130 char *brl_options
; /* Options for braille driver */
134 #define MAX_CMDLINECONSOLES 8
136 static struct console_cmdline console_cmdline
[MAX_CMDLINECONSOLES
];
137 static int selected_console
= -1;
138 static int preferred_console
= -1;
139 int console_set_on_cmdline
;
140 EXPORT_SYMBOL(console_set_on_cmdline
);
142 /* Flag: console code may call schedule() */
143 static int console_may_schedule
;
147 static char __log_buf
[__LOG_BUF_LEN
];
148 static char *log_buf
= __log_buf
;
149 static int log_buf_len
= __LOG_BUF_LEN
;
150 static unsigned logged_chars
; /* Number of chars produced since last read+clear operation */
151 static int saved_console_loglevel
= -1;
155 * This appends the listed symbols to /proc/vmcoreinfo
157 * /proc/vmcoreinfo is used by various utiilties, like crash and makedumpfile to
158 * obtain access to symbols that are otherwise very difficult to locate. These
159 * symbols are specifically used so that utilities can access and extract the
160 * dmesg log from a vmcore file after a crash.
162 void log_buf_kexec_setup(void)
164 VMCOREINFO_SYMBOL(log_buf
);
165 VMCOREINFO_SYMBOL(log_end
);
166 VMCOREINFO_SYMBOL(log_buf_len
);
167 VMCOREINFO_SYMBOL(logged_chars
);
171 /* requested log_buf_len from kernel cmdline */
172 static unsigned long __initdata new_log_buf_len
;
174 /* save requested log_buf_len since it's too early to process it */
175 static int __init
log_buf_len_setup(char *str
)
177 unsigned size
= memparse(str
, &str
);
180 size
= roundup_pow_of_two(size
);
181 if (size
> log_buf_len
)
182 new_log_buf_len
= size
;
186 early_param("log_buf_len", log_buf_len_setup
);
188 void __init
setup_log_buf(int early
)
191 unsigned start
, dest_idx
, offset
;
195 if (!new_log_buf_len
)
201 mem
= memblock_alloc(new_log_buf_len
, PAGE_SIZE
);
202 if (mem
== MEMBLOCK_ERROR
)
204 new_log_buf
= __va(mem
);
206 new_log_buf
= alloc_bootmem_nopanic(new_log_buf_len
);
209 if (unlikely(!new_log_buf
)) {
210 pr_err("log_buf_len: %ld bytes not available\n",
215 spin_lock_irqsave(&logbuf_lock
, flags
);
216 log_buf_len
= new_log_buf_len
;
217 log_buf
= new_log_buf
;
219 free
= __LOG_BUF_LEN
- log_end
;
221 offset
= start
= min(con_start
, log_start
);
223 while (start
!= log_end
) {
224 unsigned log_idx_mask
= start
& (__LOG_BUF_LEN
- 1);
226 log_buf
[dest_idx
] = __log_buf
[log_idx_mask
];
233 spin_unlock_irqrestore(&logbuf_lock
, flags
);
235 pr_info("log_buf_len: %d\n", log_buf_len
);
236 pr_info("early log buf free: %d(%d%%)\n",
237 free
, (free
* 100) / __LOG_BUF_LEN
);
240 #ifdef CONFIG_BOOT_PRINTK_DELAY
242 static int boot_delay
; /* msecs delay after each printk during bootup */
243 static unsigned long long loops_per_msec
; /* based on boot_delay */
245 static int __init
boot_delay_setup(char *str
)
249 lpj
= preset_lpj
? preset_lpj
: 1000000; /* some guess */
250 loops_per_msec
= (unsigned long long)lpj
/ 1000 * HZ
;
252 get_option(&str
, &boot_delay
);
253 if (boot_delay
> 10 * 1000)
256 pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
257 "HZ: %d, loops_per_msec: %llu\n",
258 boot_delay
, preset_lpj
, lpj
, HZ
, loops_per_msec
);
261 __setup("boot_delay=", boot_delay_setup
);
263 static void boot_delay_msec(void)
265 unsigned long long k
;
266 unsigned long timeout
;
268 if (boot_delay
== 0 || system_state
!= SYSTEM_BOOTING
)
271 k
= (unsigned long long)loops_per_msec
* boot_delay
;
273 timeout
= jiffies
+ msecs_to_jiffies(boot_delay
);
278 * use (volatile) jiffies to prevent
279 * compiler reduction; loop termination via jiffies
280 * is secondary and may or may not happen.
282 if (time_after(jiffies
, timeout
))
284 touch_nmi_watchdog();
288 static inline void boot_delay_msec(void)
293 #ifdef CONFIG_SECURITY_DMESG_RESTRICT
294 int dmesg_restrict
= 1;
299 static int syslog_action_restricted(int type
)
303 /* Unless restricted, we allow "read all" and "get buffer size" for everybody */
304 return type
!= SYSLOG_ACTION_READ_ALL
&& type
!= SYSLOG_ACTION_SIZE_BUFFER
;
307 static int check_syslog_permissions(int type
, bool from_file
)
310 * If this is from /proc/kmsg and we've already opened it, then we've
311 * already done the capabilities checks at open time.
313 if (from_file
&& type
!= SYSLOG_ACTION_OPEN
)
316 if (syslog_action_restricted(type
)) {
317 if (capable(CAP_SYSLOG
))
319 /* For historical reasons, accept CAP_SYS_ADMIN too, with a warning */
320 if (capable(CAP_SYS_ADMIN
)) {
321 printk_once(KERN_WARNING
"%s (%d): "
322 "Attempt to access syslog with CAP_SYS_ADMIN "
323 "but no CAP_SYSLOG (deprecated).\n",
324 current
->comm
, task_pid_nr(current
));
332 int do_syslog(int type
, char __user
*buf
, int len
, bool from_file
)
334 unsigned i
, j
, limit
, count
;
339 error
= check_syslog_permissions(type
, from_file
);
343 error
= security_syslog(type
);
348 case SYSLOG_ACTION_CLOSE
: /* Close log */
350 case SYSLOG_ACTION_OPEN
: /* Open log */
352 case SYSLOG_ACTION_READ
: /* Read from log */
359 if (!access_ok(VERIFY_WRITE
, buf
, len
)) {
363 error
= wait_event_interruptible(log_wait
,
364 (log_start
- log_end
));
368 spin_lock_irq(&logbuf_lock
);
369 while (!error
&& (log_start
!= log_end
) && i
< len
) {
370 c
= LOG_BUF(log_start
);
372 spin_unlock_irq(&logbuf_lock
);
373 error
= __put_user(c
,buf
);
377 spin_lock_irq(&logbuf_lock
);
379 spin_unlock_irq(&logbuf_lock
);
383 /* Read/clear last kernel messages */
384 case SYSLOG_ACTION_READ_CLEAR
:
387 /* Read last kernel messages */
388 case SYSLOG_ACTION_READ_ALL
:
395 if (!access_ok(VERIFY_WRITE
, buf
, len
)) {
400 if (count
> log_buf_len
)
402 spin_lock_irq(&logbuf_lock
);
403 if (count
> logged_chars
)
404 count
= logged_chars
;
409 * __put_user() could sleep, and while we sleep
410 * printk() could overwrite the messages
411 * we try to copy to user space. Therefore
412 * the messages are copied in reverse. <manfreds>
414 for (i
= 0; i
< count
&& !error
; i
++) {
416 if (j
+ log_buf_len
< log_end
)
419 spin_unlock_irq(&logbuf_lock
);
420 error
= __put_user(c
,&buf
[count
-1-i
]);
422 spin_lock_irq(&logbuf_lock
);
424 spin_unlock_irq(&logbuf_lock
);
429 int offset
= count
-error
;
430 /* buffer overflow during copy, correct user buffer. */
431 for (i
= 0; i
< error
; i
++) {
432 if (__get_user(c
,&buf
[i
+offset
]) ||
433 __put_user(c
,&buf
[i
])) {
441 /* Clear ring buffer */
442 case SYSLOG_ACTION_CLEAR
:
445 /* Disable logging to console */
446 case SYSLOG_ACTION_CONSOLE_OFF
:
447 if (saved_console_loglevel
== -1)
448 saved_console_loglevel
= console_loglevel
;
449 console_loglevel
= minimum_console_loglevel
;
451 /* Enable logging to console */
452 case SYSLOG_ACTION_CONSOLE_ON
:
453 if (saved_console_loglevel
!= -1) {
454 console_loglevel
= saved_console_loglevel
;
455 saved_console_loglevel
= -1;
458 /* Set level of messages printed to console */
459 case SYSLOG_ACTION_CONSOLE_LEVEL
:
461 if (len
< 1 || len
> 8)
463 if (len
< minimum_console_loglevel
)
464 len
= minimum_console_loglevel
;
465 console_loglevel
= len
;
466 /* Implicitly re-enable logging to console */
467 saved_console_loglevel
= -1;
470 /* Number of chars in the log buffer */
471 case SYSLOG_ACTION_SIZE_UNREAD
:
472 error
= log_end
- log_start
;
474 /* Size of the log buffer */
475 case SYSLOG_ACTION_SIZE_BUFFER
:
486 SYSCALL_DEFINE3(syslog
, int, type
, char __user
*, buf
, int, len
)
488 return do_syslog(type
, buf
, len
, SYSLOG_FROM_CALL
);
491 #ifdef CONFIG_KGDB_KDB
492 /* kdb dmesg command needs access to the syslog buffer. do_syslog()
493 * uses locks so it cannot be used during debugging. Just tell kdb
494 * where the start and end of the physical and logical logs are. This
495 * is equivalent to do_syslog(3).
497 void kdb_syslog_data(char *syslog_data
[4])
499 syslog_data
[0] = log_buf
;
500 syslog_data
[1] = log_buf
+ log_buf_len
;
501 syslog_data
[2] = log_buf
+ log_end
-
502 (logged_chars
< log_buf_len
? logged_chars
: log_buf_len
);
503 syslog_data
[3] = log_buf
+ log_end
;
505 #endif /* CONFIG_KGDB_KDB */
508 * Call the console drivers on a range of log_buf
510 static void __call_console_drivers(unsigned start
, unsigned end
)
514 for_each_console(con
) {
515 if (exclusive_console
&& con
!= exclusive_console
)
517 if ((con
->flags
& CON_ENABLED
) && con
->write
&&
518 (cpu_online(smp_processor_id()) ||
519 (con
->flags
& CON_ANYTIME
)))
520 con
->write(con
, &LOG_BUF(start
), end
- start
);
524 static int __read_mostly ignore_loglevel
;
526 static int __init
ignore_loglevel_setup(char *str
)
529 printk(KERN_INFO
"debug: ignoring loglevel setting.\n");
534 early_param("ignore_loglevel", ignore_loglevel_setup
);
535 module_param_named(ignore_loglevel
, ignore_loglevel
, bool, S_IRUGO
| S_IWUSR
);
536 MODULE_PARM_DESC(ignore_loglevel
, "ignore loglevel setting, to"
537 "print all kernel messages to the console.");
540 * Write out chars from start to end - 1 inclusive
542 static void _call_console_drivers(unsigned start
,
543 unsigned end
, int msg_log_level
)
545 if ((msg_log_level
< console_loglevel
|| ignore_loglevel
) &&
546 console_drivers
&& start
!= end
) {
547 if ((start
& LOG_BUF_MASK
) > (end
& LOG_BUF_MASK
)) {
549 __call_console_drivers(start
& LOG_BUF_MASK
,
551 __call_console_drivers(0, end
& LOG_BUF_MASK
);
553 __call_console_drivers(start
, end
);
559 * Parse the syslog header <[0-9]*>. The decimal value represents 32bit, the
560 * lower 3 bit are the log level, the rest are the log facility. In case
561 * userspace passes usual userspace syslog messages to /dev/kmsg or
562 * /dev/ttyprintk, the log prefix might contain the facility. Printk needs
563 * to extract the correct log level for in-kernel processing, and not mangle
564 * the original value.
566 * If a prefix is found, the length of the prefix is returned. If 'level' is
567 * passed, it will be filled in with the log level without a possible facility
568 * value. If 'special' is passed, the special printk prefix chars are accepted
569 * and returned. If no valid header is found, 0 is returned and the passed
570 * variables are not touched.
572 static size_t log_prefix(const char *p
, unsigned int *level
, char *special
)
574 unsigned int lev
= 0;
578 if (p
[0] != '<' || !p
[1])
581 /* usual single digit level number or special char */
586 case 'c': /* KERN_CONT */
587 case 'd': /* KERN_DEFAULT */
595 /* multi digit including the level and facility number */
598 if (p
[1] < '0' && p
[1] > '9')
601 lev
= (simple_strtoul(&p
[1], &endp
, 10) & 7);
602 if (endp
== NULL
|| endp
[0] != '>')
604 len
= (endp
+ 1) - p
;
607 /* do not accept special char if not asked for */
613 /* return special char, do not touch level */
624 * Call the console drivers, asking them to write out
625 * log_buf[start] to log_buf[end - 1].
626 * The console_lock must be held.
628 static void call_console_drivers(unsigned start
, unsigned end
)
630 unsigned cur_index
, start_print
;
631 static int msg_level
= -1;
633 BUG_ON(((int)(start
- end
)) > 0);
637 while (cur_index
!= end
) {
638 if (msg_level
< 0 && ((end
- cur_index
) > 2)) {
639 /* strip log prefix */
640 cur_index
+= log_prefix(&LOG_BUF(cur_index
), &msg_level
, NULL
);
641 start_print
= cur_index
;
643 while (cur_index
!= end
) {
644 char c
= LOG_BUF(cur_index
);
650 * printk() has already given us loglevel tags in
651 * the buffer. This code is here in case the
652 * log buffer has wrapped right round and scribbled
655 msg_level
= default_message_loglevel
;
657 _call_console_drivers(start_print
, cur_index
, msg_level
);
659 start_print
= cur_index
;
664 _call_console_drivers(start_print
, end
, msg_level
);
667 static void emit_log_char(char c
)
669 LOG_BUF(log_end
) = c
;
671 if (log_end
- log_start
> log_buf_len
)
672 log_start
= log_end
- log_buf_len
;
673 if (log_end
- con_start
> log_buf_len
)
674 con_start
= log_end
- log_buf_len
;
675 if (logged_chars
< log_buf_len
)
680 * Zap console related locks when oopsing. Only zap at most once
681 * every 10 seconds, to leave time for slow consoles to print a
684 static void zap_locks(void)
686 static unsigned long oops_timestamp
;
688 if (time_after_eq(jiffies
, oops_timestamp
) &&
689 !time_after(jiffies
, oops_timestamp
+ 30 * HZ
))
692 oops_timestamp
= jiffies
;
694 /* If a crash is occurring, make sure we can't deadlock */
695 spin_lock_init(&logbuf_lock
);
696 /* And make sure that we print immediately */
697 sema_init(&console_sem
, 1);
700 #if defined(CONFIG_PRINTK_TIME)
701 static int printk_time
= 1;
703 static int printk_time
= 0;
705 module_param_named(time
, printk_time
, bool, S_IRUGO
| S_IWUSR
);
707 /* Check if we have any console registered that can be called early in boot. */
708 static int have_callable_console(void)
712 for_each_console(con
)
713 if (con
->flags
& CON_ANYTIME
)
720 * printk - print a kernel message
721 * @fmt: format string
723 * This is printk(). It can be called from any context. We want it to work.
725 * We try to grab the console_lock. If we succeed, it's easy - we log the output and
726 * call the console drivers. If we fail to get the semaphore we place the output
727 * into the log buffer and return. The current holder of the console_sem will
728 * notice the new output in console_unlock(); and will send it to the
729 * consoles before releasing the lock.
731 * One effect of this deferred printing is that code which calls printk() and
732 * then changes console_loglevel may break. This is because console_loglevel
733 * is inspected when the actual printing occurs.
738 * See the vsnprintf() documentation for format string extensions over C99.
741 asmlinkage
int printk(const char *fmt
, ...)
746 #ifdef CONFIG_KGDB_KDB
747 if (unlikely(kdb_trap_printk
)) {
749 r
= vkdb_printf(fmt
, args
);
755 r
= vprintk(fmt
, args
);
761 /* cpu currently holding logbuf_lock */
762 static volatile unsigned int printk_cpu
= UINT_MAX
;
765 * Can we actually use the console at this time on this cpu?
767 * Console drivers may assume that per-cpu resources have
768 * been allocated. So unless they're explicitly marked as
769 * being able to cope (CON_ANYTIME) don't call them until
770 * this CPU is officially up.
772 static inline int can_use_console(unsigned int cpu
)
774 return cpu_online(cpu
) || have_callable_console();
778 * Try to get console ownership to actually show the kernel
779 * messages from a 'printk'. Return true (and with the
780 * console_lock held, and 'console_locked' set) if it
781 * is successful, false otherwise.
783 * This gets called with the 'logbuf_lock' spinlock held and
784 * interrupts disabled. It should return with 'lockbuf_lock'
785 * released but interrupts still disabled.
787 static int console_trylock_for_printk(unsigned int cpu
)
788 __releases(&logbuf_lock
)
790 int retval
= 0, wake
= 0;
792 if (console_trylock()) {
796 * If we can't use the console, we need to release
797 * the console semaphore by hand to avoid flushing
798 * the buffer. We need to hold the console semaphore
799 * in order to do this test safely.
801 if (!can_use_console(cpu
)) {
807 printk_cpu
= UINT_MAX
;
808 spin_unlock(&logbuf_lock
);
813 static const char recursion_bug_msg
[] =
814 KERN_CRIT
"BUG: recent printk recursion!\n";
815 static int recursion_bug
;
816 static int new_text_line
= 1;
817 static char printk_buf
[1024];
819 int printk_delay_msec __read_mostly
;
821 static inline void printk_delay(void)
823 if (unlikely(printk_delay_msec
)) {
824 int m
= printk_delay_msec
;
828 touch_nmi_watchdog();
833 asmlinkage
int vprintk(const char *fmt
, va_list args
)
836 int current_log_level
= default_message_loglevel
;
847 /* This stops the holder of console_sem just where we want him */
848 raw_local_irq_save(flags
);
849 this_cpu
= smp_processor_id();
852 * Ouch, printk recursed into itself!
854 if (unlikely(printk_cpu
== this_cpu
)) {
856 * If a crash is occurring during printk() on this CPU,
857 * then try to get the crash message out but make sure
858 * we can't deadlock. Otherwise just return to avoid the
859 * recursion and return - but flag the recursion so that
860 * it can be printed at the next appropriate moment:
862 if (!oops_in_progress
) {
864 goto out_restore_irqs
;
870 spin_lock(&logbuf_lock
);
871 printk_cpu
= this_cpu
;
875 strcpy(printk_buf
, recursion_bug_msg
);
876 printed_len
= strlen(recursion_bug_msg
);
878 /* Emit the output into the temporary buffer */
879 printed_len
+= vscnprintf(printk_buf
+ printed_len
,
880 sizeof(printk_buf
) - printed_len
, fmt
, args
);
884 /* Read log level and handle special printk prefix */
885 plen
= log_prefix(p
, ¤t_log_level
, &special
);
890 case 'c': /* Strip <c> KERN_CONT, continue line */
893 case 'd': /* Strip <d> KERN_DEFAULT, start new line */
896 if (!new_text_line
) {
904 * Copy the output into log_buf. If the caller didn't provide
905 * the appropriate log prefix, we insert them here
912 /* Copy original log prefix */
915 for (i
= 0; i
< plen
; i
++)
916 emit_log_char(printk_buf
[i
]);
921 emit_log_char(current_log_level
+ '0');
927 /* Add the current time stamp */
930 unsigned long long t
;
931 unsigned long nanosec_rem
;
933 t
= cpu_clock(printk_cpu
);
934 nanosec_rem
= do_div(t
, 1000000000);
935 tlen
= sprintf(tbuf
, "[%5lu.%06lu] ",
939 for (tp
= tbuf
; tp
< tbuf
+ tlen
; tp
++)
954 * Try to acquire and then immediately release the
955 * console semaphore. The release will do all the
956 * actual magic (print out buffers, wake up klogd,
959 * The console_trylock_for_printk() function
960 * will release 'logbuf_lock' regardless of whether it
961 * actually gets the semaphore or not.
963 if (console_trylock_for_printk(this_cpu
))
968 raw_local_irq_restore(flags
);
973 EXPORT_SYMBOL(printk
);
974 EXPORT_SYMBOL(vprintk
);
978 static void call_console_drivers(unsigned start
, unsigned end
)
984 static int __add_preferred_console(char *name
, int idx
, char *options
,
987 struct console_cmdline
*c
;
991 * See if this tty is not yet registered, and
992 * if we have a slot free.
994 for (i
= 0; i
< MAX_CMDLINECONSOLES
&& console_cmdline
[i
].name
[0]; i
++)
995 if (strcmp(console_cmdline
[i
].name
, name
) == 0 &&
996 console_cmdline
[i
].index
== idx
) {
998 selected_console
= i
;
1001 if (i
== MAX_CMDLINECONSOLES
)
1004 selected_console
= i
;
1005 c
= &console_cmdline
[i
];
1006 strlcpy(c
->name
, name
, sizeof(c
->name
));
1007 c
->options
= options
;
1008 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1009 c
->brl_options
= brl_options
;
1015 * Set up a list of consoles. Called from init/main.c
1017 static int __init
console_setup(char *str
)
1019 char buf
[sizeof(console_cmdline
[0].name
) + 4]; /* 4 for index */
1020 char *s
, *options
, *brl_options
= NULL
;
1023 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1024 if (!memcmp(str
, "brl,", 4)) {
1027 } else if (!memcmp(str
, "brl=", 4)) {
1028 brl_options
= str
+ 4;
1029 str
= strchr(brl_options
, ',');
1031 printk(KERN_ERR
"need port name after brl=\n");
1039 * Decode str into name, index, options.
1041 if (str
[0] >= '0' && str
[0] <= '9') {
1042 strcpy(buf
, "ttyS");
1043 strncpy(buf
+ 4, str
, sizeof(buf
) - 5);
1045 strncpy(buf
, str
, sizeof(buf
) - 1);
1047 buf
[sizeof(buf
) - 1] = 0;
1048 if ((options
= strchr(str
, ',')) != NULL
)
1051 if (!strcmp(str
, "ttya"))
1052 strcpy(buf
, "ttyS0");
1053 if (!strcmp(str
, "ttyb"))
1054 strcpy(buf
, "ttyS1");
1056 for (s
= buf
; *s
; s
++)
1057 if ((*s
>= '0' && *s
<= '9') || *s
== ',')
1059 idx
= simple_strtoul(s
, NULL
, 10);
1062 __add_preferred_console(buf
, idx
, options
, brl_options
);
1063 console_set_on_cmdline
= 1;
1066 __setup("console=", console_setup
);
1069 * add_preferred_console - add a device to the list of preferred consoles.
1070 * @name: device name
1071 * @idx: device index
1072 * @options: options for this console
1074 * The last preferred console added will be used for kernel messages
1075 * and stdin/out/err for init. Normally this is used by console_setup
1076 * above to handle user-supplied console arguments; however it can also
1077 * be used by arch-specific code either to override the user or more
1078 * commonly to provide a default console (ie from PROM variables) when
1079 * the user has not supplied one.
1081 int add_preferred_console(char *name
, int idx
, char *options
)
1083 return __add_preferred_console(name
, idx
, options
, NULL
);
1086 int update_console_cmdline(char *name
, int idx
, char *name_new
, int idx_new
, char *options
)
1088 struct console_cmdline
*c
;
1091 for (i
= 0; i
< MAX_CMDLINECONSOLES
&& console_cmdline
[i
].name
[0]; i
++)
1092 if (strcmp(console_cmdline
[i
].name
, name
) == 0 &&
1093 console_cmdline
[i
].index
== idx
) {
1094 c
= &console_cmdline
[i
];
1095 strlcpy(c
->name
, name_new
, sizeof(c
->name
));
1096 c
->name
[sizeof(c
->name
) - 1] = 0;
1097 c
->options
= options
;
1105 int console_suspend_enabled
= 1;
1106 EXPORT_SYMBOL(console_suspend_enabled
);
1108 static int __init
console_suspend_disable(char *str
)
1110 console_suspend_enabled
= 0;
1113 __setup("no_console_suspend", console_suspend_disable
);
1114 module_param_named(console_suspend
, console_suspend_enabled
,
1115 bool, S_IRUGO
| S_IWUSR
);
1116 MODULE_PARM_DESC(console_suspend
, "suspend console during suspend"
1117 " and hibernate operations");
1120 * suspend_console - suspend the console subsystem
1122 * This disables printk() while we go into suspend states
1124 void suspend_console(void)
1126 if (!console_suspend_enabled
)
1128 printk("Suspending console(s) (use no_console_suspend to debug)\n");
1130 console_suspended
= 1;
1134 void resume_console(void)
1136 if (!console_suspend_enabled
)
1139 console_suspended
= 0;
1144 * console_cpu_notify - print deferred console messages after CPU hotplug
1145 * @self: notifier struct
1146 * @action: CPU hotplug event
1149 * If printk() is called from a CPU that is not online yet, the messages
1150 * will be spooled but will not show up on the console. This function is
1151 * called when a new CPU comes online (or fails to come up), and ensures
1152 * that any such output gets printed.
1154 static int __cpuinit
console_cpu_notify(struct notifier_block
*self
,
1155 unsigned long action
, void *hcpu
)
1161 case CPU_DOWN_FAILED
:
1162 case CPU_UP_CANCELED
:
1170 * console_lock - lock the console system for exclusive use.
1172 * Acquires a lock which guarantees that the caller has
1173 * exclusive access to the console system and the console_drivers list.
1175 * Can sleep, returns nothing.
1177 void console_lock(void)
1179 BUG_ON(in_interrupt());
1181 if (console_suspended
)
1184 console_may_schedule
= 1;
1186 EXPORT_SYMBOL(console_lock
);
1189 * console_trylock - try to lock the console system for exclusive use.
1191 * Tried to acquire a lock which guarantees that the caller has
1192 * exclusive access to the console system and the console_drivers list.
1194 * returns 1 on success, and 0 on failure to acquire the lock.
1196 int console_trylock(void)
1198 if (down_trylock(&console_sem
))
1200 if (console_suspended
) {
1205 console_may_schedule
= 0;
1208 EXPORT_SYMBOL(console_trylock
);
1210 int is_console_locked(void)
1212 return console_locked
;
1215 static DEFINE_PER_CPU(int, printk_pending
);
1217 void printk_tick(void)
1219 if (__this_cpu_read(printk_pending
)) {
1220 __this_cpu_write(printk_pending
, 0);
1221 wake_up_interruptible(&log_wait
);
1225 int printk_needs_cpu(int cpu
)
1227 if (cpu_is_offline(cpu
))
1229 return __this_cpu_read(printk_pending
);
1232 void wake_up_klogd(void)
1234 if (waitqueue_active(&log_wait
))
1235 this_cpu_write(printk_pending
, 1);
1239 * console_unlock - unlock the console system
1241 * Releases the console_lock which the caller holds on the console system
1242 * and the console driver list.
1244 * While the console_lock was held, console output may have been buffered
1245 * by printk(). If this is the case, console_unlock(); emits
1246 * the output prior to releasing the lock.
1248 * If there is output waiting for klogd, we wake it up.
1250 * console_unlock(); may be called from any context.
1252 void console_unlock(void)
1254 unsigned long flags
;
1255 unsigned _con_start
, _log_end
;
1256 unsigned wake_klogd
= 0, retry
= 0;
1258 if (console_suspended
) {
1263 console_may_schedule
= 0;
1267 spin_lock_irqsave(&logbuf_lock
, flags
);
1268 wake_klogd
|= log_start
- log_end
;
1269 if (con_start
== log_end
)
1270 break; /* Nothing to print */
1271 _con_start
= con_start
;
1273 con_start
= log_end
; /* Flush */
1274 spin_unlock(&logbuf_lock
);
1275 stop_critical_timings(); /* don't trace print latency */
1276 call_console_drivers(_con_start
, _log_end
);
1277 start_critical_timings();
1278 local_irq_restore(flags
);
1282 /* Release the exclusive_console once it is used */
1283 if (unlikely(exclusive_console
))
1284 exclusive_console
= NULL
;
1286 spin_unlock(&logbuf_lock
);
1291 * Someone could have filled up the buffer again, so re-check if there's
1292 * something to flush. In case we cannot trylock the console_sem again,
1293 * there's a new owner and the console_unlock() from them will do the
1294 * flush, no worries.
1296 spin_lock(&logbuf_lock
);
1297 if (con_start
!= log_end
)
1299 spin_unlock_irqrestore(&logbuf_lock
, flags
);
1300 if (retry
&& console_trylock())
1306 EXPORT_SYMBOL(console_unlock
);
1309 * console_conditional_schedule - yield the CPU if required
1311 * If the console code is currently allowed to sleep, and
1312 * if this CPU should yield the CPU to another task, do
1315 * Must be called within console_lock();.
1317 void __sched
console_conditional_schedule(void)
1319 if (console_may_schedule
)
1322 EXPORT_SYMBOL(console_conditional_schedule
);
1324 void console_unblank(void)
1329 * console_unblank can no longer be called in interrupt context unless
1330 * oops_in_progress is set to 1..
1332 if (oops_in_progress
) {
1333 if (down_trylock(&console_sem
) != 0)
1339 console_may_schedule
= 0;
1341 if ((c
->flags
& CON_ENABLED
) && c
->unblank
)
1347 * Return the console tty driver structure and its associated index
1349 struct tty_driver
*console_device(int *index
)
1352 struct tty_driver
*driver
= NULL
;
1355 for_each_console(c
) {
1358 driver
= c
->device(c
, index
);
1367 * Prevent further output on the passed console device so that (for example)
1368 * serial drivers can disable console output before suspending a port, and can
1369 * re-enable output afterwards.
1371 void console_stop(struct console
*console
)
1374 console
->flags
&= ~CON_ENABLED
;
1377 EXPORT_SYMBOL(console_stop
);
1379 void console_start(struct console
*console
)
1382 console
->flags
|= CON_ENABLED
;
1385 EXPORT_SYMBOL(console_start
);
1387 static int __read_mostly keep_bootcon
;
1389 static int __init
keep_bootcon_setup(char *str
)
1392 printk(KERN_INFO
"debug: skip boot console de-registration.\n");
1397 early_param("keep_bootcon", keep_bootcon_setup
);
1400 * The console driver calls this routine during kernel initialization
1401 * to register the console printing procedure with printk() and to
1402 * print any messages that were printed by the kernel before the
1403 * console driver was initialized.
1405 * This can happen pretty early during the boot process (because of
1406 * early_printk) - sometimes before setup_arch() completes - be careful
1407 * of what kernel features are used - they may not be initialised yet.
1409 * There are two types of consoles - bootconsoles (early_printk) and
1410 * "real" consoles (everything which is not a bootconsole) which are
1411 * handled differently.
1412 * - Any number of bootconsoles can be registered at any time.
1413 * - As soon as a "real" console is registered, all bootconsoles
1414 * will be unregistered automatically.
1415 * - Once a "real" console is registered, any attempt to register a
1416 * bootconsoles will be rejected
1418 void register_console(struct console
*newcon
)
1421 unsigned long flags
;
1422 struct console
*bcon
= NULL
;
1425 * before we register a new CON_BOOT console, make sure we don't
1426 * already have a valid console
1428 if (console_drivers
&& newcon
->flags
& CON_BOOT
) {
1429 /* find the last or real console */
1430 for_each_console(bcon
) {
1431 if (!(bcon
->flags
& CON_BOOT
)) {
1432 printk(KERN_INFO
"Too late to register bootconsole %s%d\n",
1433 newcon
->name
, newcon
->index
);
1439 if (console_drivers
&& console_drivers
->flags
& CON_BOOT
)
1440 bcon
= console_drivers
;
1442 if (preferred_console
< 0 || bcon
|| !console_drivers
)
1443 preferred_console
= selected_console
;
1445 if (newcon
->early_setup
)
1446 newcon
->early_setup();
1449 * See if we want to use this console driver. If we
1450 * didn't select a console we take the first one
1451 * that registers here.
1453 if (preferred_console
< 0) {
1454 if (newcon
->index
< 0)
1456 if (newcon
->setup
== NULL
||
1457 newcon
->setup(newcon
, NULL
) == 0) {
1458 newcon
->flags
|= CON_ENABLED
;
1459 if (newcon
->device
) {
1460 newcon
->flags
|= CON_CONSDEV
;
1461 preferred_console
= 0;
1467 * See if this console matches one we selected on
1470 for (i
= 0; i
< MAX_CMDLINECONSOLES
&& console_cmdline
[i
].name
[0];
1472 if (strcmp(console_cmdline
[i
].name
, newcon
->name
) != 0)
1474 if (newcon
->index
>= 0 &&
1475 newcon
->index
!= console_cmdline
[i
].index
)
1477 if (newcon
->index
< 0)
1478 newcon
->index
= console_cmdline
[i
].index
;
1479 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1480 if (console_cmdline
[i
].brl_options
) {
1481 newcon
->flags
|= CON_BRL
;
1482 braille_register_console(newcon
,
1483 console_cmdline
[i
].index
,
1484 console_cmdline
[i
].options
,
1485 console_cmdline
[i
].brl_options
);
1489 if (newcon
->setup
&&
1490 newcon
->setup(newcon
, console_cmdline
[i
].options
) != 0)
1492 newcon
->flags
|= CON_ENABLED
;
1493 newcon
->index
= console_cmdline
[i
].index
;
1494 if (i
== selected_console
) {
1495 newcon
->flags
|= CON_CONSDEV
;
1496 preferred_console
= selected_console
;
1501 if (!(newcon
->flags
& CON_ENABLED
))
1505 * If we have a bootconsole, and are switching to a real console,
1506 * don't print everything out again, since when the boot console, and
1507 * the real console are the same physical device, it's annoying to
1508 * see the beginning boot messages twice
1510 if (bcon
&& ((newcon
->flags
& (CON_CONSDEV
| CON_BOOT
)) == CON_CONSDEV
))
1511 newcon
->flags
&= ~CON_PRINTBUFFER
;
1514 * Put this console in the list - keep the
1515 * preferred driver at the head of the list.
1518 if ((newcon
->flags
& CON_CONSDEV
) || console_drivers
== NULL
) {
1519 newcon
->next
= console_drivers
;
1520 console_drivers
= newcon
;
1522 newcon
->next
->flags
&= ~CON_CONSDEV
;
1524 newcon
->next
= console_drivers
->next
;
1525 console_drivers
->next
= newcon
;
1527 if (newcon
->flags
& CON_PRINTBUFFER
) {
1529 * console_unlock(); will print out the buffered messages
1532 spin_lock_irqsave(&logbuf_lock
, flags
);
1533 con_start
= log_start
;
1534 spin_unlock_irqrestore(&logbuf_lock
, flags
);
1536 * We're about to replay the log buffer. Only do this to the
1537 * just-registered console to avoid excessive message spam to
1538 * the already-registered consoles.
1540 exclusive_console
= newcon
;
1543 console_sysfs_notify();
1546 * By unregistering the bootconsoles after we enable the real console
1547 * we get the "console xxx enabled" message on all the consoles -
1548 * boot consoles, real consoles, etc - this is to ensure that end
1549 * users know there might be something in the kernel's log buffer that
1550 * went to the bootconsole (that they do not see on the real console)
1553 ((newcon
->flags
& (CON_CONSDEV
| CON_BOOT
)) == CON_CONSDEV
) &&
1555 /* we need to iterate through twice, to make sure we print
1556 * everything out, before we unregister the console(s)
1558 printk(KERN_INFO
"console [%s%d] enabled, bootconsole disabled\n",
1559 newcon
->name
, newcon
->index
);
1560 for_each_console(bcon
)
1561 if (bcon
->flags
& CON_BOOT
)
1562 unregister_console(bcon
);
1564 printk(KERN_INFO
"%sconsole [%s%d] enabled\n",
1565 (newcon
->flags
& CON_BOOT
) ? "boot" : "" ,
1566 newcon
->name
, newcon
->index
);
1569 EXPORT_SYMBOL(register_console
);
1571 int unregister_console(struct console
*console
)
1573 struct console
*a
, *b
;
1576 #ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1577 if (console
->flags
& CON_BRL
)
1578 return braille_unregister_console(console
);
1582 if (console_drivers
== console
) {
1583 console_drivers
=console
->next
;
1585 } else if (console_drivers
) {
1586 for (a
=console_drivers
->next
, b
=console_drivers
;
1587 a
; b
=a
, a
=b
->next
) {
1597 * If this isn't the last console and it has CON_CONSDEV set, we
1598 * need to set it on the next preferred console.
1600 if (console_drivers
!= NULL
&& console
->flags
& CON_CONSDEV
)
1601 console_drivers
->flags
|= CON_CONSDEV
;
1604 console_sysfs_notify();
1607 EXPORT_SYMBOL(unregister_console
);
1609 static int __init
printk_late_init(void)
1611 struct console
*con
;
1613 for_each_console(con
) {
1614 if (!keep_bootcon
&& con
->flags
& CON_BOOT
) {
1615 printk(KERN_INFO
"turn off boot console %s%d\n",
1616 con
->name
, con
->index
);
1617 unregister_console(con
);
1620 hotcpu_notifier(console_cpu_notify
, 0);
1623 late_initcall(printk_late_init
);
1625 #if defined CONFIG_PRINTK
1628 * printk rate limiting, lifted from the networking subsystem.
1630 * This enforces a rate limit: not more than 10 kernel messages
1631 * every 5s to make a denial-of-service attack impossible.
1633 DEFINE_RATELIMIT_STATE(printk_ratelimit_state
, 5 * HZ
, 10);
1635 int __printk_ratelimit(const char *func
)
1637 return ___ratelimit(&printk_ratelimit_state
, func
);
1639 EXPORT_SYMBOL(__printk_ratelimit
);
1642 * printk_timed_ratelimit - caller-controlled printk ratelimiting
1643 * @caller_jiffies: pointer to caller's state
1644 * @interval_msecs: minimum interval between prints
1646 * printk_timed_ratelimit() returns true if more than @interval_msecs
1647 * milliseconds have elapsed since the last time printk_timed_ratelimit()
1650 bool printk_timed_ratelimit(unsigned long *caller_jiffies
,
1651 unsigned int interval_msecs
)
1653 if (*caller_jiffies
== 0
1654 || !time_in_range(jiffies
, *caller_jiffies
,
1656 + msecs_to_jiffies(interval_msecs
))) {
1657 *caller_jiffies
= jiffies
;
1662 EXPORT_SYMBOL(printk_timed_ratelimit
);
1664 static DEFINE_SPINLOCK(dump_list_lock
);
1665 static LIST_HEAD(dump_list
);
1668 * kmsg_dump_register - register a kernel log dumper.
1669 * @dumper: pointer to the kmsg_dumper structure
1671 * Adds a kernel log dumper to the system. The dump callback in the
1672 * structure will be called when the kernel oopses or panics and must be
1673 * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
1675 int kmsg_dump_register(struct kmsg_dumper
*dumper
)
1677 unsigned long flags
;
1680 /* The dump callback needs to be set */
1684 spin_lock_irqsave(&dump_list_lock
, flags
);
1685 /* Don't allow registering multiple times */
1686 if (!dumper
->registered
) {
1687 dumper
->registered
= 1;
1688 list_add_tail_rcu(&dumper
->list
, &dump_list
);
1691 spin_unlock_irqrestore(&dump_list_lock
, flags
);
1695 EXPORT_SYMBOL_GPL(kmsg_dump_register
);
1698 * kmsg_dump_unregister - unregister a kmsg dumper.
1699 * @dumper: pointer to the kmsg_dumper structure
1701 * Removes a dump device from the system. Returns zero on success and
1702 * %-EINVAL otherwise.
1704 int kmsg_dump_unregister(struct kmsg_dumper
*dumper
)
1706 unsigned long flags
;
1709 spin_lock_irqsave(&dump_list_lock
, flags
);
1710 if (dumper
->registered
) {
1711 dumper
->registered
= 0;
1712 list_del_rcu(&dumper
->list
);
1715 spin_unlock_irqrestore(&dump_list_lock
, flags
);
1720 EXPORT_SYMBOL_GPL(kmsg_dump_unregister
);
1723 * kmsg_dump - dump kernel log to kernel message dumpers.
1724 * @reason: the reason (oops, panic etc) for dumping
1726 * Iterate through each of the dump devices and call the oops/panic
1727 * callbacks with the log buffer.
1729 void kmsg_dump(enum kmsg_dump_reason reason
)
1733 struct kmsg_dumper
*dumper
;
1734 const char *s1
, *s2
;
1735 unsigned long l1
, l2
;
1736 unsigned long flags
;
1738 /* Theoretically, the log could move on after we do this, but
1739 there's not a lot we can do about that. The new messages
1740 will overwrite the start of what we dump. */
1741 spin_lock_irqsave(&logbuf_lock
, flags
);
1742 end
= log_end
& LOG_BUF_MASK
;
1743 chars
= logged_chars
;
1744 spin_unlock_irqrestore(&logbuf_lock
, flags
);
1747 s1
= log_buf
+ log_buf_len
- chars
+ end
;
1756 s2
= log_buf
+ end
- chars
;
1761 list_for_each_entry_rcu(dumper
, &dump_list
, list
)
1762 dumper
->dump(dumper
, reason
, s1
, l1
, s2
, l2
);