Root/kernel/printk.c

1/*
2 * linux/kernel/printk.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
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).
11 * Ted Ts'o, 2/11/93.
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
17 */
18
19#include <linux/kernel.h>
20#include <linux/mm.h>
21#include <linux/tty.h>
22#include <linux/tty_driver.h>
23#include <linux/console.h>
24#include <linux/init.h>
25#include <linux/jiffies.h>
26#include <linux/nmi.h>
27#include <linux/module.h>
28#include <linux/moduleparam.h>
29#include <linux/interrupt.h> /* 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
37#include <asm/uaccess.h>
38
39/*
40 * for_each_console() allows you to iterate on each console
41 */
42#define for_each_console(con) \
43    for (con = console_drivers; con != NULL; con = con->next)
44
45/*
46 * Architectures can override it:
47 */
48void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
49{
50}
51
52#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
53
54/* printk's without a loglevel use this.. */
55#define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
56
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 */
60
61DECLARE_WAIT_QUEUE_HEAD(log_wait);
62
63int 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 */
68};
69
70static int saved_console_loglevel = -1;
71
72/*
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.
75 */
76int oops_in_progress;
77EXPORT_SYMBOL(oops_in_progress);
78
79/*
80 * console_sem protects the console_drivers list, and also
81 * provides serialisation for access to the entire console
82 * driver system.
83 */
84static DECLARE_MUTEX(console_sem);
85struct console *console_drivers;
86EXPORT_SYMBOL_GPL(console_drivers);
87
88/*
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
95 */
96static int console_locked, console_suspended;
97
98/*
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
101 * release_console_sem().
102 */
103static DEFINE_SPINLOCK(logbuf_lock);
104
105#define LOG_BUF_MASK (log_buf_len-1)
106#define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
107
108/*
109 * The indices into log_buf are not constrained to log_buf_len - they
110 * must be masked before subscripting
111 */
112static unsigned log_start; /* Index into log_buf: next char to be read by syslog() */
113static unsigned con_start; /* Index into log_buf: next char to be sent to consoles */
114static unsigned log_end; /* Index into log_buf: most-recently-written-char + 1 */
115
116/*
117 * Array of consoles built from command line options (console=)
118 */
119struct console_cmdline
120{
121    char name[8]; /* Name of the driver */
122    int index; /* Minor dev. to use */
123    char *options; /* Options for the driver */
124#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
125    char *brl_options; /* Options for braille driver */
126#endif
127};
128
129#define MAX_CMDLINECONSOLES 8
130
131static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
132static int selected_console = -1;
133static int preferred_console = -1;
134int console_set_on_cmdline;
135EXPORT_SYMBOL(console_set_on_cmdline);
136
137/* Flag: console code may call schedule() */
138static int console_may_schedule;
139
140#ifdef CONFIG_PRINTK
141
142static char __log_buf[__LOG_BUF_LEN];
143static char *log_buf = __log_buf;
144static int log_buf_len = __LOG_BUF_LEN;
145static unsigned logged_chars; /* Number of chars produced since last read+clear operation */
146
147#ifdef CONFIG_KEXEC
148/*
149 * This appends the listed symbols to /proc/vmcoreinfo
150 *
151 * /proc/vmcoreinfo is used by various utiilties, like crash and makedumpfile to
152 * obtain access to symbols that are otherwise very difficult to locate. These
153 * symbols are specifically used so that utilities can access and extract the
154 * dmesg log from a vmcore file after a crash.
155 */
156void log_buf_kexec_setup(void)
157{
158    VMCOREINFO_SYMBOL(log_buf);
159    VMCOREINFO_SYMBOL(log_end);
160    VMCOREINFO_SYMBOL(log_buf_len);
161    VMCOREINFO_SYMBOL(logged_chars);
162}
163#endif
164
165static int __init log_buf_len_setup(char *str)
166{
167    unsigned size = memparse(str, &str);
168    unsigned long flags;
169
170    if (size)
171        size = roundup_pow_of_two(size);
172    if (size > log_buf_len) {
173        unsigned start, dest_idx, offset;
174        char *new_log_buf;
175
176        new_log_buf = alloc_bootmem(size);
177        if (!new_log_buf) {
178            printk(KERN_WARNING "log_buf_len: allocation failed\n");
179            goto out;
180        }
181
182        spin_lock_irqsave(&logbuf_lock, flags);
183        log_buf_len = size;
184        log_buf = new_log_buf;
185
186        offset = start = min(con_start, log_start);
187        dest_idx = 0;
188        while (start != log_end) {
189            log_buf[dest_idx] = __log_buf[start & (__LOG_BUF_LEN - 1)];
190            start++;
191            dest_idx++;
192        }
193        log_start -= offset;
194        con_start -= offset;
195        log_end -= offset;
196        spin_unlock_irqrestore(&logbuf_lock, flags);
197
198        printk(KERN_NOTICE "log_buf_len: %d\n", log_buf_len);
199    }
200out:
201    return 1;
202}
203
204__setup("log_buf_len=", log_buf_len_setup);
205
206#ifdef CONFIG_BOOT_PRINTK_DELAY
207
208static unsigned int boot_delay; /* msecs delay after each printk during bootup */
209static unsigned long long loops_per_msec; /* based on boot_delay */
210
211static int __init boot_delay_setup(char *str)
212{
213    unsigned long lpj;
214
215    lpj = preset_lpj ? preset_lpj : 1000000; /* some guess */
216    loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
217
218    get_option(&str, &boot_delay);
219    if (boot_delay > 10 * 1000)
220        boot_delay = 0;
221
222    pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
223        "HZ: %d, loops_per_msec: %llu\n",
224        boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
225    return 1;
226}
227__setup("boot_delay=", boot_delay_setup);
228
229static void boot_delay_msec(void)
230{
231    unsigned long long k;
232    unsigned long timeout;
233
234    if (boot_delay == 0 || system_state != SYSTEM_BOOTING)
235        return;
236
237    k = (unsigned long long)loops_per_msec * boot_delay;
238
239    timeout = jiffies + msecs_to_jiffies(boot_delay);
240    while (k) {
241        k--;
242        cpu_relax();
243        /*
244         * use (volatile) jiffies to prevent
245         * compiler reduction; loop termination via jiffies
246         * is secondary and may or may not happen.
247         */
248        if (time_after(jiffies, timeout))
249            break;
250        touch_nmi_watchdog();
251    }
252}
253#else
254static inline void boot_delay_msec(void)
255{
256}
257#endif
258
259/*
260 * Commands to do_syslog:
261 *
262 * 0 -- Close the log. Currently a NOP.
263 * 1 -- Open the log. Currently a NOP.
264 * 2 -- Read from the log.
265 * 3 -- Read all messages remaining in the ring buffer.
266 * 4 -- Read and clear all messages remaining in the ring buffer
267 * 5 -- Clear ring buffer.
268 * 6 -- Disable printk's to console
269 * 7 -- Enable printk's to console
270 * 8 -- Set level of messages printed to console
271 * 9 -- Return number of unread characters in the log buffer
272 * 10 -- Return size of the log buffer
273 */
274int do_syslog(int type, char __user *buf, int len)
275{
276    unsigned i, j, limit, count;
277    int do_clear = 0;
278    char c;
279    int error = 0;
280
281    error = security_syslog(type);
282    if (error)
283        return error;
284
285    switch (type) {
286    case 0: /* Close log */
287        break;
288    case 1: /* Open log */
289        break;
290    case 2: /* Read from log */
291        error = -EINVAL;
292        if (!buf || len < 0)
293            goto out;
294        error = 0;
295        if (!len)
296            goto out;
297        if (!access_ok(VERIFY_WRITE, buf, len)) {
298            error = -EFAULT;
299            goto out;
300        }
301        error = wait_event_interruptible(log_wait,
302                            (log_start - log_end));
303        if (error)
304            goto out;
305        i = 0;
306        spin_lock_irq(&logbuf_lock);
307        while (!error && (log_start != log_end) && i < len) {
308            c = LOG_BUF(log_start);
309            log_start++;
310            spin_unlock_irq(&logbuf_lock);
311            error = __put_user(c,buf);
312            buf++;
313            i++;
314            cond_resched();
315            spin_lock_irq(&logbuf_lock);
316        }
317        spin_unlock_irq(&logbuf_lock);
318        if (!error)
319            error = i;
320        break;
321    case 4: /* Read/clear last kernel messages */
322        do_clear = 1;
323        /* FALL THRU */
324    case 3: /* Read last kernel messages */
325        error = -EINVAL;
326        if (!buf || len < 0)
327            goto out;
328        error = 0;
329        if (!len)
330            goto out;
331        if (!access_ok(VERIFY_WRITE, buf, len)) {
332            error = -EFAULT;
333            goto out;
334        }
335        count = len;
336        if (count > log_buf_len)
337            count = log_buf_len;
338        spin_lock_irq(&logbuf_lock);
339        if (count > logged_chars)
340            count = logged_chars;
341        if (do_clear)
342            logged_chars = 0;
343        limit = log_end;
344        /*
345         * __put_user() could sleep, and while we sleep
346         * printk() could overwrite the messages
347         * we try to copy to user space. Therefore
348         * the messages are copied in reverse. <manfreds>
349         */
350        for (i = 0; i < count && !error; i++) {
351            j = limit-1-i;
352            if (j + log_buf_len < log_end)
353                break;
354            c = LOG_BUF(j);
355            spin_unlock_irq(&logbuf_lock);
356            error = __put_user(c,&buf[count-1-i]);
357            cond_resched();
358            spin_lock_irq(&logbuf_lock);
359        }
360        spin_unlock_irq(&logbuf_lock);
361        if (error)
362            break;
363        error = i;
364        if (i != count) {
365            int offset = count-error;
366            /* buffer overflow during copy, correct user buffer. */
367            for (i = 0; i < error; i++) {
368                if (__get_user(c,&buf[i+offset]) ||
369                    __put_user(c,&buf[i])) {
370                    error = -EFAULT;
371                    break;
372                }
373                cond_resched();
374            }
375        }
376        break;
377    case 5: /* Clear ring buffer */
378        logged_chars = 0;
379        break;
380    case 6: /* Disable logging to console */
381        if (saved_console_loglevel == -1)
382            saved_console_loglevel = console_loglevel;
383        console_loglevel = minimum_console_loglevel;
384        break;
385    case 7: /* Enable logging to console */
386        if (saved_console_loglevel != -1) {
387            console_loglevel = saved_console_loglevel;
388            saved_console_loglevel = -1;
389        }
390        break;
391    case 8: /* Set level of messages printed to console */
392        error = -EINVAL;
393        if (len < 1 || len > 8)
394            goto out;
395        if (len < minimum_console_loglevel)
396            len = minimum_console_loglevel;
397        console_loglevel = len;
398        /* Implicitly re-enable logging to console */
399        saved_console_loglevel = -1;
400        error = 0;
401        break;
402    case 9: /* Number of chars in the log buffer */
403        error = log_end - log_start;
404        break;
405    case 10: /* Size of the log buffer */
406        error = log_buf_len;
407        break;
408    default:
409        error = -EINVAL;
410        break;
411    }
412out:
413    return error;
414}
415
416SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
417{
418    return do_syslog(type, buf, len);
419}
420
421/*
422 * Call the console drivers on a range of log_buf
423 */
424static void __call_console_drivers(unsigned start, unsigned end)
425{
426    struct console *con;
427
428    for_each_console(con) {
429        if ((con->flags & CON_ENABLED) && con->write &&
430                (cpu_online(smp_processor_id()) ||
431                (con->flags & CON_ANYTIME)))
432            con->write(con, &LOG_BUF(start), end - start);
433    }
434}
435
436static int __read_mostly ignore_loglevel;
437
438static int __init ignore_loglevel_setup(char *str)
439{
440    ignore_loglevel = 1;
441    printk(KERN_INFO "debug: ignoring loglevel setting.\n");
442
443    return 0;
444}
445
446early_param("ignore_loglevel", ignore_loglevel_setup);
447
448/*
449 * Write out chars from start to end - 1 inclusive
450 */
451static void _call_console_drivers(unsigned start,
452                unsigned end, int msg_log_level)
453{
454    if ((msg_log_level < console_loglevel || ignore_loglevel) &&
455            console_drivers && start != end) {
456        if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
457            /* wrapped write */
458            __call_console_drivers(start & LOG_BUF_MASK,
459                        log_buf_len);
460            __call_console_drivers(0, end & LOG_BUF_MASK);
461        } else {
462            __call_console_drivers(start, end);
463        }
464    }
465}
466
467/*
468 * Call the console drivers, asking them to write out
469 * log_buf[start] to log_buf[end - 1].
470 * The console_sem must be held.
471 */
472static void call_console_drivers(unsigned start, unsigned end)
473{
474    unsigned cur_index, start_print;
475    static int msg_level = -1;
476
477    BUG_ON(((int)(start - end)) > 0);
478
479    cur_index = start;
480    start_print = start;
481    while (cur_index != end) {
482        if (msg_level < 0 && ((end - cur_index) > 2) &&
483                LOG_BUF(cur_index + 0) == '<' &&
484                LOG_BUF(cur_index + 1) >= '0' &&
485                LOG_BUF(cur_index + 1) <= '7' &&
486                LOG_BUF(cur_index + 2) == '>') {
487            msg_level = LOG_BUF(cur_index + 1) - '0';
488            cur_index += 3;
489            start_print = cur_index;
490        }
491        while (cur_index != end) {
492            char c = LOG_BUF(cur_index);
493
494            cur_index++;
495            if (c == '\n') {
496                if (msg_level < 0) {
497                    /*
498                     * printk() has already given us loglevel tags in
499                     * the buffer. This code is here in case the
500                     * log buffer has wrapped right round and scribbled
501                     * on those tags
502                     */
503                    msg_level = default_message_loglevel;
504                }
505                _call_console_drivers(start_print, cur_index, msg_level);
506                msg_level = -1;
507                start_print = cur_index;
508                break;
509            }
510        }
511    }
512    _call_console_drivers(start_print, end, msg_level);
513}
514
515static void emit_log_char(char c)
516{
517    LOG_BUF(log_end) = c;
518    log_end++;
519    if (log_end - log_start > log_buf_len)
520        log_start = log_end - log_buf_len;
521    if (log_end - con_start > log_buf_len)
522        con_start = log_end - log_buf_len;
523    if (logged_chars < log_buf_len)
524        logged_chars++;
525}
526
527/*
528 * Zap console related locks when oopsing. Only zap at most once
529 * every 10 seconds, to leave time for slow consoles to print a
530 * full oops.
531 */
532static void zap_locks(void)
533{
534    static unsigned long oops_timestamp;
535
536    if (time_after_eq(jiffies, oops_timestamp) &&
537            !time_after(jiffies, oops_timestamp + 30 * HZ))
538        return;
539
540    oops_timestamp = jiffies;
541
542    /* If a crash is occurring, make sure we can't deadlock */
543    spin_lock_init(&logbuf_lock);
544    /* And make sure that we print immediately */
545    init_MUTEX(&console_sem);
546}
547
548#if defined(CONFIG_PRINTK_TIME)
549static int printk_time = 1;
550#else
551static int printk_time = 0;
552#endif
553module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
554
555/* Check if we have any console registered that can be called early in boot. */
556static int have_callable_console(void)
557{
558    struct console *con;
559
560    for_each_console(con)
561        if (con->flags & CON_ANYTIME)
562            return 1;
563
564    return 0;
565}
566
567/**
568 * printk - print a kernel message
569 * @fmt: format string
570 *
571 * This is printk(). It can be called from any context. We want it to work.
572 *
573 * We try to grab the console_sem. If we succeed, it's easy - we log the output and
574 * call the console drivers. If we fail to get the semaphore we place the output
575 * into the log buffer and return. The current holder of the console_sem will
576 * notice the new output in release_console_sem() and will send it to the
577 * consoles before releasing the semaphore.
578 *
579 * One effect of this deferred printing is that code which calls printk() and
580 * then changes console_loglevel may break. This is because console_loglevel
581 * is inspected when the actual printing occurs.
582 *
583 * See also:
584 * printf(3)
585 *
586 * See the vsnprintf() documentation for format string extensions over C99.
587 */
588
589asmlinkage int printk(const char *fmt, ...)
590{
591    va_list args;
592    int r;
593
594    va_start(args, fmt);
595    r = vprintk(fmt, args);
596    va_end(args);
597
598    return r;
599}
600
601/* cpu currently holding logbuf_lock */
602static volatile unsigned int printk_cpu = UINT_MAX;
603
604/*
605 * Can we actually use the console at this time on this cpu?
606 *
607 * Console drivers may assume that per-cpu resources have
608 * been allocated. So unless they're explicitly marked as
609 * being able to cope (CON_ANYTIME) don't call them until
610 * this CPU is officially up.
611 */
612static inline int can_use_console(unsigned int cpu)
613{
614    return cpu_online(cpu) || have_callable_console();
615}
616
617/*
618 * Try to get console ownership to actually show the kernel
619 * messages from a 'printk'. Return true (and with the
620 * console_semaphore held, and 'console_locked' set) if it
621 * is successful, false otherwise.
622 *
623 * This gets called with the 'logbuf_lock' spinlock held and
624 * interrupts disabled. It should return with 'lockbuf_lock'
625 * released but interrupts still disabled.
626 */
627static int acquire_console_semaphore_for_printk(unsigned int cpu)
628{
629    int retval = 0;
630
631    if (!try_acquire_console_sem()) {
632        retval = 1;
633
634        /*
635         * If we can't use the console, we need to release
636         * the console semaphore by hand to avoid flushing
637         * the buffer. We need to hold the console semaphore
638         * in order to do this test safely.
639         */
640        if (!can_use_console(cpu)) {
641            console_locked = 0;
642            up(&console_sem);
643            retval = 0;
644        }
645    }
646    printk_cpu = UINT_MAX;
647    spin_unlock(&logbuf_lock);
648    return retval;
649}
650static const char recursion_bug_msg [] =
651        KERN_CRIT "BUG: recent printk recursion!\n";
652static int recursion_bug;
653static int new_text_line = 1;
654static char printk_buf[1024];
655
656int printk_delay_msec __read_mostly;
657
658static inline void printk_delay(void)
659{
660    if (unlikely(printk_delay_msec)) {
661        int m = printk_delay_msec;
662
663        while (m--) {
664            mdelay(1);
665            touch_nmi_watchdog();
666        }
667    }
668}
669
670asmlinkage int vprintk(const char *fmt, va_list args)
671{
672    int printed_len = 0;
673    int current_log_level = default_message_loglevel;
674    unsigned long flags;
675    int this_cpu;
676    char *p;
677
678    boot_delay_msec();
679    printk_delay();
680
681    preempt_disable();
682    /* This stops the holder of console_sem just where we want him */
683    raw_local_irq_save(flags);
684    this_cpu = smp_processor_id();
685
686    /*
687     * Ouch, printk recursed into itself!
688     */
689    if (unlikely(printk_cpu == this_cpu)) {
690        /*
691         * If a crash is occurring during printk() on this CPU,
692         * then try to get the crash message out but make sure
693         * we can't deadlock. Otherwise just return to avoid the
694         * recursion and return - but flag the recursion so that
695         * it can be printed at the next appropriate moment:
696         */
697        if (!oops_in_progress) {
698            recursion_bug = 1;
699            goto out_restore_irqs;
700        }
701        zap_locks();
702    }
703
704    lockdep_off();
705    spin_lock(&logbuf_lock);
706    printk_cpu = this_cpu;
707
708    if (recursion_bug) {
709        recursion_bug = 0;
710        strcpy(printk_buf, recursion_bug_msg);
711        printed_len = strlen(recursion_bug_msg);
712    }
713    /* Emit the output into the temporary buffer */
714    printed_len += vscnprintf(printk_buf + printed_len,
715                  sizeof(printk_buf) - printed_len, fmt, args);
716
717
718    p = printk_buf;
719
720    /* Do we have a loglevel in the string? */
721    if (p[0] == '<') {
722        unsigned char c = p[1];
723        if (c && p[2] == '>') {
724            switch (c) {
725            case '0' ... '7': /* loglevel */
726                current_log_level = c - '0';
727            /* Fallthrough - make sure we're on a new line */
728            case 'd': /* KERN_DEFAULT */
729                if (!new_text_line) {
730                    emit_log_char('\n');
731                    new_text_line = 1;
732                }
733            /* Fallthrough - skip the loglevel */
734            case 'c': /* KERN_CONT */
735                p += 3;
736                break;
737            }
738        }
739    }
740
741    /*
742     * Copy the output into log_buf. If the caller didn't provide
743     * appropriate log level tags, we insert them here
744     */
745    for ( ; *p; p++) {
746        if (new_text_line) {
747            /* Always output the token */
748            emit_log_char('<');
749            emit_log_char(current_log_level + '0');
750            emit_log_char('>');
751            printed_len += 3;
752            new_text_line = 0;
753
754            if (printk_time) {
755                /* Follow the token with the time */
756                char tbuf[50], *tp;
757                unsigned tlen;
758                unsigned long long t;
759                unsigned long nanosec_rem;
760
761                t = cpu_clock(printk_cpu);
762                nanosec_rem = do_div(t, 1000000000);
763                tlen = sprintf(tbuf, "[%5lu.%06lu] ",
764                        (unsigned long) t,
765                        nanosec_rem / 1000);
766
767                for (tp = tbuf; tp < tbuf + tlen; tp++)
768                    emit_log_char(*tp);
769                printed_len += tlen;
770            }
771
772            if (!*p)
773                break;
774        }
775
776        emit_log_char(*p);
777        if (*p == '\n')
778            new_text_line = 1;
779    }
780
781    /*
782     * Try to acquire and then immediately release the
783     * console semaphore. The release will do all the
784     * actual magic (print out buffers, wake up klogd,
785     * etc).
786     *
787     * The acquire_console_semaphore_for_printk() function
788     * will release 'logbuf_lock' regardless of whether it
789     * actually gets the semaphore or not.
790     */
791    if (acquire_console_semaphore_for_printk(this_cpu))
792        release_console_sem();
793
794    lockdep_on();
795out_restore_irqs:
796    raw_local_irq_restore(flags);
797
798    preempt_enable();
799    return printed_len;
800}
801EXPORT_SYMBOL(printk);
802EXPORT_SYMBOL(vprintk);
803
804#else
805
806static void call_console_drivers(unsigned start, unsigned end)
807{
808}
809
810#endif
811
812static int __add_preferred_console(char *name, int idx, char *options,
813                   char *brl_options)
814{
815    struct console_cmdline *c;
816    int i;
817
818    /*
819     * See if this tty is not yet registered, and
820     * if we have a slot free.
821     */
822    for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
823        if (strcmp(console_cmdline[i].name, name) == 0 &&
824              console_cmdline[i].index == idx) {
825                if (!brl_options)
826                    selected_console = i;
827                return 0;
828        }
829    if (i == MAX_CMDLINECONSOLES)
830        return -E2BIG;
831    if (!brl_options)
832        selected_console = i;
833    c = &console_cmdline[i];
834    strlcpy(c->name, name, sizeof(c->name));
835    c->options = options;
836#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
837    c->brl_options = brl_options;
838#endif
839    c->index = idx;
840    return 0;
841}
842/*
843 * Set up a list of consoles. Called from init/main.c
844 */
845static int __init console_setup(char *str)
846{
847    char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */
848    char *s, *options, *brl_options = NULL;
849    int idx;
850
851#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
852    if (!memcmp(str, "brl,", 4)) {
853        brl_options = "";
854        str += 4;
855    } else if (!memcmp(str, "brl=", 4)) {
856        brl_options = str + 4;
857        str = strchr(brl_options, ',');
858        if (!str) {
859            printk(KERN_ERR "need port name after brl=\n");
860            return 1;
861        }
862        *(str++) = 0;
863    }
864#endif
865
866    /*
867     * Decode str into name, index, options.
868     */
869    if (str[0] >= '0' && str[0] <= '9') {
870        strcpy(buf, "ttyS");
871        strncpy(buf + 4, str, sizeof(buf) - 5);
872    } else {
873        strncpy(buf, str, sizeof(buf) - 1);
874    }
875    buf[sizeof(buf) - 1] = 0;
876    if ((options = strchr(str, ',')) != NULL)
877        *(options++) = 0;
878#ifdef __sparc__
879    if (!strcmp(str, "ttya"))
880        strcpy(buf, "ttyS0");
881    if (!strcmp(str, "ttyb"))
882        strcpy(buf, "ttyS1");
883#endif
884    for (s = buf; *s; s++)
885        if ((*s >= '0' && *s <= '9') || *s == ',')
886            break;
887    idx = simple_strtoul(s, NULL, 10);
888    *s = 0;
889
890    __add_preferred_console(buf, idx, options, brl_options);
891    console_set_on_cmdline = 1;
892    return 1;
893}
894__setup("console=", console_setup);
895
896/**
897 * add_preferred_console - add a device to the list of preferred consoles.
898 * @name: device name
899 * @idx: device index
900 * @options: options for this console
901 *
902 * The last preferred console added will be used for kernel messages
903 * and stdin/out/err for init. Normally this is used by console_setup
904 * above to handle user-supplied console arguments; however it can also
905 * be used by arch-specific code either to override the user or more
906 * commonly to provide a default console (ie from PROM variables) when
907 * the user has not supplied one.
908 */
909int add_preferred_console(char *name, int idx, char *options)
910{
911    return __add_preferred_console(name, idx, options, NULL);
912}
913
914int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
915{
916    struct console_cmdline *c;
917    int i;
918
919    for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
920        if (strcmp(console_cmdline[i].name, name) == 0 &&
921              console_cmdline[i].index == idx) {
922                c = &console_cmdline[i];
923                strlcpy(c->name, name_new, sizeof(c->name));
924                c->name[sizeof(c->name) - 1] = 0;
925                c->options = options;
926                c->index = idx_new;
927                return i;
928        }
929    /* not found */
930    return -1;
931}
932
933int console_suspend_enabled = 1;
934EXPORT_SYMBOL(console_suspend_enabled);
935
936static int __init console_suspend_disable(char *str)
937{
938    console_suspend_enabled = 0;
939    return 1;
940}
941__setup("no_console_suspend", console_suspend_disable);
942
943/**
944 * suspend_console - suspend the console subsystem
945 *
946 * This disables printk() while we go into suspend states
947 */
948void suspend_console(void)
949{
950    if (!console_suspend_enabled)
951        return;
952    printk("Suspending console(s) (use no_console_suspend to debug)\n");
953    acquire_console_sem();
954    console_suspended = 1;
955    up(&console_sem);
956}
957
958void resume_console(void)
959{
960    if (!console_suspend_enabled)
961        return;
962    down(&console_sem);
963    console_suspended = 0;
964    release_console_sem();
965}
966
967/**
968 * acquire_console_sem - lock the console system for exclusive use.
969 *
970 * Acquires a semaphore which guarantees that the caller has
971 * exclusive access to the console system and the console_drivers list.
972 *
973 * Can sleep, returns nothing.
974 */
975void acquire_console_sem(void)
976{
977    BUG_ON(in_interrupt());
978    down(&console_sem);
979    if (console_suspended)
980        return;
981    console_locked = 1;
982    console_may_schedule = 1;
983}
984EXPORT_SYMBOL(acquire_console_sem);
985
986int try_acquire_console_sem(void)
987{
988    if (down_trylock(&console_sem))
989        return -1;
990    if (console_suspended) {
991        up(&console_sem);
992        return -1;
993    }
994    console_locked = 1;
995    console_may_schedule = 0;
996    return 0;
997}
998EXPORT_SYMBOL(try_acquire_console_sem);
999
1000int is_console_locked(void)
1001{
1002    return console_locked;
1003}
1004
1005static DEFINE_PER_CPU(int, printk_pending);
1006
1007void printk_tick(void)
1008{
1009    if (__get_cpu_var(printk_pending)) {
1010        __get_cpu_var(printk_pending) = 0;
1011        wake_up_interruptible(&log_wait);
1012    }
1013}
1014
1015int printk_needs_cpu(int cpu)
1016{
1017    return per_cpu(printk_pending, cpu);
1018}
1019
1020void wake_up_klogd(void)
1021{
1022    if (waitqueue_active(&log_wait))
1023        __raw_get_cpu_var(printk_pending) = 1;
1024}
1025
1026/**
1027 * release_console_sem - unlock the console system
1028 *
1029 * Releases the semaphore which the caller holds on the console system
1030 * and the console driver list.
1031 *
1032 * While the semaphore was held, console output may have been buffered
1033 * by printk(). If this is the case, release_console_sem() emits
1034 * the output prior to releasing the semaphore.
1035 *
1036 * If there is output waiting for klogd, we wake it up.
1037 *
1038 * release_console_sem() may be called from any context.
1039 */
1040void release_console_sem(void)
1041{
1042    unsigned long flags;
1043    unsigned _con_start, _log_end;
1044    unsigned wake_klogd = 0;
1045
1046    if (console_suspended) {
1047        up(&console_sem);
1048        return;
1049    }
1050
1051    console_may_schedule = 0;
1052
1053    for ( ; ; ) {
1054        spin_lock_irqsave(&logbuf_lock, flags);
1055        wake_klogd |= log_start - log_end;
1056        if (con_start == log_end)
1057            break; /* Nothing to print */
1058        _con_start = con_start;
1059        _log_end = log_end;
1060        con_start = log_end; /* Flush */
1061        spin_unlock(&logbuf_lock);
1062        stop_critical_timings(); /* don't trace print latency */
1063        call_console_drivers(_con_start, _log_end);
1064        start_critical_timings();
1065        local_irq_restore(flags);
1066    }
1067    console_locked = 0;
1068    up(&console_sem);
1069    spin_unlock_irqrestore(&logbuf_lock, flags);
1070    if (wake_klogd)
1071        wake_up_klogd();
1072}
1073EXPORT_SYMBOL(release_console_sem);
1074
1075/**
1076 * console_conditional_schedule - yield the CPU if required
1077 *
1078 * If the console code is currently allowed to sleep, and
1079 * if this CPU should yield the CPU to another task, do
1080 * so here.
1081 *
1082 * Must be called within acquire_console_sem().
1083 */
1084void __sched console_conditional_schedule(void)
1085{
1086    if (console_may_schedule)
1087        cond_resched();
1088}
1089EXPORT_SYMBOL(console_conditional_schedule);
1090
1091void console_unblank(void)
1092{
1093    struct console *c;
1094
1095    /*
1096     * console_unblank can no longer be called in interrupt context unless
1097     * oops_in_progress is set to 1..
1098     */
1099    if (oops_in_progress) {
1100        if (down_trylock(&console_sem) != 0)
1101            return;
1102    } else
1103        acquire_console_sem();
1104
1105    console_locked = 1;
1106    console_may_schedule = 0;
1107    for_each_console(c)
1108        if ((c->flags & CON_ENABLED) && c->unblank)
1109            c->unblank();
1110    release_console_sem();
1111}
1112
1113/*
1114 * Return the console tty driver structure and its associated index
1115 */
1116struct tty_driver *console_device(int *index)
1117{
1118    struct console *c;
1119    struct tty_driver *driver = NULL;
1120
1121    acquire_console_sem();
1122    for_each_console(c) {
1123        if (!c->device)
1124            continue;
1125        driver = c->device(c, index);
1126        if (driver)
1127            break;
1128    }
1129    release_console_sem();
1130    return driver;
1131}
1132
1133/*
1134 * Prevent further output on the passed console device so that (for example)
1135 * serial drivers can disable console output before suspending a port, and can
1136 * re-enable output afterwards.
1137 */
1138void console_stop(struct console *console)
1139{
1140    acquire_console_sem();
1141    console->flags &= ~CON_ENABLED;
1142    release_console_sem();
1143}
1144EXPORT_SYMBOL(console_stop);
1145
1146void console_start(struct console *console)
1147{
1148    acquire_console_sem();
1149    console->flags |= CON_ENABLED;
1150    release_console_sem();
1151}
1152EXPORT_SYMBOL(console_start);
1153
1154/*
1155 * The console driver calls this routine during kernel initialization
1156 * to register the console printing procedure with printk() and to
1157 * print any messages that were printed by the kernel before the
1158 * console driver was initialized.
1159 *
1160 * This can happen pretty early during the boot process (because of
1161 * early_printk) - sometimes before setup_arch() completes - be careful
1162 * of what kernel features are used - they may not be initialised yet.
1163 *
1164 * There are two types of consoles - bootconsoles (early_printk) and
1165 * "real" consoles (everything which is not a bootconsole) which are
1166 * handled differently.
1167 * - Any number of bootconsoles can be registered at any time.
1168 * - As soon as a "real" console is registered, all bootconsoles
1169 * will be unregistered automatically.
1170 * - Once a "real" console is registered, any attempt to register a
1171 * bootconsoles will be rejected
1172 */
1173void register_console(struct console *newcon)
1174{
1175    int i;
1176    unsigned long flags;
1177    struct console *bcon = NULL;
1178
1179    /*
1180     * before we register a new CON_BOOT console, make sure we don't
1181     * already have a valid console
1182     */
1183    if (console_drivers && newcon->flags & CON_BOOT) {
1184        /* find the last or real console */
1185        for_each_console(bcon) {
1186            if (!(bcon->flags & CON_BOOT)) {
1187                printk(KERN_INFO "Too late to register bootconsole %s%d\n",
1188                    newcon->name, newcon->index);
1189                return;
1190            }
1191        }
1192    }
1193
1194    if (console_drivers && console_drivers->flags & CON_BOOT)
1195        bcon = console_drivers;
1196
1197    if (preferred_console < 0 || bcon || !console_drivers)
1198        preferred_console = selected_console;
1199
1200    if (newcon->early_setup)
1201        newcon->early_setup();
1202
1203    /*
1204     * See if we want to use this console driver. If we
1205     * didn't select a console we take the first one
1206     * that registers here.
1207     */
1208    if (preferred_console < 0) {
1209        if (newcon->index < 0)
1210            newcon->index = 0;
1211        if (newcon->setup == NULL ||
1212            newcon->setup(newcon, NULL) == 0) {
1213            newcon->flags |= CON_ENABLED;
1214            if (newcon->device) {
1215                newcon->flags |= CON_CONSDEV;
1216                preferred_console = 0;
1217            }
1218        }
1219    }
1220
1221    /*
1222     * See if this console matches one we selected on
1223     * the command line.
1224     */
1225    for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
1226            i++) {
1227        if (strcmp(console_cmdline[i].name, newcon->name) != 0)
1228            continue;
1229        if (newcon->index >= 0 &&
1230            newcon->index != console_cmdline[i].index)
1231            continue;
1232        if (newcon->index < 0)
1233            newcon->index = console_cmdline[i].index;
1234#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1235        if (console_cmdline[i].brl_options) {
1236            newcon->flags |= CON_BRL;
1237            braille_register_console(newcon,
1238                    console_cmdline[i].index,
1239                    console_cmdline[i].options,
1240                    console_cmdline[i].brl_options);
1241            return;
1242        }
1243#endif
1244        if (newcon->setup &&
1245            newcon->setup(newcon, console_cmdline[i].options) != 0)
1246            break;
1247        newcon->flags |= CON_ENABLED;
1248        newcon->index = console_cmdline[i].index;
1249        if (i == selected_console) {
1250            newcon->flags |= CON_CONSDEV;
1251            preferred_console = selected_console;
1252        }
1253        break;
1254    }
1255
1256    if (!(newcon->flags & CON_ENABLED))
1257        return;
1258
1259    /*
1260     * If we have a bootconsole, and are switching to a real console,
1261     * don't print everything out again, since when the boot console, and
1262     * the real console are the same physical device, it's annoying to
1263     * see the beginning boot messages twice
1264     */
1265    if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
1266        newcon->flags &= ~CON_PRINTBUFFER;
1267
1268    /*
1269     * Put this console in the list - keep the
1270     * preferred driver at the head of the list.
1271     */
1272    acquire_console_sem();
1273    if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
1274        newcon->next = console_drivers;
1275        console_drivers = newcon;
1276        if (newcon->next)
1277            newcon->next->flags &= ~CON_CONSDEV;
1278    } else {
1279        newcon->next = console_drivers->next;
1280        console_drivers->next = newcon;
1281    }
1282    if (newcon->flags & CON_PRINTBUFFER) {
1283        /*
1284         * release_console_sem() will print out the buffered messages
1285         * for us.
1286         */
1287        spin_lock_irqsave(&logbuf_lock, flags);
1288        con_start = log_start;
1289        spin_unlock_irqrestore(&logbuf_lock, flags);
1290    }
1291    release_console_sem();
1292
1293    /*
1294     * By unregistering the bootconsoles after we enable the real console
1295     * we get the "console xxx enabled" message on all the consoles -
1296     * boot consoles, real consoles, etc - this is to ensure that end
1297     * users know there might be something in the kernel's log buffer that
1298     * went to the bootconsole (that they do not see on the real console)
1299     */
1300    if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV)) {
1301        /* we need to iterate through twice, to make sure we print
1302         * everything out, before we unregister the console(s)
1303         */
1304        printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
1305            newcon->name, newcon->index);
1306        for_each_console(bcon)
1307            if (bcon->flags & CON_BOOT)
1308                unregister_console(bcon);
1309    } else {
1310        printk(KERN_INFO "%sconsole [%s%d] enabled\n",
1311            (newcon->flags & CON_BOOT) ? "boot" : "" ,
1312            newcon->name, newcon->index);
1313    }
1314}
1315EXPORT_SYMBOL(register_console);
1316
1317int unregister_console(struct console *console)
1318{
1319        struct console *a, *b;
1320    int res = 1;
1321
1322#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1323    if (console->flags & CON_BRL)
1324        return braille_unregister_console(console);
1325#endif
1326
1327    acquire_console_sem();
1328    if (console_drivers == console) {
1329        console_drivers=console->next;
1330        res = 0;
1331    } else if (console_drivers) {
1332        for (a=console_drivers->next, b=console_drivers ;
1333             a; b=a, a=b->next) {
1334            if (a == console) {
1335                b->next = a->next;
1336                res = 0;
1337                break;
1338            }
1339        }
1340    }
1341
1342    /*
1343     * If this isn't the last console and it has CON_CONSDEV set, we
1344     * need to set it on the next preferred console.
1345     */
1346    if (console_drivers != NULL && console->flags & CON_CONSDEV)
1347        console_drivers->flags |= CON_CONSDEV;
1348
1349    release_console_sem();
1350    return res;
1351}
1352EXPORT_SYMBOL(unregister_console);
1353
1354static int __init disable_boot_consoles(void)
1355{
1356    struct console *con;
1357
1358    for_each_console(con) {
1359        if (con->flags & CON_BOOT) {
1360            printk(KERN_INFO "turn off boot console %s%d\n",
1361                con->name, con->index);
1362            unregister_console(con);
1363        }
1364    }
1365    return 0;
1366}
1367late_initcall(disable_boot_consoles);
1368
1369#if defined CONFIG_PRINTK
1370
1371/*
1372 * printk rate limiting, lifted from the networking subsystem.
1373 *
1374 * This enforces a rate limit: not more than 10 kernel messages
1375 * every 5s to make a denial-of-service attack impossible.
1376 */
1377DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
1378
1379int printk_ratelimit(void)
1380{
1381    return __ratelimit(&printk_ratelimit_state);
1382}
1383EXPORT_SYMBOL(printk_ratelimit);
1384
1385/**
1386 * printk_timed_ratelimit - caller-controlled printk ratelimiting
1387 * @caller_jiffies: pointer to caller's state
1388 * @interval_msecs: minimum interval between prints
1389 *
1390 * printk_timed_ratelimit() returns true if more than @interval_msecs
1391 * milliseconds have elapsed since the last time printk_timed_ratelimit()
1392 * returned true.
1393 */
1394bool printk_timed_ratelimit(unsigned long *caller_jiffies,
1395            unsigned int interval_msecs)
1396{
1397    if (*caller_jiffies == 0
1398            || !time_in_range(jiffies, *caller_jiffies,
1399                    *caller_jiffies
1400                    + msecs_to_jiffies(interval_msecs))) {
1401        *caller_jiffies = jiffies;
1402        return true;
1403    }
1404    return false;
1405}
1406EXPORT_SYMBOL(printk_timed_ratelimit);
1407#endif
1408

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive