drivers/net/netconsole.c

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