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