linux/kernel/printk/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/aio.h>
  36#include <linux/syscalls.h>
  37#include <linux/kexec.h>
  38#include <linux/kdb.h>
  39#include <linux/ratelimit.h>
  40#include <linux/kmsg_dump.h>
  41#include <linux/syslog.h>
  42#include <linux/cpu.h>
  43#include <linux/notifier.h>
  44#include <linux/rculist.h>
  45#include <linux/poll.h>
  46#include <linux/irq_work.h>
  47#include <linux/utsname.h>
  48
  49#include <asm/uaccess.h>
  50
  51#define CREATE_TRACE_POINTS
  52#include <trace/events/printk.h>
  53
  54#include "console_cmdline.h"
  55#include "braille.h"
  56
  57/* printk's without a loglevel use this.. */
  58#define DEFAULT_MESSAGE_LOGLEVEL CONFIG_DEFAULT_MESSAGE_LOGLEVEL
  59
  60/* We show everything that is MORE important than this.. */
  61#define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
  62#define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
  63
  64int console_printk[4] = {
  65        DEFAULT_CONSOLE_LOGLEVEL,       /* console_loglevel */
  66        DEFAULT_MESSAGE_LOGLEVEL,       /* default_message_loglevel */
  67        MINIMUM_CONSOLE_LOGLEVEL,       /* minimum_console_loglevel */
  68        DEFAULT_CONSOLE_LOGLEVEL,       /* default_console_loglevel */
  69};
  70
  71/*
  72 * Low level drivers may need that to know if they can schedule in
  73 * their unblank() callback or not. So let's export it.
  74 */
  75int oops_in_progress;
  76EXPORT_SYMBOL(oops_in_progress);
  77
  78/*
  79 * console_sem protects the console_drivers list, and also
  80 * provides serialisation for access to the entire console
  81 * driver system.
  82 */
  83static DEFINE_SEMAPHORE(console_sem);
  84struct console *console_drivers;
  85EXPORT_SYMBOL_GPL(console_drivers);
  86
  87#ifdef CONFIG_LOCKDEP
  88static struct lockdep_map console_lock_dep_map = {
  89        .name = "console_lock"
  90};
  91#endif
  92
  93/*
  94 * This is used for debugging the mess that is the VT code by
  95 * keeping track if we have the console semaphore held. It's
  96 * definitely not the perfect debug tool (we don't know if _WE_
  97 * hold it are racing, but it helps tracking those weird code
  98 * path in the console code where we end up in places I want
  99 * locked without the console sempahore held
 100 */
 101static int console_locked, console_suspended;
 102
 103/*
 104 * If exclusive_console is non-NULL then only this console is to be printed to.
 105 */
 106static struct console *exclusive_console;
 107
 108/*
 109 *      Array of consoles built from command line options (console=)
 110 */
 111
 112#define MAX_CMDLINECONSOLES 8
 113
 114static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
 115
 116static int selected_console = -1;
 117static int preferred_console = -1;
 118int console_set_on_cmdline;
 119EXPORT_SYMBOL(console_set_on_cmdline);
 120
 121/* Flag: console code may call schedule() */
 122static int console_may_schedule;
 123
 124/*
 125 * The printk log buffer consists of a chain of concatenated variable
 126 * length records. Every record starts with a record header, containing
 127 * the overall length of the record.
 128 *
 129 * The heads to the first and last entry in the buffer, as well as the
 130 * sequence numbers of these both entries are maintained when messages
 131 * are stored..
 132 *
 133 * If the heads indicate available messages, the length in the header
 134 * tells the start next message. A length == 0 for the next message
 135 * indicates a wrap-around to the beginning of the buffer.
 136 *
 137 * Every record carries the monotonic timestamp in microseconds, as well as
 138 * the standard userspace syslog level and syslog facility. The usual
 139 * kernel messages use LOG_KERN; userspace-injected messages always carry
 140 * a matching syslog facility, by default LOG_USER. The origin of every
 141 * message can be reliably determined that way.
 142 *
 143 * The human readable log message directly follows the message header. The
 144 * length of the message text is stored in the header, the stored message
 145 * is not terminated.
 146 *
 147 * Optionally, a message can carry a dictionary of properties (key/value pairs),
 148 * to provide userspace with a machine-readable message context.
 149 *
 150 * Examples for well-defined, commonly used property names are:
 151 *   DEVICE=b12:8               device identifier
 152 *                                b12:8         block dev_t
 153 *                                c127:3        char dev_t
 154 *                                n8            netdev ifindex
 155 *                                +sound:card0  subsystem:devname
 156 *   SUBSYSTEM=pci              driver-core subsystem name
 157 *
 158 * Valid characters in property names are [a-zA-Z0-9.-_]. The plain text value
 159 * follows directly after a '=' character. Every property is terminated by
 160 * a '\0' character. The last property is not terminated.
 161 *
 162 * Example of a message structure:
 163 *   0000  ff 8f 00 00 00 00 00 00      monotonic time in nsec
 164 *   0008  34 00                        record is 52 bytes long
 165 *   000a        0b 00                  text is 11 bytes long
 166 *   000c              1f 00            dictionary is 23 bytes long
 167 *   000e                    03 00      LOG_KERN (facility) LOG_ERR (level)
 168 *   0010  69 74 27 73 20 61 20 6c      "it's a l"
 169 *         69 6e 65                     "ine"
 170 *   001b           44 45 56 49 43      "DEVIC"
 171 *         45 3d 62 38 3a 32 00 44      "E=b8:2\0D"
 172 *         52 49 56 45 52 3d 62 75      "RIVER=bu"
 173 *         67                           "g"
 174 *   0032     00 00 00                  padding to next message header
 175 *
 176 * The 'struct printk_log' buffer header must never be directly exported to
 177 * userspace, it is a kernel-private implementation detail that might
 178 * need to be changed in the future, when the requirements change.
 179 *
 180 * /dev/kmsg exports the structured data in the following line format:
 181 *   "level,sequnum,timestamp;<message text>\n"
 182 *
 183 * The optional key/value pairs are attached as continuation lines starting
 184 * with a space character and terminated by a newline. All possible
 185 * non-prinatable characters are escaped in the "\xff" notation.
 186 *
 187 * Users of the export format should ignore possible additional values
 188 * separated by ',', and find the message after the ';' character.
 189 */
 190
 191enum log_flags {
 192        LOG_NOCONS      = 1,    /* already flushed, do not print to console */
 193        LOG_NEWLINE     = 2,    /* text ended with a newline */
 194        LOG_PREFIX      = 4,    /* text started with a prefix */
 195        LOG_CONT        = 8,    /* text is a fragment of a continuation line */
 196};
 197
 198struct printk_log {
 199        u64 ts_nsec;            /* timestamp in nanoseconds */
 200        u16 len;                /* length of entire record */
 201        u16 text_len;           /* length of text buffer */
 202        u16 dict_len;           /* length of dictionary buffer */
 203        u8 facility;            /* syslog facility */
 204        u8 flags:5;             /* internal record flags */
 205        u8 level:3;             /* syslog level */
 206};
 207
 208/*
 209 * The logbuf_lock protects kmsg buffer, indices, counters. It is also
 210 * used in interesting ways to provide interlocking in console_unlock();
 211 */
 212static DEFINE_RAW_SPINLOCK(logbuf_lock);
 213
 214#ifdef CONFIG_PRINTK
 215DECLARE_WAIT_QUEUE_HEAD(log_wait);
 216/* the next printk record to read by syslog(READ) or /proc/kmsg */
 217static u64 syslog_seq;
 218static u32 syslog_idx;
 219static enum log_flags syslog_prev;
 220static size_t syslog_partial;
 221
 222/* index and sequence number of the first record stored in the buffer */
 223static u64 log_first_seq;
 224static u32 log_first_idx;
 225
 226/* index and sequence number of the next record to store in the buffer */
 227static u64 log_next_seq;
 228static u32 log_next_idx;
 229
 230/* the next printk record to write to the console */
 231static u64 console_seq;
 232static u32 console_idx;
 233static enum log_flags console_prev;
 234
 235/* the next printk record to read after the last 'clear' command */
 236static u64 clear_seq;
 237static u32 clear_idx;
 238
 239#define PREFIX_MAX              32
 240#define LOG_LINE_MAX            1024 - PREFIX_MAX
 241
 242/* record buffer */
 243#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
 244#define LOG_ALIGN 4
 245#else
 246#define LOG_ALIGN __alignof__(struct printk_log)
 247#endif
 248#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
 249static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
 250static char *log_buf = __log_buf;
 251static u32 log_buf_len = __LOG_BUF_LEN;
 252
 253/* cpu currently holding logbuf_lock */
 254static volatile unsigned int logbuf_cpu = UINT_MAX;
 255
 256/* human readable text of the record */
 257static char *log_text(const struct printk_log *msg)
 258{
 259        return (char *)msg + sizeof(struct printk_log);
 260}
 261
 262/* optional key/value pair dictionary attached to the record */
 263static char *log_dict(const struct printk_log *msg)
 264{
 265        return (char *)msg + sizeof(struct printk_log) + msg->text_len;
 266}
 267
 268/* get record by index; idx must point to valid msg */
 269static struct printk_log *log_from_idx(u32 idx)
 270{
 271        struct printk_log *msg = (struct printk_log *)(log_buf + idx);
 272
 273        /*
 274         * A length == 0 record is the end of buffer marker. Wrap around and
 275         * read the message at the start of the buffer.
 276         */
 277        if (!msg->len)
 278                return (struct printk_log *)log_buf;
 279        return msg;
 280}
 281
 282/* get next record; idx must point to valid msg */
 283static u32 log_next(u32 idx)
 284{
 285        struct printk_log *msg = (struct printk_log *)(log_buf + idx);
 286
 287        /* length == 0 indicates the end of the buffer; wrap */
 288        /*
 289         * A length == 0 record is the end of buffer marker. Wrap around and
 290         * read the message at the start of the buffer as *this* one, and
 291         * return the one after that.
 292         */
 293        if (!msg->len) {
 294                msg = (struct printk_log *)log_buf;
 295                return msg->len;
 296        }
 297        return idx + msg->len;
 298}
 299
 300/* insert record into the buffer, discard old ones, update heads */
 301static void log_store(int facility, int level,
 302                      enum log_flags flags, u64 ts_nsec,
 303                      const char *dict, u16 dict_len,
 304                      const char *text, u16 text_len)
 305{
 306        struct printk_log *msg;
 307        u32 size, pad_len;
 308
 309        /* number of '\0' padding bytes to next message */
 310        size = sizeof(struct printk_log) + text_len + dict_len;
 311        pad_len = (-size) & (LOG_ALIGN - 1);
 312        size += pad_len;
 313
 314        while (log_first_seq < log_next_seq) {
 315                u32 free;
 316
 317                if (log_next_idx > log_first_idx)
 318                        free = max(log_buf_len - log_next_idx, log_first_idx);
 319                else
 320                        free = log_first_idx - log_next_idx;
 321
 322                if (free > size + sizeof(struct printk_log))
 323                        break;
 324
 325                /* drop old messages until we have enough contiuous space */
 326                log_first_idx = log_next(log_first_idx);
 327                log_first_seq++;
 328        }
 329
 330        if (log_next_idx + size + sizeof(struct printk_log) >= log_buf_len) {
 331                /*
 332                 * This message + an additional empty header does not fit
 333                 * at the end of the buffer. Add an empty header with len == 0
 334                 * to signify a wrap around.
 335                 */
 336                memset(log_buf + log_next_idx, 0, sizeof(struct printk_log));
 337                log_next_idx = 0;
 338        }
 339
 340        /* fill message */
 341        msg = (struct printk_log *)(log_buf + log_next_idx);
 342        memcpy(log_text(msg), text, text_len);
 343        msg->text_len = text_len;
 344        memcpy(log_dict(msg), dict, dict_len);
 345        msg->dict_len = dict_len;
 346        msg->facility = facility;
 347        msg->level = level & 7;
 348        msg->flags = flags & 0x1f;
 349        if (ts_nsec > 0)
 350                msg->ts_nsec = ts_nsec;
 351        else
 352                msg->ts_nsec = local_clock();
 353        memset(log_dict(msg) + dict_len, 0, pad_len);
 354        msg->len = sizeof(struct printk_log) + text_len + dict_len + pad_len;
 355
 356        /* insert message */
 357        log_next_idx += msg->len;
 358        log_next_seq++;
 359}
 360
 361#ifdef CONFIG_SECURITY_DMESG_RESTRICT
 362int dmesg_restrict = 1;
 363#else
 364int dmesg_restrict;
 365#endif
 366
 367static int syslog_action_restricted(int type)
 368{
 369        if (dmesg_restrict)
 370                return 1;
 371        /*
 372         * Unless restricted, we allow "read all" and "get buffer size"
 373         * for everybody.
 374         */
 375        return type != SYSLOG_ACTION_READ_ALL &&
 376               type != SYSLOG_ACTION_SIZE_BUFFER;
 377}
 378
 379static int check_syslog_permissions(int type, bool from_file)
 380{
 381        /*
 382         * If this is from /proc/kmsg and we've already opened it, then we've
 383         * already done the capabilities checks at open time.
 384         */
 385        if (from_file && type != SYSLOG_ACTION_OPEN)
 386                return 0;
 387
 388        if (syslog_action_restricted(type)) {
 389                if (capable(CAP_SYSLOG))
 390                        return 0;
 391                /*
 392                 * For historical reasons, accept CAP_SYS_ADMIN too, with
 393                 * a warning.
 394                 */
 395                if (capable(CAP_SYS_ADMIN)) {
 396                        pr_warn_once("%s (%d): Attempt to access syslog with "
 397                                     "CAP_SYS_ADMIN but no CAP_SYSLOG "
 398                                     "(deprecated).\n",
 399                                 current->comm, task_pid_nr(current));
 400                        return 0;
 401                }
 402                return -EPERM;
 403        }
 404        return security_syslog(type);
 405}
 406
 407
 408/* /dev/kmsg - userspace message inject/listen interface */
 409struct devkmsg_user {
 410        u64 seq;
 411        u32 idx;
 412        enum log_flags prev;
 413        struct mutex lock;
 414        char buf[8192];
 415};
 416
 417static ssize_t devkmsg_writev(struct kiocb *iocb, const struct iovec *iv,
 418                              unsigned long count, loff_t pos)
 419{
 420        char *buf, *line;
 421        int i;
 422        int level = default_message_loglevel;
 423        int facility = 1;       /* LOG_USER */
 424        size_t len = iov_length(iv, count);
 425        ssize_t ret = len;
 426
 427        if (len > LOG_LINE_MAX)
 428                return -EINVAL;
 429        buf = kmalloc(len+1, GFP_KERNEL);
 430        if (buf == NULL)
 431                return -ENOMEM;
 432
 433        line = buf;
 434        for (i = 0; i < count; i++) {
 435                if (copy_from_user(line, iv[i].iov_base, iv[i].iov_len)) {
 436                        ret = -EFAULT;
 437                        goto out;
 438                }
 439                line += iv[i].iov_len;
 440        }
 441
 442        /*
 443         * Extract and skip the syslog prefix <[0-9]*>. Coming from userspace
 444         * the decimal value represents 32bit, the lower 3 bit are the log
 445         * level, the rest are the log facility.
 446         *
 447         * If no prefix or no userspace facility is specified, we
 448         * enforce LOG_USER, to be able to reliably distinguish
 449         * kernel-generated messages from userspace-injected ones.
 450         */
 451        line = buf;
 452        if (line[0] == '<') {
 453                char *endp = NULL;
 454
 455                i = simple_strtoul(line+1, &endp, 10);
 456                if (endp && endp[0] == '>') {
 457                        level = i & 7;
 458                        if (i >> 3)
 459                                facility = i >> 3;
 460                        endp++;
 461                        len -= endp - line;
 462                        line = endp;
 463                }
 464        }
 465        line[len] = '\0';
 466
 467        printk_emit(facility, level, NULL, 0, "%s", line);
 468out:
 469        kfree(buf);
 470        return ret;
 471}
 472
 473static ssize_t devkmsg_read(struct file *file, char __user *buf,
 474                            size_t count, loff_t *ppos)
 475{
 476        struct devkmsg_user *user = file->private_data;
 477        struct printk_log *msg;
 478        u64 ts_usec;
 479        size_t i;
 480        char cont = '-';
 481        size_t len;
 482        ssize_t ret;
 483
 484        if (!user)
 485                return -EBADF;
 486
 487        ret = mutex_lock_interruptible(&user->lock);
 488        if (ret)
 489                return ret;
 490        raw_spin_lock_irq(&logbuf_lock);
 491        while (user->seq == log_next_seq) {
 492                if (file->f_flags & O_NONBLOCK) {
 493                        ret = -EAGAIN;
 494                        raw_spin_unlock_irq(&logbuf_lock);
 495                        goto out;
 496                }
 497
 498                raw_spin_unlock_irq(&logbuf_lock);
 499                ret = wait_event_interruptible(log_wait,
 500                                               user->seq != log_next_seq);
 501                if (ret)
 502                        goto out;
 503                raw_spin_lock_irq(&logbuf_lock);
 504        }
 505
 506        if (user->seq < log_first_seq) {
 507                /* our last seen message is gone, return error and reset */
 508                user->idx = log_first_idx;
 509                user->seq = log_first_seq;
 510                ret = -EPIPE;
 511                raw_spin_unlock_irq(&logbuf_lock);
 512                goto out;
 513        }
 514
 515        msg = log_from_idx(user->idx);
 516        ts_usec = msg->ts_nsec;
 517        do_div(ts_usec, 1000);
 518
 519        /*
 520         * If we couldn't merge continuation line fragments during the print,
 521         * export the stored flags to allow an optional external merge of the
 522         * records. Merging the records isn't always neccessarily correct, like
 523         * when we hit a race during printing. In most cases though, it produces
 524         * better readable output. 'c' in the record flags mark the first
 525         * fragment of a line, '+' the following.
 526         */
 527        if (msg->flags & LOG_CONT && !(user->prev & LOG_CONT))
 528                cont = 'c';
 529        else if ((msg->flags & LOG_CONT) ||
 530                 ((user->prev & LOG_CONT) && !(msg->flags & LOG_PREFIX)))
 531                cont = '+';
 532
 533        len = sprintf(user->buf, "%u,%llu,%llu,%c;",
 534                      (msg->facility << 3) | msg->level,
 535                      user->seq, ts_usec, cont);
 536        user->prev = msg->flags;
 537
 538        /* escape non-printable characters */
 539        for (i = 0; i < msg->text_len; i++) {
 540                unsigned char c = log_text(msg)[i];
 541
 542                if (c < ' ' || c >= 127 || c == '\\')
 543                        len += sprintf(user->buf + len, "\\x%02x", c);
 544                else
 545                        user->buf[len++] = c;
 546        }
 547        user->buf[len++] = '\n';
 548
 549        if (msg->dict_len) {
 550                bool line = true;
 551
 552                for (i = 0; i < msg->dict_len; i++) {
 553                        unsigned char c = log_dict(msg)[i];
 554
 555                        if (line) {
 556                                user->buf[len++] = ' ';
 557                                line = false;
 558                        }
 559
 560                        if (c == '\0') {
 561                                user->buf[len++] = '\n';
 562                                line = true;
 563                                continue;
 564                        }
 565
 566                        if (c < ' ' || c >= 127 || c == '\\') {
 567                                len += sprintf(user->buf + len, "\\x%02x", c);
 568                                continue;
 569                        }
 570
 571                        user->buf[len++] = c;
 572                }
 573                user->buf[len++] = '\n';
 574        }
 575
 576        user->idx = log_next(user->idx);
 577        user->seq++;
 578        raw_spin_unlock_irq(&logbuf_lock);
 579
 580        if (len > count) {
 581                ret = -EINVAL;
 582                goto out;
 583        }
 584
 585        if (copy_to_user(buf, user->buf, len)) {
 586                ret = -EFAULT;
 587                goto out;
 588        }
 589        ret = len;
 590out:
 591        mutex_unlock(&user->lock);
 592        return ret;
 593}
 594
 595static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
 596{
 597        struct devkmsg_user *user = file->private_data;
 598        loff_t ret = 0;
 599
 600        if (!user)
 601                return -EBADF;
 602        if (offset)
 603                return -ESPIPE;
 604
 605        raw_spin_lock_irq(&logbuf_lock);
 606        switch (whence) {
 607        case SEEK_SET:
 608                /* the first record */
 609                user->idx = log_first_idx;
 610                user->seq = log_first_seq;
 611                break;
 612        case SEEK_DATA:
 613                /*
 614                 * The first record after the last SYSLOG_ACTION_CLEAR,
 615                 * like issued by 'dmesg -c'. Reading /dev/kmsg itself
 616                 * changes no global state, and does not clear anything.
 617                 */
 618                user->idx = clear_idx;
 619                user->seq = clear_seq;
 620                break;
 621        case SEEK_END:
 622                /* after the last record */
 623                user->idx = log_next_idx;
 624                user->seq = log_next_seq;
 625                break;
 626        default:
 627                ret = -EINVAL;
 628        }
 629        raw_spin_unlock_irq(&logbuf_lock);
 630        return ret;
 631}
 632
 633static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
 634{
 635        struct devkmsg_user *user = file->private_data;
 636        int ret = 0;
 637
 638        if (!user)
 639                return POLLERR|POLLNVAL;
 640
 641        poll_wait(file, &log_wait, wait);
 642
 643        raw_spin_lock_irq(&logbuf_lock);
 644        if (user->seq < log_next_seq) {
 645                /* return error when data has vanished underneath us */
 646                if (user->seq < log_first_seq)
 647                        ret = POLLIN|POLLRDNORM|POLLERR|POLLPRI;
 648                else
 649                        ret = POLLIN|POLLRDNORM;
 650        }
 651        raw_spin_unlock_irq(&logbuf_lock);
 652
 653        return ret;
 654}
 655
 656static int devkmsg_open(struct inode *inode, struct file *file)
 657{
 658        struct devkmsg_user *user;
 659        int err;
 660
 661        /* write-only does not need any file context */
 662        if ((file->f_flags & O_ACCMODE) == O_WRONLY)
 663                return 0;
 664
 665        err = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
 666                                       SYSLOG_FROM_READER);
 667        if (err)
 668                return err;
 669
 670        user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
 671        if (!user)
 672                return -ENOMEM;
 673
 674        mutex_init(&user->lock);
 675
 676        raw_spin_lock_irq(&logbuf_lock);
 677        user->idx = log_first_idx;
 678        user->seq = log_first_seq;
 679        raw_spin_unlock_irq(&logbuf_lock);
 680
 681        file->private_data = user;
 682        return 0;
 683}
 684
 685static int devkmsg_release(struct inode *inode, struct file *file)
 686{
 687        struct devkmsg_user *user = file->private_data;
 688
 689        if (!user)
 690                return 0;
 691
 692        mutex_destroy(&user->lock);
 693        kfree(user);
 694        return 0;
 695}
 696
 697const struct file_operations kmsg_fops = {
 698        .open = devkmsg_open,
 699        .read = devkmsg_read,
 700        .aio_write = devkmsg_writev,
 701        .llseek = devkmsg_llseek,
 702        .poll = devkmsg_poll,
 703        .release = devkmsg_release,
 704};
 705
 706#ifdef CONFIG_KEXEC
 707/*
 708 * This appends the listed symbols to /proc/vmcoreinfo
 709 *
 710 * /proc/vmcoreinfo is used by various utiilties, like crash and makedumpfile to
 711 * obtain access to symbols that are otherwise very difficult to locate.  These
 712 * symbols are specifically used so that utilities can access and extract the
 713 * dmesg log from a vmcore file after a crash.
 714 */
 715void log_buf_kexec_setup(void)
 716{
 717        VMCOREINFO_SYMBOL(log_buf);
 718        VMCOREINFO_SYMBOL(log_buf_len);
 719        VMCOREINFO_SYMBOL(log_first_idx);
 720        VMCOREINFO_SYMBOL(log_next_idx);
 721        /*
 722         * Export struct printk_log size and field offsets. User space tools can
 723         * parse it and detect any changes to structure down the line.
 724         */
 725        VMCOREINFO_STRUCT_SIZE(printk_log);
 726        VMCOREINFO_OFFSET(printk_log, ts_nsec);
 727        VMCOREINFO_OFFSET(printk_log, len);
 728        VMCOREINFO_OFFSET(printk_log, text_len);
 729        VMCOREINFO_OFFSET(printk_log, dict_len);
 730}
 731#endif
 732
 733/* requested log_buf_len from kernel cmdline */
 734static unsigned long __initdata new_log_buf_len;
 735
 736/* save requested log_buf_len since it's too early to process it */
 737static int __init log_buf_len_setup(char *str)
 738{
 739        unsigned size = memparse(str, &str);
 740
 741        if (size)
 742                size = roundup_pow_of_two(size);
 743        if (size > log_buf_len)
 744                new_log_buf_len = size;
 745
 746        return 0;
 747}
 748early_param("log_buf_len", log_buf_len_setup);
 749
 750void __init setup_log_buf(int early)
 751{
 752        unsigned long flags;
 753        char *new_log_buf;
 754        int free;
 755
 756        if (!new_log_buf_len)
 757                return;
 758
 759        if (early) {
 760                unsigned long mem;
 761
 762                mem = memblock_alloc(new_log_buf_len, PAGE_SIZE);
 763                if (!mem)
 764                        return;
 765                new_log_buf = __va(mem);
 766        } else {
 767                new_log_buf = alloc_bootmem_nopanic(new_log_buf_len);
 768        }
 769
 770        if (unlikely(!new_log_buf)) {
 771                pr_err("log_buf_len: %ld bytes not available\n",
 772                        new_log_buf_len);
 773                return;
 774        }
 775
 776        raw_spin_lock_irqsave(&logbuf_lock, flags);
 777        log_buf_len = new_log_buf_len;
 778        log_buf = new_log_buf;
 779        new_log_buf_len = 0;
 780        free = __LOG_BUF_LEN - log_next_idx;
 781        memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
 782        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 783
 784        pr_info("log_buf_len: %d\n", log_buf_len);
 785        pr_info("early log buf free: %d(%d%%)\n",
 786                free, (free * 100) / __LOG_BUF_LEN);
 787}
 788
 789static bool __read_mostly ignore_loglevel;
 790
 791static int __init ignore_loglevel_setup(char *str)
 792{
 793        ignore_loglevel = 1;
 794        printk(KERN_INFO "debug: ignoring loglevel setting.\n");
 795
 796        return 0;
 797}
 798
 799early_param("ignore_loglevel", ignore_loglevel_setup);
 800module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
 801MODULE_PARM_DESC(ignore_loglevel, "ignore loglevel setting, to"
 802        "print all kernel messages to the console.");
 803
 804#ifdef CONFIG_BOOT_PRINTK_DELAY
 805
 806static int boot_delay; /* msecs delay after each printk during bootup */
 807static unsigned long long loops_per_msec;       /* based on boot_delay */
 808
 809static int __init boot_delay_setup(char *str)
 810{
 811        unsigned long lpj;
 812
 813        lpj = preset_lpj ? preset_lpj : 1000000;        /* some guess */
 814        loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
 815
 816        get_option(&str, &boot_delay);
 817        if (boot_delay > 10 * 1000)
 818                boot_delay = 0;
 819
 820        pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
 821                "HZ: %d, loops_per_msec: %llu\n",
 822                boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
 823        return 1;
 824}
 825__setup("boot_delay=", boot_delay_setup);
 826
 827static void boot_delay_msec(int level)
 828{
 829        unsigned long long k;
 830        unsigned long timeout;
 831
 832        if ((boot_delay == 0 || system_state != SYSTEM_BOOTING)
 833                || (level >= console_loglevel && !ignore_loglevel)) {
 834                return;
 835        }
 836
 837        k = (unsigned long long)loops_per_msec * boot_delay;
 838
 839        timeout = jiffies + msecs_to_jiffies(boot_delay);
 840        while (k) {
 841                k--;
 842                cpu_relax();
 843                /*
 844                 * use (volatile) jiffies to prevent
 845                 * compiler reduction; loop termination via jiffies
 846                 * is secondary and may or may not happen.
 847                 */
 848                if (time_after(jiffies, timeout))
 849                        break;
 850                touch_nmi_watchdog();
 851        }
 852}
 853#else
 854static inline void boot_delay_msec(int level)
 855{
 856}
 857#endif
 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 printk_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 printk_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 printk_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 printk_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 printk_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 printk_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 printk_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_READER);
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, 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        raw_spin_unlock(&logbuf_lock);
1368        if (wake)
1369                up(&console_sem);
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 printk_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 printk_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
1726#ifdef CONFIG_EARLY_PRINTK
1727struct console *early_console;
1728
1729void early_vprintk(const char *fmt, va_list ap)
1730{
1731        if (early_console) {
1732                char buf[512];
1733                int n = vscnprintf(buf, sizeof(buf), fmt, ap);
1734
1735                early_console->write(early_console, buf, n);
1736        }
1737}
1738
1739asmlinkage void early_printk(const char *fmt, ...)
1740{
1741        va_list ap;
1742
1743        va_start(ap, fmt);
1744        early_vprintk(fmt, ap);
1745        va_end(ap);
1746}
1747#endif
1748
1749static int __add_preferred_console(char *name, int idx, char *options,
1750                                   char *brl_options)
1751{
1752        struct console_cmdline *c;
1753        int i;
1754
1755        /*
1756         *      See if this tty is not yet registered, and
1757         *      if we have a slot free.
1758         */
1759        for (i = 0, c = console_cmdline;
1760             i < MAX_CMDLINECONSOLES && c->name[0];
1761             i++, c++) {
1762                if (strcmp(c->name, name) == 0 && c->index == idx) {
1763                        if (!brl_options)
1764                                selected_console = i;
1765                        return 0;
1766                }
1767        }
1768        if (i == MAX_CMDLINECONSOLES)
1769                return -E2BIG;
1770        if (!brl_options)
1771                selected_console = i;
1772        strlcpy(c->name, name, sizeof(c->name));
1773        c->options = options;
1774        braille_set_options(c, brl_options);
1775
1776        c->index = idx;
1777        return 0;
1778}
1779/*
1780 * Set up a list of consoles.  Called from init/main.c
1781 */
1782static int __init console_setup(char *str)
1783{
1784        char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */
1785        char *s, *options, *brl_options = NULL;
1786        int idx;
1787
1788        if (_braille_console_setup(&str, &brl_options))
1789                return 1;
1790
1791        /*
1792         * Decode str into name, index, options.
1793         */
1794        if (str[0] >= '0' && str[0] <= '9') {
1795                strcpy(buf, "ttyS");
1796                strncpy(buf + 4, str, sizeof(buf) - 5);
1797        } else {
1798                strncpy(buf, str, sizeof(buf) - 1);
1799        }
1800        buf[sizeof(buf) - 1] = 0;
1801        if ((options = strchr(str, ',')) != NULL)
1802                *(options++) = 0;
1803#ifdef __sparc__
1804        if (!strcmp(str, "ttya"))
1805                strcpy(buf, "ttyS0");
1806        if (!strcmp(str, "ttyb"))
1807                strcpy(buf, "ttyS1");
1808#endif
1809        for (s = buf; *s; s++)
1810                if ((*s >= '0' && *s <= '9') || *s == ',')
1811                        break;
1812        idx = simple_strtoul(s, NULL, 10);
1813        *s = 0;
1814
1815        __add_preferred_console(buf, idx, options, brl_options);
1816        console_set_on_cmdline = 1;
1817        return 1;
1818}
1819__setup("console=", console_setup);
1820
1821/**
1822 * add_preferred_console - add a device to the list of preferred consoles.
1823 * @name: device name
1824 * @idx: device index
1825 * @options: options for this console
1826 *
1827 * The last preferred console added will be used for kernel messages
1828 * and stdin/out/err for init.  Normally this is used by console_setup
1829 * above to handle user-supplied console arguments; however it can also
1830 * be used by arch-specific code either to override the user or more
1831 * commonly to provide a default console (ie from PROM variables) when
1832 * the user has not supplied one.
1833 */
1834int add_preferred_console(char *name, int idx, char *options)
1835{
1836        return __add_preferred_console(name, idx, options, NULL);
1837}
1838
1839int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
1840{
1841        struct console_cmdline *c;
1842        int i;
1843
1844        for (i = 0, c = console_cmdline;
1845             i < MAX_CMDLINECONSOLES && c->name[0];
1846             i++, c++)
1847                if (strcmp(c->name, name) == 0 && c->index == idx) {
1848                        strlcpy(c->name, name_new, sizeof(c->name));
1849                        c->name[sizeof(c->name) - 1] = 0;
1850                        c->options = options;
1851                        c->index = idx_new;
1852                        return i;
1853                }
1854        /* not found */
1855        return -1;
1856}
1857
1858bool console_suspend_enabled = 1;
1859EXPORT_SYMBOL(console_suspend_enabled);
1860
1861static int __init console_suspend_disable(char *str)
1862{
1863        console_suspend_enabled = 0;
1864        return 1;
1865}
1866__setup("no_console_suspend", console_suspend_disable);
1867module_param_named(console_suspend, console_suspend_enabled,
1868                bool, S_IRUGO | S_IWUSR);
1869MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
1870        " and hibernate operations");
1871
1872/**
1873 * suspend_console - suspend the console subsystem
1874 *
1875 * This disables printk() while we go into suspend states
1876 */
1877void suspend_console(void)
1878{
1879        if (!console_suspend_enabled)
1880                return;
1881        printk("Suspending console(s) (use no_console_suspend to debug)\n");
1882        console_lock();
1883        console_suspended = 1;
1884        up(&console_sem);
1885}
1886
1887void resume_console(void)
1888{
1889        if (!console_suspend_enabled)
1890                return;
1891        down(&console_sem);
1892        console_suspended = 0;
1893        console_unlock();
1894}
1895
1896/**
1897 * console_cpu_notify - print deferred console messages after CPU hotplug
1898 * @self: notifier struct
1899 * @action: CPU hotplug event
1900 * @hcpu: unused
1901 *
1902 * If printk() is called from a CPU that is not online yet, the messages
1903 * will be spooled but will not show up on the console.  This function is
1904 * called when a new CPU comes online (or fails to come up), and ensures
1905 * that any such output gets printed.
1906 */
1907static int console_cpu_notify(struct notifier_block *self,
1908        unsigned long action, void *hcpu)
1909{
1910        switch (action) {
1911        case CPU_ONLINE:
1912        case CPU_DEAD:
1913        case CPU_DOWN_FAILED:
1914        case CPU_UP_CANCELED:
1915                console_lock();
1916                console_unlock();
1917        }
1918        return NOTIFY_OK;
1919}
1920
1921/**
1922 * console_lock - lock the console system for exclusive use.
1923 *
1924 * Acquires a lock which guarantees that the caller has
1925 * exclusive access to the console system and the console_drivers list.
1926 *
1927 * Can sleep, returns nothing.
1928 */
1929void console_lock(void)
1930{
1931        might_sleep();
1932
1933        down(&console_sem);
1934        if (console_suspended)
1935                return;
1936        console_locked = 1;
1937        console_may_schedule = 1;
1938        mutex_acquire(&console_lock_dep_map, 0, 0, _RET_IP_);
1939}
1940EXPORT_SYMBOL(console_lock);
1941
1942/**
1943 * console_trylock - try to lock the console system for exclusive use.
1944 *
1945 * Tried to acquire a lock which guarantees that the caller has
1946 * exclusive access to the console system and the console_drivers list.
1947 *
1948 * returns 1 on success, and 0 on failure to acquire the lock.
1949 */
1950int console_trylock(void)
1951{
1952        if (down_trylock(&console_sem))
1953                return 0;
1954        if (console_suspended) {
1955                up(&console_sem);
1956                return 0;
1957        }
1958        console_locked = 1;
1959        console_may_schedule = 0;
1960        mutex_acquire(&console_lock_dep_map, 0, 1, _RET_IP_);
1961        return 1;
1962}
1963EXPORT_SYMBOL(console_trylock);
1964
1965int is_console_locked(void)
1966{
1967        return console_locked;
1968}
1969
1970static void console_cont_flush(char *text, size_t size)
1971{
1972        unsigned long flags;
1973        size_t len;
1974
1975        raw_spin_lock_irqsave(&logbuf_lock, flags);
1976
1977        if (!cont.len)
1978                goto out;
1979
1980        /*
1981         * We still queue earlier records, likely because the console was
1982         * busy. The earlier ones need to be printed before this one, we
1983         * did not flush any fragment so far, so just let it queue up.
1984         */
1985        if (console_seq < log_next_seq && !cont.cons)
1986                goto out;
1987
1988        len = cont_print_text(text, size);
1989        raw_spin_unlock(&logbuf_lock);
1990        stop_critical_timings();
1991        call_console_drivers(cont.level, text, len);
1992        start_critical_timings();
1993        local_irq_restore(flags);
1994        return;
1995out:
1996        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
1997}
1998
1999/**
2000 * console_unlock - unlock the console system
2001 *
2002 * Releases the console_lock which the caller holds on the console system
2003 * and the console driver list.
2004 *
2005 * While the console_lock was held, console output may have been buffered
2006 * by printk().  If this is the case, console_unlock(); emits
2007 * the output prior to releasing the lock.
2008 *
2009 * If there is output waiting, we wake /dev/kmsg and syslog() users.
2010 *
2011 * console_unlock(); may be called from any context.
2012 */
2013void console_unlock(void)
2014{
2015        static char text[LOG_LINE_MAX + PREFIX_MAX];
2016        static u64 seen_seq;
2017        unsigned long flags;
2018        bool wake_klogd = false;
2019        bool retry;
2020
2021        if (console_suspended) {
2022                up(&console_sem);
2023                return;
2024        }
2025
2026        console_may_schedule = 0;
2027
2028        /* flush buffered message fragment immediately to console */
2029        console_cont_flush(text, sizeof(text));
2030again:
2031        for (;;) {
2032                struct printk_log *msg;
2033                size_t len;
2034                int level;
2035
2036                raw_spin_lock_irqsave(&logbuf_lock, flags);
2037                if (seen_seq != log_next_seq) {
2038                        wake_klogd = true;
2039                        seen_seq = log_next_seq;
2040                }
2041
2042                if (console_seq < log_first_seq) {
2043                        /* messages are gone, move to first one */
2044                        console_seq = log_first_seq;
2045                        console_idx = log_first_idx;
2046                        console_prev = 0;
2047                }
2048skip:
2049                if (console_seq == log_next_seq)
2050                        break;
2051
2052                msg = log_from_idx(console_idx);
2053                if (msg->flags & LOG_NOCONS) {
2054                        /*
2055                         * Skip record we have buffered and already printed
2056                         * directly to the console when we received it.
2057                         */
2058                        console_idx = log_next(console_idx);
2059                        console_seq++;
2060                        /*
2061                         * We will get here again when we register a new
2062                         * CON_PRINTBUFFER console. Clear the flag so we
2063                         * will properly dump everything later.
2064                         */
2065                        msg->flags &= ~LOG_NOCONS;
2066                        console_prev = msg->flags;
2067                        goto skip;
2068                }
2069
2070                level = msg->level;
2071                len = msg_print_text(msg, console_prev, false,
2072                                     text, sizeof(text));
2073                console_idx = log_next(console_idx);
2074                console_seq++;
2075                console_prev = msg->flags;
2076                raw_spin_unlock(&logbuf_lock);
2077
2078                stop_critical_timings();        /* don't trace print latency */
2079                call_console_drivers(level, text, len);
2080                start_critical_timings();
2081                local_irq_restore(flags);
2082        }
2083        console_locked = 0;
2084        mutex_release(&console_lock_dep_map, 1, _RET_IP_);
2085
2086        /* Release the exclusive_console once it is used */
2087        if (unlikely(exclusive_console))
2088                exclusive_console = NULL;
2089
2090        raw_spin_unlock(&logbuf_lock);
2091
2092        up(&console_sem);
2093
2094        /*
2095         * Someone could have filled up the buffer again, so re-check if there's
2096         * something to flush. In case we cannot trylock the console_sem again,
2097         * there's a new owner and the console_unlock() from them will do the
2098         * flush, no worries.
2099         */
2100        raw_spin_lock(&logbuf_lock);
2101        retry = console_seq != log_next_seq;
2102        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2103
2104        if (retry && console_trylock())
2105                goto again;
2106
2107        if (wake_klogd)
2108                wake_up_klogd();
2109}
2110EXPORT_SYMBOL(console_unlock);
2111
2112/**
2113 * console_conditional_schedule - yield the CPU if required
2114 *
2115 * If the console code is currently allowed to sleep, and
2116 * if this CPU should yield the CPU to another task, do
2117 * so here.
2118 *
2119 * Must be called within console_lock();.
2120 */
2121void __sched console_conditional_schedule(void)
2122{
2123        if (console_may_schedule)
2124                cond_resched();
2125}
2126EXPORT_SYMBOL(console_conditional_schedule);
2127
2128void console_unblank(void)
2129{
2130        struct console *c;
2131
2132        /*
2133         * console_unblank can no longer be called in interrupt context unless
2134         * oops_in_progress is set to 1..
2135         */
2136        if (oops_in_progress) {
2137                if (down_trylock(&console_sem) != 0)
2138                        return;
2139        } else
2140                console_lock();
2141
2142        console_locked = 1;
2143        console_may_schedule = 0;
2144        for_each_console(c)
2145                if ((c->flags & CON_ENABLED) && c->unblank)
2146                        c->unblank();
2147        console_unlock();
2148}
2149
2150/*
2151 * Return the console tty driver structure and its associated index
2152 */
2153struct tty_driver *console_device(int *index)
2154{
2155        struct console *c;
2156        struct tty_driver *driver = NULL;
2157
2158        console_lock();
2159        for_each_console(c) {
2160                if (!c->device)
2161                        continue;
2162                driver = c->device(c, index);
2163                if (driver)
2164                        break;
2165        }
2166        console_unlock();
2167        return driver;
2168}
2169
2170/*
2171 * Prevent further output on the passed console device so that (for example)
2172 * serial drivers can disable console output before suspending a port, and can
2173 * re-enable output afterwards.
2174 */
2175void console_stop(struct console *console)
2176{
2177        console_lock();
2178        console->flags &= ~CON_ENABLED;
2179        console_unlock();
2180}
2181EXPORT_SYMBOL(console_stop);
2182
2183void console_start(struct console *console)
2184{
2185        console_lock();
2186        console->flags |= CON_ENABLED;
2187        console_unlock();
2188}
2189EXPORT_SYMBOL(console_start);
2190
2191static int __read_mostly keep_bootcon;
2192
2193static int __init keep_bootcon_setup(char *str)
2194{
2195        keep_bootcon = 1;
2196        printk(KERN_INFO "debug: skip boot console de-registration.\n");
2197
2198        return 0;
2199}
2200
2201early_param("keep_bootcon", keep_bootcon_setup);
2202
2203/*
2204 * The console driver calls this routine during kernel initialization
2205 * to register the console printing procedure with printk() and to
2206 * print any messages that were printed by the kernel before the
2207 * console driver was initialized.
2208 *
2209 * This can happen pretty early during the boot process (because of
2210 * early_printk) - sometimes before setup_arch() completes - be careful
2211 * of what kernel features are used - they may not be initialised yet.
2212 *
2213 * There are two types of consoles - bootconsoles (early_printk) and
2214 * "real" consoles (everything which is not a bootconsole) which are
2215 * handled differently.
2216 *  - Any number of bootconsoles can be registered at any time.
2217 *  - As soon as a "real" console is registered, all bootconsoles
2218 *    will be unregistered automatically.
2219 *  - Once a "real" console is registered, any attempt to register a
2220 *    bootconsoles will be rejected
2221 */
2222void register_console(struct console *newcon)
2223{
2224        int i;
2225        unsigned long flags;
2226        struct console *bcon = NULL;
2227        struct console_cmdline *c;
2228
2229        if (console_drivers)
2230                for_each_console(bcon)
2231                        if (WARN(bcon == newcon,
2232                                        "console '%s%d' already registered\n",
2233                                        bcon->name, bcon->index))
2234                                return;
2235
2236        /*
2237         * before we register a new CON_BOOT console, make sure we don't
2238         * already have a valid console
2239         */
2240        if (console_drivers && newcon->flags & CON_BOOT) {
2241                /* find the last or real console */
2242                for_each_console(bcon) {
2243                        if (!(bcon->flags & CON_BOOT)) {
2244                                printk(KERN_INFO "Too late to register bootconsole %s%d\n",
2245                                        newcon->name, newcon->index);
2246                                return;
2247                        }
2248                }
2249        }
2250
2251        if (console_drivers && console_drivers->flags & CON_BOOT)
2252                bcon = console_drivers;
2253
2254        if (preferred_console < 0 || bcon || !console_drivers)
2255                preferred_console = selected_console;
2256
2257        if (newcon->early_setup)
2258                newcon->early_setup();
2259
2260        /*
2261         *      See if we want to use this console driver. If we
2262         *      didn't select a console we take the first one
2263         *      that registers here.
2264         */
2265        if (preferred_console < 0) {
2266                if (newcon->index < 0)
2267                        newcon->index = 0;
2268                if (newcon->setup == NULL ||
2269                    newcon->setup(newcon, NULL) == 0) {
2270                        newcon->flags |= CON_ENABLED;
2271                        if (newcon->device) {
2272                                newcon->flags |= CON_CONSDEV;
2273                                preferred_console = 0;
2274                        }
2275                }
2276        }
2277
2278        /*
2279         *      See if this console matches one we selected on
2280         *      the command line.
2281         */
2282        for (i = 0, c = console_cmdline;
2283             i < MAX_CMDLINECONSOLES && c->name[0];
2284             i++, c++) {
2285                if (strcmp(c->name, newcon->name) != 0)
2286                        continue;
2287                if (newcon->index >= 0 &&
2288                    newcon->index != c->index)
2289                        continue;
2290                if (newcon->index < 0)
2291                        newcon->index = c->index;
2292
2293                if (_braille_register_console(newcon, c))
2294                        return;
2295
2296                if (newcon->setup &&
2297                    newcon->setup(newcon, console_cmdline[i].options) != 0)
2298                        break;
2299                newcon->flags |= CON_ENABLED;
2300                newcon->index = c->index;
2301                if (i == selected_console) {
2302                        newcon->flags |= CON_CONSDEV;
2303                        preferred_console = selected_console;
2304                }
2305                break;
2306        }
2307
2308        if (!(newcon->flags & CON_ENABLED))
2309                return;
2310
2311        /*
2312         * If we have a bootconsole, and are switching to a real console,
2313         * don't print everything out again, since when the boot console, and
2314         * the real console are the same physical device, it's annoying to
2315         * see the beginning boot messages twice
2316         */
2317        if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
2318                newcon->flags &= ~CON_PRINTBUFFER;
2319
2320        /*
2321         *      Put this console in the list - keep the
2322         *      preferred driver at the head of the list.
2323         */
2324        console_lock();
2325        if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
2326                newcon->next = console_drivers;
2327                console_drivers = newcon;
2328                if (newcon->next)
2329                        newcon->next->flags &= ~CON_CONSDEV;
2330        } else {
2331                newcon->next = console_drivers->next;
2332                console_drivers->next = newcon;
2333        }
2334        if (newcon->flags & CON_PRINTBUFFER) {
2335                /*
2336                 * console_unlock(); will print out the buffered messages
2337                 * for us.
2338                 */
2339                raw_spin_lock_irqsave(&logbuf_lock, flags);
2340                console_seq = syslog_seq;
2341                console_idx = syslog_idx;
2342                console_prev = syslog_prev;
2343                raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2344                /*
2345                 * We're about to replay the log buffer.  Only do this to the
2346                 * just-registered console to avoid excessive message spam to
2347                 * the already-registered consoles.
2348                 */
2349                exclusive_console = newcon;
2350        }
2351        console_unlock();
2352        console_sysfs_notify();
2353
2354        /*
2355         * By unregistering the bootconsoles after we enable the real console
2356         * we get the "console xxx enabled" message on all the consoles -
2357         * boot consoles, real consoles, etc - this is to ensure that end
2358         * users know there might be something in the kernel's log buffer that
2359         * went to the bootconsole (that they do not see on the real console)
2360         */
2361        if (bcon &&
2362            ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
2363            !keep_bootcon) {
2364                /* we need to iterate through twice, to make sure we print
2365                 * everything out, before we unregister the console(s)
2366                 */
2367                printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
2368                        newcon->name, newcon->index);
2369                for_each_console(bcon)
2370                        if (bcon->flags & CON_BOOT)
2371                                unregister_console(bcon);
2372        } else {
2373                printk(KERN_INFO "%sconsole [%s%d] enabled\n",
2374                        (newcon->flags & CON_BOOT) ? "boot" : "" ,
2375                        newcon->name, newcon->index);
2376        }
2377}
2378EXPORT_SYMBOL(register_console);
2379
2380int unregister_console(struct console *console)
2381{
2382        struct console *a, *b;
2383        int res;
2384
2385        res = _braille_unregister_console(console);
2386        if (res)
2387                return res;
2388
2389        res = 1;
2390        console_lock();
2391        if (console_drivers == console) {
2392                console_drivers=console->next;
2393                res = 0;
2394        } else if (console_drivers) {
2395                for (a=console_drivers->next, b=console_drivers ;
2396                     a; b=a, a=b->next) {
2397                        if (a == console) {
2398                                b->next = a->next;
2399                                res = 0;
2400                                break;
2401                        }
2402                }
2403        }
2404
2405        /*
2406         * If this isn't the last console and it has CON_CONSDEV set, we
2407         * need to set it on the next preferred console.
2408         */
2409        if (console_drivers != NULL && console->flags & CON_CONSDEV)
2410                console_drivers->flags |= CON_CONSDEV;
2411
2412        console_unlock();
2413        console_sysfs_notify();
2414        return res;
2415}
2416EXPORT_SYMBOL(unregister_console);
2417
2418static int __init printk_late_init(void)
2419{
2420        struct console *con;
2421
2422        for_each_console(con) {
2423                if (!keep_bootcon && con->flags & CON_BOOT) {
2424                        printk(KERN_INFO "turn off boot console %s%d\n",
2425                                con->name, con->index);
2426                        unregister_console(con);
2427                }
2428        }
2429        hotcpu_notifier(console_cpu_notify, 0);
2430        return 0;
2431}
2432late_initcall(printk_late_init);
2433
2434#if defined CONFIG_PRINTK
2435/*
2436 * Delayed printk version, for scheduler-internal messages:
2437 */
2438#define PRINTK_BUF_SIZE         512
2439
2440#define PRINTK_PENDING_WAKEUP   0x01
2441#define PRINTK_PENDING_SCHED    0x02
2442
2443static DEFINE_PER_CPU(int, printk_pending);
2444static DEFINE_PER_CPU(char [PRINTK_BUF_SIZE], printk_sched_buf);
2445
2446static void wake_up_klogd_work_func(struct irq_work *irq_work)
2447{
2448        int pending = __this_cpu_xchg(printk_pending, 0);
2449
2450        if (pending & PRINTK_PENDING_SCHED) {
2451                char *buf = __get_cpu_var(printk_sched_buf);
2452                printk(KERN_WARNING "[sched_delayed] %s", buf);
2453        }
2454
2455        if (pending & PRINTK_PENDING_WAKEUP)
2456                wake_up_interruptible(&log_wait);
2457}
2458
2459static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
2460        .func = wake_up_klogd_work_func,
2461        .flags = IRQ_WORK_LAZY,
2462};
2463
2464void wake_up_klogd(void)
2465{
2466        preempt_disable();
2467        if (waitqueue_active(&log_wait)) {
2468                this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
2469                irq_work_queue(&__get_cpu_var(wake_up_klogd_work));
2470        }
2471        preempt_enable();
2472}
2473
2474int printk_sched(const char *fmt, ...)
2475{
2476        unsigned long flags;
2477        va_list args;
2478        char *buf;
2479        int r;
2480
2481        local_irq_save(flags);
2482        buf = __get_cpu_var(printk_sched_buf);
2483
2484        va_start(args, fmt);
2485        r = vsnprintf(buf, PRINTK_BUF_SIZE, fmt, args);
2486        va_end(args);
2487
2488        __this_cpu_or(printk_pending, PRINTK_PENDING_SCHED);
2489        irq_work_queue(&__get_cpu_var(wake_up_klogd_work));
2490        local_irq_restore(flags);
2491
2492        return r;
2493}
2494
2495/*
2496 * printk rate limiting, lifted from the networking subsystem.
2497 *
2498 * This enforces a rate limit: not more than 10 kernel messages
2499 * every 5s to make a denial-of-service attack impossible.
2500 */
2501DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
2502
2503int __printk_ratelimit(const char *func)
2504{
2505        return ___ratelimit(&printk_ratelimit_state, func);
2506}
2507EXPORT_SYMBOL(__printk_ratelimit);
2508
2509/**
2510 * printk_timed_ratelimit - caller-controlled printk ratelimiting
2511 * @caller_jiffies: pointer to caller's state
2512 * @interval_msecs: minimum interval between prints
2513 *
2514 * printk_timed_ratelimit() returns true if more than @interval_msecs
2515 * milliseconds have elapsed since the last time printk_timed_ratelimit()
2516 * returned true.
2517 */
2518bool printk_timed_ratelimit(unsigned long *caller_jiffies,
2519                        unsigned int interval_msecs)
2520{
2521        if (*caller_jiffies == 0
2522                        || !time_in_range(jiffies, *caller_jiffies,
2523                                        *caller_jiffies
2524                                        + msecs_to_jiffies(interval_msecs))) {
2525                *caller_jiffies = jiffies;
2526                return true;
2527        }
2528        return false;
2529}
2530EXPORT_SYMBOL(printk_timed_ratelimit);
2531
2532static DEFINE_SPINLOCK(dump_list_lock);
2533static LIST_HEAD(dump_list);
2534
2535/**
2536 * kmsg_dump_register - register a kernel log dumper.
2537 * @dumper: pointer to the kmsg_dumper structure
2538 *
2539 * Adds a kernel log dumper to the system. The dump callback in the
2540 * structure will be called when the kernel oopses or panics and must be
2541 * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
2542 */
2543int kmsg_dump_register(struct kmsg_dumper *dumper)
2544{
2545        unsigned long flags;
2546        int err = -EBUSY;
2547
2548        /* The dump callback needs to be set */
2549        if (!dumper->dump)
2550                return -EINVAL;
2551
2552        spin_lock_irqsave(&dump_list_lock, flags);
2553        /* Don't allow registering multiple times */
2554        if (!dumper->registered) {
2555                dumper->registered = 1;
2556                list_add_tail_rcu(&dumper->list, &dump_list);
2557                err = 0;
2558        }
2559        spin_unlock_irqrestore(&dump_list_lock, flags);
2560
2561        return err;
2562}
2563EXPORT_SYMBOL_GPL(kmsg_dump_register);
2564
2565/**
2566 * kmsg_dump_unregister - unregister a kmsg dumper.
2567 * @dumper: pointer to the kmsg_dumper structure
2568 *
2569 * Removes a dump device from the system. Returns zero on success and
2570 * %-EINVAL otherwise.
2571 */
2572int kmsg_dump_unregister(struct kmsg_dumper *dumper)
2573{
2574        unsigned long flags;
2575        int err = -EINVAL;
2576
2577        spin_lock_irqsave(&dump_list_lock, flags);
2578        if (dumper->registered) {
2579                dumper->registered = 0;
2580                list_del_rcu(&dumper->list);
2581                err = 0;
2582        }
2583        spin_unlock_irqrestore(&dump_list_lock, flags);
2584        synchronize_rcu();
2585
2586        return err;
2587}
2588EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
2589
2590static bool always_kmsg_dump;
2591module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
2592
2593/**
2594 * kmsg_dump - dump kernel log to kernel message dumpers.
2595 * @reason: the reason (oops, panic etc) for dumping
2596 *
2597 * Call each of the registered dumper's dump() callback, which can
2598 * retrieve the kmsg records with kmsg_dump_get_line() or
2599 * kmsg_dump_get_buffer().
2600 */
2601void kmsg_dump(enum kmsg_dump_reason reason)
2602{
2603        struct kmsg_dumper *dumper;
2604        unsigned long flags;
2605
2606        if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
2607                return;
2608
2609        rcu_read_lock();
2610        list_for_each_entry_rcu(dumper, &dump_list, list) {
2611                if (dumper->max_reason && reason > dumper->max_reason)
2612                        continue;
2613
2614                /* initialize iterator with data about the stored records */
2615                dumper->active = true;
2616
2617                raw_spin_lock_irqsave(&logbuf_lock, flags);
2618                dumper->cur_seq = clear_seq;
2619                dumper->cur_idx = clear_idx;
2620                dumper->next_seq = log_next_seq;
2621                dumper->next_idx = log_next_idx;
2622                raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2623
2624                /* invoke dumper which will iterate over records */
2625                dumper->dump(dumper, reason);
2626
2627                /* reset iterator */
2628                dumper->active = false;
2629        }
2630        rcu_read_unlock();
2631}
2632
2633/**
2634 * kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version)
2635 * @dumper: registered kmsg dumper
2636 * @syslog: include the "<4>" prefixes
2637 * @line: buffer to copy the line to
2638 * @size: maximum size of the buffer
2639 * @len: length of line placed into buffer
2640 *
2641 * Start at the beginning of the kmsg buffer, with the oldest kmsg
2642 * record, and copy one record into the provided buffer.
2643 *
2644 * Consecutive calls will return the next available record moving
2645 * towards the end of the buffer with the youngest messages.
2646 *
2647 * A return value of FALSE indicates that there are no more records to
2648 * read.
2649 *
2650 * The function is similar to kmsg_dump_get_line(), but grabs no locks.
2651 */
2652bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
2653                               char *line, size_t size, size_t *len)
2654{
2655        struct printk_log *msg;
2656        size_t l = 0;
2657        bool ret = false;
2658
2659        if (!dumper->active)
2660                goto out;
2661
2662        if (dumper->cur_seq < log_first_seq) {
2663                /* messages are gone, move to first available one */
2664                dumper->cur_seq = log_first_seq;
2665                dumper->cur_idx = log_first_idx;
2666        }
2667
2668        /* last entry */
2669        if (dumper->cur_seq >= log_next_seq)
2670                goto out;
2671
2672        msg = log_from_idx(dumper->cur_idx);
2673        l = msg_print_text(msg, 0, syslog, line, size);
2674
2675        dumper->cur_idx = log_next(dumper->cur_idx);
2676        dumper->cur_seq++;
2677        ret = true;
2678out:
2679        if (len)
2680                *len = l;
2681        return ret;
2682}
2683
2684/**
2685 * kmsg_dump_get_line - retrieve one kmsg log line
2686 * @dumper: registered kmsg dumper
2687 * @syslog: include the "<4>" prefixes
2688 * @line: buffer to copy the line to
2689 * @size: maximum size of the buffer
2690 * @len: length of line placed into buffer
2691 *
2692 * Start at the beginning of the kmsg buffer, with the oldest kmsg
2693 * record, and copy one record into the provided buffer.
2694 *
2695 * Consecutive calls will return the next available record moving
2696 * towards the end of the buffer with the youngest messages.
2697 *
2698 * A return value of FALSE indicates that there are no more records to
2699 * read.
2700 */
2701bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
2702                        char *line, size_t size, size_t *len)
2703{
2704        unsigned long flags;
2705        bool ret;
2706
2707        raw_spin_lock_irqsave(&logbuf_lock, flags);
2708        ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
2709        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2710
2711        return ret;
2712}
2713EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
2714
2715/**
2716 * kmsg_dump_get_buffer - copy kmsg log lines
2717 * @dumper: registered kmsg dumper
2718 * @syslog: include the "<4>" prefixes
2719 * @buf: buffer to copy the line to
2720 * @size: maximum size of the buffer
2721 * @len: length of line placed into buffer
2722 *
2723 * Start at the end of the kmsg buffer and fill the provided buffer
2724 * with as many of the the *youngest* kmsg records that fit into it.
2725 * If the buffer is large enough, all available kmsg records will be
2726 * copied with a single call.
2727 *
2728 * Consecutive calls will fill the buffer with the next block of
2729 * available older records, not including the earlier retrieved ones.
2730 *
2731 * A return value of FALSE indicates that there are no more records to
2732 * read.
2733 */
2734bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
2735                          char *buf, size_t size, size_t *len)
2736{
2737        unsigned long flags;
2738        u64 seq;
2739        u32 idx;
2740        u64 next_seq;
2741        u32 next_idx;
2742        enum log_flags prev;
2743        size_t l = 0;
2744        bool ret = false;
2745
2746        if (!dumper->active)
2747                goto out;
2748
2749        raw_spin_lock_irqsave(&logbuf_lock, flags);
2750        if (dumper->cur_seq < log_first_seq) {
2751                /* messages are gone, move to first available one */
2752                dumper->cur_seq = log_first_seq;
2753                dumper->cur_idx = log_first_idx;
2754        }
2755
2756        /* last entry */
2757        if (dumper->cur_seq >= dumper->next_seq) {
2758                raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2759                goto out;
2760        }
2761
2762        /* calculate length of entire buffer */
2763        seq = dumper->cur_seq;
2764        idx = dumper->cur_idx;
2765        prev = 0;
2766        while (seq < dumper->next_seq) {
2767                struct printk_log *msg = log_from_idx(idx);
2768
2769                l += msg_print_text(msg, prev, true, NULL, 0);
2770                idx = log_next(idx);
2771                seq++;
2772                prev = msg->flags;
2773        }
2774
2775        /* move first record forward until length fits into the buffer */
2776        seq = dumper->cur_seq;
2777        idx = dumper->cur_idx;
2778        prev = 0;
2779        while (l > size && seq < dumper->next_seq) {
2780                struct printk_log *msg = log_from_idx(idx);
2781
2782                l -= msg_print_text(msg, prev, true, NULL, 0);
2783                idx = log_next(idx);
2784                seq++;
2785                prev = msg->flags;
2786        }
2787
2788        /* last message in next interation */
2789        next_seq = seq;
2790        next_idx = idx;
2791
2792        l = 0;
2793        prev = 0;
2794        while (seq < dumper->next_seq) {
2795                struct printk_log *msg = log_from_idx(idx);
2796
2797                l += msg_print_text(msg, prev, syslog, buf + l, size - l);
2798                idx = log_next(idx);
2799                seq++;
2800                prev = msg->flags;
2801        }
2802
2803        dumper->next_seq = next_seq;
2804        dumper->next_idx = next_idx;
2805        ret = true;
2806        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2807out:
2808        if (len)
2809                *len = l;
2810        return ret;
2811}
2812EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
2813
2814/**
2815 * kmsg_dump_rewind_nolock - reset the interator (unlocked version)
2816 * @dumper: registered kmsg dumper
2817 *
2818 * Reset the dumper's iterator so that kmsg_dump_get_line() and
2819 * kmsg_dump_get_buffer() can be called again and used multiple
2820 * times within the same dumper.dump() callback.
2821 *
2822 * The function is similar to kmsg_dump_rewind(), but grabs no locks.
2823 */
2824void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
2825{
2826        dumper->cur_seq = clear_seq;
2827        dumper->cur_idx = clear_idx;
2828        dumper->next_seq = log_next_seq;
2829        dumper->next_idx = log_next_idx;
2830}
2831
2832/**
2833 * kmsg_dump_rewind - reset the interator
2834 * @dumper: registered kmsg dumper
2835 *
2836 * Reset the dumper's iterator so that kmsg_dump_get_line() and
2837 * kmsg_dump_get_buffer() can be called again and used multiple
2838 * times within the same dumper.dump() callback.
2839 */
2840void kmsg_dump_rewind(struct kmsg_dumper *dumper)
2841{
2842        unsigned long flags;
2843
2844        raw_spin_lock_irqsave(&logbuf_lock, flags);
2845        kmsg_dump_rewind_nolock(dumper);
2846        raw_spin_unlock_irqrestore(&logbuf_lock, flags);
2847}
2848EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
2849
2850static char dump_stack_arch_desc_str[128];
2851
2852/**
2853 * dump_stack_set_arch_desc - set arch-specific str to show with task dumps
2854 * @fmt: printf-style format string
2855 * @...: arguments for the format string
2856 *
2857 * The configured string will be printed right after utsname during task
2858 * dumps.  Usually used to add arch-specific system identifiers.  If an
2859 * arch wants to make use of such an ID string, it should initialize this
2860 * as soon as possible during boot.
2861 */
2862void __init dump_stack_set_arch_desc(const char *fmt, ...)
2863{
2864        va_list args;
2865
2866        va_start(args, fmt);
2867        vsnprintf(dump_stack_arch_desc_str, sizeof(dump_stack_arch_desc_str),
2868                  fmt, args);
2869        va_end(args);
2870}
2871
2872/**
2873 * dump_stack_print_info - print generic debug info for dump_stack()
2874 * @log_lvl: log level
2875 *
2876 * Arch-specific dump_stack() implementations can use this function to
2877 * print out the same debug information as the generic dump_stack().
2878 */
2879void dump_stack_print_info(const char *log_lvl)
2880{
2881        printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n",
2882               log_lvl, raw_smp_processor_id(), current->pid, current->comm,
2883               print_tainted(), init_utsname()->release,
2884               (int)strcspn(init_utsname()->version, " "),
2885               init_utsname()->version);
2886
2887        if (dump_stack_arch_desc_str[0] != '\0')
2888                printk("%sHardware name: %s\n",
2889                       log_lvl, dump_stack_arch_desc_str);
2890
2891        print_worker_info(log_lvl, current);
2892}
2893
2894/**
2895 * show_regs_print_info - print generic debug info for show_regs()
2896 * @log_lvl: log level
2897 *
2898 * show_regs() implementations can use this function to print out generic
2899 * debug information.
2900 */
2901void show_regs_print_info(const char *log_lvl)
2902{
2903        dump_stack_print_info(log_lvl);
2904
2905        printk("%stask: %p ti: %p task.ti: %p\n",
2906               log_lvl, current, current_thread_info(),
2907               task_thread_info(current));
2908}
2909
2910#endif
2911
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.