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