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 * manfreds@colorfullife.com
15 * Rewrote bits to get rid of console_lock
16 * 01Mar01 Andrew Morton <andrewm@uow.edu.au>
19 #include <linux/kernel.h>
21 #include <linux/tty.h>
22 #include <linux/tty_driver.h>
23 #include <linux/smp_lock.h>
24 #include <linux/console.h>
25 #include <linux/init.h>
26 #include <linux/module.h>
27 #include <linux/interrupt.h> /* For in_interrupt() */
28 #include <linux/config.h>
29 #include <linux/delay.h>
30 #include <linux/smp.h>
31 #include <linux/security.h>
32 #include <linux/bootmem.h>
33 #include <linux/syscalls.h>
35 #include <asm/uaccess.h>
37 #define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
39 /* printk's without a loglevel use this.. */
40 #define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
42 /* We show everything that is MORE important than this.. */
43 #define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
44 #define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
46 DECLARE_WAIT_QUEUE_HEAD(log_wait
);
48 int console_printk
[4] = {
49 DEFAULT_CONSOLE_LOGLEVEL
, /* console_loglevel */
50 DEFAULT_MESSAGE_LOGLEVEL
, /* default_message_loglevel */
51 MINIMUM_CONSOLE_LOGLEVEL
, /* minimum_console_loglevel */
52 DEFAULT_CONSOLE_LOGLEVEL
, /* default_console_loglevel */
55 EXPORT_SYMBOL(console_printk
);
60 * console_sem protects the console_drivers list, and also
61 * provides serialisation for access to the entire console
64 static DECLARE_MUTEX(console_sem
);
65 struct console
*console_drivers
;
67 * This is used for debugging the mess that is the VT code by
68 * keeping track if we have the console semaphore held. It's
69 * definitely not the perfect debug tool (we don't know if _WE_
70 * hold it are racing, but it helps tracking those weird code
71 * path in the console code where we end up in places I want
72 * locked without the console sempahore held
74 static int console_locked
;
77 * logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
78 * It is also used in interesting ways to provide interlocking in
79 * release_console_sem().
81 static spinlock_t logbuf_lock
= SPIN_LOCK_UNLOCKED
;
83 static char __log_buf
[__LOG_BUF_LEN
];
84 static char *log_buf
= __log_buf
;
85 static int log_buf_len
= __LOG_BUF_LEN
;
87 #define LOG_BUF_MASK (log_buf_len-1)
88 #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
91 * The indices into log_buf are not constrained to log_buf_len - they
92 * must be masked before subscripting
94 static unsigned long log_start
; /* Index into log_buf: next char to be read by syslog() */
95 static unsigned long con_start
; /* Index into log_buf: next char to be sent to consoles */
96 static unsigned long log_end
; /* Index into log_buf: most-recently-written-char + 1 */
97 static unsigned long logged_chars
; /* Number of chars produced since last read+clear operation */
100 * Array of consoles built from command line options (console=)
102 struct console_cmdline
104 char name
[8]; /* Name of the driver */
105 int index
; /* Minor dev. to use */
106 char *options
; /* Options for the driver */
109 #define MAX_CMDLINECONSOLES 8
111 static struct console_cmdline console_cmdline
[MAX_CMDLINECONSOLES
];
112 static int selected_console
= -1;
113 static int preferred_console
= -1;
115 /* Flag: console code may call schedule() */
116 static int console_may_schedule
;
119 * Setup a list of consoles. Called from init/main.c
121 static int __init
console_setup(char *str
)
123 char name
[sizeof(console_cmdline
[0].name
)];
128 * Decode str into name, index, options.
130 if (str
[0] >= '0' && str
[0] <= '9') {
131 strcpy(name
, "ttyS");
132 strncpy(name
+ 4, str
, sizeof(name
) - 5);
134 strncpy(name
, str
, sizeof(name
) - 1);
135 name
[sizeof(name
) - 1] = 0;
136 if ((options
= strchr(str
, ',')) != NULL
)
139 if (!strcmp(str
, "ttya"))
140 strcpy(name
, "ttyS0");
141 if (!strcmp(str
, "ttyb"))
142 strcpy(name
, "ttyS1");
144 for(s
= name
; *s
; s
++)
145 if (*s
>= '0' && *s
<= '9')
147 idx
= simple_strtoul(s
, NULL
, 10);
150 add_preferred_console(name
, idx
, options
);
154 __setup("console=", console_setup
);
157 * add_preferred_console - add a device to the list of preferred consoles.
159 * The last preferred console added will be used for kernel messages
160 * and stdin/out/err for init. Normally this is used by console_setup
161 * above to handle user-supplied console arguments; however it can also
162 * be used by arch-specific code either to override the user or more
163 * commonly to provide a default console (ie from PROM variables) when
164 * the user has not supplied one.
166 int __init
add_preferred_console(char *name
, int idx
, char *options
)
168 struct console_cmdline
*c
;
172 * See if this tty is not yet registered, and
173 * if we have a slot free.
175 for(i
= 0; i
< MAX_CMDLINECONSOLES
&& console_cmdline
[i
].name
[0]; i
++)
176 if (strcmp(console_cmdline
[i
].name
, name
) == 0 &&
177 console_cmdline
[i
].index
== idx
) {
178 selected_console
= i
;
181 if (i
== MAX_CMDLINECONSOLES
)
183 selected_console
= i
;
184 c
= &console_cmdline
[i
];
185 memcpy(c
->name
, name
, sizeof(c
->name
));
186 c
->name
[sizeof(c
->name
) - 1] = 0;
187 c
->options
= options
;
192 static int __init
log_buf_len_setup(char *str
)
194 unsigned long size
= memparse(str
, &str
);
198 size
= roundup_pow_of_two(size
);
199 if (size
> log_buf_len
) {
200 unsigned long start
, dest_idx
, offset
;
203 new_log_buf
= alloc_bootmem(size
);
205 printk("log_buf_len: allocation failed\n");
209 spin_lock_irqsave(&logbuf_lock
, flags
);
211 log_buf
= new_log_buf
;
213 offset
= start
= min(con_start
, log_start
);
215 while (start
!= log_end
) {
216 log_buf
[dest_idx
] = __log_buf
[start
& (__LOG_BUF_LEN
- 1)];
223 spin_unlock_irqrestore(&logbuf_lock
, flags
);
225 printk("log_buf_len: %d\n", log_buf_len
);
232 __setup("log_buf_len=", log_buf_len_setup
);
235 * Commands to do_syslog:
237 * 0 -- Close the log. Currently a NOP.
238 * 1 -- Open the log. Currently a NOP.
239 * 2 -- Read from the log.
240 * 3 -- Read all messages remaining in the ring buffer.
241 * 4 -- Read and clear all messages remaining in the ring buffer
242 * 5 -- Clear ring buffer.
243 * 6 -- Disable printk's to console
244 * 7 -- Enable printk's to console
245 * 8 -- Set level of messages printed to console
246 * 9 -- Return number of unread characters in the log buffer
247 * 10 -- Return size of the log buffer
249 int do_syslog(int type
, char __user
* buf
, int len
)
251 unsigned long i
, j
, limit
, count
;
256 error
= security_syslog(type
);
261 case 0: /* Close log */
263 case 1: /* Open log */
265 case 2: /* Read from log */
272 error
= verify_area(VERIFY_WRITE
,buf
,len
);
275 error
= wait_event_interruptible(log_wait
, (log_start
- log_end
));
279 spin_lock_irq(&logbuf_lock
);
280 while (!error
&& (log_start
!= log_end
) && i
< len
) {
281 c
= LOG_BUF(log_start
);
283 spin_unlock_irq(&logbuf_lock
);
284 error
= __put_user(c
,buf
);
287 spin_lock_irq(&logbuf_lock
);
289 spin_unlock_irq(&logbuf_lock
);
293 case 4: /* Read/clear last kernel messages */
296 case 3: /* Read last kernel messages */
303 error
= verify_area(VERIFY_WRITE
,buf
,len
);
307 if (count
> log_buf_len
)
309 spin_lock_irq(&logbuf_lock
);
310 if (count
> logged_chars
)
311 count
= logged_chars
;
316 * __put_user() could sleep, and while we sleep
317 * printk() could overwrite the messages
318 * we try to copy to user space. Therefore
319 * the messages are copied in reverse. <manfreds>
321 for(i
= 0; i
< count
&& !error
; i
++) {
323 if (j
+ log_buf_len
< log_end
)
326 spin_unlock_irq(&logbuf_lock
);
327 error
= __put_user(c
,&buf
[count
-1-i
]);
328 spin_lock_irq(&logbuf_lock
);
330 spin_unlock_irq(&logbuf_lock
);
335 int offset
= count
-error
;
336 /* buffer overflow during copy, correct user buffer. */
337 for(i
=0;i
<error
;i
++) {
338 if (__get_user(c
,&buf
[i
+offset
]) ||
339 __put_user(c
,&buf
[i
])) {
346 case 5: /* Clear ring buffer */
349 case 6: /* Disable logging to console */
350 console_loglevel
= minimum_console_loglevel
;
352 case 7: /* Enable logging to console */
353 console_loglevel
= default_console_loglevel
;
355 case 8: /* Set level of messages printed to console */
357 if (len
< 1 || len
> 8)
359 if (len
< minimum_console_loglevel
)
360 len
= minimum_console_loglevel
;
361 console_loglevel
= len
;
364 case 9: /* Number of chars in the log buffer */
365 error
= log_end
- log_start
;
367 case 10: /* Size of the log buffer */
378 asmlinkage
long sys_syslog(int type
, char __user
* buf
, int len
)
380 return do_syslog(type
, buf
, len
);
384 * Call the console drivers on a range of log_buf
386 static void __call_console_drivers(unsigned long start
, unsigned long end
)
390 for (con
= console_drivers
; con
; con
= con
->next
) {
391 if ((con
->flags
& CON_ENABLED
) && con
->write
)
392 con
->write(con
, &LOG_BUF(start
), end
- start
);
397 * Write out chars from start to end - 1 inclusive
399 static void _call_console_drivers(unsigned long start
,
400 unsigned long end
, int msg_log_level
)
402 if (msg_log_level
< console_loglevel
&&
403 console_drivers
&& start
!= end
) {
404 if ((start
& LOG_BUF_MASK
) > (end
& LOG_BUF_MASK
)) {
406 __call_console_drivers(start
& LOG_BUF_MASK
,
408 __call_console_drivers(0, end
& LOG_BUF_MASK
);
410 __call_console_drivers(start
, end
);
416 * Call the console drivers, asking them to write out
417 * log_buf[start] to log_buf[end - 1].
418 * The console_sem must be held.
420 static void call_console_drivers(unsigned long start
, unsigned long end
)
422 unsigned long cur_index
, start_print
;
423 static int msg_level
= -1;
425 if (((long)(start
- end
)) > 0)
430 while (cur_index
!= end
) {
431 if ( msg_level
< 0 &&
432 ((end
- cur_index
) > 2) &&
433 LOG_BUF(cur_index
+ 0) == '<' &&
434 LOG_BUF(cur_index
+ 1) >= '0' &&
435 LOG_BUF(cur_index
+ 1) <= '7' &&
436 LOG_BUF(cur_index
+ 2) == '>')
438 msg_level
= LOG_BUF(cur_index
+ 1) - '0';
440 start_print
= cur_index
;
442 while (cur_index
!= end
) {
443 char c
= LOG_BUF(cur_index
);
449 * printk() has already given us loglevel tags in
450 * the buffer. This code is here in case the
451 * log buffer has wrapped right round and scribbled
454 msg_level
= default_message_loglevel
;
456 _call_console_drivers(start_print
, cur_index
, msg_level
);
458 start_print
= cur_index
;
463 _call_console_drivers(start_print
, end
, msg_level
);
466 static void emit_log_char(char c
)
468 LOG_BUF(log_end
) = c
;
470 if (log_end
- log_start
> log_buf_len
)
471 log_start
= log_end
- log_buf_len
;
472 if (log_end
- con_start
> log_buf_len
)
473 con_start
= log_end
- log_buf_len
;
474 if (logged_chars
< log_buf_len
)
479 * Zap console related locks when oopsing. Only zap at most once
480 * every 10 seconds, to leave time for slow consoles to print a
483 static void zap_locks(void)
485 static unsigned long oops_timestamp
;
487 if (time_after_eq(jiffies
, oops_timestamp
) &&
488 !time_after(jiffies
, oops_timestamp
+ 30*HZ
))
491 oops_timestamp
= jiffies
;
493 /* If a crash is occurring, make sure we can't deadlock */
494 spin_lock_init(&logbuf_lock
);
495 /* And make sure that we print immediately */
496 init_MUTEX(&console_sem
);
500 * This is printk. It can be called from any context. We want it to work.
502 * We try to grab the console_sem. If we succeed, it's easy - we log the output and
503 * call the console drivers. If we fail to get the semaphore we place the output
504 * into the log buffer and return. The current holder of the console_sem will
505 * notice the new output in release_console_sem() and will send it to the
506 * consoles before releasing the semaphore.
508 * One effect of this deferred printing is that code which calls printk() and
509 * then changes console_loglevel may break. This is because console_loglevel
510 * is inspected when the actual printing occurs.
512 asmlinkage
int printk(const char *fmt
, ...)
518 r
= vprintk(fmt
, args
);
524 asmlinkage
int vprintk(const char *fmt
, va_list args
)
529 static char printk_buf
[1024];
530 static int log_level_unknown
= 1;
532 if (unlikely(oops_in_progress
))
535 /* This stops the holder of console_sem just where we want him */
536 spin_lock_irqsave(&logbuf_lock
, flags
);
538 /* Emit the output into the temporary buffer */
539 printed_len
= vscnprintf(printk_buf
, sizeof(printk_buf
), fmt
, args
);
542 * Copy the output into log_buf. If the caller didn't provide
543 * appropriate log level tags, we insert them here
545 for (p
= printk_buf
; *p
; p
++) {
546 if (log_level_unknown
) {
547 if (p
[0] != '<' || p
[1] < '0' || p
[1] > '7' || p
[2] != '>') {
549 emit_log_char(default_message_loglevel
+ '0');
552 log_level_unknown
= 0;
556 log_level_unknown
= 1;
559 if (!cpu_online(smp_processor_id()) &&
560 system_state
!= SYSTEM_RUNNING
) {
562 * Some console drivers may assume that per-cpu resources have
563 * been allocated. So don't allow them to be called by this
564 * CPU until it is officially up. We shouldn't be calling into
565 * random console drivers on a CPU which doesn't exist yet..
567 spin_unlock_irqrestore(&logbuf_lock
, flags
);
570 if (!down_trylock(&console_sem
)) {
573 * We own the drivers. We can drop the spinlock and let
574 * release_console_sem() print the text
576 spin_unlock_irqrestore(&logbuf_lock
, flags
);
577 console_may_schedule
= 0;
578 release_console_sem();
581 * Someone else owns the drivers. We drop the spinlock, which
582 * allows the semaphore holder to proceed and to call the
583 * console drivers with the output which we just produced.
585 spin_unlock_irqrestore(&logbuf_lock
, flags
);
590 EXPORT_SYMBOL(printk
);
591 EXPORT_SYMBOL(vprintk
);
594 * acquire_console_sem - lock the console system for exclusive use.
596 * Acquires a semaphore which guarantees that the caller has
597 * exclusive access to the console system and the console_drivers list.
599 * Can sleep, returns nothing.
601 void acquire_console_sem(void)
607 console_may_schedule
= 1;
609 EXPORT_SYMBOL(acquire_console_sem
);
611 int is_console_locked(void)
613 return console_locked
;
615 EXPORT_SYMBOL(is_console_locked
);
618 * release_console_sem - unlock the console system
620 * Releases the semaphore which the caller holds on the console system
621 * and the console driver list.
623 * While the semaphore was held, console output may have been buffered
624 * by printk(). If this is the case, release_console_sem() emits
625 * the output prior to releasing the semaphore.
627 * If there is output waiting for klogd, we wake it up.
629 * release_console_sem() may be called from any context.
631 void release_console_sem(void)
634 unsigned long _con_start
, _log_end
;
635 unsigned long wake_klogd
= 0;
638 spin_lock_irqsave(&logbuf_lock
, flags
);
639 wake_klogd
|= log_start
- log_end
;
640 if (con_start
== log_end
)
641 break; /* Nothing to print */
642 _con_start
= con_start
;
644 con_start
= log_end
; /* Flush */
645 spin_unlock_irqrestore(&logbuf_lock
, flags
);
646 call_console_drivers(_con_start
, _log_end
);
649 console_may_schedule
= 0;
651 spin_unlock_irqrestore(&logbuf_lock
, flags
);
652 if (wake_klogd
&& !oops_in_progress
&& waitqueue_active(&log_wait
))
653 wake_up_interruptible(&log_wait
);
655 EXPORT_SYMBOL(release_console_sem
);
657 /** console_conditional_schedule - yield the CPU if required
659 * If the console code is currently allowed to sleep, and
660 * if this CPU should yield the CPU to another task, do
663 * Must be called within acquire_console_sem().
665 void __sched
console_conditional_schedule(void)
667 if (console_may_schedule
)
670 EXPORT_SYMBOL(console_conditional_schedule
);
672 void console_print(const char *s
)
674 printk(KERN_EMERG
"%s", s
);
676 EXPORT_SYMBOL(console_print
);
678 void console_unblank(void)
683 * Try to get the console semaphore. If someone else owns it
684 * we have to return without unblanking because console_unblank
685 * may be called in interrupt context.
687 if (down_trylock(&console_sem
) != 0)
690 console_may_schedule
= 0;
691 for (c
= console_drivers
; c
!= NULL
; c
= c
->next
)
692 if ((c
->flags
& CON_ENABLED
) && c
->unblank
)
694 release_console_sem();
696 EXPORT_SYMBOL(console_unblank
);
699 * Return the console tty driver structure and its associated index
701 struct tty_driver
*console_device(int *index
)
704 struct tty_driver
*driver
= NULL
;
706 acquire_console_sem();
707 for (c
= console_drivers
; c
!= NULL
; c
= c
->next
) {
710 driver
= c
->device(c
, index
);
714 release_console_sem();
719 * Prevent further output on the passed console device so that (for example)
720 * serial drivers can disable console output before suspending a port, and can
721 * re-enable output afterwards.
723 void console_stop(struct console
*console
)
725 acquire_console_sem();
726 console
->flags
&= ~CON_ENABLED
;
727 release_console_sem();
729 EXPORT_SYMBOL(console_stop
);
731 void console_start(struct console
*console
)
733 acquire_console_sem();
734 console
->flags
|= CON_ENABLED
;
735 release_console_sem();
737 EXPORT_SYMBOL(console_start
);
740 * The console driver calls this routine during kernel initialization
741 * to register the console printing procedure with printk() and to
742 * print any messages that were printed by the kernel before the
743 * console driver was initialized.
745 void register_console(struct console
* console
)
750 if (preferred_console
< 0)
751 preferred_console
= selected_console
;
754 * See if we want to use this console driver. If we
755 * didn't select a console we take the first one
756 * that registers here.
758 if (preferred_console
< 0) {
759 if (console
->index
< 0)
761 if (console
->setup
== NULL
||
762 console
->setup(console
, NULL
) == 0) {
763 console
->flags
|= CON_ENABLED
| CON_CONSDEV
;
764 preferred_console
= 0;
769 * See if this console matches one we selected on
772 for(i
= 0; i
< MAX_CMDLINECONSOLES
&& console_cmdline
[i
].name
[0]; i
++) {
773 if (strcmp(console_cmdline
[i
].name
, console
->name
) != 0)
775 if (console
->index
>= 0 &&
776 console
->index
!= console_cmdline
[i
].index
)
778 if (console
->index
< 0)
779 console
->index
= console_cmdline
[i
].index
;
780 if (console
->setup
&&
781 console
->setup(console
, console_cmdline
[i
].options
) != 0)
783 console
->flags
|= CON_ENABLED
;
784 console
->index
= console_cmdline
[i
].index
;
785 if (i
== preferred_console
)
786 console
->flags
|= CON_CONSDEV
;
790 if (!(console
->flags
& CON_ENABLED
))
794 * Put this console in the list - keep the
795 * preferred driver at the head of the list.
797 acquire_console_sem();
798 if ((console
->flags
& CON_CONSDEV
) || console_drivers
== NULL
) {
799 console
->next
= console_drivers
;
800 console_drivers
= console
;
802 console
->next
= console_drivers
->next
;
803 console_drivers
->next
= console
;
805 if (console
->flags
& CON_PRINTBUFFER
) {
807 * release_console_sem() will print out the buffered messages
810 spin_lock_irqsave(&logbuf_lock
, flags
);
811 con_start
= log_start
;
812 spin_unlock_irqrestore(&logbuf_lock
, flags
);
814 release_console_sem();
816 EXPORT_SYMBOL(register_console
);
818 int unregister_console(struct console
* console
)
820 struct console
*a
,*b
;
823 acquire_console_sem();
824 if (console_drivers
== console
) {
825 console_drivers
=console
->next
;
828 for (a
=console_drivers
->next
, b
=console_drivers
;
838 /* If last console is removed, we re-enable picking the first
839 * one that gets registered. Without that, pmac early boot console
840 * would prevent fbcon from taking over.
842 if (console_drivers
== NULL
)
843 preferred_console
= selected_console
;
846 release_console_sem();
849 EXPORT_SYMBOL(unregister_console
);
852 * tty_write_message - write a message to a certain tty, not just the console.
854 * This is used for messages that need to be redirected to a specific tty.
855 * We don't put it into the syslog queue right now maybe in the future if
858 void tty_write_message(struct tty_struct
*tty
, char *msg
)
860 if (tty
&& tty
->driver
->write
)
861 tty
->driver
->write(tty
, msg
, strlen(msg
));
866 * printk rate limiting, lifted from the networking subsystem.
868 * This enforces a rate limit: not more than one kernel message
869 * every printk_ratelimit_jiffies to make a denial-of-service
872 int __printk_ratelimit(int ratelimit_jiffies
, int ratelimit_burst
)
874 static spinlock_t ratelimit_lock
= SPIN_LOCK_UNLOCKED
;
875 static unsigned long toks
= 10*5*HZ
;
876 static unsigned long last_msg
;
879 unsigned long now
= jiffies
;
881 spin_lock_irqsave(&ratelimit_lock
, flags
);
882 toks
+= now
- last_msg
;
884 if (toks
> (ratelimit_burst
* ratelimit_jiffies
))
885 toks
= ratelimit_burst
* ratelimit_jiffies
;
886 if (toks
>= ratelimit_jiffies
) {
889 toks
-= ratelimit_jiffies
;
890 spin_unlock_irqrestore(&ratelimit_lock
, flags
);
892 printk(KERN_WARNING
"printk: %d messages suppressed.\n", lost
);
896 spin_unlock_irqrestore(&ratelimit_lock
, flags
);
899 EXPORT_SYMBOL(__printk_ratelimit
);
901 /* minimum time in jiffies between messages */
902 int printk_ratelimit_jiffies
= 5*HZ
;
904 /* number of messages we send before ratelimiting */
905 int printk_ratelimit_burst
= 10;
907 int printk_ratelimit(void)
909 return __printk_ratelimit(printk_ratelimit_jiffies
,
910 printk_ratelimit_burst
);
912 EXPORT_SYMBOL(printk_ratelimit
);