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