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