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