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