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 #include <linux/mm.h> 38 #include <linux/init.h> 39 #include <linux/module.h> 40 #include <linux/slab.h> 41 #include <linux/console.h> 42 #include <linux/moduleparam.h> 43 #include <linux/string.h> 44 #include <linux/netpoll.h> 45 #include <linux/inet.h> 46 #include <linux/configfs.h> 47 48 MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>"); 49 MODULE_DESCRIPTION("Console driver for network interfaces"); 50 MODULE_LICENSE("GPL"); 51 52 #define MAX_PARAM_LENGTH 256 53 #define MAX_PRINT_CHUNK 1000 54 55 static char config[MAX_PARAM_LENGTH]; 56 module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0); 57 MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]"); 58 59 #ifndef MODULE 60 static int __init option_setup(char *opt) 61 { 62 strlcpy(config, opt, MAX_PARAM_LENGTH); 63 return 1; 64 } 65 __setup("netconsole=", option_setup); 66 #endif /* MODULE */ 67 68 /* Linked list of all configured targets */ 69 static LIST_HEAD(target_list); 70 71 /* This needs to be a spinlock because write_msg() cannot sleep */ 72 static DEFINE_SPINLOCK(target_list_lock); 73 74 /** 75 * struct netconsole_target - Represents a configured netconsole target. 76 * @list: Links this target into the target_list. 77 * @item: Links us into the configfs subsystem hierarchy. 78 * @enabled: On / off knob to enable / disable target. 79 * Visible from userspace (read-write). 80 * We maintain a strict 1:1 correspondence between this and 81 * whether the corresponding netpoll is active or inactive. 82 * Also, other parameters of a target may be modified at 83 * runtime only when it is disabled (enabled == 0). 84 * @np: The netpoll structure for this target. 85 * Contains the other userspace visible parameters: 86 * dev_name (read-write) 87 * local_port (read-write) 88 * remote_port (read-write) 89 * local_ip (read-write) 90 * remote_ip (read-write) 91 * local_mac (read-only) 92 * remote_mac (read-write) 93 */ 94 struct netconsole_target { 95 struct list_head list; 96 #ifdef CONFIG_NETCONSOLE_DYNAMIC 97 struct config_item item; 98 #endif 99 int enabled; 100 struct netpoll np; 101 }; 102 103 #ifdef CONFIG_NETCONSOLE_DYNAMIC 104 105 static struct configfs_subsystem netconsole_subsys; 106 107 static int __init dynamic_netconsole_init(void) 108 { 109 config_group_init(&netconsole_subsys.su_group); 110 mutex_init(&netconsole_subsys.su_mutex); 111 return configfs_register_subsystem(&netconsole_subsys); 112 } 113 114 static void __exit dynamic_netconsole_exit(void) 115 { 116 configfs_unregister_subsystem(&netconsole_subsys); 117 } 118 119 /* 120 * Targets that were created by parsing the boot/module option string 121 * do not exist in the configfs hierarchy (and have NULL names) and will 122 * never go away, so make these a no-op for them. 123 */ 124 static void netconsole_target_get(struct netconsole_target *nt) 125 { 126 if (config_item_name(&nt->item)) 127 config_item_get(&nt->item); 128 } 129 130 static void netconsole_target_put(struct netconsole_target *nt) 131 { 132 if (config_item_name(&nt->item)) 133 config_item_put(&nt->item); 134 } 135 136 #else /* !CONFIG_NETCONSOLE_DYNAMIC */ 137 138 static int __init dynamic_netconsole_init(void) 139 { 140 return 0; 141 } 142 143 static void __exit dynamic_netconsole_exit(void) 144 { 145 } 146 147 /* 148 * No danger of targets going away from under us when dynamic 149 * reconfigurability is off. 150 */ 151 static void netconsole_target_get(struct netconsole_target *nt) 152 { 153 } 154 155 static void netconsole_target_put(struct netconsole_target *nt) 156 { 157 } 158 159 #endif /* CONFIG_NETCONSOLE_DYNAMIC */ 160 161 /* Allocate new target (from boot/module param) and setup netpoll for it */ 162 static struct netconsole_target *alloc_param_target(char *target_config) 163 { 164 int err = -ENOMEM; 165 struct netconsole_target *nt; 166 167 /* 168 * Allocate and initialize with defaults. 169 * Note that these targets get their config_item fields zeroed-out. 170 */ 171 nt = kzalloc(sizeof(*nt), GFP_KERNEL); 172 if (!nt) { 173 printk(KERN_ERR "netconsole: failed to allocate memory\n"); 174 goto fail; 175 } 176 177 nt->np.name = "netconsole"; 178 strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ); 179 nt->np.local_port = 6665; 180 nt->np.remote_port = 6666; 181 memset(nt->np.remote_mac, 0xff, ETH_ALEN); 182 183 /* Parse parameters and setup netpoll */ 184 err = netpoll_parse_options(&nt->np, target_config); 185 if (err) 186 goto fail; 187 188 err = netpoll_setup(&nt->np); 189 if (err) 190 goto fail; 191 192 nt->enabled = 1; 193 194 return nt; 195 196 fail: 197 kfree(nt); 198 return ERR_PTR(err); 199 } 200 201 /* Cleanup netpoll for given target (from boot/module param) and free it */ 202 static void free_param_target(struct netconsole_target *nt) 203 { 204 netpoll_cleanup(&nt->np); 205 kfree(nt); 206 } 207 208 #ifdef CONFIG_NETCONSOLE_DYNAMIC 209 210 /* 211 * Our subsystem hierarchy is: 212 * 213 * /sys/kernel/config/netconsole/ 214 * | 215 * <target>/ 216 * | enabled 217 * | dev_name 218 * | local_port 219 * | remote_port 220 * | local_ip 221 * | remote_ip 222 * | local_mac 223 * | remote_mac 224 * | 225 * <target>/... 226 */ 227 228 struct netconsole_target_attr { 229 struct configfs_attribute attr; 230 ssize_t (*show)(struct netconsole_target *nt, 231 char *buf); 232 ssize_t (*store)(struct netconsole_target *nt, 233 const char *buf, 234 size_t count); 235 }; 236 237 static struct netconsole_target *to_target(struct config_item *item) 238 { 239 return item ? 240 container_of(item, struct netconsole_target, item) : 241 NULL; 242 } 243 244 /* 245 * Attribute operations for netconsole_target. 246 */ 247 248 static ssize_t show_enabled(struct netconsole_target *nt, char *buf) 249 { 250 return snprintf(buf, PAGE_SIZE, "%d\n", nt->enabled); 251 } 252 253 static ssize_t show_dev_name(struct netconsole_target *nt, char *buf) 254 { 255 return snprintf(buf, PAGE_SIZE, "%s\n", nt->np.dev_name); 256 } 257 258 static ssize_t show_local_port(struct netconsole_target *nt, char *buf) 259 { 260 return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.local_port); 261 } 262 263 static ssize_t show_remote_port(struct netconsole_target *nt, char *buf) 264 { 265 return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.remote_port); 266 } 267 268 static ssize_t show_local_ip(struct netconsole_target *nt, char *buf) 269 { 270 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip); 271 } 272 273 static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf) 274 { 275 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip); 276 } 277 278 static ssize_t show_local_mac(struct netconsole_target *nt, char *buf) 279 { 280 struct net_device *dev = nt->np.dev; 281 static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 282 283 return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast); 284 } 285 286 static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf) 287 { 288 return snprintf(buf, PAGE_SIZE, "%pM\n", nt->np.remote_mac); 289 } 290 291 /* 292 * This one is special -- targets created through the configfs interface 293 * are not enabled (and the corresponding netpoll activated) by default. 294 * The user is expected to set the desired parameters first (which 295 * would enable him to dynamically add new netpoll targets for new 296 * network interfaces as and when they come up). 297 */ 298 static ssize_t store_enabled(struct netconsole_target *nt, 299 const char *buf, 300 size_t count) 301 { 302 int enabled; 303 int err; 304 305 err = kstrtoint(buf, 10, &enabled); 306 if (err < 0) 307 return err; 308 if (enabled < 0 || enabled > 1) 309 return -EINVAL; 310 if (enabled == nt->enabled) { 311 printk(KERN_INFO "netconsole: network logging has already %s\n", 312 nt->enabled ? "started" : "stopped"); 313 return -EINVAL; 314 } 315 316 if (enabled) { /* 1 */ 317 318 /* 319 * Skip netpoll_parse_options() -- all the attributes are 320 * already configured via configfs. Just print them out. 321 */ 322 netpoll_print_options(&nt->np); 323 324 err = netpoll_setup(&nt->np); 325 if (err) 326 return err; 327 328 printk(KERN_INFO "netconsole: network logging started\n"); 329 330 } else { /* 0 */ 331 netpoll_cleanup(&nt->np); 332 } 333 334 nt->enabled = enabled; 335 336 return strnlen(buf, count); 337 } 338 339 static ssize_t store_dev_name(struct netconsole_target *nt, 340 const char *buf, 341 size_t count) 342 { 343 size_t len; 344 345 if (nt->enabled) { 346 printk(KERN_ERR "netconsole: target (%s) is enabled, " 347 "disable to update parameters\n", 348 config_item_name(&nt->item)); 349 return -EINVAL; 350 } 351 352 strlcpy(nt->np.dev_name, buf, IFNAMSIZ); 353 354 /* Get rid of possible trailing newline from echo(1) */ 355 len = strnlen(nt->np.dev_name, IFNAMSIZ); 356 if (nt->np.dev_name[len - 1] == '\n') 357 nt->np.dev_name[len - 1] = '\0'; 358 359 return strnlen(buf, count); 360 } 361 362 static ssize_t store_local_port(struct netconsole_target *nt, 363 const char *buf, 364 size_t count) 365 { 366 int rv; 367 368 if (nt->enabled) { 369 printk(KERN_ERR "netconsole: target (%s) is enabled, " 370 "disable to update parameters\n", 371 config_item_name(&nt->item)); 372 return -EINVAL; 373 } 374 375 rv = kstrtou16(buf, 10, &nt->np.local_port); 376 if (rv < 0) 377 return rv; 378 return strnlen(buf, count); 379 } 380 381 static ssize_t store_remote_port(struct netconsole_target *nt, 382 const char *buf, 383 size_t count) 384 { 385 int rv; 386 387 if (nt->enabled) { 388 printk(KERN_ERR "netconsole: target (%s) is enabled, " 389 "disable to update parameters\n", 390 config_item_name(&nt->item)); 391 return -EINVAL; 392 } 393 394 rv = kstrtou16(buf, 10, &nt->np.remote_port); 395 if (rv < 0) 396 return rv; 397 return strnlen(buf, count); 398 } 399 400 static ssize_t store_local_ip(struct netconsole_target *nt, 401 const char *buf, 402 size_t count) 403 { 404 if (nt->enabled) { 405 printk(KERN_ERR "netconsole: target (%s) is enabled, " 406 "disable to update parameters\n", 407 config_item_name(&nt->item)); 408 return -EINVAL; 409 } 410 411 nt->np.local_ip = in_aton(buf); 412 413 return strnlen(buf, count); 414 } 415 416 static ssize_t store_remote_ip(struct netconsole_target *nt, 417 const char *buf, 418 size_t count) 419 { 420 if (nt->enabled) { 421 printk(KERN_ERR "netconsole: target (%s) is enabled, " 422 "disable to update parameters\n", 423 config_item_name(&nt->item)); 424 return -EINVAL; 425 } 426 427 nt->np.remote_ip = in_aton(buf); 428 429 return strnlen(buf, count); 430 } 431 432 static ssize_t store_remote_mac(struct netconsole_target *nt, 433 const char *buf, 434 size_t count) 435 { 436 u8 remote_mac[ETH_ALEN]; 437 438 if (nt->enabled) { 439 printk(KERN_ERR "netconsole: target (%s) is enabled, " 440 "disable to update parameters\n", 441 config_item_name(&nt->item)); 442 return -EINVAL; 443 } 444 445 if (!mac_pton(buf, remote_mac)) 446 return -EINVAL; 447 if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n') 448 return -EINVAL; 449 memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN); 450 451 return strnlen(buf, count); 452 } 453 454 /* 455 * Attribute definitions for netconsole_target. 456 */ 457 458 #define NETCONSOLE_TARGET_ATTR_RO(_name) \ 459 static struct netconsole_target_attr netconsole_target_##_name = \ 460 __CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL) 461 462 #define NETCONSOLE_TARGET_ATTR_RW(_name) \ 463 static struct netconsole_target_attr netconsole_target_##_name = \ 464 __CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name) 465 466 NETCONSOLE_TARGET_ATTR_RW(enabled); 467 NETCONSOLE_TARGET_ATTR_RW(dev_name); 468 NETCONSOLE_TARGET_ATTR_RW(local_port); 469 NETCONSOLE_TARGET_ATTR_RW(remote_port); 470 NETCONSOLE_TARGET_ATTR_RW(local_ip); 471 NETCONSOLE_TARGET_ATTR_RW(remote_ip); 472 NETCONSOLE_TARGET_ATTR_RO(local_mac); 473 NETCONSOLE_TARGET_ATTR_RW(remote_mac); 474 475 static struct configfs_attribute *netconsole_target_attrs[] = { 476 &netconsole_target_enabled.attr, 477 &netconsole_target_dev_name.attr, 478 &netconsole_target_local_port.attr, 479 &netconsole_target_remote_port.attr, 480 &netconsole_target_local_ip.attr, 481 &netconsole_target_remote_ip.attr, 482 &netconsole_target_local_mac.attr, 483 &netconsole_target_remote_mac.attr, 484 NULL, 485 }; 486 487 /* 488 * Item operations and type for netconsole_target. 489 */ 490 491 static void netconsole_target_release(struct config_item *item) 492 { 493 kfree(to_target(item)); 494 } 495 496 static ssize_t netconsole_target_attr_show(struct config_item *item, 497 struct configfs_attribute *attr, 498 char *buf) 499 { 500 ssize_t ret = -EINVAL; 501 struct netconsole_target *nt = to_target(item); 502 struct netconsole_target_attr *na = 503 container_of(attr, struct netconsole_target_attr, attr); 504 505 if (na->show) 506 ret = na->show(nt, buf); 507 508 return ret; 509 } 510 511 static ssize_t netconsole_target_attr_store(struct config_item *item, 512 struct configfs_attribute *attr, 513 const char *buf, 514 size_t count) 515 { 516 ssize_t ret = -EINVAL; 517 struct netconsole_target *nt = to_target(item); 518 struct netconsole_target_attr *na = 519 container_of(attr, struct netconsole_target_attr, attr); 520 521 if (na->store) 522 ret = na->store(nt, buf, count); 523 524 return ret; 525 } 526 527 static struct configfs_item_operations netconsole_target_item_ops = { 528 .release = netconsole_target_release, 529 .show_attribute = netconsole_target_attr_show, 530 .store_attribute = netconsole_target_attr_store, 531 }; 532 533 static struct config_item_type netconsole_target_type = { 534 .ct_attrs = netconsole_target_attrs, 535 .ct_item_ops = &netconsole_target_item_ops, 536 .ct_owner = THIS_MODULE, 537 }; 538 539 /* 540 * Group operations and type for netconsole_subsys. 541 */ 542 543 static struct config_item *make_netconsole_target(struct config_group *group, 544 const char *name) 545 { 546 unsigned long flags; 547 struct netconsole_target *nt; 548 549 /* 550 * Allocate and initialize with defaults. 551 * Target is disabled at creation (enabled == 0). 552 */ 553 nt = kzalloc(sizeof(*nt), GFP_KERNEL); 554 if (!nt) { 555 printk(KERN_ERR "netconsole: failed to allocate memory\n"); 556 return ERR_PTR(-ENOMEM); 557 } 558 559 nt->np.name = "netconsole"; 560 strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ); 561 nt->np.local_port = 6665; 562 nt->np.remote_port = 6666; 563 memset(nt->np.remote_mac, 0xff, ETH_ALEN); 564 565 /* Initialize the config_item member */ 566 config_item_init_type_name(&nt->item, name, &netconsole_target_type); 567 568 /* Adding, but it is disabled */ 569 spin_lock_irqsave(&target_list_lock, flags); 570 list_add(&nt->list, &target_list); 571 spin_unlock_irqrestore(&target_list_lock, flags); 572 573 return &nt->item; 574 } 575 576 static void drop_netconsole_target(struct config_group *group, 577 struct config_item *item) 578 { 579 unsigned long flags; 580 struct netconsole_target *nt = to_target(item); 581 582 spin_lock_irqsave(&target_list_lock, flags); 583 list_del(&nt->list); 584 spin_unlock_irqrestore(&target_list_lock, flags); 585 586 /* 587 * The target may have never been enabled, or was manually disabled 588 * before being removed so netpoll may have already been cleaned up. 589 */ 590 if (nt->enabled) 591 netpoll_cleanup(&nt->np); 592 593 config_item_put(&nt->item); 594 } 595 596 static struct configfs_group_operations netconsole_subsys_group_ops = { 597 .make_item = make_netconsole_target, 598 .drop_item = drop_netconsole_target, 599 }; 600 601 static struct config_item_type netconsole_subsys_type = { 602 .ct_group_ops = &netconsole_subsys_group_ops, 603 .ct_owner = THIS_MODULE, 604 }; 605 606 /* The netconsole configfs subsystem */ 607 static struct configfs_subsystem netconsole_subsys = { 608 .su_group = { 609 .cg_item = { 610 .ci_namebuf = "netconsole", 611 .ci_type = &netconsole_subsys_type, 612 }, 613 }, 614 }; 615 616 #endif /* CONFIG_NETCONSOLE_DYNAMIC */ 617 618 /* Handle network interface device notifications */ 619 static int netconsole_netdev_event(struct notifier_block *this, 620 unsigned long event, 621 void *ptr) 622 { 623 unsigned long flags; 624 struct netconsole_target *nt; 625 struct net_device *dev = ptr; 626 bool stopped = false; 627 628 if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER || 629 event == NETDEV_RELEASE || event == NETDEV_JOIN)) 630 goto done; 631 632 spin_lock_irqsave(&target_list_lock, flags); 633 list_for_each_entry(nt, &target_list, list) { 634 netconsole_target_get(nt); 635 if (nt->np.dev == dev) { 636 switch (event) { 637 case NETDEV_CHANGENAME: 638 strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ); 639 break; 640 case NETDEV_RELEASE: 641 case NETDEV_JOIN: 642 case NETDEV_UNREGISTER: 643 /* 644 * rtnl_lock already held 645 */ 646 if (nt->np.dev) { 647 spin_unlock_irqrestore( 648 &target_list_lock, 649 flags); 650 __netpoll_cleanup(&nt->np); 651 spin_lock_irqsave(&target_list_lock, 652 flags); 653 dev_put(nt->np.dev); 654 nt->np.dev = NULL; 655 netconsole_target_put(nt); 656 } 657 nt->enabled = 0; 658 stopped = true; 659 break; 660 } 661 } 662 netconsole_target_put(nt); 663 } 664 spin_unlock_irqrestore(&target_list_lock, flags); 665 if (stopped) { 666 printk(KERN_INFO "netconsole: network logging stopped on " 667 "interface %s as it ", dev->name); 668 switch (event) { 669 case NETDEV_UNREGISTER: 670 printk(KERN_CONT "unregistered\n"); 671 break; 672 case NETDEV_RELEASE: 673 printk(KERN_CONT "released slaves\n"); 674 break; 675 case NETDEV_JOIN: 676 printk(KERN_CONT "is joining a master device\n"); 677 break; 678 } 679 } 680 681 done: 682 return NOTIFY_DONE; 683 } 684 685 static struct notifier_block netconsole_netdev_notifier = { 686 .notifier_call = netconsole_netdev_event, 687 }; 688 689 static void write_msg(struct console *con, const char *msg, unsigned int len) 690 { 691 int frag, left; 692 unsigned long flags; 693 struct netconsole_target *nt; 694 const char *tmp; 695 696 /* Avoid taking lock and disabling interrupts unnecessarily */ 697 if (list_empty(&target_list)) 698 return; 699 700 spin_lock_irqsave(&target_list_lock, flags); 701 list_for_each_entry(nt, &target_list, list) { 702 netconsole_target_get(nt); 703 if (nt->enabled && netif_running(nt->np.dev)) { 704 /* 705 * We nest this inside the for-each-target loop above 706 * so that we're able to get as much logging out to 707 * at least one target if we die inside here, instead 708 * of unnecessarily keeping all targets in lock-step. 709 */ 710 tmp = msg; 711 for (left = len; left;) { 712 frag = min(left, MAX_PRINT_CHUNK); 713 netpoll_send_udp(&nt->np, tmp, frag); 714 tmp += frag; 715 left -= frag; 716 } 717 } 718 netconsole_target_put(nt); 719 } 720 spin_unlock_irqrestore(&target_list_lock, flags); 721 } 722 723 static struct console netconsole = { 724 .name = "netcon", 725 .flags = CON_ENABLED, 726 .write = write_msg, 727 }; 728 729 static int __init init_netconsole(void) 730 { 731 int err; 732 struct netconsole_target *nt, *tmp; 733 unsigned long flags; 734 char *target_config; 735 char *input = config; 736 737 if (strnlen(input, MAX_PARAM_LENGTH)) { 738 while ((target_config = strsep(&input, ";"))) { 739 nt = alloc_param_target(target_config); 740 if (IS_ERR(nt)) { 741 err = PTR_ERR(nt); 742 goto fail; 743 } 744 /* Dump existing printks when we register */ 745 netconsole.flags |= CON_PRINTBUFFER; 746 747 spin_lock_irqsave(&target_list_lock, flags); 748 list_add(&nt->list, &target_list); 749 spin_unlock_irqrestore(&target_list_lock, flags); 750 } 751 } 752 753 err = register_netdevice_notifier(&netconsole_netdev_notifier); 754 if (err) 755 goto fail; 756 757 err = dynamic_netconsole_init(); 758 if (err) 759 goto undonotifier; 760 761 register_console(&netconsole); 762 printk(KERN_INFO "netconsole: network logging started\n"); 763 764 return err; 765 766 undonotifier: 767 unregister_netdevice_notifier(&netconsole_netdev_notifier); 768 769 fail: 770 printk(KERN_ERR "netconsole: cleaning up\n"); 771 772 /* 773 * Remove all targets and destroy them (only targets created 774 * from the boot/module option exist here). Skipping the list 775 * lock is safe here, and netpoll_cleanup() will sleep. 776 */ 777 list_for_each_entry_safe(nt, tmp, &target_list, list) { 778 list_del(&nt->list); 779 free_param_target(nt); 780 } 781 782 return err; 783 } 784 785 static void __exit cleanup_netconsole(void) 786 { 787 struct netconsole_target *nt, *tmp; 788 789 unregister_console(&netconsole); 790 dynamic_netconsole_exit(); 791 unregister_netdevice_notifier(&netconsole_netdev_notifier); 792 793 /* 794 * Targets created via configfs pin references on our module 795 * and would first be rmdir(2)'ed from userspace. We reach 796 * here only when they are already destroyed, and only those 797 * created from the boot/module option are left, so remove and 798 * destroy them. Skipping the list lock is safe here, and 799 * netpoll_cleanup() will sleep. 800 */ 801 list_for_each_entry_safe(nt, tmp, &target_list, list) { 802 list_del(&nt->list); 803 free_param_target(nt); 804 } 805 } 806 807 /* 808 * Use late_initcall to ensure netconsole is 809 * initialized after network device driver if built-in. 810 * 811 * late_initcall() and module_init() are identical if built as module. 812 */ 813 late_initcall(init_netconsole); 814 module_exit(cleanup_netconsole); 815