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