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/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  * Wrapper over simple_strtol (base 10) with sanity and range checking.
 246  * We return (signed) long only because we may want to return errors.
 247  * Do not use this to convert numbers that are allowed to be negative.
 248  */
 249 static long strtol10_check_range(const char *cp, long min, long max)
 250 {
 251         long ret;
 252         char *p = (char *) cp;
 253
 254         WARN_ON(min < 0);
 255         WARN_ON(max < min);
 256
 257         ret = simple_strtol(p, &p, 10);
 258
 259         if (*p && (*p != '\n')) {
 260                 printk(KERN_ERR "netconsole: invalid input\n");
 261                 return -EINVAL;
 262         }
 263         if ((ret < min) || (ret > max)) {
 264                 printk(KERN_ERR "netconsole: input %ld must be between "
 265                                 "%ld and %ld\n", ret, min, max);
 266                 return -EINVAL;
 267         }
 268
 269         return ret;
 270 }
 271
 272 /*
 273  * Attribute operations for netconsole_target.
 274  */
 275
 276 static ssize_t show_enabled(struct netconsole_target *nt, char *buf)
 277 {
 278         return snprintf(buf, PAGE_SIZE, "%d\n", nt->enabled);
 279 }
 280
 281 static ssize_t show_dev_name(struct netconsole_target *nt, char *buf)
 282 {
 283         return snprintf(buf, PAGE_SIZE, "%s\n", nt->np.dev_name);
 284 }
 285
 286 static ssize_t show_local_port(struct netconsole_target *nt, char *buf)
 287 {
 288         return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.local_port);
 289 }
 290
 291 static ssize_t show_remote_port(struct netconsole_target *nt, char *buf)
 292 {
 293         return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.remote_port);
 294 }
 295
 296 static ssize_t show_local_ip(struct netconsole_target *nt, char *buf)
 297 {
 298         return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip);
 299 }
 300
 301 static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf)
 302 {
 303         return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip);
 304 }
 305
 306 static ssize_t show_local_mac(struct netconsole_target *nt, char *buf)
 307 {
 308         struct net_device *dev = nt->np.dev;
 309         static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 310
 311         return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast);
 312 }
 313
 314 static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
 315 {
 316         return snprintf(buf, PAGE_SIZE, "%pM\n", nt->np.remote_mac);
 317 }
 318
 319 /*
 320  * This one is special -- targets created through the configfs interface
 321  * are not enabled (and the corresponding netpoll activated) by default.
 322  * The user is expected to set the desired parameters first (which
 323  * would enable him to dynamically add new netpoll targets for new
 324  * network interfaces as and when they come up).
 325  */
 326 static ssize_t store_enabled(struct netconsole_target *nt,
 327                              const char *buf,
 328                              size_t count)
 329 {
 330         int err;
 331         long enabled;
 332
 333         enabled = strtol10_check_range(buf, 0, 1);
 334         if (enabled < 0)
 335                 return enabled;
 336
 337         if (enabled) {  /* 1 */
 338
 339                 /*
 340                  * Skip netpoll_parse_options() -- all the attributes are
 341                  * already configured via configfs. Just print them out.
 342                  */
 343                 netpoll_print_options(&nt->np);
 344
 345                 err = netpoll_setup(&nt->np);
 346                 if (err)
 347                         return err;
 348
 349                 printk(KERN_INFO "netconsole: network logging started\n");
 350
 351         } else {        /* 0 */
 352                 netpoll_cleanup(&nt->np);
 353         }
 354
 355         nt->enabled = enabled;
 356
 357         return strnlen(buf, count);
 358 }
 359
 360 static ssize_t store_dev_name(struct netconsole_target *nt,
 361                               const char *buf,
 362                               size_t count)
 363 {
 364         size_t len;
 365
 366         if (nt->enabled) {
 367                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
 368                                 "disable to update parameters\n",
 369                                 config_item_name(&nt->item));
 370                 return -EINVAL;
 371         }
 372
 373         strlcpy(nt->np.dev_name, buf, IFNAMSIZ);
 374
 375         /* Get rid of possible trailing newline from echo(1) */
 376         len = strnlen(nt->np.dev_name, IFNAMSIZ);
 377         if (nt->np.dev_name[len - 1] == '\n')
 378                 nt->np.dev_name[len - 1] = '\0';
 379
 380         return strnlen(buf, count);
 381 }
 382
 383 static ssize_t store_local_port(struct netconsole_target *nt,
 384                                 const char *buf,
 385                                 size_t count)
 386 {
 387         long local_port;
 388 #define __U16_MAX       ((__u16) ~0U)
 389
 390         if (nt->enabled) {
 391                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
 392                                 "disable to update parameters\n",
 393                                 config_item_name(&nt->item));
 394                 return -EINVAL;
 395         }
 396
 397         local_port = strtol10_check_range(buf, 0, __U16_MAX);
 398         if (local_port < 0)
 399                 return local_port;
 400
 401         nt->np.local_port = local_port;
 402
 403         return strnlen(buf, count);
 404 }
 405
 406 static ssize_t store_remote_port(struct netconsole_target *nt,
 407                                  const char *buf,
 408                                  size_t count)
 409 {
 410         long remote_port;
 411 #define __U16_MAX       ((__u16) ~0U)
 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         remote_port = strtol10_check_range(buf, 0, __U16_MAX);
 421         if (remote_port < 0)
 422                 return remote_port;
 423
 424         nt->np.remote_port = remote_port;
 425
 426         return strnlen(buf, count);
 427 }
 428
 429 static ssize_t store_local_ip(struct netconsole_target *nt,
 430                               const char *buf,
 431                               size_t count)
 432 {
 433         if (nt->enabled) {
 434                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
 435                                 "disable to update parameters\n",
 436                                 config_item_name(&nt->item));
 437                 return -EINVAL;
 438         }
 439
 440         nt->np.local_ip = in_aton(buf);
 441
 442         return strnlen(buf, count);
 443 }
 444
 445 static ssize_t store_remote_ip(struct netconsole_target *nt,
 446                                const char *buf,
 447                                size_t count)
 448 {
 449         if (nt->enabled) {
 450                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
 451                                 "disable to update parameters\n",
 452                                 config_item_name(&nt->item));
 453                 return -EINVAL;
 454         }
 455
 456         nt->np.remote_ip = in_aton(buf);
 457
 458         return strnlen(buf, count);
 459 }
 460
 461 static ssize_t store_remote_mac(struct netconsole_target *nt,
 462                                 const char *buf,
 463                                 size_t count)
 464 {
 465         u8 remote_mac[ETH_ALEN];
 466         char *p = (char *) buf;
 467         int i;
 468
 469         if (nt->enabled) {
 470                 printk(KERN_ERR "netconsole: target (%s) is enabled, "
 471                                 "disable to update parameters\n",
 472                                 config_item_name(&nt->item));
 473                 return -EINVAL;
 474         }
 475
 476         for (i = 0; i < ETH_ALEN - 1; i++) {
 477                 remote_mac[i] = simple_strtoul(p, &p, 16);
 478                 if (*p != ':')
 479                         goto invalid;
 480                 p++;
 481         }
 482         remote_mac[ETH_ALEN - 1] = simple_strtoul(p, &p, 16);
 483         if (*p && (*p != '\n'))
 484                 goto invalid;
 485
 486         memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
 487
 488         return strnlen(buf, count);
 489
 490 invalid:
 491         printk(KERN_ERR "netconsole: invalid input\n");
 492         return -EINVAL;
 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                 printk(KERN_ERR "netconsole: failed to allocate memory\n");
 597                 return ERR_PTR(-ENOMEM);
 598         }
 599
 600         nt->np.name = "netconsole";
 601         strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
 602         nt->np.local_port = 6665;
 603         nt->np.remote_port = 6666;
 604         memset(nt->np.remote_mac, 0xff, ETH_ALEN);
 605
 606         /* Initialize the config_item member */
 607         config_item_init_type_name(&nt->item, name, &netconsole_target_type);
 608
 609         /* Adding, but it is disabled */
 610         spin_lock_irqsave(&target_list_lock, flags);
 611         list_add(&nt->list, &target_list);
 612         spin_unlock_irqrestore(&target_list_lock, flags);
 613
 614         return &nt->item;
 615 }
 616
 617 static void drop_netconsole_target(struct config_group *group,
 618                                    struct config_item *item)
 619 {
 620         unsigned long flags;
 621         struct netconsole_target *nt = to_target(item);
 622
 623         spin_lock_irqsave(&target_list_lock, flags);
 624         list_del(&nt->list);
 625         spin_unlock_irqrestore(&target_list_lock, flags);
 626
 627         /*
 628          * The target may have never been enabled, or was manually disabled
 629          * before being removed so netpoll may have already been cleaned up.
 630          */
 631         if (nt->enabled)
 632                 netpoll_cleanup(&nt->np);
 633
 634         config_item_put(&nt->item);
 635 }
 636
 637 static struct configfs_group_operations netconsole_subsys_group_ops = {
 638         .make_item      = make_netconsole_target,
 639         .drop_item      = drop_netconsole_target,
 640 };
 641
 642 static struct config_item_type netconsole_subsys_type = {
 643         .ct_group_ops   = &netconsole_subsys_group_ops,
 644         .ct_owner       = THIS_MODULE,
 645 };
 646
 647 /* The netconsole configfs subsystem */
 648 static struct configfs_subsystem netconsole_subsys = {
 649         .su_group       = {
 650                 .cg_item        = {
 651                         .ci_namebuf     = "netconsole",
 652                         .ci_type        = &netconsole_subsys_type,
 653                 },
 654         },
 655 };
 656
 657 #endif  /* CONFIG_NETCONSOLE_DYNAMIC */
 658
 659 /* Handle network interface device notifications */
 660 static int netconsole_netdev_event(struct notifier_block *this,
 661                                    unsigned long event,
 662                                    void *ptr)
 663 {
 664         unsigned long flags;
 665         struct netconsole_target *nt;
 666         struct net_device *dev = ptr;
 667
 668         if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
 669               event == NETDEV_BONDING_DESLAVE || event == NETDEV_GOING_DOWN))
 670                 goto done;
 671
 672         spin_lock_irqsave(&target_list_lock, flags);
 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_UNREGISTER:
 681                                 netpoll_cleanup(&nt->np);
 682                                 /* Fall through */
 683                         case NETDEV_GOING_DOWN:
 684                         case NETDEV_BONDING_DESLAVE:
 685                                 nt->enabled = 0;
 686                                 break;
 687                         }
 688                 }
 689                 netconsole_target_put(nt);
 690         }
 691         spin_unlock_irqrestore(&target_list_lock, flags);
 692         if (event == NETDEV_UNREGISTER || event == NETDEV_BONDING_DESLAVE)
 693                 printk(KERN_INFO "netconsole: network logging stopped, "
 694                         "interface %s %s\n",  dev->name,
 695                         event == NETDEV_UNREGISTER ? "unregistered" : "released slaves");
 696
 697 done:
 698         return NOTIFY_DONE;
 699 }
 700
 701 static struct notifier_block netconsole_netdev_notifier = {
 702         .notifier_call  = netconsole_netdev_event,
 703 };
 704
 705 static void write_msg(struct console *con, const char *msg, unsigned int len)
 706 {
 707         int frag, left;
 708         unsigned long flags;
 709         struct netconsole_target *nt;
 710         const char *tmp;
 711
 712         /* Avoid taking lock and disabling interrupts unnecessarily */
 713         if (list_empty(&target_list))
 714                 return;
 715
 716         spin_lock_irqsave(&target_list_lock, flags);
 717         list_for_each_entry(nt, &target_list, list) {
 718                 netconsole_target_get(nt);
 719                 if (nt->enabled && netif_running(nt->np.dev)) {
 720                         /*
 721                          * We nest this inside the for-each-target loop above
 722                          * so that we're able to get as much logging out to
 723                          * at least one target if we die inside here, instead
 724                          * of unnecessarily keeping all targets in lock-step.
 725                          */
 726                         tmp = msg;
 727                         for (left = len; left;) {
 728                                 frag = min(left, MAX_PRINT_CHUNK);
 729                                 netpoll_send_udp(&nt->np, tmp, frag);
 730                                 tmp += frag;
 731                                 left -= frag;
 732                         }
 733                 }
 734                 netconsole_target_put(nt);
 735         }
 736         spin_unlock_irqrestore(&target_list_lock, flags);
 737 }
 738
 739 static struct console netconsole = {
 740         .name   = "netcon",
 741         .flags  = CON_ENABLED,
 742         .write  = write_msg,
 743 };
 744
 745 static int __init init_netconsole(void)
 746 {
 747         int err;
 748         struct netconsole_target *nt, *tmp;
 749         unsigned long flags;
 750         char *target_config;
 751         char *input = config;
 752
 753         if (strnlen(input, MAX_PARAM_LENGTH)) {
 754                 while ((target_config = strsep(&input, ";"))) {
 755                         nt = alloc_param_target(target_config);
 756                         if (IS_ERR(nt)) {
 757                                 err = PTR_ERR(nt);
 758                                 goto fail;
 759                         }
 760                         /* Dump existing printks when we register */
 761                         netconsole.flags |= CON_PRINTBUFFER;
 762
 763                         spin_lock_irqsave(&target_list_lock, flags);
 764                         list_add(&nt->list, &target_list);
 765                         spin_unlock_irqrestore(&target_list_lock, flags);
 766                 }
 767         }
 768
 769         err = register_netdevice_notifier(&netconsole_netdev_notifier);
 770         if (err)
 771                 goto fail;
 772
 773         err = dynamic_netconsole_init();
 774         if (err)
 775                 goto undonotifier;
 776
 777         register_console(&netconsole);
 778         printk(KERN_INFO "netconsole: network logging started\n");
 779
 780         return err;
 781
 782 undonotifier:
 783         unregister_netdevice_notifier(&netconsole_netdev_notifier);
 784
 785 fail:
 786         printk(KERN_ERR "netconsole: cleaning up\n");
 787
 788         /*
 789          * Remove all targets and destroy them (only targets created
 790          * from the boot/module option exist here). Skipping the list
 791          * lock is safe here, and netpoll_cleanup() will sleep.
 792          */
 793         list_for_each_entry_safe(nt, tmp, &target_list, list) {
 794                 list_del(&nt->list);
 795                 free_param_target(nt);
 796         }
 797
 798         return err;
 799 }
 800
 801 static void __exit cleanup_netconsole(void)
 802 {
 803         struct netconsole_target *nt, *tmp;
 804
 805         unregister_console(&netconsole);
 806         dynamic_netconsole_exit();
 807         unregister_netdevice_notifier(&netconsole_netdev_notifier);
 808
 809         /*
 810          * Targets created via configfs pin references on our module
 811          * and would first be rmdir(2)'ed from userspace. We reach
 812          * here only when they are already destroyed, and only those
 813          * created from the boot/module option are left, so remove and
 814          * destroy them. Skipping the list lock is safe here, and
 815          * 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
 823 module_init(init_netconsole);
 824 module_exit(cleanup_netconsole);