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