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#include <linux/kdb.h>
37#include <linux/ratelimit.h>
38#include <linux/kmsg_dump.h>
39#include <linux/syslog.h>
40#include <linux/cpu.h>
41#include <linux/notifier.h>
42#include <linux/rculist.h>
43
44#include <asm/uaccess.h>
45
46/*
47 * Architectures can override it:
48 */
49void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
50{
51}
52
53#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
54
55/* printk's without a loglevel use this.. */
56#define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
57
58/* We show everything that is MORE important than this.. */
59#define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
60#define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
61
62DECLARE_WAIT_QUEUE_HEAD(log_wait);
63
64int console_printk[4] = {
65    DEFAULT_CONSOLE_LOGLEVEL, /* console_loglevel */
66    DEFAULT_MESSAGE_LOGLEVEL, /* default_message_loglevel */
67    MINIMUM_CONSOLE_LOGLEVEL, /* minimum_console_loglevel */
68    DEFAULT_CONSOLE_LOGLEVEL, /* default_console_loglevel */
69};
70
71/*
72 * Low level drivers may need that to know if they can schedule in
73 * their unblank() callback or not. So let's export it.
74 */
75int oops_in_progress;
76EXPORT_SYMBOL(oops_in_progress);
77
78/*
79 * console_sem protects the console_drivers list, and also
80 * provides serialisation for access to the entire console
81 * driver system.
82 */
83static DEFINE_SEMAPHORE(console_sem);
84struct console *console_drivers;
85EXPORT_SYMBOL_GPL(console_drivers);
86
87/*
88 * This is used for debugging the mess that is the VT code by
89 * keeping track if we have the console semaphore held. It's
90 * definitely not the perfect debug tool (we don't know if _WE_
91 * hold it are racing, but it helps tracking those weird code
92 * path in the console code where we end up in places I want
93 * locked without the console sempahore held
94 */
95static int console_locked, console_suspended;
96
97/*
98 * logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
99 * It is also used in interesting ways to provide interlocking in
100 * console_unlock();.
101 */
102static DEFINE_SPINLOCK(logbuf_lock);
103
104#define LOG_BUF_MASK (log_buf_len-1)
105#define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
106
107/*
108 * The indices into log_buf are not constrained to log_buf_len - they
109 * must be masked before subscripting
110 */
111static unsigned log_start; /* Index into log_buf: next char to be read by syslog() */
112static unsigned con_start; /* Index into log_buf: next char to be sent to consoles */
113static unsigned log_end; /* Index into log_buf: most-recently-written-char + 1 */
114
115/*
116 * Array of consoles built from command line options (console=)
117 */
118struct console_cmdline
119{
120    char name[8]; /* Name of the driver */
121    int index; /* Minor dev. to use */
122    char *options; /* Options for the driver */
123#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
124    char *brl_options; /* Options for braille driver */
125#endif
126};
127
128#define MAX_CMDLINECONSOLES 8
129
130static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
131static int selected_console = -1;
132static int preferred_console = -1;
133int console_set_on_cmdline;
134EXPORT_SYMBOL(console_set_on_cmdline);
135
136/* Flag: console code may call schedule() */
137static int console_may_schedule;
138
139#ifdef CONFIG_PRINTK
140
141static char __log_buf[__LOG_BUF_LEN];
142static char *log_buf = __log_buf;
143static int log_buf_len = __LOG_BUF_LEN;
144static unsigned logged_chars; /* Number of chars produced since last read+clear operation */
145static int saved_console_loglevel = -1;
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 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#ifdef CONFIG_SECURITY_DMESG_RESTRICT
260int dmesg_restrict = 1;
261#else
262int dmesg_restrict;
263#endif
264
265static int syslog_action_restricted(int type)
266{
267    if (dmesg_restrict)
268        return 1;
269    /* Unless restricted, we allow "read all" and "get buffer size" for everybody */
270    return type != SYSLOG_ACTION_READ_ALL && type != SYSLOG_ACTION_SIZE_BUFFER;
271}
272
273static int check_syslog_permissions(int type, bool from_file)
274{
275    /*
276     * If this is from /proc/kmsg and we've already opened it, then we've
277     * already done the capabilities checks at open time.
278     */
279    if (from_file && type != SYSLOG_ACTION_OPEN)
280        return 0;
281
282    if (syslog_action_restricted(type)) {
283        if (capable(CAP_SYSLOG))
284            return 0;
285        /* For historical reasons, accept CAP_SYS_ADMIN too, with a warning */
286        if (capable(CAP_SYS_ADMIN)) {
287            WARN_ONCE(1, "Attempt to access syslog with CAP_SYS_ADMIN "
288                 "but no CAP_SYSLOG (deprecated).\n");
289            return 0;
290        }
291        return -EPERM;
292    }
293    return 0;
294}
295
296int do_syslog(int type, char __user *buf, int len, bool from_file)
297{
298    unsigned i, j, limit, count;
299    int do_clear = 0;
300    char c;
301    int error;
302
303    error = check_syslog_permissions(type, from_file);
304    if (error)
305        goto out;
306
307    error = security_syslog(type);
308    if (error)
309        return error;
310
311    switch (type) {
312    case SYSLOG_ACTION_CLOSE: /* Close log */
313        break;
314    case SYSLOG_ACTION_OPEN: /* Open log */
315        break;
316    case SYSLOG_ACTION_READ: /* Read from log */
317        error = -EINVAL;
318        if (!buf || len < 0)
319            goto out;
320        error = 0;
321        if (!len)
322            goto out;
323        if (!access_ok(VERIFY_WRITE, buf, len)) {
324            error = -EFAULT;
325            goto out;
326        }
327        error = wait_event_interruptible(log_wait,
328                            (log_start - log_end));
329        if (error)
330            goto out;
331        i = 0;
332        spin_lock_irq(&logbuf_lock);
333        while (!error && (log_start != log_end) && i < len) {
334            c = LOG_BUF(log_start);
335            log_start++;
336            spin_unlock_irq(&logbuf_lock);
337            error = __put_user(c,buf);
338            buf++;
339            i++;
340            cond_resched();
341            spin_lock_irq(&logbuf_lock);
342        }
343        spin_unlock_irq(&logbuf_lock);
344        if (!error)
345            error = i;
346        break;
347    /* Read/clear last kernel messages */
348    case SYSLOG_ACTION_READ_CLEAR:
349        do_clear = 1;
350        /* FALL THRU */
351    /* Read last kernel messages */
352    case SYSLOG_ACTION_READ_ALL:
353        error = -EINVAL;
354        if (!buf || len < 0)
355            goto out;
356        error = 0;
357        if (!len)
358            goto out;
359        if (!access_ok(VERIFY_WRITE, buf, len)) {
360            error = -EFAULT;
361            goto out;
362        }
363        count = len;
364        if (count > log_buf_len)
365            count = log_buf_len;
366        spin_lock_irq(&logbuf_lock);
367        if (count > logged_chars)
368            count = logged_chars;
369        if (do_clear)
370            logged_chars = 0;
371        limit = log_end;
372        /*
373         * __put_user() could sleep, and while we sleep
374         * printk() could overwrite the messages
375         * we try to copy to user space. Therefore
376         * the messages are copied in reverse. <manfreds>
377         */
378        for (i = 0; i < count && !error; i++) {
379            j = limit-1-i;
380            if (j + log_buf_len < log_end)
381                break;
382            c = LOG_BUF(j);
383            spin_unlock_irq(&logbuf_lock);
384            error = __put_user(c,&buf[count-1-i]);
385            cond_resched();
386            spin_lock_irq(&logbuf_lock);
387        }
388        spin_unlock_irq(&logbuf_lock);
389        if (error)
390            break;
391        error = i;
392        if (i != count) {
393            int offset = count-error;
394            /* buffer overflow during copy, correct user buffer. */
395            for (i = 0; i < error; i++) {
396                if (__get_user(c,&buf[i+offset]) ||
397                    __put_user(c,&buf[i])) {
398                    error = -EFAULT;
399                    break;
400                }
401                cond_resched();
402            }
403        }
404        break;
405    /* Clear ring buffer */
406    case SYSLOG_ACTION_CLEAR:
407        logged_chars = 0;
408        break;
409    /* Disable logging to console */
410    case SYSLOG_ACTION_CONSOLE_OFF:
411        if (saved_console_loglevel == -1)
412            saved_console_loglevel = console_loglevel;
413        console_loglevel = minimum_console_loglevel;
414        break;
415    /* Enable logging to console */
416    case SYSLOG_ACTION_CONSOLE_ON:
417        if (saved_console_loglevel != -1) {
418            console_loglevel = saved_console_loglevel;
419            saved_console_loglevel = -1;
420        }
421        break;
422    /* Set level of messages printed to console */
423    case SYSLOG_ACTION_CONSOLE_LEVEL:
424        error = -EINVAL;
425        if (len < 1 || len > 8)
426            goto out;
427        if (len < minimum_console_loglevel)
428            len = minimum_console_loglevel;
429        console_loglevel = len;
430        /* Implicitly re-enable logging to console */
431        saved_console_loglevel = -1;
432        error = 0;
433        break;
434    /* Number of chars in the log buffer */
435    case SYSLOG_ACTION_SIZE_UNREAD:
436        error = log_end - log_start;
437        break;
438    /* Size of the log buffer */
439    case SYSLOG_ACTION_SIZE_BUFFER:
440        error = log_buf_len;
441        break;
442    default:
443        error = -EINVAL;
444        break;
445    }
446out:
447    return error;
448}
449
450SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
451{
452    return do_syslog(type, buf, len, SYSLOG_FROM_CALL);
453}
454
455#ifdef CONFIG_KGDB_KDB
456/* kdb dmesg command needs access to the syslog buffer. do_syslog()
457 * uses locks so it cannot be used during debugging. Just tell kdb
458 * where the start and end of the physical and logical logs are. This
459 * is equivalent to do_syslog(3).
460 */
461void kdb_syslog_data(char *syslog_data[4])
462{
463    syslog_data[0] = log_buf;
464    syslog_data[1] = log_buf + log_buf_len;
465    syslog_data[2] = log_buf + log_end -
466        (logged_chars < log_buf_len ? logged_chars : log_buf_len);
467    syslog_data[3] = log_buf + log_end;
468}
469#endif /* CONFIG_KGDB_KDB */
470
471/*
472 * Call the console drivers on a range of log_buf
473 */
474static void __call_console_drivers(unsigned start, unsigned end)
475{
476    struct console *con;
477
478    for_each_console(con) {
479        if ((con->flags & CON_ENABLED) && con->write &&
480                (cpu_online(smp_processor_id()) ||
481                (con->flags & CON_ANYTIME)))
482            con->write(con, &LOG_BUF(start), end - start);
483    }
484}
485
486static int __read_mostly ignore_loglevel;
487
488static int __init ignore_loglevel_setup(char *str)
489{
490    ignore_loglevel = 1;
491    printk(KERN_INFO "debug: ignoring loglevel setting.\n");
492
493    return 0;
494}
495
496early_param("ignore_loglevel", ignore_loglevel_setup);
497
498/*
499 * Write out chars from start to end - 1 inclusive
500 */
501static void _call_console_drivers(unsigned start,
502                unsigned end, int msg_log_level)
503{
504    if ((msg_log_level < console_loglevel || ignore_loglevel) &&
505            console_drivers && start != end) {
506        if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
507            /* wrapped write */
508            __call_console_drivers(start & LOG_BUF_MASK,
509                        log_buf_len);
510            __call_console_drivers(0, end & LOG_BUF_MASK);
511        } else {
512            __call_console_drivers(start, end);
513        }
514    }
515}
516
517/*
518 * Call the console drivers, asking them to write out
519 * log_buf[start] to log_buf[end - 1].
520 * The console_lock must be held.
521 */
522static void call_console_drivers(unsigned start, unsigned end)
523{
524    unsigned cur_index, start_print;
525    static int msg_level = -1;
526
527    BUG_ON(((int)(start - end)) > 0);
528
529    cur_index = start;
530    start_print = start;
531    while (cur_index != end) {
532        if (msg_level < 0 && ((end - cur_index) > 2) &&
533                LOG_BUF(cur_index + 0) == '<' &&
534                LOG_BUF(cur_index + 1) >= '0' &&
535                LOG_BUF(cur_index + 1) <= '7' &&
536                LOG_BUF(cur_index + 2) == '>') {
537            msg_level = LOG_BUF(cur_index + 1) - '0';
538            cur_index += 3;
539            start_print = cur_index;
540        }
541        while (cur_index != end) {
542            char c = LOG_BUF(cur_index);
543
544            cur_index++;
545            if (c == '\n') {
546                if (msg_level < 0) {
547                    /*
548                     * printk() has already given us loglevel tags in
549                     * the buffer. This code is here in case the
550                     * log buffer has wrapped right round and scribbled
551                     * on those tags
552                     */
553                    msg_level = default_message_loglevel;
554                }
555                _call_console_drivers(start_print, cur_index, msg_level);
556                msg_level = -1;
557                start_print = cur_index;
558                break;
559            }
560        }
561    }
562    _call_console_drivers(start_print, end, msg_level);
563}
564
565static void emit_log_char(char c)
566{
567    LOG_BUF(log_end) = c;
568    log_end++;
569    if (log_end - log_start > log_buf_len)
570        log_start = log_end - log_buf_len;
571    if (log_end - con_start > log_buf_len)
572        con_start = log_end - log_buf_len;
573    if (logged_chars < log_buf_len)
574        logged_chars++;
575}
576
577/*
578 * Zap console related locks when oopsing. Only zap at most once
579 * every 10 seconds, to leave time for slow consoles to print a
580 * full oops.
581 */
582static void zap_locks(void)
583{
584    static unsigned long oops_timestamp;
585
586    if (time_after_eq(jiffies, oops_timestamp) &&
587            !time_after(jiffies, oops_timestamp + 30 * HZ))
588        return;
589
590    oops_timestamp = jiffies;
591
592    /* If a crash is occurring, make sure we can't deadlock */
593    spin_lock_init(&logbuf_lock);
594    /* And make sure that we print immediately */
595    sema_init(&console_sem, 1);
596}
597
598#if defined(CONFIG_PRINTK_TIME)
599static int printk_time = 1;
600#else
601static int printk_time = 0;
602#endif
603module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
604
605/* Check if we have any console registered that can be called early in boot. */
606static int have_callable_console(void)
607{
608    struct console *con;
609
610    for_each_console(con)
611        if (con->flags & CON_ANYTIME)
612            return 1;
613
614    return 0;
615}
616
617/**
618 * printk - print a kernel message
619 * @fmt: format string
620 *
621 * This is printk(). It can be called from any context. We want it to work.
622 *
623 * We try to grab the console_lock. If we succeed, it's easy - we log the output and
624 * call the console drivers. If we fail to get the semaphore we place the output
625 * into the log buffer and return. The current holder of the console_sem will
626 * notice the new output in console_unlock(); and will send it to the
627 * consoles before releasing the lock.
628 *
629 * One effect of this deferred printing is that code which calls printk() and
630 * then changes console_loglevel may break. This is because console_loglevel
631 * is inspected when the actual printing occurs.
632 *
633 * See also:
634 * printf(3)
635 *
636 * See the vsnprintf() documentation for format string extensions over C99.
637 */
638
639asmlinkage int printk(const char *fmt, ...)
640{
641    va_list args;
642    int r;
643
644#ifdef CONFIG_KGDB_KDB
645    if (unlikely(kdb_trap_printk)) {
646        va_start(args, fmt);
647        r = vkdb_printf(fmt, args);
648        va_end(args);
649        return r;
650    }
651#endif
652    va_start(args, fmt);
653    r = vprintk(fmt, args);
654    va_end(args);
655
656    return r;
657}
658
659/* cpu currently holding logbuf_lock */
660static volatile unsigned int printk_cpu = UINT_MAX;
661
662/*
663 * Can we actually use the console at this time on this cpu?
664 *
665 * Console drivers may assume that per-cpu resources have
666 * been allocated. So unless they're explicitly marked as
667 * being able to cope (CON_ANYTIME) don't call them until
668 * this CPU is officially up.
669 */
670static inline int can_use_console(unsigned int cpu)
671{
672    return cpu_online(cpu) || have_callable_console();
673}
674
675/*
676 * Try to get console ownership to actually show the kernel
677 * messages from a 'printk'. Return true (and with the
678 * console_lock held, and 'console_locked' set) if it
679 * is successful, false otherwise.
680 *
681 * This gets called with the 'logbuf_lock' spinlock held and
682 * interrupts disabled. It should return with 'lockbuf_lock'
683 * released but interrupts still disabled.
684 */
685static int console_trylock_for_printk(unsigned int cpu)
686    __releases(&logbuf_lock)
687{
688    int retval = 0;
689
690    if (console_trylock()) {
691        retval = 1;
692
693        /*
694         * If we can't use the console, we need to release
695         * the console semaphore by hand to avoid flushing
696         * the buffer. We need to hold the console semaphore
697         * in order to do this test safely.
698         */
699        if (!can_use_console(cpu)) {
700            console_locked = 0;
701            up(&console_sem);
702            retval = 0;
703        }
704    }
705    printk_cpu = UINT_MAX;
706    spin_unlock(&logbuf_lock);
707    return retval;
708}
709static const char recursion_bug_msg [] =
710        KERN_CRIT "BUG: recent printk recursion!\n";
711static int recursion_bug;
712static int new_text_line = 1;
713static char printk_buf[1024];
714
715int printk_delay_msec __read_mostly;
716
717static inline void printk_delay(void)
718{
719    if (unlikely(printk_delay_msec)) {
720        int m = printk_delay_msec;
721
722        while (m--) {
723            mdelay(1);
724            touch_nmi_watchdog();
725        }
726    }
727}
728
729asmlinkage int vprintk(const char *fmt, va_list args)
730{
731    int printed_len = 0;
732    int current_log_level = default_message_loglevel;
733    unsigned long flags;
734    int this_cpu;
735    char *p;
736
737    boot_delay_msec();
738    printk_delay();
739
740    preempt_disable();
741    /* This stops the holder of console_sem just where we want him */
742    raw_local_irq_save(flags);
743    this_cpu = smp_processor_id();
744
745    /*
746     * Ouch, printk recursed into itself!
747     */
748    if (unlikely(printk_cpu == this_cpu)) {
749        /*
750         * If a crash is occurring during printk() on this CPU,
751         * then try to get the crash message out but make sure
752         * we can't deadlock. Otherwise just return to avoid the
753         * recursion and return - but flag the recursion so that
754         * it can be printed at the next appropriate moment:
755         */
756        if (!oops_in_progress) {
757            recursion_bug = 1;
758            goto out_restore_irqs;
759        }
760        zap_locks();
761    }
762
763    lockdep_off();
764    spin_lock(&logbuf_lock);
765    printk_cpu = this_cpu;
766
767    if (recursion_bug) {
768        recursion_bug = 0;
769        strcpy(printk_buf, recursion_bug_msg);
770        printed_len = strlen(recursion_bug_msg);
771    }
772    /* Emit the output into the temporary buffer */
773    printed_len += vscnprintf(printk_buf + printed_len,
774                  sizeof(printk_buf) - printed_len, fmt, args);
775
776
777    p = printk_buf;
778
779    /* Do we have a loglevel in the string? */
780    if (p[0] == '<') {
781        unsigned char c = p[1];
782        if (c && p[2] == '>') {
783            switch (c) {
784            case '0' ... '7': /* loglevel */
785                current_log_level = c - '0';
786            /* Fallthrough - make sure we're on a new line */
787            case 'd': /* KERN_DEFAULT */
788                if (!new_text_line) {
789                    emit_log_char('\n');
790                    new_text_line = 1;
791                }
792            /* Fallthrough - skip the loglevel */
793            case 'c': /* KERN_CONT */
794                p += 3;
795                break;
796            }
797        }
798    }
799
800    /*
801     * Copy the output into log_buf. If the caller didn't provide
802     * appropriate log level tags, we insert them here
803     */
804    for ( ; *p; p++) {
805        if (new_text_line) {
806            /* Always output the token */
807            emit_log_char('<');
808            emit_log_char(current_log_level + '0');
809            emit_log_char('>');
810            printed_len += 3;
811            new_text_line = 0;
812
813            if (printk_time) {
814                /* Follow the token with the time */
815                char tbuf[50], *tp;
816                unsigned tlen;
817                unsigned long long t;
818                unsigned long nanosec_rem;
819
820                t = cpu_clock(printk_cpu);
821                nanosec_rem = do_div(t, 1000000000);
822                tlen = sprintf(tbuf, "[%5lu.%06lu] ",
823                        (unsigned long) t,
824                        nanosec_rem / 1000);
825
826                for (tp = tbuf; tp < tbuf + tlen; tp++)
827                    emit_log_char(*tp);
828                printed_len += tlen;
829            }
830
831            if (!*p)
832                break;
833        }
834
835        emit_log_char(*p);
836        if (*p == '\n')
837            new_text_line = 1;
838    }
839
840    /*
841     * Try to acquire and then immediately release the
842     * console semaphore. The release will do all the
843     * actual magic (print out buffers, wake up klogd,
844     * etc).
845     *
846     * The console_trylock_for_printk() function
847     * will release 'logbuf_lock' regardless of whether it
848     * actually gets the semaphore or not.
849     */
850    if (console_trylock_for_printk(this_cpu))
851        console_unlock();
852
853    lockdep_on();
854out_restore_irqs:
855    raw_local_irq_restore(flags);
856
857    preempt_enable();
858    return printed_len;
859}
860EXPORT_SYMBOL(printk);
861EXPORT_SYMBOL(vprintk);
862
863#else
864
865static void call_console_drivers(unsigned start, unsigned end)
866{
867}
868
869#endif
870
871static int __add_preferred_console(char *name, int idx, char *options,
872                   char *brl_options)
873{
874    struct console_cmdline *c;
875    int i;
876
877    /*
878     * See if this tty is not yet registered, and
879     * if we have a slot free.
880     */
881    for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
882        if (strcmp(console_cmdline[i].name, name) == 0 &&
883              console_cmdline[i].index == idx) {
884                if (!brl_options)
885                    selected_console = i;
886                return 0;
887        }
888    if (i == MAX_CMDLINECONSOLES)
889        return -E2BIG;
890    if (!brl_options)
891        selected_console = i;
892    c = &console_cmdline[i];
893    strlcpy(c->name, name, sizeof(c->name));
894    c->options = options;
895#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
896    c->brl_options = brl_options;
897#endif
898    c->index = idx;
899    return 0;
900}
901/*
902 * Set up a list of consoles. Called from init/main.c
903 */
904static int __init console_setup(char *str)
905{
906    char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */
907    char *s, *options, *brl_options = NULL;
908    int idx;
909
910#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
911    if (!memcmp(str, "brl,", 4)) {
912        brl_options = "";
913        str += 4;
914    } else if (!memcmp(str, "brl=", 4)) {
915        brl_options = str + 4;
916        str = strchr(brl_options, ',');
917        if (!str) {
918            printk(KERN_ERR "need port name after brl=\n");
919            return 1;
920        }
921        *(str++) = 0;
922    }
923#endif
924
925    /*
926     * Decode str into name, index, options.
927     */
928    if (str[0] >= '0' && str[0] <= '9') {
929        strcpy(buf, "ttyS");
930        strncpy(buf + 4, str, sizeof(buf) - 5);
931    } else {
932        strncpy(buf, str, sizeof(buf) - 1);
933    }
934    buf[sizeof(buf) - 1] = 0;
935    if ((options = strchr(str, ',')) != NULL)
936        *(options++) = 0;
937#ifdef __sparc__
938    if (!strcmp(str, "ttya"))
939        strcpy(buf, "ttyS0");
940    if (!strcmp(str, "ttyb"))
941        strcpy(buf, "ttyS1");
942#endif
943    for (s = buf; *s; s++)
944        if ((*s >= '0' && *s <= '9') || *s == ',')
945            break;
946    idx = simple_strtoul(s, NULL, 10);
947    *s = 0;
948
949    __add_preferred_console(buf, idx, options, brl_options);
950    console_set_on_cmdline = 1;
951    return 1;
952}
953__setup("console=", console_setup);
954
955/**
956 * add_preferred_console - add a device to the list of preferred consoles.
957 * @name: device name
958 * @idx: device index
959 * @options: options for this console
960 *
961 * The last preferred console added will be used for kernel messages
962 * and stdin/out/err for init. Normally this is used by console_setup
963 * above to handle user-supplied console arguments; however it can also
964 * be used by arch-specific code either to override the user or more
965 * commonly to provide a default console (ie from PROM variables) when
966 * the user has not supplied one.
967 */
968int add_preferred_console(char *name, int idx, char *options)
969{
970    return __add_preferred_console(name, idx, options, NULL);
971}
972
973int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
974{
975    struct console_cmdline *c;
976    int i;
977
978    for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
979        if (strcmp(console_cmdline[i].name, name) == 0 &&
980              console_cmdline[i].index == idx) {
981                c = &console_cmdline[i];
982                strlcpy(c->name, name_new, sizeof(c->name));
983                c->name[sizeof(c->name) - 1] = 0;
984                c->options = options;
985                c->index = idx_new;
986                return i;
987        }
988    /* not found */
989    return -1;
990}
991
992int console_suspend_enabled = 1;
993EXPORT_SYMBOL(console_suspend_enabled);
994
995static int __init console_suspend_disable(char *str)
996{
997    console_suspend_enabled = 0;
998    return 1;
999}
1000__setup("no_console_suspend", console_suspend_disable);
1001
1002/**
1003 * suspend_console - suspend the console subsystem
1004 *
1005 * This disables printk() while we go into suspend states
1006 */
1007void suspend_console(void)
1008{
1009    if (!console_suspend_enabled)
1010        return;
1011    printk("Suspending console(s) (use no_console_suspend to debug)\n");
1012    console_lock();
1013    console_suspended = 1;
1014    up(&console_sem);
1015}
1016
1017void resume_console(void)
1018{
1019    if (!console_suspend_enabled)
1020        return;
1021    down(&console_sem);
1022    console_suspended = 0;
1023    console_unlock();
1024}
1025
1026/**
1027 * console_cpu_notify - print deferred console messages after CPU hotplug
1028 * @self: notifier struct
1029 * @action: CPU hotplug event
1030 * @hcpu: unused
1031 *
1032 * If printk() is called from a CPU that is not online yet, the messages
1033 * will be spooled but will not show up on the console. This function is
1034 * called when a new CPU comes online (or fails to come up), and ensures
1035 * that any such output gets printed.
1036 */
1037static int __cpuinit console_cpu_notify(struct notifier_block *self,
1038    unsigned long action, void *hcpu)
1039{
1040    switch (action) {
1041    case CPU_ONLINE:
1042    case CPU_DEAD:
1043    case CPU_DYING:
1044    case CPU_DOWN_FAILED:
1045    case CPU_UP_CANCELED:
1046        console_lock();
1047        console_unlock();
1048    }
1049    return NOTIFY_OK;
1050}
1051
1052/**
1053 * console_lock - lock the console system for exclusive use.
1054 *
1055 * Acquires a lock which guarantees that the caller has
1056 * exclusive access to the console system and the console_drivers list.
1057 *
1058 * Can sleep, returns nothing.
1059 */
1060void console_lock(void)
1061{
1062    BUG_ON(in_interrupt());
1063    down(&console_sem);
1064    if (console_suspended)
1065        return;
1066    console_locked = 1;
1067    console_may_schedule = 1;
1068}
1069EXPORT_SYMBOL(console_lock);
1070
1071/**
1072 * console_trylock - try to lock the console system for exclusive use.
1073 *
1074 * Tried to acquire a lock which guarantees that the caller has
1075 * exclusive access to the console system and the console_drivers list.
1076 *
1077 * returns 1 on success, and 0 on failure to acquire the lock.
1078 */
1079int console_trylock(void)
1080{
1081    if (down_trylock(&console_sem))
1082        return 0;
1083    if (console_suspended) {
1084        up(&console_sem);
1085        return 0;
1086    }
1087    console_locked = 1;
1088    console_may_schedule = 0;
1089    return 1;
1090}
1091EXPORT_SYMBOL(console_trylock);
1092
1093int is_console_locked(void)
1094{
1095    return console_locked;
1096}
1097
1098static DEFINE_PER_CPU(int, printk_pending);
1099
1100void printk_tick(void)
1101{
1102    if (__this_cpu_read(printk_pending)) {
1103        __this_cpu_write(printk_pending, 0);
1104        wake_up_interruptible(&log_wait);
1105    }
1106}
1107
1108int printk_needs_cpu(int cpu)
1109{
1110    if (cpu_is_offline(cpu))
1111        printk_tick();
1112    return __this_cpu_read(printk_pending);
1113}
1114
1115void wake_up_klogd(void)
1116{
1117    if (waitqueue_active(&log_wait))
1118        this_cpu_write(printk_pending, 1);
1119}
1120
1121/**
1122 * console_unlock - unlock the console system
1123 *
1124 * Releases the console_lock which the caller holds on the console system
1125 * and the console driver list.
1126 *
1127 * While the console_lock was held, console output may have been buffered
1128 * by printk(). If this is the case, console_unlock(); emits
1129 * the output prior to releasing the lock.
1130 *
1131 * If there is output waiting for klogd, we wake it up.
1132 *
1133 * console_unlock(); may be called from any context.
1134 */
1135void console_unlock(void)
1136{
1137    unsigned long flags;
1138    unsigned _con_start, _log_end;
1139    unsigned wake_klogd = 0;
1140
1141    if (console_suspended) {
1142        up(&console_sem);
1143        return;
1144    }
1145
1146    console_may_schedule = 0;
1147
1148    for ( ; ; ) {
1149        spin_lock_irqsave(&logbuf_lock, flags);
1150        wake_klogd |= log_start - log_end;
1151        if (con_start == log_end)
1152            break; /* Nothing to print */
1153        _con_start = con_start;
1154        _log_end = log_end;
1155        con_start = log_end; /* Flush */
1156        spin_unlock(&logbuf_lock);
1157        stop_critical_timings(); /* don't trace print latency */
1158        call_console_drivers(_con_start, _log_end);
1159        start_critical_timings();
1160        local_irq_restore(flags);
1161    }
1162    console_locked = 0;
1163    up(&console_sem);
1164    spin_unlock_irqrestore(&logbuf_lock, flags);
1165    if (wake_klogd)
1166        wake_up_klogd();
1167}
1168EXPORT_SYMBOL(console_unlock);
1169
1170/**
1171 * console_conditional_schedule - yield the CPU if required
1172 *
1173 * If the console code is currently allowed to sleep, and
1174 * if this CPU should yield the CPU to another task, do
1175 * so here.
1176 *
1177 * Must be called within console_lock();.
1178 */
1179void __sched console_conditional_schedule(void)
1180{
1181    if (console_may_schedule)
1182        cond_resched();
1183}
1184EXPORT_SYMBOL(console_conditional_schedule);
1185
1186void console_unblank(void)
1187{
1188    struct console *c;
1189
1190    /*
1191     * console_unblank can no longer be called in interrupt context unless
1192     * oops_in_progress is set to 1..
1193     */
1194    if (oops_in_progress) {
1195        if (down_trylock(&console_sem) != 0)
1196            return;
1197    } else
1198        console_lock();
1199
1200    console_locked = 1;
1201    console_may_schedule = 0;
1202    for_each_console(c)
1203        if ((c->flags & CON_ENABLED) && c->unblank)
1204            c->unblank();
1205    console_unlock();
1206}
1207
1208/*
1209 * Return the console tty driver structure and its associated index
1210 */
1211struct tty_driver *console_device(int *index)
1212{
1213    struct console *c;
1214    struct tty_driver *driver = NULL;
1215
1216    console_lock();
1217    for_each_console(c) {
1218        if (!c->device)
1219            continue;
1220        driver = c->device(c, index);
1221        if (driver)
1222            break;
1223    }
1224    console_unlock();
1225    return driver;
1226}
1227
1228/*
1229 * Prevent further output on the passed console device so that (for example)
1230 * serial drivers can disable console output before suspending a port, and can
1231 * re-enable output afterwards.
1232 */
1233void console_stop(struct console *console)
1234{
1235    console_lock();
1236    console->flags &= ~CON_ENABLED;
1237    console_unlock();
1238}
1239EXPORT_SYMBOL(console_stop);
1240
1241void console_start(struct console *console)
1242{
1243    console_lock();
1244    console->flags |= CON_ENABLED;
1245    console_unlock();
1246}
1247EXPORT_SYMBOL(console_start);
1248
1249/*
1250 * The console driver calls this routine during kernel initialization
1251 * to register the console printing procedure with printk() and to
1252 * print any messages that were printed by the kernel before the
1253 * console driver was initialized.
1254 *
1255 * This can happen pretty early during the boot process (because of
1256 * early_printk) - sometimes before setup_arch() completes - be careful
1257 * of what kernel features are used - they may not be initialised yet.
1258 *
1259 * There are two types of consoles - bootconsoles (early_printk) and
1260 * "real" consoles (everything which is not a bootconsole) which are
1261 * handled differently.
1262 * - Any number of bootconsoles can be registered at any time.
1263 * - As soon as a "real" console is registered, all bootconsoles
1264 * will be unregistered automatically.
1265 * - Once a "real" console is registered, any attempt to register a
1266 * bootconsoles will be rejected
1267 */
1268void register_console(struct console *newcon)
1269{
1270    int i;
1271    unsigned long flags;
1272    struct console *bcon = NULL;
1273
1274    /*
1275     * before we register a new CON_BOOT console, make sure we don't
1276     * already have a valid console
1277     */
1278    if (console_drivers && newcon->flags & CON_BOOT) {
1279        /* find the last or real console */
1280        for_each_console(bcon) {
1281            if (!(bcon->flags & CON_BOOT)) {
1282                printk(KERN_INFO "Too late to register bootconsole %s%d\n",
1283                    newcon->name, newcon->index);
1284                return;
1285            }
1286        }
1287    }
1288
1289    if (console_drivers && console_drivers->flags & CON_BOOT)
1290        bcon = console_drivers;
1291
1292    if (preferred_console < 0 || bcon || !console_drivers)
1293        preferred_console = selected_console;
1294
1295    if (newcon->early_setup)
1296        newcon->early_setup();
1297
1298    /*
1299     * See if we want to use this console driver. If we
1300     * didn't select a console we take the first one
1301     * that registers here.
1302     */
1303    if (preferred_console < 0) {
1304        if (newcon->index < 0)
1305            newcon->index = 0;
1306        if (newcon->setup == NULL ||
1307            newcon->setup(newcon, NULL) == 0) {
1308            newcon->flags |= CON_ENABLED;
1309            if (newcon->device) {
1310                newcon->flags |= CON_CONSDEV;
1311                preferred_console = 0;
1312            }
1313        }
1314    }
1315
1316    /*
1317     * See if this console matches one we selected on
1318     * the command line.
1319     */
1320    for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
1321            i++) {
1322        if (strcmp(console_cmdline[i].name, newcon->name) != 0)
1323            continue;
1324        if (newcon->index >= 0 &&
1325            newcon->index != console_cmdline[i].index)
1326            continue;
1327        if (newcon->index < 0)
1328            newcon->index = console_cmdline[i].index;
1329#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1330        if (console_cmdline[i].brl_options) {
1331            newcon->flags |= CON_BRL;
1332            braille_register_console(newcon,
1333                    console_cmdline[i].index,
1334                    console_cmdline[i].options,
1335                    console_cmdline[i].brl_options);
1336            return;
1337        }
1338#endif
1339        if (newcon->setup &&
1340            newcon->setup(newcon, console_cmdline[i].options) != 0)
1341            break;
1342        newcon->flags |= CON_ENABLED;
1343        newcon->index = console_cmdline[i].index;
1344        if (i == selected_console) {
1345            newcon->flags |= CON_CONSDEV;
1346            preferred_console = selected_console;
1347        }
1348        break;
1349    }
1350
1351    if (!(newcon->flags & CON_ENABLED))
1352        return;
1353
1354    /*
1355     * If we have a bootconsole, and are switching to a real console,
1356     * don't print everything out again, since when the boot console, and
1357     * the real console are the same physical device, it's annoying to
1358     * see the beginning boot messages twice
1359     */
1360    if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
1361        newcon->flags &= ~CON_PRINTBUFFER;
1362
1363    /*
1364     * Put this console in the list - keep the
1365     * preferred driver at the head of the list.
1366     */
1367    console_lock();
1368    if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
1369        newcon->next = console_drivers;
1370        console_drivers = newcon;
1371        if (newcon->next)
1372            newcon->next->flags &= ~CON_CONSDEV;
1373    } else {
1374        newcon->next = console_drivers->next;
1375        console_drivers->next = newcon;
1376    }
1377    if (newcon->flags & CON_PRINTBUFFER) {
1378        /*
1379         * console_unlock(); will print out the buffered messages
1380         * for us.
1381         */
1382        spin_lock_irqsave(&logbuf_lock, flags);
1383        con_start = log_start;
1384        spin_unlock_irqrestore(&logbuf_lock, flags);
1385    }
1386    console_unlock();
1387    console_sysfs_notify();
1388
1389    /*
1390     * By unregistering the bootconsoles after we enable the real console
1391     * we get the "console xxx enabled" message on all the consoles -
1392     * boot consoles, real consoles, etc - this is to ensure that end
1393     * users know there might be something in the kernel's log buffer that
1394     * went to the bootconsole (that they do not see on the real console)
1395     */
1396    if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV)) {
1397        /* we need to iterate through twice, to make sure we print
1398         * everything out, before we unregister the console(s)
1399         */
1400        printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
1401            newcon->name, newcon->index);
1402        for_each_console(bcon)
1403            if (bcon->flags & CON_BOOT)
1404                unregister_console(bcon);
1405    } else {
1406        printk(KERN_INFO "%sconsole [%s%d] enabled\n",
1407            (newcon->flags & CON_BOOT) ? "boot" : "" ,
1408            newcon->name, newcon->index);
1409    }
1410}
1411EXPORT_SYMBOL(register_console);
1412
1413int unregister_console(struct console *console)
1414{
1415        struct console *a, *b;
1416    int res = 1;
1417
1418#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1419    if (console->flags & CON_BRL)
1420        return braille_unregister_console(console);
1421#endif
1422
1423    console_lock();
1424    if (console_drivers == console) {
1425        console_drivers=console->next;
1426        res = 0;
1427    } else if (console_drivers) {
1428        for (a=console_drivers->next, b=console_drivers ;
1429             a; b=a, a=b->next) {
1430            if (a == console) {
1431                b->next = a->next;
1432                res = 0;
1433                break;
1434            }
1435        }
1436    }
1437
1438    /*
1439     * If this isn't the last console and it has CON_CONSDEV set, we
1440     * need to set it on the next preferred console.
1441     */
1442    if (console_drivers != NULL && console->flags & CON_CONSDEV)
1443        console_drivers->flags |= CON_CONSDEV;
1444
1445    console_unlock();
1446    console_sysfs_notify();
1447    return res;
1448}
1449EXPORT_SYMBOL(unregister_console);
1450
1451static int __init printk_late_init(void)
1452{
1453    struct console *con;
1454
1455    for_each_console(con) {
1456        if (con->flags & CON_BOOT) {
1457            printk(KERN_INFO "turn off boot console %s%d\n",
1458                con->name, con->index);
1459            unregister_console(con);
1460        }
1461    }
1462    hotcpu_notifier(console_cpu_notify, 0);
1463    return 0;
1464}
1465late_initcall(printk_late_init);
1466
1467#if defined CONFIG_PRINTK
1468
1469/*
1470 * printk rate limiting, lifted from the networking subsystem.
1471 *
1472 * This enforces a rate limit: not more than 10 kernel messages
1473 * every 5s to make a denial-of-service attack impossible.
1474 */
1475DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
1476
1477int __printk_ratelimit(const char *func)
1478{
1479    return ___ratelimit(&printk_ratelimit_state, func);
1480}
1481EXPORT_SYMBOL(__printk_ratelimit);
1482
1483/**
1484 * printk_timed_ratelimit - caller-controlled printk ratelimiting
1485 * @caller_jiffies: pointer to caller's state
1486 * @interval_msecs: minimum interval between prints
1487 *
1488 * printk_timed_ratelimit() returns true if more than @interval_msecs
1489 * milliseconds have elapsed since the last time printk_timed_ratelimit()
1490 * returned true.
1491 */
1492bool printk_timed_ratelimit(unsigned long *caller_jiffies,
1493            unsigned int interval_msecs)
1494{
1495    if (*caller_jiffies == 0
1496            || !time_in_range(jiffies, *caller_jiffies,
1497                    *caller_jiffies
1498                    + msecs_to_jiffies(interval_msecs))) {
1499        *caller_jiffies = jiffies;
1500        return true;
1501    }
1502    return false;
1503}
1504EXPORT_SYMBOL(printk_timed_ratelimit);
1505
1506static DEFINE_SPINLOCK(dump_list_lock);
1507static LIST_HEAD(dump_list);
1508
1509/**
1510 * kmsg_dump_register - register a kernel log dumper.
1511 * @dumper: pointer to the kmsg_dumper structure
1512 *
1513 * Adds a kernel log dumper to the system. The dump callback in the
1514 * structure will be called when the kernel oopses or panics and must be
1515 * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
1516 */
1517int kmsg_dump_register(struct kmsg_dumper *dumper)
1518{
1519    unsigned long flags;
1520    int err = -EBUSY;
1521
1522    /* The dump callback needs to be set */
1523    if (!dumper->dump)
1524        return -EINVAL;
1525
1526    spin_lock_irqsave(&dump_list_lock, flags);
1527    /* Don't allow registering multiple times */
1528    if (!dumper->registered) {
1529        dumper->registered = 1;
1530        list_add_tail_rcu(&dumper->list, &dump_list);
1531        err = 0;
1532    }
1533    spin_unlock_irqrestore(&dump_list_lock, flags);
1534
1535    return err;
1536}
1537EXPORT_SYMBOL_GPL(kmsg_dump_register);
1538
1539/**
1540 * kmsg_dump_unregister - unregister a kmsg dumper.
1541 * @dumper: pointer to the kmsg_dumper structure
1542 *
1543 * Removes a dump device from the system. Returns zero on success and
1544 * %-EINVAL otherwise.
1545 */
1546int kmsg_dump_unregister(struct kmsg_dumper *dumper)
1547{
1548    unsigned long flags;
1549    int err = -EINVAL;
1550
1551    spin_lock_irqsave(&dump_list_lock, flags);
1552    if (dumper->registered) {
1553        dumper->registered = 0;
1554        list_del_rcu(&dumper->list);
1555        err = 0;
1556    }
1557    spin_unlock_irqrestore(&dump_list_lock, flags);
1558    synchronize_rcu();
1559
1560    return err;
1561}
1562EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
1563
1564/**
1565 * kmsg_dump - dump kernel log to kernel message dumpers.
1566 * @reason: the reason (oops, panic etc) for dumping
1567 *
1568 * Iterate through each of the dump devices and call the oops/panic
1569 * callbacks with the log buffer.
1570 */
1571void kmsg_dump(enum kmsg_dump_reason reason)
1572{
1573    unsigned long end;
1574    unsigned chars;
1575    struct kmsg_dumper *dumper;
1576    const char *s1, *s2;
1577    unsigned long l1, l2;
1578    unsigned long flags;
1579
1580    /* Theoretically, the log could move on after we do this, but
1581       there's not a lot we can do about that. The new messages
1582       will overwrite the start of what we dump. */
1583    spin_lock_irqsave(&logbuf_lock, flags);
1584    end = log_end & LOG_BUF_MASK;
1585    chars = logged_chars;
1586    spin_unlock_irqrestore(&logbuf_lock, flags);
1587
1588    if (chars > end) {
1589        s1 = log_buf + log_buf_len - chars + end;
1590        l1 = chars - end;
1591
1592        s2 = log_buf;
1593        l2 = end;
1594    } else {
1595        s1 = "";
1596        l1 = 0;
1597
1598        s2 = log_buf + end - chars;
1599        l2 = chars;
1600    }
1601
1602    rcu_read_lock();
1603    list_for_each_entry_rcu(dumper, &dump_list, list)
1604        dumper->dump(dumper, reason, s1, l1, s2, l2);
1605    rcu_read_unlock();
1606}
1607#endif
1608

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