1 /* 2 * linux/drivers/net/netconsole.c 3 * 4 * Copyright (C) 2001 Ingo Molnar <mingo@redhat.com> 5 * 6 * This file contains the implementation of an IRQ-safe, crash-safe 7 * kernel console implementation that outputs kernel messages to the 8 * network. 9 * 10 * Modification history: 11 * 12 * 2001-09-17 started by Ingo Molnar. 13 * 2003-08-11 2.6 port by Matt Mackall 14 * simplified options 15 * generic card hooks 16 * works non-modular 17 * 2003-09-07 rewritten with netpoll api 18 */ 19 20 /**************************************************************** 21 * This program is free software; you can redistribute it and/or modify 22 * it under the terms of the GNU General Public License as published by 23 * the Free Software Foundation; either version 2, or (at your option) 24 * any later version. 25 * 26 * This program is distributed in the hope that it will be useful, 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of 28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 29 * GNU General Public License for more details. 30 * 31 * You should have received a copy of the GNU General Public License 32 * along with this program; if not, write to the Free Software 33 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 34 * 35 ****************************************************************/ 36 37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 38 39 #include <linux/mm.h> 40 #include <linux/init.h> 41 #include <linux/module.h> 42 #include <linux/slab.h> 43 #include <linux/console.h> 44 #include <linux/moduleparam.h> 45 #include <linux/kernel.h> 46 #include <linux/string.h> 47 #include <linux/netpoll.h> 48 #include <linux/inet.h> 49 #include <linux/configfs.h> 50 #include <linux/etherdevice.h> 51 52 MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>"); 53 MODULE_DESCRIPTION("Console driver for network interfaces"); 54 MODULE_LICENSE("GPL"); 55 56 #define MAX_PARAM_LENGTH 256 57 #define MAX_PRINT_CHUNK 1000 58 59 static char config[MAX_PARAM_LENGTH]; 60 module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0); 61 MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]"); 62 63 static bool oops_only = false; 64 module_param(oops_only, bool, 0600); 65 MODULE_PARM_DESC(oops_only, "Only log oops messages"); 66 67 #ifndef MODULE 68 static int __init option_setup(char *opt) 69 { 70 strlcpy(config, opt, MAX_PARAM_LENGTH); 71 return 1; 72 } 73 __setup("netconsole=", option_setup); 74 #endif /* MODULE */ 75 76 /* Linked list of all configured targets */ 77 static LIST_HEAD(target_list); 78 79 /* This needs to be a spinlock because write_msg() cannot sleep */ 80 static DEFINE_SPINLOCK(target_list_lock); 81 82 /* 83 * Console driver for extended netconsoles. Registered on the first use to 84 * avoid unnecessarily enabling ext message formatting. 85 */ 86 static struct console netconsole_ext; 87 88 /** 89 * struct netconsole_target - Represents a configured netconsole target. 90 * @list: Links this target into the target_list. 91 * @item: Links us into the configfs subsystem hierarchy. 92 * @enabled: On / off knob to enable / disable target. 93 * Visible from userspace (read-write). 94 * We maintain a strict 1:1 correspondence between this and 95 * whether the corresponding netpoll is active or inactive. 96 * Also, other parameters of a target may be modified at 97 * runtime only when it is disabled (enabled == 0). 98 * @np: The netpoll structure for this target. 99 * Contains the other userspace visible parameters: 100 * dev_name (read-write) 101 * local_port (read-write) 102 * remote_port (read-write) 103 * local_ip (read-write) 104 * remote_ip (read-write) 105 * local_mac (read-only) 106 * remote_mac (read-write) 107 */ 108 struct netconsole_target { 109 struct list_head list; 110 #ifdef CONFIG_NETCONSOLE_DYNAMIC 111 struct config_item item; 112 #endif 113 bool enabled; 114 bool extended; 115 struct netpoll np; 116 }; 117 118 #ifdef CONFIG_NETCONSOLE_DYNAMIC 119 120 static struct configfs_subsystem netconsole_subsys; 121 static DEFINE_MUTEX(dynamic_netconsole_mutex); 122 123 static int __init dynamic_netconsole_init(void) 124 { 125 config_group_init(&netconsole_subsys.su_group); 126 mutex_init(&netconsole_subsys.su_mutex); 127 return configfs_register_subsystem(&netconsole_subsys); 128 } 129 130 static void __exit dynamic_netconsole_exit(void) 131 { 132 configfs_unregister_subsystem(&netconsole_subsys); 133 } 134 135 /* 136 * Targets that were created by parsing the boot/module option string 137 * do not exist in the configfs hierarchy (and have NULL names) and will 138 * never go away, so make these a no-op for them. 139 */ 140 static void netconsole_target_get(struct netconsole_target *nt) 141 { 142 if (config_item_name(&nt->item)) 143 config_item_get(&nt->item); 144 } 145 146 static void netconsole_target_put(struct netconsole_target *nt) 147 { 148 if (config_item_name(&nt->item)) 149 config_item_put(&nt->item); 150 } 151 152 #else /* !CONFIG_NETCONSOLE_DYNAMIC */ 153 154 static int __init dynamic_netconsole_init(void) 155 { 156 return 0; 157 } 158 159 static void __exit dynamic_netconsole_exit(void) 160 { 161 } 162 163 /* 164 * No danger of targets going away from under us when dynamic 165 * reconfigurability is off. 166 */ 167 static void netconsole_target_get(struct netconsole_target *nt) 168 { 169 } 170 171 static void netconsole_target_put(struct netconsole_target *nt) 172 { 173 } 174 175 #endif /* CONFIG_NETCONSOLE_DYNAMIC */ 176 177 /* Allocate new target (from boot/module param) and setup netpoll for it */ 178 static struct netconsole_target *alloc_param_target(char *target_config) 179 { 180 int err = -ENOMEM; 181 struct netconsole_target *nt; 182 183 /* 184 * Allocate and initialize with defaults. 185 * Note that these targets get their config_item fields zeroed-out. 186 */ 187 nt = kzalloc(sizeof(*nt), GFP_KERNEL); 188 if (!nt) 189 goto fail; 190 191 nt->np.name = "netconsole"; 192 strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ); 193 nt->np.local_port = 6665; 194 nt->np.remote_port = 6666; 195 eth_broadcast_addr(nt->np.remote_mac); 196 197 if (*target_config == '+') { 198 nt->extended = true; 199 target_config++; 200 } 201 202 /* Parse parameters and setup netpoll */ 203 err = netpoll_parse_options(&nt->np, target_config); 204 if (err) 205 goto fail; 206 207 err = netpoll_setup(&nt->np); 208 if (err) 209 goto fail; 210 211 nt->enabled = true; 212 213 return nt; 214 215 fail: 216 kfree(nt); 217 return ERR_PTR(err); 218 } 219 220 /* Cleanup netpoll for given target (from boot/module param) and free it */ 221 static void free_param_target(struct netconsole_target *nt) 222 { 223 netpoll_cleanup(&nt->np); 224 kfree(nt); 225 } 226 227 #ifdef CONFIG_NETCONSOLE_DYNAMIC 228 229 /* 230 * Our subsystem hierarchy is: 231 * 232 * /sys/kernel/config/netconsole/ 233 * | 234 * <target>/ 235 * | enabled 236 * | dev_name 237 * | local_port 238 * | remote_port 239 * | local_ip 240 * | remote_ip 241 * | local_mac 242 * | remote_mac 243 * | 244 * <target>/... 245 */ 246 247 static struct netconsole_target *to_target(struct config_item *item) 248 { 249 return item ? 250 container_of(item, struct netconsole_target, item) : 251 NULL; 252 } 253 254 /* 255 * Attribute operations for netconsole_target. 256 */ 257 258 static ssize_t enabled_show(struct config_item *item, char *buf) 259 { 260 return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->enabled); 261 } 262 263 static ssize_t extended_show(struct config_item *item, char *buf) 264 { 265 return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->extended); 266 } 267 268 static ssize_t dev_name_show(struct config_item *item, char *buf) 269 { 270 return snprintf(buf, PAGE_SIZE, "%s\n", to_target(item)->np.dev_name); 271 } 272 273 static ssize_t local_port_show(struct config_item *item, char *buf) 274 { 275 return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->np.local_port); 276 } 277 278 static ssize_t remote_port_show(struct config_item *item, char *buf) 279 { 280 return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->np.remote_port); 281 } 282 283 static ssize_t local_ip_show(struct config_item *item, char *buf) 284 { 285 struct netconsole_target *nt = to_target(item); 286 287 if (nt->np.ipv6) 288 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.local_ip.in6); 289 else 290 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip); 291 } 292 293 static ssize_t remote_ip_show(struct config_item *item, char *buf) 294 { 295 struct netconsole_target *nt = to_target(item); 296 297 if (nt->np.ipv6) 298 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.remote_ip.in6); 299 else 300 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip); 301 } 302 303 static ssize_t local_mac_show(struct config_item *item, char *buf) 304 { 305 struct net_device *dev = to_target(item)->np.dev; 306 static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 307 308 return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast); 309 } 310 311 static ssize_t remote_mac_show(struct config_item *item, char *buf) 312 { 313 return snprintf(buf, PAGE_SIZE, "%pM\n", to_target(item)->np.remote_mac); 314 } 315 316 /* 317 * This one is special -- targets created through the configfs interface 318 * are not enabled (and the corresponding netpoll activated) by default. 319 * The user is expected to set the desired parameters first (which 320 * would enable him to dynamically add new netpoll targets for new 321 * network interfaces as and when they come up). 322 */ 323 static ssize_t enabled_store(struct config_item *item, 324 const char *buf, size_t count) 325 { 326 struct netconsole_target *nt = to_target(item); 327 unsigned long flags; 328 int enabled; 329 int err; 330 331 mutex_lock(&dynamic_netconsole_mutex); 332 err = kstrtoint(buf, 10, &enabled); 333 if (err < 0) 334 goto out_unlock; 335 336 err = -EINVAL; 337 if (enabled < 0 || enabled > 1) 338 goto out_unlock; 339 if ((bool)enabled == nt->enabled) { 340 pr_info("network logging has already %s\n", 341 nt->enabled ? "started" : "stopped"); 342 goto out_unlock; 343 } 344 345 if (enabled) { /* true */ 346 if (nt->extended && !(netconsole_ext.flags & CON_ENABLED)) { 347 netconsole_ext.flags |= CON_ENABLED; 348 register_console(&netconsole_ext); 349 } 350 351 /* 352 * Skip netpoll_parse_options() -- all the attributes are 353 * already configured via configfs. Just print them out. 354 */ 355 netpoll_print_options(&nt->np); 356 357 err = netpoll_setup(&nt->np); 358 if (err) 359 goto out_unlock; 360 361 pr_info("network logging started\n"); 362 } else { /* false */ 363 /* We need to disable the netconsole before cleaning it up 364 * otherwise we might end up in write_msg() with 365 * nt->np.dev == NULL and nt->enabled == true 366 */ 367 spin_lock_irqsave(&target_list_lock, flags); 368 nt->enabled = false; 369 spin_unlock_irqrestore(&target_list_lock, flags); 370 netpoll_cleanup(&nt->np); 371 } 372 373 nt->enabled = enabled; 374 375 mutex_unlock(&dynamic_netconsole_mutex); 376 return strnlen(buf, count); 377 out_unlock: 378 mutex_unlock(&dynamic_netconsole_mutex); 379 return err; 380 } 381 382 static ssize_t extended_store(struct config_item *item, const char *buf, 383 size_t count) 384 { 385 struct netconsole_target *nt = to_target(item); 386 int extended; 387 int err; 388 389 mutex_lock(&dynamic_netconsole_mutex); 390 if (nt->enabled) { 391 pr_err("target (%s) is enabled, disable to update parameters\n", 392 config_item_name(&nt->item)); 393 err = -EINVAL; 394 goto out_unlock; 395 } 396 397 err = kstrtoint(buf, 10, &extended); 398 if (err < 0) 399 goto out_unlock; 400 if (extended < 0 || extended > 1) { 401 err = -EINVAL; 402 goto out_unlock; 403 } 404 405 nt->extended = extended; 406 407 mutex_unlock(&dynamic_netconsole_mutex); 408 return strnlen(buf, count); 409 out_unlock: 410 mutex_unlock(&dynamic_netconsole_mutex); 411 return err; 412 } 413 414 static ssize_t dev_name_store(struct config_item *item, const char *buf, 415 size_t count) 416 { 417 struct netconsole_target *nt = to_target(item); 418 size_t len; 419 420 mutex_lock(&dynamic_netconsole_mutex); 421 if (nt->enabled) { 422 pr_err("target (%s) is enabled, disable to update parameters\n", 423 config_item_name(&nt->item)); 424 mutex_unlock(&dynamic_netconsole_mutex); 425 return -EINVAL; 426 } 427 428 strlcpy(nt->np.dev_name, buf, IFNAMSIZ); 429 430 /* Get rid of possible trailing newline from echo(1) */ 431 len = strnlen(nt->np.dev_name, IFNAMSIZ); 432 if (nt->np.dev_name[len - 1] == '\n') 433 nt->np.dev_name[len - 1] = '\0'; 434 435 mutex_unlock(&dynamic_netconsole_mutex); 436 return strnlen(buf, count); 437 } 438 439 static ssize_t local_port_store(struct config_item *item, const char *buf, 440 size_t count) 441 { 442 struct netconsole_target *nt = to_target(item); 443 int rv = -EINVAL; 444 445 mutex_lock(&dynamic_netconsole_mutex); 446 if (nt->enabled) { 447 pr_err("target (%s) is enabled, disable to update parameters\n", 448 config_item_name(&nt->item)); 449 goto out_unlock; 450 } 451 452 rv = kstrtou16(buf, 10, &nt->np.local_port); 453 if (rv < 0) 454 goto out_unlock; 455 mutex_unlock(&dynamic_netconsole_mutex); 456 return strnlen(buf, count); 457 out_unlock: 458 mutex_unlock(&dynamic_netconsole_mutex); 459 return rv; 460 } 461 462 static ssize_t remote_port_store(struct config_item *item, 463 const char *buf, size_t count) 464 { 465 struct netconsole_target *nt = to_target(item); 466 int rv = -EINVAL; 467 468 mutex_lock(&dynamic_netconsole_mutex); 469 if (nt->enabled) { 470 pr_err("target (%s) is enabled, disable to update parameters\n", 471 config_item_name(&nt->item)); 472 goto out_unlock; 473 } 474 475 rv = kstrtou16(buf, 10, &nt->np.remote_port); 476 if (rv < 0) 477 goto out_unlock; 478 mutex_unlock(&dynamic_netconsole_mutex); 479 return strnlen(buf, count); 480 out_unlock: 481 mutex_unlock(&dynamic_netconsole_mutex); 482 return rv; 483 } 484 485 static ssize_t local_ip_store(struct config_item *item, const char *buf, 486 size_t count) 487 { 488 struct netconsole_target *nt = to_target(item); 489 490 mutex_lock(&dynamic_netconsole_mutex); 491 if (nt->enabled) { 492 pr_err("target (%s) is enabled, disable to update parameters\n", 493 config_item_name(&nt->item)); 494 goto out_unlock; 495 } 496 497 if (strnchr(buf, count, ':')) { 498 const char *end; 499 if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) { 500 if (*end && *end != '\n') { 501 pr_err("invalid IPv6 address at: <%c>\n", *end); 502 goto out_unlock; 503 } 504 nt->np.ipv6 = true; 505 } else 506 goto out_unlock; 507 } else { 508 if (!nt->np.ipv6) { 509 nt->np.local_ip.ip = in_aton(buf); 510 } else 511 goto out_unlock; 512 } 513 514 mutex_unlock(&dynamic_netconsole_mutex); 515 return strnlen(buf, count); 516 out_unlock: 517 mutex_unlock(&dynamic_netconsole_mutex); 518 return -EINVAL; 519 } 520 521 static ssize_t remote_ip_store(struct config_item *item, const char *buf, 522 size_t count) 523 { 524 struct netconsole_target *nt = to_target(item); 525 526 mutex_lock(&dynamic_netconsole_mutex); 527 if (nt->enabled) { 528 pr_err("target (%s) is enabled, disable to update parameters\n", 529 config_item_name(&nt->item)); 530 goto out_unlock; 531 } 532 533 if (strnchr(buf, count, ':')) { 534 const char *end; 535 if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) { 536 if (*end && *end != '\n') { 537 pr_err("invalid IPv6 address at: <%c>\n", *end); 538 goto out_unlock; 539 } 540 nt->np.ipv6 = true; 541 } else 542 goto out_unlock; 543 } else { 544 if (!nt->np.ipv6) { 545 nt->np.remote_ip.ip = in_aton(buf); 546 } else 547 goto out_unlock; 548 } 549 550 mutex_unlock(&dynamic_netconsole_mutex); 551 return strnlen(buf, count); 552 out_unlock: 553 mutex_unlock(&dynamic_netconsole_mutex); 554 return -EINVAL; 555 } 556 557 static ssize_t remote_mac_store(struct config_item *item, const char *buf, 558 size_t count) 559 { 560 struct netconsole_target *nt = to_target(item); 561 u8 remote_mac[ETH_ALEN]; 562 563 mutex_lock(&dynamic_netconsole_mutex); 564 if (nt->enabled) { 565 pr_err("target (%s) is enabled, disable to update parameters\n", 566 config_item_name(&nt->item)); 567 goto out_unlock; 568 } 569 570 if (!mac_pton(buf, remote_mac)) 571 goto out_unlock; 572 if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n') 573 goto out_unlock; 574 memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN); 575 576 mutex_unlock(&dynamic_netconsole_mutex); 577 return strnlen(buf, count); 578 out_unlock: 579 mutex_unlock(&dynamic_netconsole_mutex); 580 return -EINVAL; 581 } 582 583 CONFIGFS_ATTR(, enabled); 584 CONFIGFS_ATTR(, extended); 585 CONFIGFS_ATTR(, dev_name); 586 CONFIGFS_ATTR(, local_port); 587 CONFIGFS_ATTR(, remote_port); 588 CONFIGFS_ATTR(, local_ip); 589 CONFIGFS_ATTR(, remote_ip); 590 CONFIGFS_ATTR_RO(, local_mac); 591 CONFIGFS_ATTR(, remote_mac); 592 593 static struct configfs_attribute *netconsole_target_attrs[] = { 594 &attr_enabled, 595 &attr_extended, 596 &attr_dev_name, 597 &attr_local_port, 598 &attr_remote_port, 599 &attr_local_ip, 600 &attr_remote_ip, 601 &attr_local_mac, 602 &attr_remote_mac, 603 NULL, 604 }; 605 606 /* 607 * Item operations and type for netconsole_target. 608 */ 609 610 static void netconsole_target_release(struct config_item *item) 611 { 612 kfree(to_target(item)); 613 } 614 615 static struct configfs_item_operations netconsole_target_item_ops = { 616 .release = netconsole_target_release, 617 }; 618 619 static struct config_item_type netconsole_target_type = { 620 .ct_attrs = netconsole_target_attrs, 621 .ct_item_ops = &netconsole_target_item_ops, 622 .ct_owner = THIS_MODULE, 623 }; 624 625 /* 626 * Group operations and type for netconsole_subsys. 627 */ 628 629 static struct config_item *make_netconsole_target(struct config_group *group, 630 const char *name) 631 { 632 unsigned long flags; 633 struct netconsole_target *nt; 634 635 /* 636 * Allocate and initialize with defaults. 637 * Target is disabled at creation (!enabled). 638 */ 639 nt = kzalloc(sizeof(*nt), GFP_KERNEL); 640 if (!nt) 641 return ERR_PTR(-ENOMEM); 642 643 nt->np.name = "netconsole"; 644 strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ); 645 nt->np.local_port = 6665; 646 nt->np.remote_port = 6666; 647 eth_broadcast_addr(nt->np.remote_mac); 648 649 /* Initialize the config_item member */ 650 config_item_init_type_name(&nt->item, name, &netconsole_target_type); 651 652 /* Adding, but it is disabled */ 653 spin_lock_irqsave(&target_list_lock, flags); 654 list_add(&nt->list, &target_list); 655 spin_unlock_irqrestore(&target_list_lock, flags); 656 657 return &nt->item; 658 } 659 660 static void drop_netconsole_target(struct config_group *group, 661 struct config_item *item) 662 { 663 unsigned long flags; 664 struct netconsole_target *nt = to_target(item); 665 666 spin_lock_irqsave(&target_list_lock, flags); 667 list_del(&nt->list); 668 spin_unlock_irqrestore(&target_list_lock, flags); 669 670 /* 671 * The target may have never been enabled, or was manually disabled 672 * before being removed so netpoll may have already been cleaned up. 673 */ 674 if (nt->enabled) 675 netpoll_cleanup(&nt->np); 676 677 config_item_put(&nt->item); 678 } 679 680 static struct configfs_group_operations netconsole_subsys_group_ops = { 681 .make_item = make_netconsole_target, 682 .drop_item = drop_netconsole_target, 683 }; 684 685 static struct config_item_type netconsole_subsys_type = { 686 .ct_group_ops = &netconsole_subsys_group_ops, 687 .ct_owner = THIS_MODULE, 688 }; 689 690 /* The netconsole configfs subsystem */ 691 static struct configfs_subsystem netconsole_subsys = { 692 .su_group = { 693 .cg_item = { 694 .ci_namebuf = "netconsole", 695 .ci_type = &netconsole_subsys_type, 696 }, 697 }, 698 }; 699 700 #endif /* CONFIG_NETCONSOLE_DYNAMIC */ 701 702 /* Handle network interface device notifications */ 703 static int netconsole_netdev_event(struct notifier_block *this, 704 unsigned long event, void *ptr) 705 { 706 unsigned long flags; 707 struct netconsole_target *nt; 708 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 709 bool stopped = false; 710 711 if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER || 712 event == NETDEV_RELEASE || event == NETDEV_JOIN)) 713 goto done; 714 715 spin_lock_irqsave(&target_list_lock, flags); 716 restart: 717 list_for_each_entry(nt, &target_list, list) { 718 netconsole_target_get(nt); 719 if (nt->np.dev == dev) { 720 switch (event) { 721 case NETDEV_CHANGENAME: 722 strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ); 723 break; 724 case NETDEV_RELEASE: 725 case NETDEV_JOIN: 726 case NETDEV_UNREGISTER: 727 /* rtnl_lock already held 728 * we might sleep in __netpoll_cleanup() 729 */ 730 spin_unlock_irqrestore(&target_list_lock, flags); 731 732 __netpoll_cleanup(&nt->np); 733 734 spin_lock_irqsave(&target_list_lock, flags); 735 dev_put(nt->np.dev); 736 nt->np.dev = NULL; 737 nt->enabled = false; 738 stopped = true; 739 netconsole_target_put(nt); 740 goto restart; 741 } 742 } 743 netconsole_target_put(nt); 744 } 745 spin_unlock_irqrestore(&target_list_lock, flags); 746 if (stopped) { 747 const char *msg = "had an event"; 748 switch (event) { 749 case NETDEV_UNREGISTER: 750 msg = "unregistered"; 751 break; 752 case NETDEV_RELEASE: 753 msg = "released slaves"; 754 break; 755 case NETDEV_JOIN: 756 msg = "is joining a master device"; 757 break; 758 } 759 pr_info("network logging stopped on interface %s as it %s\n", 760 dev->name, msg); 761 } 762 763 done: 764 return NOTIFY_DONE; 765 } 766 767 static struct notifier_block netconsole_netdev_notifier = { 768 .notifier_call = netconsole_netdev_event, 769 }; 770 771 /** 772 * send_ext_msg_udp - send extended log message to target 773 * @nt: target to send message to 774 * @msg: extended log message to send 775 * @msg_len: length of message 776 * 777 * Transfer extended log @msg to @nt. If @msg is longer than 778 * MAX_PRINT_CHUNK, it'll be split and transmitted in multiple chunks with 779 * ncfrag header field added to identify them. 780 */ 781 static void send_ext_msg_udp(struct netconsole_target *nt, const char *msg, 782 int msg_len) 783 { 784 static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */ 785 const char *header, *body; 786 int offset = 0; 787 int header_len, body_len; 788 789 if (msg_len <= MAX_PRINT_CHUNK) { 790 netpoll_send_udp(&nt->np, msg, msg_len); 791 return; 792 } 793 794 /* need to insert extra header fields, detect header and body */ 795 header = msg; 796 body = memchr(msg, ';', msg_len); 797 if (WARN_ON_ONCE(!body)) 798 return; 799 800 header_len = body - header; 801 body_len = msg_len - header_len - 1; 802 body++; 803 804 /* 805 * Transfer multiple chunks with the following extra header. 806 * "ncfrag=<byte-offset>/<total-bytes>" 807 */ 808 memcpy(buf, header, header_len); 809 810 while (offset < body_len) { 811 int this_header = header_len; 812 int this_chunk; 813 814 this_header += scnprintf(buf + this_header, 815 sizeof(buf) - this_header, 816 ",ncfrag=%d/%d;", offset, body_len); 817 818 this_chunk = min(body_len - offset, 819 MAX_PRINT_CHUNK - this_header); 820 if (WARN_ON_ONCE(this_chunk <= 0)) 821 return; 822 823 memcpy(buf + this_header, body + offset, this_chunk); 824 825 netpoll_send_udp(&nt->np, buf, this_header + this_chunk); 826 827 offset += this_chunk; 828 } 829 } 830 831 static void write_ext_msg(struct console *con, const char *msg, 832 unsigned int len) 833 { 834 struct netconsole_target *nt; 835 unsigned long flags; 836 837 if ((oops_only && !oops_in_progress) || list_empty(&target_list)) 838 return; 839 840 spin_lock_irqsave(&target_list_lock, flags); 841 list_for_each_entry(nt, &target_list, list) 842 if (nt->extended && nt->enabled && netif_running(nt->np.dev)) 843 send_ext_msg_udp(nt, msg, len); 844 spin_unlock_irqrestore(&target_list_lock, flags); 845 } 846 847 static void write_msg(struct console *con, const char *msg, unsigned int len) 848 { 849 int frag, left; 850 unsigned long flags; 851 struct netconsole_target *nt; 852 const char *tmp; 853 854 if (oops_only && !oops_in_progress) 855 return; 856 /* Avoid taking lock and disabling interrupts unnecessarily */ 857 if (list_empty(&target_list)) 858 return; 859 860 spin_lock_irqsave(&target_list_lock, flags); 861 list_for_each_entry(nt, &target_list, list) { 862 if (!nt->extended && nt->enabled && netif_running(nt->np.dev)) { 863 /* 864 * We nest this inside the for-each-target loop above 865 * so that we're able to get as much logging out to 866 * at least one target if we die inside here, instead 867 * of unnecessarily keeping all targets in lock-step. 868 */ 869 tmp = msg; 870 for (left = len; left;) { 871 frag = min(left, MAX_PRINT_CHUNK); 872 netpoll_send_udp(&nt->np, tmp, frag); 873 tmp += frag; 874 left -= frag; 875 } 876 } 877 } 878 spin_unlock_irqrestore(&target_list_lock, flags); 879 } 880 881 static struct console netconsole_ext = { 882 .name = "netcon_ext", 883 .flags = CON_EXTENDED, /* starts disabled, registered on first use */ 884 .write = write_ext_msg, 885 }; 886 887 static struct console netconsole = { 888 .name = "netcon", 889 .flags = CON_ENABLED, 890 .write = write_msg, 891 }; 892 893 static int __init init_netconsole(void) 894 { 895 int err; 896 struct netconsole_target *nt, *tmp; 897 unsigned long flags; 898 char *target_config; 899 char *input = config; 900 901 if (strnlen(input, MAX_PARAM_LENGTH)) { 902 while ((target_config = strsep(&input, ";"))) { 903 nt = alloc_param_target(target_config); 904 if (IS_ERR(nt)) { 905 err = PTR_ERR(nt); 906 goto fail; 907 } 908 /* Dump existing printks when we register */ 909 if (nt->extended) 910 netconsole_ext.flags |= CON_PRINTBUFFER | 911 CON_ENABLED; 912 else 913 netconsole.flags |= CON_PRINTBUFFER; 914 915 spin_lock_irqsave(&target_list_lock, flags); 916 list_add(&nt->list, &target_list); 917 spin_unlock_irqrestore(&target_list_lock, flags); 918 } 919 } 920 921 err = register_netdevice_notifier(&netconsole_netdev_notifier); 922 if (err) 923 goto fail; 924 925 err = dynamic_netconsole_init(); 926 if (err) 927 goto undonotifier; 928 929 if (netconsole_ext.flags & CON_ENABLED) 930 register_console(&netconsole_ext); 931 register_console(&netconsole); 932 pr_info("network logging started\n"); 933 934 return err; 935 936 undonotifier: 937 unregister_netdevice_notifier(&netconsole_netdev_notifier); 938 939 fail: 940 pr_err("cleaning up\n"); 941 942 /* 943 * Remove all targets and destroy them (only targets created 944 * from the boot/module option exist here). Skipping the list 945 * lock is safe here, and netpoll_cleanup() will sleep. 946 */ 947 list_for_each_entry_safe(nt, tmp, &target_list, list) { 948 list_del(&nt->list); 949 free_param_target(nt); 950 } 951 952 return err; 953 } 954 955 static void __exit cleanup_netconsole(void) 956 { 957 struct netconsole_target *nt, *tmp; 958 959 unregister_console(&netconsole_ext); 960 unregister_console(&netconsole); 961 dynamic_netconsole_exit(); 962 unregister_netdevice_notifier(&netconsole_netdev_notifier); 963 964 /* 965 * Targets created via configfs pin references on our module 966 * and would first be rmdir(2)'ed from userspace. We reach 967 * here only when they are already destroyed, and only those 968 * created from the boot/module option are left, so remove and 969 * destroy them. Skipping the list lock is safe here, and 970 * netpoll_cleanup() will sleep. 971 */ 972 list_for_each_entry_safe(nt, tmp, &target_list, list) { 973 list_del(&nt->list); 974 free_param_target(nt); 975 } 976 } 977 978 /* 979 * Use late_initcall to ensure netconsole is 980 * initialized after network device driver if built-in. 981 * 982 * late_initcall() and module_init() are identical if built as module. 983 */ 984 late_initcall(init_netconsole); 985 module_exit(cleanup_netconsole); 986