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