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