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