kernel/printk.c

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