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#include <linux/poll.h>
  45
  46#include <asm/uaccess.h>
  47
  48#define CREATE_TRACE_POINTS
  49#include <trace/events/printk.h>
  50
  51/*
  52 * Architectures can override it:
  53 */
  54void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
  55{
  56}
  57
  58/* printk's without a loglevel use this.. */
  59#define DEFAULT_MESSAGE_LOGLEVEL CONFIG_DEFAULT_MESSAGE_LOGLEVEL
  60
  61/* We show everything that is MORE important than this.. */
  62#define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
  63#define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
  64
  65DECLARE_WAIT_QUEUE_HEAD(log_wait);
  66
  67int console_printk[4] = {
  68        DEFAULT_CONSOLE_LOGLEVEL,       /* console_loglevel */
  69        DEFAULT_MESSAGE_LOGLEVEL,       /* default_message_loglevel */
  70        MINIMUM_CONSOLE_LOGLEVEL,       /* minimum_console_loglevel */
  71        DEFAULT_CONSOLE_LOGLEVEL,       /* default_console_loglevel */
  72};
  73
  74/*
  75 * Low level drivers may need that to know if they can schedule in
  76 * their unblank() callback or not. So let's export it.
  77 */
  78int oops_in_progress;
  79EXPORT_SYMBOL(oops_in_progress);
  80
  81/*
  82 * console_sem protects the console_drivers list, and also
  83 * provides serialisation for access to the entire console
  84 * driver system.
  85 */
  86static DEFINE_SEMAPHORE(console_sem);
  87struct console *console_drivers;
  88EXPORT_SYMBOL_GPL(console_drivers);
  89
  90/*
  91 * This is used for debugging the mess that is the VT code by
  92 * keeping track if we have the console semaphore held. It's
  93 * definitely not the perfect debug tool (we don't know if _WE_
  94 * hold it are racing, but it helps tracking those weird code
  95 * path in the console code where we end up in places I want
  96 * locked without the console sempahore held
  97 */
  98static int console_locked, console_suspended;
  99
 100/*
 101 * If exclusive_console is non-NULL then only this console is to be printed to.
 102 */
 103static struct console *exclusive_console;
 104
 105/*
 106 *      Array of consoles built from command line options (console=)
 107 */
 108struct console_cmdline
 109{
 110        char    name[8];                        /* Name of the driver       */
 111        int     index;                          /* Minor dev. to use        */
 112        char    *options;                       /* Options for the driver   */
 113#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
 114        char    *brl_options;                   /* Options for braille driver */
 115#endif
 116};
 117
 118#define MAX_CMDLINECONSOLES 8
 119
 120static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
 121static int selected_console = -1;
 122static int preferred_console = -1;
 123int console_set_on_cmdline;
 124EXPORT_SYMBOL(console_set_on_cmdline);
 125
 126/* Flag: console code may call schedule() */
 127static int console_may_schedule;
 128
 129/*
 130 * The printk log buffer consists of a chain of concatenated variable
 131 * length records. Every record starts with a record header, containing
 132 * the overall length of the record.
 133 *
 134 * The heads to the first and last entry in the buffer, as well as the
 135 * sequence numbers of these both entries are maintained when messages
 136 * are stored..
 137 *
 138 * If the heads indicate available messages, the length in the header
 139 * tells the start next message. A length == 0 for the next message
 140 * indicates a wrap-around to the beginning of the buffer.
 141 *
 142 * Every record carries the monotonic timestamp in microseconds, as well as
 143 * the standard userspace syslog level and syslog facility. The usual
 144 * kernel messages use LOG_KERN; userspace-injected messages always carry
 145 * a matching syslog facility, by default LOG_USER. The origin of every
 146 * message can be reliably determined that way.
 147 *
 148 * The human readable log message directly follows the message header. The
 149 * length of the message text is stored in the header, the stored message
 150 * is not terminated.
 151 *
 152 * Optionally, a message can carry a dictionary of properties (key/value pairs),
 153 * to provide userspace with a machine-readable message context.
 154 *
 155 * Examples for well-defined, commonly used property names are:
 156 *   DEVICE=b12:8               device identifier
 157 *                                b12:8         block dev_t
 158 *                                c127:3        char dev_t
 159 *                                n8            netdev ifindex
 160 *                                +sound:card0  subsystem:devname
 161 *   SUBSYSTEM=pci              driver-core subsystem name
 162 *
 163 * Valid characters in property names are [a-zA-Z0-9.-_]. The plain text value
 164 * follows directly after a '=' character. Every property is terminated by
 165 * a '\0' character. The last property is not terminated.
 166 *
 167 * Example of a message structure:
 168 *   0000  ff 8f 00 00 00 00 00 00      monotonic time in nsec
 169 *   0008  34 00                        record is 52 bytes long
 170 *   000a        0b 00                  text is 11 bytes long
 171 *   000c              1f 00            dictionary is 23 bytes long
 172 *   000e                    03 00      LOG_KERN (facility) LOG_ERR (level)
 173 *   0010  69 74 27 73 20 61 20 6c      "it's a l"
 174 *         69 6e 65                     "ine"
 175 *   001b           44 45 56 49 43      "DEVIC"
 176 *         45 3d 62 38 3a 32 00 44      "E=b8:2\0D"
 177 *         52 49 56 45 52 3d 62 75      "RIVER=bu"
 178 *         67                           "g"
 179 *   0032     00 00 00                  padding to next message header
 180 *
 181 * The 'struct log' buffer header must never be directly exported to
 182 * userspace, it is a kernel-private implementation detail that might
 183 * need to be changed in the future, when the requirements change.
 184 *
 185 * /dev/kmsg exports the structured data in the following line format:
 186 *   "level,sequnum,timestamp;<message text>\n"
 187 *
 188 * The optional key/value pairs are attached as continuation lines starting
 189 * with a space character and terminated by a newline. All possible
 190 * non-prinatable characters are escaped in the "\xff" notation.
 191 *
 192 * Users of the export format should ignore possible additional values
 193 * separated by ',', and find the message after the ';' character.
 194 */
 195
 196enum log_flags {
 197        LOG_NOCONS      = 1,    /* already flushed, do not print to console */
 198        LOG_NEWLINE     = 2,    /* text ended with a newline */
 199        LOG_PREFIX      = 4,    /* text started with a prefix */
 200        LOG_CONT        = 8,    /* text is a fragment of a continuation line */
 201};
 202
 203struct log {
 204        u64 ts_nsec;            /* timestamp in nanoseconds */
 205        u16 len;                /* length of entire record */
 206        u16 text_len;           /* length of text buffer */
 207        u16 dict_len;           /* length of dictionary buffer */
 208        u8 facility;            /* syslog facility */
 209        u8 flags:5;             /* internal record flags */
 210        u8 level:3;             /* syslog level */
 211};
 212
 213/*
 214 * The logbuf_lock protects kmsg buffer, indices, counters. It is also
 215 * used in interesting ways to provide interlocking in console_unlock();
 216 */
 217static DEFINE_RAW_SPINLOCK(logbuf_lock);
 218
 219/* the next printk record to read by syslog(READ) or /proc/kmsg */
 220static u64 syslog_seq;
 221static u32 syslog_idx;
 222static enum log_flags syslog_prev;
 223static size_t syslog_partial;
 224
 225/* index and sequence number of the first record stored in the buffer */
 226static u64 log_first_seq;
 227static u32 log_first_idx;
 228
 229/* index and sequence number of the next record to store in the buffer */
 230static u64 log_next_seq;
 231#ifdef CONFIG_PRINTK
 232static u32 log_next_idx;
 233
 234/* the next printk record to read after the last 'clear' command */
 235static u64 clear_seq;
 236static u32 clear_idx;
 237
 238#define PREFIX_MAX              32
 239#define LOG_LINE_MAX            1024 - PREFIX_MAX
 240
 241/* record buffer */
 242#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
 243#define LOG_ALIGN 4
 244#else
 245#define LOG_ALIGN __alignof__(struct log)
 246#endif
 247#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
 248static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
 249static char *log_buf = __log_buf;
 250static u32 log_buf_len = __LOG_BUF_LEN;
 251
 252/* cpu currently holding logbuf_lock */
 253static volatile unsigned int logbuf_cpu = UINT_MAX;
 254
 255/* human readable text of the record */
 256static char *log_text(const struct log *msg)
 257{
 258        return (char *)msg + sizeof(struct log);
 259}
 260
 261/* optional key/value pair dictionary attached to the record */
 262static char *log_dict(const struct log *msg)
 263{
 264        return (char *)msg + sizeof(struct log) + msg->text_len;
 265}
 266
 267/* get record by index; idx must point to valid msg */
 268static struct log *log_from_idx(u32 idx)
 269{
 270        struct log *msg = (struct log *)(log_buf + idx);
 271
 272        /*
 273         * A length == 0 record is the end of buffer marker. Wrap around and
 274         * read the message at the start of the buffer.
 275         */
 276        if (!msg->len)
 277                return (struct log *)log_buf;
 278        return msg;
 279}
 280
 281/* get next record; idx must point to valid msg */
 282static u32 log_next(u32 idx)
 283{
 284        struct log *msg = (struct log *)(log_buf + idx);
 285
 286        /* length == 0 indicates the end of the buffer; wrap */
 287        /*
 288         * A length == 0 record is the end of buffer marker. Wrap around and
 289         * read the message at the start of the buffer as *this* one, and
 290         * return the one after that.
 291         */
 292        if (!msg->len) {
 293                msg = (struct log *)log_buf;
 294                return msg->len;
 295        }
 296        return idx + msg->len;
 297}
 298
 299/* insert record into the buffer, discard old ones, update heads */
 300static void log_store(int facility, int level,
 301                      enum log_flags flags, u64 ts_nsec,
 302                      const char *dict, u16 dict_len,
 303                      const char *text, u16 text_len)
 304{
 305        struct log *msg;
 306        u32 size, pad_len;
 307
 308        /* number of '\0' padding bytes to next message */
 309        size = sizeof(struct log) + text_len + dict_len;
 310        pad_len = (-size) & (LOG_ALIGN - 1);
 311        size += pad_len;
 312
 313        while (log_first_seq < log_next_seq) {
 314                u32 free;
 315
 316                if (log_next_idx > log_first_idx)
 317                        free = max(log_buf_len - log_next_idx, log_first_idx);
 318                else
 319                        free = log_first_idx - log_next_idx;
 320
 321                if (free > size + sizeof(struct log))
 322                        break;
 323
 324                /* drop old messages until we have enough contiuous space */
 325                log_first_idx = log_next(log_first_idx);
 326                log_first_seq++;
 327        }
 328
 329        if (log_next_idx + size + sizeof(struct log) >= log_buf_len) {
 330                /*
 331                 * This message + an additional empty header does not fit
 332                 * at the end of the buffer. Add an empty header with len == 0
 333                 * to signify a wrap around.
 334                 */
 335                memset(log_buf + log_next_idx, 0, sizeof(struct log));
 336                log_next_idx = 0;
 337        }
 338
 339        /* fill message */
 340        msg = (struct log *)(log_buf + log_next_idx);
 341        memcpy(log_text(msg), text, text_len);
 342        msg->text_len = text_len;
 343        memcpy(log_dict(msg), dict, dict_len);
 344        msg->dict_len = dict_len;
 345        msg->facility = facility;
 346        msg->level = level & 7;
 347        msg->flags = flags & 0x1f;
 348        if (ts_nsec > 0)
 349                msg->ts_nsec = ts_nsec;
 350        else
 351                msg->ts_nsec = local_clock();
 352        memset(log_dict(msg) + dict_len, 0, pad_len);
 353        msg->len = sizeof(struct log) + text_len + dict_len + pad_len;
 354
 355        /* insert message */
 356        log_next_idx += msg->len;
 357        log_next_seq++;
 358}
 359
 360/* /dev/kmsg - userspace message inject/listen interface */
 361struct devkmsg_user {
 362        u64 seq;
 363        u32 idx;
 364        struct mutex lock;
 365        char buf[8192];
 366};
 367
 368static ssize_t devkmsg_writev(struct kiocb *iocb, const struct iovec *iv,
 369                              unsigned long count, loff_t pos)
 370{
 371        char *buf, *line;
 372        int i;
 373        int level = default_message_loglevel;
 374        int facility = 1;       /* LOG_USER */
 375        size_t len = iov_length(iv, count);
 376        ssize_t ret = len;
 377
 378        if (len > LOG_LINE_MAX)
 379                return -EINVAL;
 380        buf = kmalloc(len+1, GFP_KERNEL);
 381        if (buf == NULL)
 382                return -ENOMEM;
 383
 384        line = buf;
 385        for (i = 0; i < count; i++) {
 386                if (copy_from_user(line, iv[i].iov_base, iv[i].iov_len))
 387                        goto out;
 388                line += iv[i].iov_len;
 389        }
 390
 391        /*
 392         * Extract and skip the syslog prefix <[0-9]*>. Coming from userspace
 393         * the decimal value represents 32bit, the lower 3 bit are the log
 394         * level, the rest are the log facility.
 395         *
 396         * If no prefix or no userspace facility is specified, we
 397         * enforce LOG_USER, to be able to reliably distinguish
 398         * kernel-generated messages from userspace-injected ones.
 399         */
 400        line = buf;
 401        if (line[0] == '<') {
 402                char *endp = NULL;
 403
 404                i = simple_strtoul(line+1, &endp, 10);
 405                if (endp && endp[0] == '>') {
 406                        level = i & 7;
 407                        if (i >> 3)
 408                                facility = i >> 3;
 409                        endp++;
 410                        len -= endp - line;
 411                        line = endp;
 412                }
 413        }
 414        line[len] = '\0';
 415
 416        printk_emit(facility, level, NULL, 0, "%s", line);
 417out:
 418        kfree(buf);
 419        return ret;
 420}
 421
 422static ssize_t devkmsg_read(struct file *file, char __user *buf,
 423                            size_t count, loff_t *ppos)
 424{
 425        struct devkmsg_user *user = file->private_data;
 426        struct log *msg;
 427        u64 ts_usec;
 428        size_t i;
 429        size_t len;
 430        ssize_t ret;
 431
 432        if (!user)
 433                return -EBADF;
 434
 435        ret = mutex_lock_interruptible(&user->lock);
 436        if (ret)
 437                return ret;
 438        raw_spin_lock_irq(&logbuf_lock);
 439        while (user->seq == log_next_seq) {
 440                if (file->f_flags & O_NONBLOCK) {
 441                        ret = -EAGAIN;
 442                        raw_spin_unlock_irq(&logbuf_lock);
 443                        goto out;
 444                }
 445
 446                raw_spin_unlock_irq(&logbuf_lock);
 447                ret = wait_event_interruptible(log_wait,
 448                                               user->seq != log_next_seq);
 449                if (ret)
 450                        goto out;
 451                raw_spin_lock_irq(&logbuf_lock);
 452        }
 453
 454        if (user->seq < log_first_seq) {
 455                /* our last seen message is gone, return error and reset */
 456                user->idx = log_first_idx;
 457                user->seq = log_first_seq;
 458                ret = -EPIPE;
 459                raw_spin_unlock_irq(&logbuf_lock);
 460                goto out;
 461        }
 462
 463        msg = log_from_idx(user->idx);
 464        ts_usec = msg->ts_nsec;
 465        do_div(ts_usec, 1000);
 466        len = sprintf(user->buf, "%u,%llu,%llu;",
 467                      (msg->facility << 3) | msg->level, user->seq, ts_usec);
 468
 469        /* escape non-printable characters */
 470        for (i = 0; i < msg->text_len; i++) {
 471                unsigned char c = log_text(msg)[i];
 472
 473                if (c < ' ' || c >= 127 || c == '\\')
 474                        len += sprintf(user->buf + len, "\\x%02x", c);
 475                else
 476                        user->buf[len++] = c;
 477        }
 478        user->buf[len++] = '\n';
 479
 480        if (msg->dict_len) {
 481                bool line = true;
 482
 483                for (i = 0; i < msg->dict_len; i++) {
 484                        unsigned char c = log_dict(msg)[i];
 485
 486                        if (line) {
 487                                user->buf[len++] = ' ';
 488                                line = false;
 489                        }
 490
 491                        if (c == '\0') {
 492                                user->buf[len++] = '\n';
 493                                line = true;
 494                                continue;
 495                        }
 496
 497                        if (c < ' ' || c >= 127 || c == '\\') {
 498                                len += sprintf(user->buf + len, "\\x%02x", c);
 499                                continue;
 500                        }
 501
 502                        user->buf[len++] = c;
 503                }
 504                user->buf[len++] = '\n';
 505        }
 506
 507        user->idx = log_next(user->idx);
 508        user->seq++;
 509        raw_spin_unlock_irq(&logbuf_lock);
 510
 511        if (len > count) {
 512                ret = -EINVAL;
 513                goto out;
 514        }
 515
 516        if (copy_to_user(buf, user->buf, len)) {
 517                ret = -EFAULT;
 518                goto out;
 519        }
 520        ret = len;
 521out:
 522        mutex_unlock(&user->lock);
 523        return ret;
 524}
 525
 526static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
 527{
 528        struct devkmsg_user *user = file->private_data;
 529        loff_t ret = 0;
 530
 531        if (!user)
 532                return -EBADF;
 533        if (offset)
 534                return -ESPIPE;
 535
 536        raw_spin_lock_irq(&logbuf_lock);
 537        switch (whence) {
 538        case SEEK_SET:
 539                /* the first record */
 540                user->idx = log_first_idx;
 541                user->seq = log_first_seq;
 542                break;
 543        case SEEK_DATA:
 544                /*
 545                 * The first record after the last SYSLOG_ACTION_CLEAR,
 546                 * like issued by 'dmesg -c'. Reading /dev/kmsg itself
 547                 * changes no global state, and does not clear anything.
 548                 */
 549                user->idx = clear_idx;
 550                user->seq = clear_seq;
 551                break;
 552        case SEEK_END:
 553                /* after the last record */
 554                user->idx = log_next_idx;
 555                user->seq = log_next_seq;
 556                break;
 557        default:
 558                ret = -EINVAL;
 559        }
 560        raw_spin_unlock_irq(&logbuf_lock);
 561        return ret;
 562}
 563
 564static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
 565{
 566        struct devkmsg_user *user = file->private_data;
 567        int ret = 0;
 568
 569        if (!user)
 570                return POLLERR|POLLNVAL;
 571
 572        poll_wait(file, &log_wait, wait);
 573
 574        raw_spin_lock_irq(&logbuf_lock);
 575        if (user->seq < log_next_seq) {
 576                /* return error when data has vanished underneath us */
 577                if (user->seq < log_first_seq)
 578                        ret = POLLIN|POLLRDNORM|POLLERR|POLLPRI;
 579                ret = POLLIN|POLLRDNORM;
 580        }
 581        raw_spin_unlock_irq(&logbuf_lock);
 582
 583        return ret;
 584}
 585
 586static int devkmsg_open(struct inode *inode, struct file *file)
 587{
 588        struct devkmsg_user *user;
 589        int err;
 590
 591        /* write-only does not need any file context */
 592        if ((file->f_flags & O_ACCMODE) == O_WRONLY)
 593                return 0;
 594
 595        err = security_syslog(SYSLOG_ACTION_READ_ALL);
 596        if (err)
 597                return err;
 598
 599        user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
 600        if (!user)
 601                return -ENOMEM;
 602
 603        mutex_init(&user->lock);
 604
 605        raw_spin_lock_irq(&logbuf_lock);
 606        user->idx = log_first_idx;
 607        user->seq = log_first_seq;
 608        raw_spin_unlock_irq(&logbuf_lock);
 609
 610        file->private_data = user;
 611        return 0;
 612}
 613
 614static int devkmsg_release(struct inode *inode, struct file *file)
 615{
 616        struct devkmsg_user *user = file->private_data;
 617
 618        if (!user)
 619                return 0;
 620
 621        mutex_destroy(&user->lock);
 622        kfree(user);
 623        return 0;
 624}
 625
 626const struct file_operations kmsg_fops = {
 627        .open = devkmsg_open,
 628        .read = devkmsg_read,
 629        .aio_write = devkmsg_writev,
 630        .llseek = devkmsg_llseek,
 631        .poll = devkmsg_poll,
 632        .release = devkmsg_release,
 633};
 634
 635#ifdef CONFIG_KEXEC
 636/*
 637 * This appends the listed symbols to /proc/vmcoreinfo
 638 *
 639 * /proc/vmcoreinfo is used by various utiilties, like crash and makedumpfile to
 640 * obtain access to symbols that are otherwise very difficult to locate.  These
 641 * symbols are specifically used so that utilities can access and extract the
 642 * dmesg log from a vmcore file after a crash.
 643 */
 644void log_buf_kexec_setup(void)
 645{
 646        VMCOREINFO_SYMBOL(log_buf);
 647        VMCOREINFO_SYMBOL(log_buf_len);
 648        VMCOREINFO_SYMBOL(log_first_idx);
 649        VMCOREINFO_SYMBOL(log_next_idx);
 650}
 651#endif
 652
 653/* requested log_buf_len from kernel cmdline */
 654static unsigned long __initdata new_log_buf_len;
 655
 656/* save requested log_buf_len since it's too early to process it */
 657static int __init log_buf_len_setup(char *str)
 658{
 659        unsigned size = memparse(str, &str);
 660
 661        if (size)
 662                size = roundup_pow_of_two(size);
 663        if (size > log_buf_len)
 664                new_log_buf_len = size;
 665
 666        return 0;
 667}
 668early_param("log_buf_len", log_buf_len_setup);
 669
 670void __init setup_log_buf(int early)
 671{
 672        unsigned long flags;
 673        char *new_log_buf;
 674        int free;
 675
 676        if (!new_log_buf_len)
 677                return;
 678
 679        if (early) {
 680                unsigned long mem;
 681
 682                mem = memblock_alloc(new_log_buf_len, PAGE_SIZE);
 683                if (!mem)
 684                        return;
 685                new_log_buf = __va(mem);
 686        } else {
 687                new_log_buf = alloc_bootmem_nopanic(new_log_buf_len);
 688        }
 689
 690        if (unlikely(!new_log_buf)) {
 691                pr_err("log_buf_len: %ld bytes not available\n",
 692                        new_log_buf_len);
 693                return;
 694        }
 695
 696        raw_spin_lock_irqsave(&logbuf_lock, flags);
 697        log_buf_len = new_log_buf_len;
 698        log_buf = new_log_buf;
 699        new_log_buf_len = 0;
 700        free = __LOG_BUF_LEN - log_next_idx;
 701        memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
 702        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 703
 704        pr_info("log_buf_len: %d\n", log_buf_len);
 705        pr_info("early log buf free: %d(%d%%)\n",
 706                free, (free * 100) / __LOG_BUF_LEN);
 707}
 708
 709#ifdef CONFIG_BOOT_PRINTK_DELAY
 710
 711static int boot_delay; /* msecs delay after each printk during bootup */
 712static unsigned long long loops_per_msec;       /* based on boot_delay */
 713
 714static int __init boot_delay_setup(char *str)
 715{
 716        unsigned long lpj;
 717
 718        lpj = preset_lpj ? preset_lpj : 1000000;        /* some guess */
 719        loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
 720
 721        get_option(&str, &boot_delay);
 722        if (boot_delay > 10 * 1000)
 723                boot_delay = 0;
 724
 725        pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
 726                "HZ: %d, loops_per_msec: %llu\n",
 727                boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
 728        return 1;
 729}
 730__setup("boot_delay=", boot_delay_setup);
 731
 732static void boot_delay_msec(void)
 733{
 734        unsigned long long k;
 735        unsigned long timeout;
 736
 737        if (boot_delay == 0 || system_state != SYSTEM_BOOTING)
 738                return;
 739
 740        k = (unsigned long long)loops_per_msec * boot_delay;
 741
 742        timeout = jiffies + msecs_to_jiffies(boot_delay);
 743        while (k) {
 744                k--;
 745                cpu_relax();
 746                /*
 747                 * use (volatile) jiffies to prevent
 748                 * compiler reduction; loop termination via jiffies
 749                 * is secondary and may or may not happen.
 750                 */
 751                if (time_after(jiffies, timeout))
 752                        break;
 753                touch_nmi_watchdog();
 754        }
 755}
 756#else
 757static inline void boot_delay_msec(void)
 758{
 759}
 760#endif
 761
 762#ifdef CONFIG_SECURITY_DMESG_RESTRICT
 763int dmesg_restrict = 1;
 764#else
 765int dmesg_restrict;
 766#endif
 767
 768static int syslog_action_restricted(int type)
 769{
 770        if (dmesg_restrict)
 771                return 1;
 772        /* Unless restricted, we allow "read all" and "get buffer size" for everybody */
 773        return type != SYSLOG_ACTION_READ_ALL && type != SYSLOG_ACTION_SIZE_BUFFER;
 774}
 775
 776static int check_syslog_permissions(int type, bool from_file)
 777{
 778        /*
 779         * If this is from /proc/kmsg and we've already opened it, then we've
 780         * already done the capabilities checks at open time.
 781         */
 782        if (from_file && type != SYSLOG_ACTION_OPEN)
 783                return 0;
 784
 785        if (syslog_action_restricted(type)) {
 786                if (capable(CAP_SYSLOG))
 787                        return 0;
 788                /* For historical reasons, accept CAP_SYS_ADMIN too, with a warning */
 789                if (capable(CAP_SYS_ADMIN)) {
 790                        printk_once(KERN_WARNING "%s (%d): "
 791                                 "Attempt to access syslog with CAP_SYS_ADMIN "
 792                                 "but no CAP_SYSLOG (deprecated).\n",
 793                                 current->comm, task_pid_nr(current));
 794                        return 0;
 795                }
 796                return -EPERM;
 797        }
 798        return 0;
 799}
 800
 801#if defined(CONFIG_PRINTK_TIME)
 802static bool printk_time = 1;
 803#else
 804static bool printk_time;
 805#endif
 806module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
 807
 808static size_t print_time(u64 ts, char *buf)
 809{
 810        unsigned long rem_nsec;
 811
 812        if (!printk_time)
 813                return 0;
 814
 815        if (!buf)
 816                return 15;
 817
 818        rem_nsec = do_div(ts, 1000000000);
 819        return sprintf(buf, "[%5lu.%06lu] ",
 820                       (unsigned long)ts, rem_nsec / 1000);
 821}
 822
 823static size_t print_prefix(const struct log *msg, bool syslog, char *buf)
 824{
 825        size_t len = 0;
 826        unsigned int prefix = (msg->facility << 3) | msg->level;
 827
 828        if (syslog) {
 829                if (buf) {
 830                        len += sprintf(buf, "<%u>", prefix);
 831                } else {
 832                        len += 3;
 833                        if (prefix > 999)
 834                                len += 3;
 835                        else if (prefix > 99)
 836                                len += 2;
 837                        else if (prefix > 9)
 838                                len++;
 839                }
 840        }
 841
 842        len += print_time(msg->ts_nsec, buf ? buf + len : NULL);
 843        return len;
 844}
 845
 846static size_t msg_print_text(const struct log *msg, enum log_flags prev,
 847                             bool syslog, char *buf, size_t size)
 848{
 849        const char *text = log_text(msg);
 850        size_t text_size = msg->text_len;
 851        bool prefix = true;
 852        bool newline = true;
 853        size_t len = 0;
 854
 855        if ((prev & LOG_CONT) && !(msg->flags & LOG_PREFIX))
 856                prefix = false;
 857
 858        if (msg->flags & LOG_CONT) {
 859                if ((prev & LOG_CONT) && !(prev & LOG_NEWLINE))
 860                        prefix = false;
 861
 862                if (!(msg->flags & LOG_NEWLINE))
 863                        newline = false;
 864        }
 865
 866        do {
 867                const char *next = memchr(text, '\n', text_size);
 868                size_t text_len;
 869
 870                if (next) {
 871                        text_len = next - text;
 872                        next++;
 873                        text_size -= next - text;
 874                } else {
 875                        text_len = text_size;
 876                }
 877
 878                if (buf) {
 879                        if (print_prefix(msg, syslog, NULL) +
 880                            text_len + 1 >= size - len)
 881                                break;
 882
 883                        if (prefix)
 884                                len += print_prefix(msg, syslog, buf + len);
 885                        memcpy(buf + len, text, text_len);
 886                        len += text_len;
 887                        if (next || newline)
 888                                buf[len++] = '\n';
 889                } else {
 890                        /* SYSLOG_ACTION_* buffer size only calculation */
 891                        if (prefix)
 892                                len += print_prefix(msg, syslog, NULL);
 893                        len += text_len;
 894                        if (next || newline)
 895                                len++;
 896                }
 897
 898                prefix = true;
 899                text = next;
 900        } while (text);
 901
 902        return len;
 903}
 904
 905static int syslog_print(char __user *buf, int size)
 906{
 907        char *text;
 908        struct log *msg;
 909        int len = 0;
 910
 911        text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
 912        if (!text)
 913                return -ENOMEM;
 914
 915        while (size > 0) {
 916                size_t n;
 917                size_t skip;
 918
 919                raw_spin_lock_irq(&logbuf_lock);
 920                if (syslog_seq < log_first_seq) {
 921                        /* messages are gone, move to first one */
 922                        syslog_seq = log_first_seq;
 923                        syslog_idx = log_first_idx;
 924                        syslog_prev = 0;
 925                        syslog_partial = 0;
 926                }
 927                if (syslog_seq == log_next_seq) {
 928                        raw_spin_unlock_irq(&logbuf_lock);
 929                        break;
 930                }
 931
 932                skip = syslog_partial;
 933                msg = log_from_idx(syslog_idx);
 934                n = msg_print_text(msg, syslog_prev, true, text,
 935                                   LOG_LINE_MAX + PREFIX_MAX);
 936                if (n - syslog_partial <= size) {
 937                        /* message fits into buffer, move forward */
 938                        syslog_idx = log_next(syslog_idx);
 939                        syslog_seq++;
 940                        syslog_prev = msg->flags;
 941                        n -= syslog_partial;
 942                        syslog_partial = 0;
 943                } else if (!len){
 944                        /* partial read(), remember position */
 945                        n = size;
 946                        syslog_partial += n;
 947                } else
 948                        n = 0;
 949                raw_spin_unlock_irq(&logbuf_lock);
 950
 951                if (!n)
 952                        break;
 953
 954                if (copy_to_user(buf, text + skip, n)) {
 955                        if (!len)
 956                                len = -EFAULT;
 957                        break;
 958                }
 959
 960                len += n;
 961                size -= n;
 962                buf += n;
 963        }
 964
 965        kfree(text);
 966        return len;
 967}
 968
 969static int syslog_print_all(char __user *buf, int size, bool clear)
 970{
 971        char *text;
 972        int len = 0;
 973
 974        text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
 975        if (!text)
 976                return -ENOMEM;
 977
 978        raw_spin_lock_irq(&logbuf_lock);
 979        if (buf) {
 980                u64 next_seq;
 981                u64 seq;
 982                u32 idx;
 983                enum log_flags prev;
 984
 985                if (clear_seq < log_first_seq) {
 986                        /* messages are gone, move to first available one */
 987                        clear_seq = log_first_seq;
 988                        clear_idx = log_first_idx;
 989                }
 990
 991                /*
 992                 * Find first record that fits, including all following records,
 993                 * into the user-provided buffer for this dump.
 994                 */
 995                seq = clear_seq;
 996                idx = clear_idx;
 997                prev = 0;
 998                while (seq < log_next_seq) {
 999                        struct log *msg = log_from_idx(idx);
1000
1001                        len += msg_print_text(msg, prev, true, NULL, 0);
1002                        prev = msg->flags;
1003                        idx = log_next(idx);
1004                        seq++;
1005                }
1006
1007                /* move first record forward until length fits into the buffer */
1008                seq = clear_seq;
1009                idx = clear_idx;
1010                prev = 0;
1011                while (len > size && seq < log_next_seq) {
1012                        struct log *msg = log_from_idx(idx);
1013
1014                        len -= msg_print_text(msg, prev, true, NULL, 0);
1015                        prev = msg->flags;
1016                        idx = log_next(idx);
1017                        seq++;
1018                }
1019
1020                /* last message fitting into this dump */
1021                next_seq = log_next_seq;
1022
1023                len = 0;
1024                prev = 0;
1025                while (len >= 0 && seq < next_seq) {
1026                        struct log *msg = log_from_idx(idx);
1027                        int textlen;
1028
1029                        textlen = msg_print_text(msg, prev, true, text,
1030                                                 LOG_LINE_MAX + PREFIX_MAX);
1031                        if (textlen < 0) {
1032                                len = textlen;
1033                                break;
1034                        }
1035                        idx = log_next(idx);
1036                        seq++;
1037                        prev = msg->flags;
1038
1039                        raw_spin_unlock_irq(&logbuf_lock);
1040                        if (copy_to_user(buf + len, text, textlen))
1041                                len = -EFAULT;
1042                        else
1043                                len += textlen;
1044                        raw_spin_lock_irq(&logbuf_lock);
1045
1046                        if (seq < log_first_seq) {
1047                                /* messages are gone, move to next one */
1048                                seq = log_first_seq;
1049                                idx = log_first_idx;
1050                                prev = 0;
1051                        }
1052                }
1053        }
1054
1055        if (clear) {
1056                clear_seq = log_next_seq;
1057                clear_idx = log_next_idx;
1058        }
1059        raw_spin_unlock_irq(&logbuf_lock);
1060
1061        kfree(text);
1062        return len;
1063}
1064
1065int do_syslog(int type, char __user *buf, int len, bool from_file)
1066{
1067        bool clear = false;
1068        static int saved_console_loglevel = -1;
1069        int error;
1070
1071        error = check_syslog_permissions(type, from_file);
1072        if (error)
1073                goto out;
1074
1075        error = security_syslog(type);
1076        if (error)
1077                return error;
1078
1079        switch (type) {
1080        case SYSLOG_ACTION_CLOSE:       /* Close log */
1081                break;
1082        case SYSLOG_ACTION_OPEN:        /* Open log */
1083                break;
1084        case SYSLOG_ACTION_READ:        /* Read from log */
1085                error = -EINVAL;
1086                if (!buf || len < 0)
1087                        goto out;
1088                error = 0;
1089                if (!len)
1090                        goto out;
1091                if (!access_ok(VERIFY_WRITE, buf, len)) {
1092                        error = -EFAULT;
1093                        goto out;
1094                }
1095                error = wait_event_interruptible(log_wait,
1096                                                 syslog_seq != log_next_seq);
1097                if (error)
1098                        goto out;
1099                error = syslog_print(buf, len);
1100                break;
1101        /* Read/clear last kernel messages */
1102        case SYSLOG_ACTION_READ_CLEAR:
1103                clear = true;
1104                /* FALL THRU */
1105        /* Read last kernel messages */
1106        case SYSLOG_ACTION_READ_ALL:
1107                error = -EINVAL;
1108                if (!buf || len < 0)
1109                        goto out;
1110                error = 0;
1111                if (!len)
1112                        goto out;
1113                if (!access_ok(VERIFY_WRITE, buf, len)) {
1114                        error = -EFAULT;
1115                        goto out;
1116                }
1117                error = syslog_print_all(buf, len, clear);
1118                break;
1119        /* Clear ring buffer */
1120        case SYSLOG_ACTION_CLEAR:
1121                syslog_print_all(NULL, 0, true);
1122                break;
1123        /* Disable logging to console */
1124        case SYSLOG_ACTION_CONSOLE_OFF:
1125                if (saved_console_loglevel == -1)
1126                        saved_console_loglevel = console_loglevel;
1127                console_loglevel = minimum_console_loglevel;
1128                break;
1129        /* Enable logging to console */
1130        case SYSLOG_ACTION_CONSOLE_ON:
1131                if (saved_console_loglevel != -1) {
1132                        console_loglevel = saved_console_loglevel;
1133                        saved_console_loglevel = -1;
1134                }
1135                break;
1136        /* Set level of messages printed to console */
1137        case SYSLOG_ACTION_CONSOLE_LEVEL:
1138                error = -EINVAL;
1139                if (len < 1 || len > 8)
1140                        goto out;
1141                if (len < minimum_console_loglevel)
1142                        len = minimum_console_loglevel;
1143                console_loglevel = len;
1144                /* Implicitly re-enable logging to console */
1145                saved_console_loglevel = -1;
1146                error = 0;
1147                break;
1148        /* Number of chars in the log buffer */
1149        case SYSLOG_ACTION_SIZE_UNREAD:
1150                raw_spin_lock_irq(&logbuf_lock);
1151                if (syslog_seq < log_first_seq) {
1152                        /* messages are gone, move to first one */
1153                        syslog_seq = log_first_seq;
1154                        syslog_idx = log_first_idx;
1155                        syslog_prev = 0;
1156                        syslog_partial = 0;
1157                }
1158                if (from_file) {
1159                        /*
1160                         * Short-cut for poll(/"proc/kmsg") which simply checks
1161                         * for pending data, not the size; return the count of
1162                         * records, not the length.
1163                         */
1164                        error = log_next_idx - syslog_idx;
1165                } else {
1166                        u64 seq = syslog_seq;
1167                        u32 idx = syslog_idx;
1168                        enum log_flags prev = syslog_prev;
1169
1170                        error = 0;
1171                        while (seq < log_next_seq) {
1172                                struct log *msg = log_from_idx(idx);
1173
1174                                error += msg_print_text(msg, prev, true, NULL, 0);
1175                                idx = log_next(idx);
1176                                seq++;
1177                                prev = msg->flags;
1178                        }
1179                        error -= syslog_partial;
1180                }
1181                raw_spin_unlock_irq(&logbuf_lock);
1182                break;
1183        /* Size of the log buffer */
1184        case SYSLOG_ACTION_SIZE_BUFFER:
1185                error = log_buf_len;
1186                break;
1187        default:
1188                error = -EINVAL;
1189                break;
1190        }
1191out:
1192        return error;
1193}
1194
1195SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
1196{
1197        return do_syslog(type, buf, len, SYSLOG_FROM_CALL);
1198}
1199
1200static bool __read_mostly ignore_loglevel;
1201
1202static int __init ignore_loglevel_setup(char *str)
1203{
1204        ignore_loglevel = 1;
1205        printk(KERN_INFO "debug: ignoring loglevel setting.\n");
1206
1207        return 0;
1208}
1209
1210early_param("ignore_loglevel", ignore_loglevel_setup);
1211module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
1212MODULE_PARM_DESC(ignore_loglevel, "ignore loglevel setting, to"
1213        "print all kernel messages to the console.");
1214
1215/*
1216 * Call the console drivers, asking them to write out
1217 * log_buf[start] to log_buf[end - 1].
1218 * The console_lock must be held.
1219 */
1220static void call_console_drivers(int level, const char *text, size_t len)
1221{
1222        struct console *con;
1223
1224        trace_console(text, 0, len, len);
1225
1226        if (level >= console_loglevel && !ignore_loglevel)
1227                return;
1228        if (!console_drivers)
1229                return;
1230
1231        for_each_console(con) {
1232                if (exclusive_console && con != exclusive_console)
1233                        continue;
1234                if (!(con->flags & CON_ENABLED))
1235                        continue;
1236                if (!con->write)
1237                        continue;
1238                if (!cpu_online(smp_processor_id()) &&
1239                    !(con->flags & CON_ANYTIME))
1240                        continue;
1241                con->write(con, text, len);
1242        }
1243}
1244
1245/*
1246 * Zap console related locks when oopsing. Only zap at most once
1247 * every 10 seconds, to leave time for slow consoles to print a
1248 * full oops.
1249 */
1250static void zap_locks(void)
1251{
1252        static unsigned long oops_timestamp;
1253
1254        if (time_after_eq(jiffies, oops_timestamp) &&
1255                        !time_after(jiffies, oops_timestamp + 30 * HZ))
1256                return;
1257
1258        oops_timestamp = jiffies;
1259
1260        debug_locks_off();
1261        /* If a crash is occurring, make sure we can't deadlock */
1262        raw_spin_lock_init(&logbuf_lock);
1263        /* And make sure that we print immediately */
1264        sema_init(&console_sem, 1);
1265}
1266
1267/* Check if we have any console registered that can be called early in boot. */
1268static int have_callable_console(void)
1269{
1270        struct console *con;
1271
1272        for_each_console(con)
1273                if (con->flags & CON_ANYTIME)
1274                        return 1;
1275
1276        return 0;
1277}
1278
1279/*
1280 * Can we actually use the console at this time on this cpu?
1281 *
1282 * Console drivers may assume that per-cpu resources have
1283 * been allocated. So unless they're explicitly marked as
1284 * being able to cope (CON_ANYTIME) don't call them until
1285 * this CPU is officially up.
1286 */
1287static inline int can_use_console(unsigned int cpu)
1288{
1289        return cpu_online(cpu) || have_callable_console();
1290}
1291
1292/*
1293 * Try to get console ownership to actually show the kernel
1294 * messages from a 'printk'. Return true (and with the
1295 * console_lock held, and 'console_locked' set) if it
1296 * is successful, false otherwise.
1297 *
1298 * This gets called with the 'logbuf_lock' spinlock held and
1299 * interrupts disabled. It should return with 'lockbuf_lock'
1300 * released but interrupts still disabled.
1301 */
1302static int console_trylock_for_printk(unsigned int cpu)
1303        __releases(&logbuf_lock)
1304{
1305        int retval = 0, wake = 0;
1306
1307        if (console_trylock()) {
1308                retval = 1;
1309
1310                /*
1311                 * If we can't use the console, we need to release
1312                 * the console semaphore by hand to avoid flushing
1313                 * the buffer. We need to hold the console semaphore
1314                 * in order to do this test safely.
1315                 */
1316                if (!can_use_console(cpu)) {
1317                        console_locked = 0;
1318                        wake = 1;
1319                        retval = 0;
1320                }
1321        }
1322        logbuf_cpu = UINT_MAX;
1323        if (wake)
1324                up(&console_sem);
1325        raw_spin_unlock(&logbuf_lock);
1326        return retval;
1327}
1328
1329int printk_delay_msec __read_mostly;
1330
1331static inline void printk_delay(void)
1332{
1333        if (unlikely(printk_delay_msec)) {
1334                int m = printk_delay_msec;
1335
1336                while (m--) {
1337                        mdelay(1);
1338                        touch_nmi_watchdog();
1339                }
1340        }
1341}
1342
1343/*
1344 * Continuation lines are buffered, and not committed to the record buffer
1345 * until the line is complete, or a race forces it. The line fragments
1346 * though, are printed immediately to the consoles to ensure everything has
1347 * reached the console in case of a kernel crash.
1348 */
1349static struct cont {
1350        char buf[LOG_LINE_MAX];
1351        size_t len;                     /* length == 0 means unused buffer */
1352        size_t cons;                    /* bytes written to console */
1353        struct task_struct *owner;      /* task of first print*/
1354        u64 ts_nsec;                    /* time of first print */
1355        u8 level;                       /* log level of first message */
1356        u8 facility;                    /* log level of first message */
1357        bool flushed:1;                 /* buffer sealed and committed */
1358} cont;
1359
1360static void cont_flush(enum log_flags flags)
1361{
1362        if (cont.flushed)
1363                return;
1364        if (cont.len == 0)
1365                return;
1366
1367        log_store(cont.facility, cont.level, LOG_NOCONS | flags,
1368                  cont.ts_nsec, NULL, 0, cont.buf, cont.len);
1369
1370        cont.flushed = true;
1371}
1372
1373static bool cont_add(int facility, int level, const char *text, size_t len)
1374{
1375        if (cont.len && cont.flushed)
1376                return false;
1377
1378        if (cont.len + len > sizeof(cont.buf)) {
1379                /* the line gets too long, split it up in separate records */
1380                cont_flush(LOG_CONT);
1381                return false;
1382        }
1383
1384        if (!cont.len) {
1385                cont.facility = facility;
1386                cont.level = level;
1387                cont.owner = current;
1388                cont.ts_nsec = local_clock();
1389                cont.cons = 0;
1390                cont.flushed = false;
1391        }
1392
1393        memcpy(cont.buf + cont.len, text, len);
1394        cont.len += len;
1395        return true;
1396}
1397
1398static size_t cont_print_text(char *text, size_t size)
1399{
1400        size_t textlen = 0;
1401        size_t len;
1402
1403        if (cont.cons == 0) {
1404                textlen += print_time(cont.ts_nsec, text);
1405                size -= textlen;
1406        }
1407
1408        len = cont.len - cont.cons;
1409        if (len > 0) {
1410                if (len+1 > size)
1411                        len = size-1;
1412                memcpy(text + textlen, cont.buf + cont.cons, len);
1413                textlen += len;
1414                cont.cons = cont.len;
1415        }
1416
1417        if (cont.flushed) {
1418                text[textlen++] = '\n';
1419                /* got everything, release buffer */
1420                cont.len = 0;
1421        }
1422        return textlen;
1423}
1424
1425asmlinkage int vprintk_emit(int facility, int level,
1426                            const char *dict, size_t dictlen,
1427                            const char *fmt, va_list args)
1428{
1429        static int recursion_bug;
1430        static char textbuf[LOG_LINE_MAX];
1431        char *text = textbuf;
1432        size_t text_len;
1433        enum log_flags lflags = 0;
1434        unsigned long flags;
1435        int this_cpu;
1436        int printed_len = 0;
1437
1438        boot_delay_msec();
1439        printk_delay();
1440
1441        /* This stops the holder of console_sem just where we want him */
1442        local_irq_save(flags);
1443        this_cpu = smp_processor_id();
1444
1445        /*
1446         * Ouch, printk recursed into itself!
1447         */
1448        if (unlikely(logbuf_cpu == this_cpu)) {
1449                /*
1450                 * If a crash is occurring during printk() on this CPU,
1451                 * then try to get the crash message out but make sure
1452                 * we can't deadlock. Otherwise just return to avoid the
1453                 * recursion and return - but flag the recursion so that
1454                 * it can be printed at the next appropriate moment:
1455                 */
1456                if (!oops_in_progress && !lockdep_recursing(current)) {
1457                        recursion_bug = 1;
1458                        goto out_restore_irqs;
1459                }
1460                zap_locks();
1461        }
1462
1463        lockdep_off();
1464        raw_spin_lock(&logbuf_lock);
1465        logbuf_cpu = this_cpu;
1466
1467        if (recursion_bug) {
1468                static const char recursion_msg[] =
1469                        "BUG: recent printk recursion!";
1470
1471                recursion_bug = 0;
1472                printed_len += strlen(recursion_msg);
1473                /* emit KERN_CRIT message */
1474                log_store(0, 2, LOG_PREFIX|LOG_NEWLINE, 0,
1475                          NULL, 0, recursion_msg, printed_len);
1476        }
1477
1478        /*
1479         * The printf needs to come first; we need the syslog
1480         * prefix which might be passed-in as a parameter.
1481         */
1482        text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
1483
1484        /* mark and strip a trailing newline */
1485        if (text_len && text[text_len-1] == '\n') {
1486                text_len--;
1487                lflags |= LOG_NEWLINE;
1488        }
1489
1490        /* strip syslog prefix and extract log level or control flags */
1491        if (text[0] == '<' && text[1] && text[2] == '>') {
1492                switch (text[1]) {
1493                case '0' ... '7':
1494                        if (level == -1)
1495                                level = text[1] - '0';
1496                case 'd':       /* KERN_DEFAULT */
1497                        lflags |= LOG_PREFIX;
1498                case 'c':       /* KERN_CONT */
1499                        text += 3;
1500                        text_len -= 3;
1501                }
1502        }
1503
1504        if (level == -1)
1505                level = default_message_loglevel;
1506
1507        if (dict)
1508                lflags |= LOG_PREFIX|LOG_NEWLINE;
1509
1510        if (!(lflags & LOG_NEWLINE)) {
1511                /*
1512                 * Flush the conflicting buffer. An earlier newline was missing,
1513                 * or another task also prints continuation lines.
1514                 */
1515                if (cont.len && (lflags & LOG_PREFIX || cont.owner != current))
1516                        cont_flush(0);
1517
1518                /* buffer line if possible, otherwise store it right away */
1519                if (!cont_add(facility, level, text, text_len))
1520                        log_store(facility, level, lflags | LOG_CONT, 0,
1521                                  dict, dictlen, text, text_len);
1522        } else {
1523                bool stored = false;
1524
1525                /*
1526                 * If an earlier newline was missing and it was the same task,
1527                 * either merge it with the current buffer and flush, or if
1528                 * there was a race with interrupts (prefix == true) then just
1529                 * flush it out and store this line separately.
1530                 */
1531                if (cont.len && cont.owner == current) {
1532                        if (!(lflags & LOG_PREFIX))
1533                                stored = cont_add(facility, level, text, text_len);
1534                        cont_flush(0);
1535                }
1536
1537                if (!stored)
1538                        log_store(facility, level, lflags, 0,
1539                                  dict, dictlen, text, text_len);
1540        }
1541        printed_len += text_len;
1542
1543        /*
1544         * Try to acquire and then immediately release the console semaphore.
1545         * The release will print out buffers and wake up /dev/kmsg and syslog()
1546         * users.
1547         *
1548         * The console_trylock_for_printk() function will release 'logbuf_lock'
1549         * regardless of whether it actually gets the console semaphore or not.
1550         */
1551        if (console_trylock_for_printk(this_cpu))
1552                console_unlock();
1553
1554        lockdep_on();
1555out_restore_irqs:
1556        local_irq_restore(flags);
1557
1558        return printed_len;
1559}
1560EXPORT_SYMBOL(vprintk_emit);
1561
1562asmlinkage int vprintk(const char *fmt, va_list args)
1563{
1564        return vprintk_emit(0, -1, NULL, 0, fmt, args);
1565}
1566EXPORT_SYMBOL(vprintk);
1567
1568asmlinkage int printk_emit(int facility, int level,
1569                           const char *dict, size_t dictlen,
1570                           const char *fmt, ...)
1571{
1572        va_list args;
1573        int r;
1574
1575        va_start(args, fmt);
1576        r = vprintk_emit(facility, level, dict, dictlen, fmt, args);
1577        va_end(args);
1578
1579        return r;
1580}
1581EXPORT_SYMBOL(printk_emit);
1582
1583/**
1584 * printk - print a kernel message
1585 * @fmt: format string
1586 *
1587 * This is printk(). It can be called from any context. We want it to work.
1588 *
1589 * We try to grab the console_lock. If we succeed, it's easy - we log the
1590 * output and call the console drivers.  If we fail to get the semaphore, we
1591 * place the output into the log buffer and return. The current holder of
1592 * the console_sem will notice the new output in console_unlock(); and will
1593 * send it to the consoles before releasing the lock.
1594 *
1595 * One effect of this deferred printing is that code which calls printk() and
1596 * then changes console_loglevel may break. This is because console_loglevel
1597 * is inspected when the actual printing occurs.
1598 *
1599 * See also:
1600 * printf(3)
1601 *
1602 * See the vsnprintf() documentation for format string extensions over C99.
1603 */
1604asmlinkage int printk(const char *fmt, ...)
1605{
1606        va_list args;
1607        int r;
1608
1609#ifdef CONFIG_KGDB_KDB
1610        if (unlikely(kdb_trap_printk)) {
1611                va_start(args, fmt);
1612                r = vkdb_printf(fmt, args);
1613                va_end(args);
1614                return r;
1615        }
1616#endif
1617        va_start(args, fmt);
1618        r = vprintk_emit(0, -1, NULL, 0, fmt, args);
1619        va_end(args);
1620
1621        return r;
1622}
1623EXPORT_SYMBOL(printk);
1624
1625#else
1626
1627#define LOG_LINE_MAX            0
1628#define PREFIX_MAX              0
1629static struct cont {
1630        size_t len;
1631        size_t cons;
1632        u8 level;
1633        bool flushed:1;
1634} cont;
1635static struct log *log_from_idx(u32 idx) { return NULL; }
1636static u32 log_next(u32 idx) { return 0; }
1637static void call_console_drivers(int level, const char *text, size_t len) {}
1638static size_t msg_print_text(const struct log *msg, enum log_flags prev,
1639                             bool syslog, char *buf, size_t size) { return 0; }
1640static size_t cont_print_text(char *text, size_t size) { return 0; }
1641
1642#endif /* CONFIG_PRINTK */
1643
1644static int __add_preferred_console(char *name, int idx, char *options,
1645                                   char *brl_options)
1646{
1647        struct console_cmdline *c;
1648        int i;
1649
1650        /*
1651         *      See if this tty is not yet registered, and
1652         *      if we have a slot free.
1653         */
1654        for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
1655                if (strcmp(console_cmdline[i].name, name) == 0 &&
1656                          console_cmdline[i].index == idx) {
1657                                if (!brl_options)
1658                                        selected_console = i;
1659                                return 0;
1660                }
1661        if (i == MAX_CMDLINECONSOLES)
1662                return -E2BIG;
1663        if (!brl_options)
1664                selected_console = i;
1665        c = &console_cmdline[i];
1666        strlcpy(c->name, name, sizeof(c->name));
1667        c->options = options;
1668#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1669        c->brl_options = brl_options;
1670#endif
1671        c->index = idx;
1672        return 0;
1673}
1674/*
1675 * Set up a list of consoles.  Called from init/main.c
1676 */
1677static int __init console_setup(char *str)
1678{
1679        char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */
1680        char *s, *options, *brl_options = NULL;
1681        int idx;
1682
1683#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
1684        if (!memcmp(str, "brl,", 4)) {
1685                brl_options = "";
1686                str += 4;
1687        } else if (!memcmp(str, "brl=", 4)) {
1688                brl_options = str + 4;
1689                str = strchr(brl_options, ',');
1690                if (!str) {
1691                        printk(KERN_ERR "need port name after brl=\n");
1692                        return 1;
1693                }
1694                *(str++) = 0;
1695        }
1696#endif
1697
1698        /*
1699         * Decode str into name, index, options.
1700         */
1701        if (str[0] >= '0' && str[0] <= '9') {
1702                strcpy(buf, "ttyS");
1703                strncpy(buf + 4, str, sizeof(buf) - 5);
1704        } else {
1705                strncpy(buf, str, sizeof(buf) - 1);
1706        }
1707        buf[sizeof(buf) - 1] = 0;
1708        if ((options = strchr(str, ',')) != NULL)
1709                *(options++) = 0;
1710#ifdef __sparc__
1711        if (!strcmp(str, "ttya"))
1712                strcpy(buf, "ttyS0");
1713        if (!strcmp(str, "ttyb"))
1714                strcpy(buf, "ttyS1");
1715#endif
1716        for (s = buf; *s; s++)
1717                if ((*s >= '0' && *s <= '9') || *s == ',')
1718                        break;
1719        idx = simple_strtoul(s, NULL, 10);
1720        *s = 0;
1721
1722        __add_preferred_console(buf, idx, options, brl_options);
1723        console_set_on_cmdline = 1;
1724        return 1;
1725}
1726__setup("console=", console_setup);
1727
1728/**
1729 * add_preferred_console - add a device to the list of preferred consoles.
1730 * @name: device name
1731 * @idx: device index
1732 * @options: options for this console
1733 *
1734 * The last preferred console added will be used for kernel messages
1735 * and stdin/out/err for init.  Normally this is used by console_setup
1736 * above to handle user-supplied console arguments; however it can also
1737 * be used by arch-specific code either to override the user or more
1738 * commonly to provide a default console (ie from PROM variables) when
1739 * the user has not supplied one.
1740 */
1741int add_preferred_console(char *name, int idx, char *options)
1742{
1743        return __add_preferred_console(name, idx, options, NULL);
1744}
1745
1746int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
1747{
1748        struct console_cmdline *c;
1749        int i;
1750
1751        for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
1752                if (strcmp(console_cmdline[i].name, name) == 0 &&
1753                          console_cmdline[i].index == idx) {
1754                                c = &console_cmdline[i];
1755                                strlcpy(c->name, name_new, sizeof(c->name));
1756                                c->name[sizeof(c->name) - 1] = 0;
1757                                c->options = options;
1758                                c->index = idx_new;
1759                                return i;
1760                }
1761        /* not found */
1762        return -1;
1763}
1764
1765bool console_suspend_enabled = 1;
1766EXPORT_SYMBOL(console_suspend_enabled);
1767
1768static int __init console_suspend_disable(char *str)
1769{
1770        console_suspend_enabled = 0;
1771        return 1;
1772}
1773__setup("no_console_suspend", console_suspend_disable);
1774module_param_named(console_suspend, console_suspend_enabled,
1775                bool, S_IRUGO | S_IWUSR);
1776MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
1777        " and hibernate operations");
1778
1779/**
1780 * suspend_console - suspend the console subsystem
1781 *
1782 * This disables printk() while we go into suspend states
1783 */
1784void suspend_console(void)
1785{
1786        if (!console_suspend_enabled)
1787                return;
1788        printk("Suspending console(s) (use no_console_suspend to debug)\n");
1789        console_lock();
1790        console_suspended = 1;
1791        up(&console_sem);
1792}
1793
1794void resume_console(void)
1795{
1796        if (!console_suspend_enabled)
1797                return;
1798        down(&console_sem);
1799        console_suspended = 0;
1800        console_unlock();
1801}
1802
1803/**
1804 * console_cpu_notify - print deferred console messages after CPU hotplug
1805 * @self: notifier struct
1806 * @action: CPU hotplug event
1807 * @hcpu: unused
1808 *
1809 * If printk() is called from a CPU that is not online yet, the messages
1810 * will be spooled but will not show up on the console.  This function is
1811 * called when a new CPU comes online (or fails to come up), and ensures
1812 * that any such output gets printed.
1813 */
1814static int __cpuinit console_cpu_notify(struct notifier_block *self,
1815        unsigned long action, void *hcpu)
1816{
1817        switch (action) {
1818        case CPU_ONLINE:
1819        case CPU_DEAD:
1820        case CPU_DYING:
1821        case CPU_DOWN_FAILED:
1822        case CPU_UP_CANCELED:
1823                console_lock();
1824                console_unlock();
1825        }
1826        return NOTIFY_OK;
1827}
1828
1829/**
1830 * console_lock - lock the console system for exclusive use.
1831 *
1832 * Acquires a lock which guarantees that the caller has
1833 * exclusive access to the console system and the console_drivers list.
1834 *
1835 * Can sleep, returns nothing.
1836 */
1837void console_lock(void)
1838{
1839        BUG_ON(in_interrupt());
1840        down(&console_sem);
1841        if (console_suspended)
1842                return;
1843        console_locked = 1;
1844        console_may_schedule = 1;
1845}
1846EXPORT_SYMBOL(console_lock);
1847
1848/**
1849 * console_trylock - try to lock the console system for exclusive use.
1850 *
1851 * Tried to acquire a lock which guarantees that the caller has
1852 * exclusive access to the console system and the console_drivers list.
1853 *
1854 * returns 1 on success, and 0 on failure to acquire the lock.
1855 */
1856int console_trylock(void)
1857{
1858        if (down_trylock(&console_sem))
1859                return 0;
1860        if (console_suspended) {
1861                up(&console_sem);
1862                return 0;
1863        }
1864        console_locked = 1;
1865        console_may_schedule = 0;
1866        return 1;
1867}
1868EXPORT_SYMBOL(console_trylock);
1869
1870int is_console_locked(void)
1871{
1872        return console_locked;
1873}
1874
1875/*
1876 * Delayed printk version, for scheduler-internal messages:
1877 */
1878#define PRINTK_BUF_SIZE         512
1879
1880#define PRINTK_PENDING_WAKEUP   0x01
1881#define PRINTK_PENDING_SCHED    0x02
1882
1883static DEFINE_PER_CPU(int, printk_pending);
1884static DEFINE_PER_CPU(char [PRINTK_BUF_SIZE], printk_sched_buf);
1885
1886void printk_tick(void)
1887{
1888        if (__this_cpu_read(printk_pending)) {
1889                int pending = __this_cpu_xchg(printk_pending, 0);
1890                if (pending & PRINTK_PENDING_SCHED) {
1891                        char *buf = __get_cpu_var(printk_sched_buf);
1892                        printk(KERN_WARNING "[sched_delayed] %s", buf);
1893                }
1894                if (pending & PRINTK_PENDING_WAKEUP)
1895                        wake_up_interruptible(&log_wait);
1896        }
1897}
1898
1899int printk_needs_cpu(int cpu)
1900{
1901        if (cpu_is_offline(cpu))
1902                printk_tick();
1903        return __this_cpu_read(printk_pending);
1904}
1905
1906void wake_up_klogd(void)
1907{
1908        if (waitqueue_active(&log_wait))
1909                this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
1910}
1911
1912/* the next printk record to write to the console */
1913static u64 console_seq;
1914static u32 console_idx;
1915static enum log_flags console_prev;
1916
1917/**
1918 * console_unlock - unlock the console system
1919 *
1920 * Releases the console_lock which the caller holds on the console system
1921 * and the console driver list.
1922 *
1923 * While the console_lock was held, console output may have been buffered
1924 * by printk().  If this is the case, console_unlock(); emits
1925 * the output prior to releasing the lock.
1926 *
1927 * If there is output waiting, we wake /dev/kmsg and syslog() users.
1928 *
1929 * console_unlock(); may be called from any context.
1930 */
1931void console_unlock(void)
1932{
1933        static char text[LOG_LINE_MAX + PREFIX_MAX];
1934        static u64 seen_seq;
1935        unsigned long flags;
1936        bool wake_klogd = false;
1937        bool retry;
1938
1939        if (console_suspended) {
1940                up(&console_sem);
1941                return;
1942        }
1943
1944        console_may_schedule = 0;
1945
1946        /* flush buffered message fragment immediately to console */
1947        raw_spin_lock_irqsave(&logbuf_lock, flags);
1948        if (cont.len && (cont.cons < cont.len || cont.flushed)) {
1949                size_t len;
1950
1951                len = cont_print_text(text, sizeof(text));
1952                raw_spin_unlock(&logbuf_lock);
1953                stop_critical_timings();
1954                call_console_drivers(cont.level, text, len);
1955                start_critical_timings();
1956                local_irq_restore(flags);
1957        } else
1958                raw_spin_unlock_irqrestore(&logbuf_lock, flags);
1959
1960again:
1961        for (;;) {
1962                struct log *msg;
1963                size_t len;
1964                int level;
1965
1966                raw_spin_lock_irqsave(&logbuf_lock, flags);
1967                if (seen_seq != log_next_seq) {
1968                        wake_klogd = true;
1969                        seen_seq = log_next_seq;
1970                }
1971
1972                if (console_seq < log_first_seq) {
1973                        /* messages are gone, move to first one */
1974                        console_seq = log_first_seq;
1975                        console_idx = log_first_idx;
1976                        console_prev = 0;
1977                }
1978skip:
1979                if (console_seq == log_next_seq)
1980                        break;
1981
1982                msg = log_from_idx(console_idx);
1983                if (msg->flags & LOG_NOCONS) {
1984                        /*
1985                         * Skip record we have buffered and already printed
1986                         * directly to the console when we received it.
1987                         */
1988                        console_idx = log_next(console_idx);
1989                        console_seq++;
1990                        /*
1991                         * We will get here again when we register a new
1992                         * CON_PRINTBUFFER console. Clear the flag so we
1993                         * will properly dump everything later.
1994                         */
1995                        msg->flags &= ~LOG_NOCONS;
1996                        goto skip;
1997                }
1998
1999                level = msg->level;
2000                len = msg_print_text(msg, console_prev, false,
2001                                     text, sizeof(text));
2002                console_idx = log_next(console_idx);
2003                console_seq++;
2004                console_prev = msg->flags;
2005                raw_spin_unlock(&logbuf_lock);
2006
2007                stop_critical_timings();        /* don't trace print latency */
2008                call_console_drivers(level, text, len);
2009                start_critical_timings();
2010                local_irq_restore(flags);
2011        }
2012        console_locked = 0;
2013
2014        /* Release the exclusive_console once it is used */
2015        if (unlikely(exclusive_console))
2016                exclusive_console = NULL;
2017
2018        raw_spin_unlock(&logbuf_lock);
2019
2020        up(&console_sem);
2021
2022        /*
2023         * Someone could have filled up the buffer again, so re-check if there's
2024         * something to flush. In case we cannot trylock the console_sem again,
2025         * there's a new owner and the console_unlock() from them will do the
2026         * flush, no worries.
2027         */
2028        raw_spin_lock(&logbuf_lock);
2029        retry = console_seq != log_next_seq;
2030        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2031
2032        if (retry && console_trylock())
2033                goto again;
2034
2035        if (wake_klogd)
2036                wake_up_klogd();
2037}
2038EXPORT_SYMBOL(console_unlock);
2039
2040/**
2041 * console_conditional_schedule - yield the CPU if required
2042 *
2043 * If the console code is currently allowed to sleep, and
2044 * if this CPU should yield the CPU to another task, do
2045 * so here.
2046 *
2047 * Must be called within console_lock();.
2048 */
2049void __sched console_conditional_schedule(void)
2050{
2051        if (console_may_schedule)
2052                cond_resched();
2053}
2054EXPORT_SYMBOL(console_conditional_schedule);
2055
2056void console_unblank(void)
2057{
2058        struct console *c;
2059
2060        /*
2061         * console_unblank can no longer be called in interrupt context unless
2062         * oops_in_progress is set to 1..
2063         */
2064        if (oops_in_progress) {
2065                if (down_trylock(&console_sem) != 0)
2066                        return;
2067        } else
2068                console_lock();
2069
2070        console_locked = 1;
2071        console_may_schedule = 0;
2072        for_each_console(c)
2073                if ((c->flags & CON_ENABLED) && c->unblank)
2074                        c->unblank();
2075        console_unlock();
2076}
2077
2078/*
2079 * Return the console tty driver structure and its associated index
2080 */
2081struct tty_driver *console_device(int *index)
2082{
2083        struct console *c;
2084        struct tty_driver *driver = NULL;
2085
2086        console_lock();
2087        for_each_console(c) {
2088                if (!c->device)
2089                        continue;
2090                driver = c->device(c, index);
2091                if (driver)
2092                        break;
2093        }
2094        console_unlock();
2095        return driver;
2096}
2097
2098/*
2099 * Prevent further output on the passed console device so that (for example)
2100 * serial drivers can disable console output before suspending a port, and can
2101 * re-enable output afterwards.
2102 */
2103void console_stop(struct console *console)
2104{
2105        console_lock();
2106        console->flags &= ~CON_ENABLED;
2107        console_unlock();
2108}
2109EXPORT_SYMBOL(console_stop);
2110
2111void console_start(struct console *console)
2112{
2113        console_lock();
2114        console->flags |= CON_ENABLED;
2115        console_unlock();
2116}
2117EXPORT_SYMBOL(console_start);
2118
2119static int __read_mostly keep_bootcon;
2120
2121static int __init keep_bootcon_setup(char *str)
2122{
2123        keep_bootcon = 1;
2124        printk(KERN_INFO "debug: skip boot console de-registration.\n");
2125
2126        return 0;
2127}
2128
2129early_param("keep_bootcon", keep_bootcon_setup);
2130
2131/*
2132 * The console driver calls this routine during kernel initialization
2133 * to register the console printing procedure with printk() and to
2134 * print any messages that were printed by the kernel before the
2135 * console driver was initialized.
2136 *
2137 * This can happen pretty early during the boot process (because of
2138 * early_printk) - sometimes before setup_arch() completes - be careful
2139 * of what kernel features are used - they may not be initialised yet.
2140 *
2141 * There are two types of consoles - bootconsoles (early_printk) and
2142 * "real" consoles (everything which is not a bootconsole) which are
2143 * handled differently.
2144 *  - Any number of bootconsoles can be registered at any time.
2145 *  - As soon as a "real" console is registered, all bootconsoles
2146 *    will be unregistered automatically.
2147 *  - Once a "real" console is registered, any attempt to register a
2148 *    bootconsoles will be rejected
2149 */
2150void register_console(struct console *newcon)
2151{
2152        int i;
2153        unsigned long flags;
2154        struct console *bcon = NULL;
2155
2156        /*
2157         * before we register a new CON_BOOT console, make sure we don't
2158         * already have a valid console
2159         */
2160        if (console_drivers && newcon->flags & CON_BOOT) {
2161                /* find the last or real console */
2162                for_each_console(bcon) {
2163                        if (!(bcon->flags & CON_BOOT)) {
2164                                printk(KERN_INFO "Too late to register bootconsole %s%d\n",
2165                                        newcon->name, newcon->index);
2166                                return;
2167                        }
2168                }
2169        }
2170
2171        if (console_drivers && console_drivers->flags & CON_BOOT)
2172                bcon = console_drivers;
2173
2174        if (preferred_console < 0 || bcon || !console_drivers)
2175                preferred_console = selected_console;
2176
2177        if (newcon->early_setup)
2178                newcon->early_setup();
2179
2180        /*
2181         *      See if we want to use this console driver. If we
2182         *      didn't select a console we take the first one
2183         *      that registers here.
2184         */
2185        if (preferred_console < 0) {
2186                if (newcon->index < 0)
2187                        newcon->index = 0;
2188                if (newcon->setup == NULL ||
2189                    newcon->setup(newcon, NULL) == 0) {
2190                        newcon->flags |= CON_ENABLED;
2191                        if (newcon->device) {
2192                                newcon->flags |= CON_CONSDEV;
2193                                preferred_console = 0;
2194                        }
2195                }
2196        }
2197
2198        /*
2199         *      See if this console matches one we selected on
2200         *      the command line.
2201         */
2202        for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
2203                        i++) {
2204                if (strcmp(console_cmdline[i].name, newcon->name) != 0)
2205                        continue;
2206                if (newcon->index >= 0 &&
2207                    newcon->index != console_cmdline[i].index)
2208                        continue;
2209                if (newcon->index < 0)
2210                        newcon->index = console_cmdline[i].index;
2211#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
2212                if (console_cmdline[i].brl_options) {
2213                        newcon->flags |= CON_BRL;
2214                        braille_register_console(newcon,
2215                                        console_cmdline[i].index,
2216                                        console_cmdline[i].options,
2217                                        console_cmdline[i].brl_options);
2218                        return;
2219                }
2220#endif
2221                if (newcon->setup &&
2222                    newcon->setup(newcon, console_cmdline[i].options) != 0)
2223                        break;
2224                newcon->flags |= CON_ENABLED;
2225                newcon->index = console_cmdline[i].index;
2226                if (i == selected_console) {
2227                        newcon->flags |= CON_CONSDEV;
2228                        preferred_console = selected_console;
2229                }
2230                break;
2231        }
2232
2233        if (!(newcon->flags & CON_ENABLED))
2234                return;
2235
2236        /*
2237         * If we have a bootconsole, and are switching to a real console,
2238         * don't print everything out again, since when the boot console, and
2239         * the real console are the same physical device, it's annoying to
2240         * see the beginning boot messages twice
2241         */
2242        if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
2243                newcon->flags &= ~CON_PRINTBUFFER;
2244
2245        /*
2246         *      Put this console in the list - keep the
2247         *      preferred driver at the head of the list.
2248         */
2249        console_lock();
2250        if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
2251                newcon->next = console_drivers;
2252                console_drivers = newcon;
2253                if (newcon->next)
2254                        newcon->next->flags &= ~CON_CONSDEV;
2255        } else {
2256                newcon->next = console_drivers->next;
2257                console_drivers->next = newcon;
2258        }
2259        if (newcon->flags & CON_PRINTBUFFER) {
2260                /*
2261                 * console_unlock(); will print out the buffered messages
2262                 * for us.
2263                 */
2264                raw_spin_lock_irqsave(&logbuf_lock, flags);
2265                console_seq = syslog_seq;
2266                console_idx = syslog_idx;
2267                console_prev = syslog_prev;
2268                raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2269                /*
2270                 * We're about to replay the log buffer.  Only do this to the
2271                 * just-registered console to avoid excessive message spam to
2272                 * the already-registered consoles.
2273                 */
2274                exclusive_console = newcon;
2275        }
2276        console_unlock();
2277        console_sysfs_notify();
2278
2279        /*
2280         * By unregistering the bootconsoles after we enable the real console
2281         * we get the "console xxx enabled" message on all the consoles -
2282         * boot consoles, real consoles, etc - this is to ensure that end
2283         * users know there might be something in the kernel's log buffer that
2284         * went to the bootconsole (that they do not see on the real console)
2285         */
2286        if (bcon &&
2287            ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
2288            !keep_bootcon) {
2289                /* we need to iterate through twice, to make sure we print
2290                 * everything out, before we unregister the console(s)
2291                 */
2292                printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
2293                        newcon->name, newcon->index);
2294                for_each_console(bcon)
2295                        if (bcon->flags & CON_BOOT)
2296                                unregister_console(bcon);
2297        } else {
2298                printk(KERN_INFO "%sconsole [%s%d] enabled\n",
2299                        (newcon->flags & CON_BOOT) ? "boot" : "" ,
2300                        newcon->name, newcon->index);
2301        }
2302}
2303EXPORT_SYMBOL(register_console);
2304
2305int unregister_console(struct console *console)
2306{
2307        struct console *a, *b;
2308        int res = 1;
2309
2310#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
2311        if (console->flags & CON_BRL)
2312                return braille_unregister_console(console);
2313#endif
2314
2315        console_lock();
2316        if (console_drivers == console) {
2317                console_drivers=console->next;
2318                res = 0;
2319        } else if (console_drivers) {
2320                for (a=console_drivers->next, b=console_drivers ;
2321                     a; b=a, a=b->next) {
2322                        if (a == console) {
2323                                b->next = a->next;
2324                                res = 0;
2325                                break;
2326                        }
2327                }
2328        }
2329
2330        /*
2331         * If this isn't the last console and it has CON_CONSDEV set, we
2332         * need to set it on the next preferred console.
2333         */
2334        if (console_drivers != NULL && console->flags & CON_CONSDEV)
2335                console_drivers->flags |= CON_CONSDEV;
2336
2337        console_unlock();
2338        console_sysfs_notify();
2339        return res;
2340}
2341EXPORT_SYMBOL(unregister_console);
2342
2343static int __init printk_late_init(void)
2344{
2345        struct console *con;
2346
2347        for_each_console(con) {
2348                if (!keep_bootcon && con->flags & CON_BOOT) {
2349                        printk(KERN_INFO "turn off boot console %s%d\n",
2350                                con->name, con->index);
2351                        unregister_console(con);
2352                }
2353        }
2354        hotcpu_notifier(console_cpu_notify, 0);
2355        return 0;
2356}
2357late_initcall(printk_late_init);
2358
2359#if defined CONFIG_PRINTK
2360
2361int printk_sched(const char *fmt, ...)
2362{
2363        unsigned long flags;
2364        va_list args;
2365        char *buf;
2366        int r;
2367
2368        local_irq_save(flags);
2369        buf = __get_cpu_var(printk_sched_buf);
2370
2371        va_start(args, fmt);
2372        r = vsnprintf(buf, PRINTK_BUF_SIZE, fmt, args);
2373        va_end(args);
2374
2375        __this_cpu_or(printk_pending, PRINTK_PENDING_SCHED);
2376        local_irq_restore(flags);
2377
2378        return r;
2379}
2380
2381/*
2382 * printk rate limiting, lifted from the networking subsystem.
2383 *
2384 * This enforces a rate limit: not more than 10 kernel messages
2385 * every 5s to make a denial-of-service attack impossible.
2386 */
2387DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
2388
2389int __printk_ratelimit(const char *func)
2390{
2391        return ___ratelimit(&printk_ratelimit_state, func);
2392}
2393EXPORT_SYMBOL(__printk_ratelimit);
2394
2395/**
2396 * printk_timed_ratelimit - caller-controlled printk ratelimiting
2397 * @caller_jiffies: pointer to caller's state
2398 * @interval_msecs: minimum interval between prints
2399 *
2400 * printk_timed_ratelimit() returns true if more than @interval_msecs
2401 * milliseconds have elapsed since the last time printk_timed_ratelimit()
2402 * returned true.
2403 */
2404bool printk_timed_ratelimit(unsigned long *caller_jiffies,
2405                        unsigned int interval_msecs)
2406{
2407        if (*caller_jiffies == 0
2408                        || !time_in_range(jiffies, *caller_jiffies,
2409                                        *caller_jiffies
2410                                        + msecs_to_jiffies(interval_msecs))) {
2411                *caller_jiffies = jiffies;
2412                return true;
2413        }
2414        return false;
2415}
2416EXPORT_SYMBOL(printk_timed_ratelimit);
2417
2418static DEFINE_SPINLOCK(dump_list_lock);
2419static LIST_HEAD(dump_list);
2420
2421/**
2422 * kmsg_dump_register - register a kernel log dumper.
2423 * @dumper: pointer to the kmsg_dumper structure
2424 *
2425 * Adds a kernel log dumper to the system. The dump callback in the
2426 * structure will be called when the kernel oopses or panics and must be
2427 * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
2428 */
2429int kmsg_dump_register(struct kmsg_dumper *dumper)
2430{
2431        unsigned long flags;
2432        int err = -EBUSY;
2433
2434        /* The dump callback needs to be set */
2435        if (!dumper->dump)
2436                return -EINVAL;
2437
2438        spin_lock_irqsave(&dump_list_lock, flags);
2439        /* Don't allow registering multiple times */
2440        if (!dumper->registered) {
2441                dumper->registered = 1;
2442                list_add_tail_rcu(&dumper->list, &dump_list);
2443                err = 0;
2444        }
2445        spin_unlock_irqrestore(&dump_list_lock, flags);
2446
2447        return err;
2448}
2449EXPORT_SYMBOL_GPL(kmsg_dump_register);
2450
2451/**
2452 * kmsg_dump_unregister - unregister a kmsg dumper.
2453 * @dumper: pointer to the kmsg_dumper structure
2454 *
2455 * Removes a dump device from the system. Returns zero on success and
2456 * %-EINVAL otherwise.
2457 */
2458int kmsg_dump_unregister(struct kmsg_dumper *dumper)
2459{
2460        unsigned long flags;
2461        int err = -EINVAL;
2462
2463        spin_lock_irqsave(&dump_list_lock, flags);
2464        if (dumper->registered) {
2465                dumper->registered = 0;
2466                list_del_rcu(&dumper->list);
2467                err = 0;
2468        }
2469        spin_unlock_irqrestore(&dump_list_lock, flags);
2470        synchronize_rcu();
2471
2472        return err;
2473}
2474EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
2475
2476static bool always_kmsg_dump;
2477module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
2478
2479/**
2480 * kmsg_dump - dump kernel log to kernel message dumpers.
2481 * @reason: the reason (oops, panic etc) for dumping
2482 *
2483 * Call each of the registered dumper's dump() callback, which can
2484 * retrieve the kmsg records with kmsg_dump_get_line() or
2485 * kmsg_dump_get_buffer().
2486 */
2487void kmsg_dump(enum kmsg_dump_reason reason)
2488{
2489        struct kmsg_dumper *dumper;
2490        unsigned long flags;
2491
2492        if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
2493                return;
2494
2495        rcu_read_lock();
2496        list_for_each_entry_rcu(dumper, &dump_list, list) {
2497                if (dumper->max_reason && reason > dumper->max_reason)
2498                        continue;
2499
2500                /* initialize iterator with data about the stored records */
2501                dumper->active = true;
2502
2503                raw_spin_lock_irqsave(&logbuf_lock, flags);
2504                dumper->cur_seq = clear_seq;
2505                dumper->cur_idx = clear_idx;
2506                dumper->next_seq = log_next_seq;
2507                dumper->next_idx = log_next_idx;
2508                raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2509
2510                /* invoke dumper which will iterate over records */
2511                dumper->dump(dumper, reason);
2512
2513                /* reset iterator */
2514                dumper->active = false;
2515        }
2516        rcu_read_unlock();
2517}
2518
2519/**
2520 * kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version)
2521 * @dumper: registered kmsg dumper
2522 * @syslog: include the "<4>" prefixes
2523 * @line: buffer to copy the line to
2524 * @size: maximum size of the buffer
2525 * @len: length of line placed into buffer
2526 *
2527 * Start at the beginning of the kmsg buffer, with the oldest kmsg
2528 * record, and copy one record into the provided buffer.
2529 *
2530 * Consecutive calls will return the next available record moving
2531 * towards the end of the buffer with the youngest messages.
2532 *
2533 * A return value of FALSE indicates that there are no more records to
2534 * read.
2535 *
2536 * The function is similar to kmsg_dump_get_line(), but grabs no locks.
2537 */
2538bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
2539                               char *line, size_t size, size_t *len)
2540{
2541        struct log *msg;
2542        size_t l = 0;
2543        bool ret = false;
2544
2545        if (!dumper->active)
2546                goto out;
2547
2548        if (dumper->cur_seq < log_first_seq) {
2549                /* messages are gone, move to first available one */
2550                dumper->cur_seq = log_first_seq;
2551                dumper->cur_idx = log_first_idx;
2552        }
2553
2554        /* last entry */
2555        if (dumper->cur_seq >= log_next_seq)
2556                goto out;
2557
2558        msg = log_from_idx(dumper->cur_idx);
2559        l = msg_print_text(msg, 0, syslog, line, size);
2560
2561        dumper->cur_idx = log_next(dumper->cur_idx);
2562        dumper->cur_seq++;
2563        ret = true;
2564out:
2565        if (len)
2566                *len = l;
2567        return ret;
2568}
2569
2570/**
2571 * kmsg_dump_get_line - retrieve one kmsg log line
2572 * @dumper: registered kmsg dumper
2573 * @syslog: include the "<4>" prefixes
2574 * @line: buffer to copy the line to
2575 * @size: maximum size of the buffer
2576 * @len: length of line placed into buffer
2577 *
2578 * Start at the beginning of the kmsg buffer, with the oldest kmsg
2579 * record, and copy one record into the provided buffer.
2580 *
2581 * Consecutive calls will return the next available record moving
2582 * towards the end of the buffer with the youngest messages.
2583 *
2584 * A return value of FALSE indicates that there are no more records to
2585 * read.
2586 */
2587bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
2588                        char *line, size_t size, size_t *len)
2589{
2590        unsigned long flags;
2591        bool ret;
2592
2593        raw_spin_lock_irqsave(&logbuf_lock, flags);
2594        ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
2595        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2596
2597        return ret;
2598}
2599EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
2600
2601/**
2602 * kmsg_dump_get_buffer - copy kmsg log lines
2603 * @dumper: registered kmsg dumper
2604 * @syslog: include the "<4>" prefixes
2605 * @buf: buffer to copy the line to
2606 * @size: maximum size of the buffer
2607 * @len: length of line placed into buffer
2608 *
2609 * Start at the end of the kmsg buffer and fill the provided buffer
2610 * with as many of the the *youngest* kmsg records that fit into it.
2611 * If the buffer is large enough, all available kmsg records will be
2612 * copied with a single call.
2613 *
2614 * Consecutive calls will fill the buffer with the next block of
2615 * available older records, not including the earlier retrieved ones.
2616 *
2617 * A return value of FALSE indicates that there are no more records to
2618 * read.
2619 */
2620bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
2621                          char *buf, size_t size, size_t *len)
2622{
2623        unsigned long flags;
2624        u64 seq;
2625        u32 idx;
2626        u64 next_seq;
2627        u32 next_idx;
2628        enum log_flags prev;
2629        size_t l = 0;
2630        bool ret = false;
2631
2632        if (!dumper->active)
2633                goto out;
2634
2635        raw_spin_lock_irqsave(&logbuf_lock, flags);
2636        if (dumper->cur_seq < log_first_seq) {
2637                /* messages are gone, move to first available one */
2638                dumper->cur_seq = log_first_seq;
2639                dumper->cur_idx = log_first_idx;
2640        }
2641
2642        /* last entry */
2643        if (dumper->cur_seq >= dumper->next_seq) {
2644                raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2645                goto out;
2646        }
2647
2648        /* calculate length of entire buffer */
2649        seq = dumper->cur_seq;
2650        idx = dumper->cur_idx;
2651        prev = 0;
2652        while (seq < dumper->next_seq) {
2653                struct log *msg = log_from_idx(idx);
2654
2655                l += msg_print_text(msg, prev, true, NULL, 0);
2656                idx = log_next(idx);
2657                seq++;
2658                prev = msg->flags;
2659        }
2660
2661        /* move first record forward until length fits into the buffer */
2662        seq = dumper->cur_seq;
2663        idx = dumper->cur_idx;
2664        prev = 0;
2665        while (l > size && seq < dumper->next_seq) {
2666                struct log *msg = log_from_idx(idx);
2667
2668                l -= msg_print_text(msg, prev, true, NULL, 0);
2669                idx = log_next(idx);
2670                seq++;
2671                prev = msg->flags;
2672        }
2673
2674        /* last message in next interation */
2675        next_seq = seq;
2676        next_idx = idx;
2677
2678        l = 0;
2679        prev = 0;
2680        while (seq < dumper->next_seq) {
2681                struct log *msg = log_from_idx(idx);
2682
2683                l += msg_print_text(msg, prev, syslog, buf + l, size - l);
2684                idx = log_next(idx);
2685                seq++;
2686                prev = msg->flags;
2687        }
2688
2689        dumper->next_seq = next_seq;
2690        dumper->next_idx = next_idx;
2691        ret = true;
2692        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2693out:
2694        if (len)
2695                *len = l;
2696        return ret;
2697}
2698EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
2699
2700/**
2701 * kmsg_dump_rewind_nolock - reset the interator (unlocked version)
2702 * @dumper: registered kmsg dumper
2703 *
2704 * Reset the dumper's iterator so that kmsg_dump_get_line() and
2705 * kmsg_dump_get_buffer() can be called again and used multiple
2706 * times within the same dumper.dump() callback.
2707 *
2708 * The function is similar to kmsg_dump_rewind(), but grabs no locks.
2709 */
2710void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
2711{
2712        dumper->cur_seq = clear_seq;
2713        dumper->cur_idx = clear_idx;
2714        dumper->next_seq = log_next_seq;
2715        dumper->next_idx = log_next_idx;
2716}
2717
2718/**
2719 * kmsg_dump_rewind - reset the interator
2720 * @dumper: registered kmsg dumper
2721 *
2722 * Reset the dumper's iterator so that kmsg_dump_get_line() and
2723 * kmsg_dump_get_buffer() can be called again and used multiple
2724 * times within the same dumper.dump() callback.
2725 */
2726void kmsg_dump_rewind(struct kmsg_dumper *dumper)
2727{
2728        unsigned long flags;
2729
2730        raw_spin_lock_irqsave(&logbuf_lock, flags);
2731        kmsg_dump_rewind_nolock(dumper);
2732        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2733}
2734EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
2735#endif
2736
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.