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