drivers/net/netconsole.c

   1 /*
   2  *  linux/drivers/net/netconsole.c
   3  *
   4  *  Copyright (C) 2001  Ingo Molnar <mingo@redhat.com>
   5  *
   6  *  This file contains the implementation of an IRQ-safe, crash-safe
   7  *  kernel console implementation that outputs kernel messages to the
   8  *  network.
   9  *
  10  * Modification history:
  11  *
  12  * 2001-09-17    started by Ingo Molnar.
  13  * 2003-08-11    2.6 port by Matt Mackall
  14  *               simplified options
  15  *               generic card hooks
  16  *               works non-modular
  17  * 2003-09-07    rewritten with netpoll api
  18  */
  19
  20 /****************************************************************
  21  *      This program is free software; you can redistribute it and/or modify
  22  *      it under the terms of the GNU General Public License as published by
  23  *      the Free Software Foundation; either version 2, or (at your option)
  24  *      any later version.
  25  *
  26  *      This program is distributed in the hope that it will be useful,
  27  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29  *      GNU General Public License for more details.
  30  *
  31  *      You should have received a copy of the GNU General Public License
  32  *      along with this program; if not, write to the Free Software
  33  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  34  *
  35  ****************************************************************/
  36
  37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  38
  39 #include <linux/mm.h>
  40 #include <linux/init.h>
  41 #include <linux/module.h>
  42 #include <linux/slab.h>
  43 #include <linux/console.h>
  44 #include <linux/moduleparam.h>
  45 #include <linux/kernel.h>
  46 #include <linux/string.h>
  47 #include <linux/netpoll.h>
  48 #include <linux/inet.h>
  49 #include <linux/configfs.h>
  50 #include <linux/etherdevice.h>
  51
  52 MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
  53 MODULE_DESCRIPTION("Console driver for network interfaces");
  54 MODULE_LICENSE("GPL");
  55
  56 #define MAX_PARAM_LENGTH        256
  57 #define MAX_PRINT_CHUNK         1000
  58
  59 static char config[MAX_PARAM_LENGTH];
  60 module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0);
  61 MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]");
  62
  63 static bool oops_only = false;
  64 module_param(oops_only, bool, 0600);
  65 MODULE_PARM_DESC(oops_only, "Only log oops messages");
  66
  67 #ifndef MODULE
  68 static int __init option_setup(char *opt)
  69 {
  70         strlcpy(config, opt, MAX_PARAM_LENGTH);
  71         return 1;
  72 }
  73 __setup("netconsole=", option_setup);
  74 #endif  /* MODULE */
  75
  76 /* Linked list of all configured targets */
  77 static LIST_HEAD(target_list);
  78
  79 /* This needs to be a spinlock because write_msg() cannot sleep */
  80 static DEFINE_SPINLOCK(target_list_lock);
  81
  82 /*
  83  * Console driver for extended netconsoles.  Registered on the first use to
  84  * avoid unnecessarily enabling ext message formatting.
  85  */
  86 static struct console netconsole_ext;
  87
  88 /**
  89  * struct netconsole_target - Represents a configured netconsole target.
  90  * @list:       Links this target into the target_list.
  91  * @item:       Links us into the configfs subsystem hierarchy.
  92  * @enabled:    On / off knob to enable / disable target.
  93  *              Visible from userspace (read-write).
  94  *              We maintain a strict 1:1 correspondence between this and
  95  *              whether the corresponding netpoll is active or inactive.
  96  *              Also, other parameters of a target may be modified at
  97  *              runtime only when it is disabled (enabled == 0).
  98  * @np:         The netpoll structure for this target.
  99  *              Contains the other userspace visible parameters:
 100  *              dev_name        (read-write)
 101  *              local_port      (read-write)
 102  *              remote_port     (read-write)
 103  *              local_ip        (read-write)
 104  *              remote_ip       (read-write)
 105  *              local_mac       (read-only)
 106  *              remote_mac      (read-write)
 107  */
 108 struct netconsole_target {
 109         struct list_head        list;
 110 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
 111         struct config_item      item;
 112 #endif
 113         bool                    enabled;
 114         bool                    extended;
 115         struct netpoll          np;
 116 };
 117
 118 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
 119
 120 static struct configfs_subsystem netconsole_subsys;
 121 static DEFINE_MUTEX(dynamic_netconsole_mutex);
 122
 123 static int __init dynamic_netconsole_init(void)
 124 {
 125         config_group_init(&netconsole_subsys.su_group);
 126         mutex_init(&netconsole_subsys.su_mutex);
 127         return configfs_register_subsystem(&netconsole_subsys);
 128 }
 129
 130 static void __exit dynamic_netconsole_exit(void)
 131 {
 132         configfs_unregister_subsystem(&netconsole_subsys);
 133 }
 134
 135 /*
 136  * Targets that were created by parsing the boot/module option string
 137  * do not exist in the configfs hierarchy (and have NULL names) and will
 138  * never go away, so make these a no-op for them.
 139  */
 140 static void netconsole_target_get(struct netconsole_target *nt)
 141 {
 142         if (config_item_name(&nt->item))
 143                 config_item_get(&nt->item);
 144 }
 145
 146 static void netconsole_target_put(struct netconsole_target *nt)
 147 {
 148         if (config_item_name(&nt->item))
 149                 config_item_put(&nt->item);
 150 }
 151
 152 #else   /* !CONFIG_NETCONSOLE_DYNAMIC */
 153
 154 static int __init dynamic_netconsole_init(void)
 155 {
 156         return 0;
 157 }
 158
 159 static void __exit dynamic_netconsole_exit(void)
 160 {
 161 }
 162
 163 /*
 164  * No danger of targets going away from under us when dynamic
 165  * reconfigurability is off.
 166  */
 167 static void netconsole_target_get(struct netconsole_target *nt)
 168 {
 169 }
 170
 171 static void netconsole_target_put(struct netconsole_target *nt)
 172 {
 173 }
 174
 175 #endif  /* CONFIG_NETCONSOLE_DYNAMIC */
 176
 177 /* Allocate new target (from boot/module param) and setup netpoll for it */
 178 static struct netconsole_target *alloc_param_target(char *target_config)
 179 {
 180         int err = -ENOMEM;
 181         struct netconsole_target *nt;
 182
 183         /*
 184          * Allocate and initialize with defaults.
 185          * Note that these targets get their config_item fields zeroed-out.
 186          */
 187         nt = kzalloc(sizeof(*nt), GFP_KERNEL);
 188         if (!nt)
 189                 goto fail;
 190
 191         nt->np.name = "netconsole";
 192         strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
 193         nt->np.local_port = 6665;
 194         nt->np.remote_port = 6666;
 195         eth_broadcast_addr(nt->np.remote_mac);
 196
 197         if (*target_config == '+') {
 198                 nt->extended = true;
 199                 target_config++;
 200         }
 201
 202         /* Parse parameters and setup netpoll */
 203         err = netpoll_parse_options(&nt->np, target_config);
 204         if (err)
 205                 goto fail;
 206
 207         err = netpoll_setup(&nt->np);
 208         if (err)
 209                 goto fail;
 210
 211         nt->enabled = true;
 212
 213         return nt;
 214
 215 fail:
 216         kfree(nt);
 217         return ERR_PTR(err);
 218 }
 219
 220 /* Cleanup netpoll for given target (from boot/module param) and free it */
 221 static void free_param_target(struct netconsole_target *nt)
 222 {
 223         netpoll_cleanup(&nt->np);
 224         kfree(nt);
 225 }
 226
 227 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
 228
 229 /*
 230  * Our subsystem hierarchy is:
 231  *
 232  * /sys/kernel/config/netconsole/
 233  *                              |
 234  *                              <target>/
 235  *                              |       enabled
 236  *                              |       dev_name
 237  *                              |       local_port
 238  *                              |       remote_port
 239  *                              |       local_ip
 240  *                              |       remote_ip
 241  *                              |       local_mac
 242  *                              |       remote_mac
 243  *                              |
 244  *                              <target>/...
 245  */
 246
 247 static struct netconsole_target *to_target(struct config_item *item)
 248 {
 249         return item ?
 250                 container_of(item, struct netconsole_target, item) :
 251                 NULL;
 252 }
 253
 254 /*
 255  * Attribute operations for netconsole_target.
 256  */
 257
 258 static ssize_t enabled_show(struct config_item *item, char *buf)
 259 {
 260         return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->enabled);
 261 }
 262
 263 static ssize_t extended_show(struct config_item *item, char *buf)
 264 {
 265         return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->extended);
 266 }
 267
 268 static ssize_t dev_name_show(struct config_item *item, char *buf)
 269 {
 270         return snprintf(buf, PAGE_SIZE, "%s\n", to_target(item)->np.dev_name);
 271 }
 272
 273 static ssize_t local_port_show(struct config_item *item, char *buf)
 274 {
 275         return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->np.local_port);
 276 }
 277
 278 static ssize_t remote_port_show(struct config_item *item, char *buf)
 279 {
 280         return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->np.remote_port);
 281 }
 282
 283 static ssize_t local_ip_show(struct config_item *item, char *buf)
 284 {
 285         struct netconsole_target *nt = to_target(item);
 286
 287         if (nt->np.ipv6)
 288                 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.local_ip.in6);
 289         else
 290                 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip);
 291 }
 292
 293 static ssize_t remote_ip_show(struct config_item *item, char *buf)
 294 {
 295         struct netconsole_target *nt = to_target(item);
 296
 297         if (nt->np.ipv6)
 298                 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.remote_ip.in6);
 299         else
 300                 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip);
 301 }
 302
 303 static ssize_t local_mac_show(struct config_item *item, char *buf)
 304 {
 305         struct net_device *dev = to_target(item)->np.dev;
 306         static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 307
 308         return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast);
 309 }
 310
 311 static ssize_t remote_mac_show(struct config_item *item, char *buf)
 312 {
 313         return snprintf(buf, PAGE_SIZE, "%pM\n", to_target(item)->np.remote_mac);
 314 }
 315
 316 /*
 317  * This one is special -- targets created through the configfs interface
 318  * are not enabled (and the corresponding netpoll activated) by default.
 319  * The user is expected to set the desired parameters first (which
 320  * would enable him to dynamically add new netpoll targets for new
 321  * network interfaces as and when they come up).
 322  */
 323 static ssize_t enabled_store(struct config_item *item,
 324                 const char *buf, size_t count)
 325 {
 326         struct netconsole_target *nt = to_target(item);
 327         unsigned long flags;
 328         int enabled;
 329         int err;
 330
 331         mutex_lock(&dynamic_netconsole_mutex);
 332         err = kstrtoint(buf, 10, &enabled);
 333         if (err < 0)
 334                 goto out_unlock;
 335
 336         err = -EINVAL;
 337         if (enabled < 0 || enabled > 1)
 338                 goto out_unlock;
 339         if ((bool)enabled == nt->enabled) {
 340                 pr_info("network logging has already %s\n",
 341                         nt->enabled ? "started" : "stopped");
 342                 goto out_unlock;
 343         }
 344
 345         if (enabled) {  /* true */
 346                 if (nt->extended && !(netconsole_ext.flags & CON_ENABLED)) {
 347                         netconsole_ext.flags |= CON_ENABLED;
 348                         register_console(&netconsole_ext);
 349                 }
 350
 351                 /*
 352                  * Skip netpoll_parse_options() -- all the attributes are
 353                  * already configured via configfs. Just print them out.
 354                  */
 355                 netpoll_print_options(&nt->np);
 356
 357                 err = netpoll_setup(&nt->np);
 358                 if (err)
 359                         goto out_unlock;
 360
 361                 pr_info("netconsole: network logging started\n");
 362         } else {        /* false */
 363                 /* We need to disable the netconsole before cleaning it up
 364                  * otherwise we might end up in write_msg() with
 365                  * nt->np.dev == NULL and nt->enabled == true
 366                  */
 367                 spin_lock_irqsave(&target_list_lock, flags);
 368                 nt->enabled = false;
 369                 spin_unlock_irqrestore(&target_list_lock, flags);
 370                 netpoll_cleanup(&nt->np);
 371         }
 372
 373         nt->enabled = enabled;
 374
 375         mutex_unlock(&dynamic_netconsole_mutex);
 376         return strnlen(buf, count);
 377 out_unlock:
 378         mutex_unlock(&dynamic_netconsole_mutex);
 379         return err;
 380 }
 381
 382 static ssize_t extended_store(struct config_item *item, const char *buf,
 383                 size_t count)
 384 {
 385         struct netconsole_target *nt = to_target(item);
 386         int extended;
 387         int err;
 388
 389         mutex_lock(&dynamic_netconsole_mutex);
 390         if (nt->enabled) {
 391                 pr_err("target (%s) is enabled, disable to update parameters\n",
 392                        config_item_name(&nt->item));
 393                 err = -EINVAL;
 394                 goto out_unlock;
 395         }
 396
 397         err = kstrtoint(buf, 10, &extended);
 398         if (err < 0)
 399                 goto out_unlock;
 400         if (extended < 0 || extended > 1) {
 401                 err = -EINVAL;
 402                 goto out_unlock;
 403         }
 404
 405         nt->extended = extended;
 406
 407         mutex_unlock(&dynamic_netconsole_mutex);
 408         return strnlen(buf, count);
 409 out_unlock:
 410         mutex_unlock(&dynamic_netconsole_mutex);
 411         return err;
 412 }
 413
 414 static ssize_t dev_name_store(struct config_item *item, const char *buf,
 415                 size_t count)
 416 {
 417         struct netconsole_target *nt = to_target(item);
 418         size_t len;
 419
 420         mutex_lock(&dynamic_netconsole_mutex);
 421         if (nt->enabled) {
 422                 pr_err("target (%s) is enabled, disable to update parameters\n",
 423                        config_item_name(&nt->item));
 424                 mutex_unlock(&dynamic_netconsole_mutex);
 425                 return -EINVAL;
 426         }
 427
 428         strlcpy(nt->np.dev_name, buf, IFNAMSIZ);
 429
 430         /* Get rid of possible trailing newline from echo(1) */
 431         len = strnlen(nt->np.dev_name, IFNAMSIZ);
 432         if (nt->np.dev_name[len - 1] == '\n')
 433                 nt->np.dev_name[len - 1] = '\0';
 434
 435         mutex_unlock(&dynamic_netconsole_mutex);
 436         return strnlen(buf, count);
 437 }
 438
 439 static ssize_t local_port_store(struct config_item *item, const char *buf,
 440                 size_t count)
 441 {
 442         struct netconsole_target *nt = to_target(item);
 443         int rv = -EINVAL;
 444
 445         mutex_lock(&dynamic_netconsole_mutex);
 446         if (nt->enabled) {
 447                 pr_err("target (%s) is enabled, disable to update parameters\n",
 448                        config_item_name(&nt->item));
 449                 goto out_unlock;
 450         }
 451
 452         rv = kstrtou16(buf, 10, &nt->np.local_port);
 453         if (rv < 0)
 454                 goto out_unlock;
 455         mutex_unlock(&dynamic_netconsole_mutex);
 456         return strnlen(buf, count);
 457 out_unlock:
 458         mutex_unlock(&dynamic_netconsole_mutex);
 459         return rv;
 460 }
 461
 462 static ssize_t remote_port_store(struct config_item *item,
 463                 const char *buf, size_t count)
 464 {
 465         struct netconsole_target *nt = to_target(item);
 466         int rv = -EINVAL;
 467
 468         mutex_lock(&dynamic_netconsole_mutex);
 469         if (nt->enabled) {
 470                 pr_err("target (%s) is enabled, disable to update parameters\n",
 471                        config_item_name(&nt->item));
 472                 goto out_unlock;
 473         }
 474
 475         rv = kstrtou16(buf, 10, &nt->np.remote_port);
 476         if (rv < 0)
 477                 goto out_unlock;
 478         mutex_unlock(&dynamic_netconsole_mutex);
 479         return strnlen(buf, count);
 480 out_unlock:
 481         mutex_unlock(&dynamic_netconsole_mutex);
 482         return rv;
 483 }
 484
 485 static ssize_t local_ip_store(struct config_item *item, const char *buf,
 486                 size_t count)
 487 {
 488         struct netconsole_target *nt = to_target(item);
 489
 490         mutex_lock(&dynamic_netconsole_mutex);
 491         if (nt->enabled) {
 492                 pr_err("target (%s) is enabled, disable to update parameters\n",
 493                        config_item_name(&nt->item));
 494                 goto out_unlock;
 495         }
 496
 497         if (strnchr(buf, count, ':')) {
 498                 const char *end;
 499                 if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) {
 500                         if (*end && *end != '\n') {
 501                                 pr_err("invalid IPv6 address at: <%c>\n", *end);
 502                                 goto out_unlock;
 503                         }
 504                         nt->np.ipv6 = true;
 505                 } else
 506                         goto out_unlock;
 507         } else {
 508                 if (!nt->np.ipv6) {
 509                         nt->np.local_ip.ip = in_aton(buf);
 510                 } else
 511                         goto out_unlock;
 512         }
 513
 514         mutex_unlock(&dynamic_netconsole_mutex);
 515         return strnlen(buf, count);
 516 out_unlock:
 517         mutex_unlock(&dynamic_netconsole_mutex);
 518         return -EINVAL;
 519 }
 520
 521 static ssize_t remote_ip_store(struct config_item *item, const char *buf,
 522                size_t count)
 523 {
 524         struct netconsole_target *nt = to_target(item);
 525
 526         mutex_lock(&dynamic_netconsole_mutex);
 527         if (nt->enabled) {
 528                 pr_err("target (%s) is enabled, disable to update parameters\n",
 529                        config_item_name(&nt->item));
 530                 goto out_unlock;
 531         }
 532
 533         if (strnchr(buf, count, ':')) {
 534                 const char *end;
 535                 if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) {
 536                         if (*end && *end != '\n') {
 537                                 pr_err("invalid IPv6 address at: <%c>\n", *end);
 538                                 goto out_unlock;
 539                         }
 540                         nt->np.ipv6 = true;
 541                 } else
 542                         goto out_unlock;
 543         } else {
 544                 if (!nt->np.ipv6) {
 545                         nt->np.remote_ip.ip = in_aton(buf);
 546                 } else
 547                         goto out_unlock;
 548         }
 549
 550         mutex_unlock(&dynamic_netconsole_mutex);
 551         return strnlen(buf, count);
 552 out_unlock:
 553         mutex_unlock(&dynamic_netconsole_mutex);
 554         return -EINVAL;
 555 }
 556
 557 static ssize_t remote_mac_store(struct config_item *item, const char *buf,
 558                 size_t count)
 559 {
 560         struct netconsole_target *nt = to_target(item);
 561         u8 remote_mac[ETH_ALEN];
 562
 563         mutex_lock(&dynamic_netconsole_mutex);
 564         if (nt->enabled) {
 565                 pr_err("target (%s) is enabled, disable to update parameters\n",
 566                        config_item_name(&nt->item));
 567                 goto out_unlock;
 568         }
 569
 570         if (!mac_pton(buf, remote_mac))
 571                 goto out_unlock;
 572         if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n')
 573                 goto out_unlock;
 574         memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
 575
 576         mutex_unlock(&dynamic_netconsole_mutex);
 577         return strnlen(buf, count);
 578 out_unlock:
 579         mutex_unlock(&dynamic_netconsole_mutex);
 580         return -EINVAL;
 581 }
 582
 583 CONFIGFS_ATTR(, enabled);
 584 CONFIGFS_ATTR(, extended);
 585 CONFIGFS_ATTR(, dev_name);
 586 CONFIGFS_ATTR(, local_port);
 587 CONFIGFS_ATTR(, remote_port);
 588 CONFIGFS_ATTR(, local_ip);
 589 CONFIGFS_ATTR(, remote_ip);
 590 CONFIGFS_ATTR_RO(, local_mac);
 591 CONFIGFS_ATTR(, remote_mac);
 592
 593 static struct configfs_attribute *netconsole_target_attrs[] = {
 594         &attr_enabled,
 595         &attr_extended,
 596         &attr_dev_name,
 597         &attr_local_port,
 598         &attr_remote_port,
 599         &attr_local_ip,
 600         &attr_remote_ip,
 601         &attr_local_mac,
 602         &attr_remote_mac,
 603         NULL,
 604 };
 605
 606 /*
 607  * Item operations and type for netconsole_target.
 608  */
 609
 610 static void netconsole_target_release(struct config_item *item)
 611 {
 612         kfree(to_target(item));
 613 }
 614
 615 static struct configfs_item_operations netconsole_target_item_ops = {
 616         .release                = netconsole_target_release,
 617 };
 618
 619 static struct config_item_type netconsole_target_type = {
 620         .ct_attrs               = netconsole_target_attrs,
 621         .ct_item_ops            = &netconsole_target_item_ops,
 622         .ct_owner               = THIS_MODULE,
 623 };
 624
 625 /*
 626  * Group operations and type for netconsole_subsys.
 627  */
 628
 629 static struct config_item *make_netconsole_target(struct config_group *group,
 630                                                   const char *name)
 631 {
 632         unsigned long flags;
 633         struct netconsole_target *nt;
 634
 635         /*
 636          * Allocate and initialize with defaults.
 637          * Target is disabled at creation (!enabled).
 638          */
 639         nt = kzalloc(sizeof(*nt), GFP_KERNEL);
 640         if (!nt)
 641                 return ERR_PTR(-ENOMEM);
 642
 643         nt->np.name = "netconsole";
 644         strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
 645         nt->np.local_port = 6665;
 646         nt->np.remote_port = 6666;
 647         eth_broadcast_addr(nt->np.remote_mac);
 648
 649         /* Initialize the config_item member */
 650         config_item_init_type_name(&nt->item, name, &netconsole_target_type);
 651
 652         /* Adding, but it is disabled */
 653         spin_lock_irqsave(&target_list_lock, flags);
 654         list_add(&nt->list, &target_list);
 655         spin_unlock_irqrestore(&target_list_lock, flags);
 656
 657         return &nt->item;
 658 }
 659
 660 static void drop_netconsole_target(struct config_group *group,
 661                                    struct config_item *item)
 662 {
 663         unsigned long flags;
 664         struct netconsole_target *nt = to_target(item);
 665
 666         spin_lock_irqsave(&target_list_lock, flags);
 667         list_del(&nt->list);
 668         spin_unlock_irqrestore(&target_list_lock, flags);
 669
 670         /*
 671          * The target may have never been enabled, or was manually disabled
 672          * before being removed so netpoll may have already been cleaned up.
 673          */
 674         if (nt->enabled)
 675                 netpoll_cleanup(&nt->np);
 676
 677         config_item_put(&nt->item);
 678 }
 679
 680 static struct configfs_group_operations netconsole_subsys_group_ops = {
 681         .make_item      = make_netconsole_target,
 682         .drop_item      = drop_netconsole_target,
 683 };
 684
 685 static struct config_item_type netconsole_subsys_type = {
 686         .ct_group_ops   = &netconsole_subsys_group_ops,
 687         .ct_owner       = THIS_MODULE,
 688 };
 689
 690 /* The netconsole configfs subsystem */
 691 static struct configfs_subsystem netconsole_subsys = {
 692         .su_group       = {
 693                 .cg_item        = {
 694                         .ci_namebuf     = "netconsole",
 695                         .ci_type        = &netconsole_subsys_type,
 696                 },
 697         },
 698 };
 699
 700 #endif  /* CONFIG_NETCONSOLE_DYNAMIC */
 701
 702 /* Handle network interface device notifications */
 703 static int netconsole_netdev_event(struct notifier_block *this,
 704                                    unsigned long event, void *ptr)
 705 {
 706         unsigned long flags;
 707         struct netconsole_target *nt;
 708         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 709         bool stopped = false;
 710
 711         if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
 712               event == NETDEV_RELEASE || event == NETDEV_JOIN))
 713                 goto done;
 714
 715         spin_lock_irqsave(&target_list_lock, flags);
 716 restart:
 717         list_for_each_entry(nt, &target_list, list) {
 718                 netconsole_target_get(nt);
 719                 if (nt->np.dev == dev) {
 720                         switch (event) {
 721                         case NETDEV_CHANGENAME:
 722                                 strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
 723                                 break;
 724                         case NETDEV_RELEASE:
 725                         case NETDEV_JOIN:
 726                         case NETDEV_UNREGISTER:
 727                                 /* rtnl_lock already held
 728                                  * we might sleep in __netpoll_cleanup()
 729                                  */
 730                                 spin_unlock_irqrestore(&target_list_lock, flags);
 731
 732                                 __netpoll_cleanup(&nt->np);
 733
 734                                 spin_lock_irqsave(&target_list_lock, flags);
 735                                 dev_put(nt->np.dev);
 736                                 nt->np.dev = NULL;
 737                                 nt->enabled = false;
 738                                 stopped = true;
 739                                 netconsole_target_put(nt);
 740                                 goto restart;
 741                         }
 742                 }
 743                 netconsole_target_put(nt);
 744         }
 745         spin_unlock_irqrestore(&target_list_lock, flags);
 746         if (stopped) {
 747                 const char *msg = "had an event";
 748                 switch (event) {
 749                 case NETDEV_UNREGISTER:
 750                         msg = "unregistered";
 751                         break;
 752                 case NETDEV_RELEASE:
 753                         msg = "released slaves";
 754                         break;
 755                 case NETDEV_JOIN:
 756                         msg = "is joining a master device";
 757                         break;
 758                 }
 759                 pr_info("network logging stopped on interface %s as it %s\n",
 760                         dev->name, msg);
 761         }
 762
 763 done:
 764         return NOTIFY_DONE;
 765 }
 766
 767 static struct notifier_block netconsole_netdev_notifier = {
 768         .notifier_call  = netconsole_netdev_event,
 769 };
 770
 771 /**
 772  * send_ext_msg_udp - send extended log message to target
 773  * @nt: target to send message to
 774  * @msg: extended log message to send
 775  * @msg_len: length of message
 776  *
 777  * Transfer extended log @msg to @nt.  If @msg is longer than
 778  * MAX_PRINT_CHUNK, it'll be split and transmitted in multiple chunks with
 779  * ncfrag header field added to identify them.
 780  */
 781 static void send_ext_msg_udp(struct netconsole_target *nt, const char *msg,
 782                              int msg_len)
 783 {
 784         static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */
 785         const char *header, *body;
 786         int offset = 0;
 787         int header_len, body_len;
 788
 789         if (msg_len <= MAX_PRINT_CHUNK) {
 790                 netpoll_send_udp(&nt->np, msg, msg_len);
 791                 return;
 792         }
 793
 794         /* need to insert extra header fields, detect header and body */
 795         header = msg;
 796         body = memchr(msg, ';', msg_len);
 797         if (WARN_ON_ONCE(!body))
 798                 return;
 799
 800         header_len = body - header;
 801         body_len = msg_len - header_len - 1;
 802         body++;
 803
 804         /*
 805          * Transfer multiple chunks with the following extra header.
 806          * "ncfrag=<byte-offset>/<total-bytes>"
 807          */
 808         memcpy(buf, header, header_len);
 809
 810         while (offset < body_len) {
 811                 int this_header = header_len;
 812                 int this_chunk;
 813
 814                 this_header += scnprintf(buf + this_header,
 815                                          sizeof(buf) - this_header,
 816                                          ",ncfrag=%d/%d;", offset, body_len);
 817
 818                 this_chunk = min(body_len - offset,
 819                                  MAX_PRINT_CHUNK - this_header);
 820                 if (WARN_ON_ONCE(this_chunk <= 0))
 821                         return;
 822
 823                 memcpy(buf + this_header, body + offset, this_chunk);
 824
 825                 netpoll_send_udp(&nt->np, buf, this_header + this_chunk);
 826
 827                 offset += this_chunk;
 828         }
 829 }
 830
 831 static void write_ext_msg(struct console *con, const char *msg,
 832                           unsigned int len)
 833 {
 834         struct netconsole_target *nt;
 835         unsigned long flags;
 836
 837         if ((oops_only && !oops_in_progress) || list_empty(&target_list))
 838                 return;
 839
 840         spin_lock_irqsave(&target_list_lock, flags);
 841         list_for_each_entry(nt, &target_list, list)
 842                 if (nt->extended && nt->enabled && netif_running(nt->np.dev))
 843                         send_ext_msg_udp(nt, msg, len);
 844         spin_unlock_irqrestore(&target_list_lock, flags);
 845 }
 846
 847 static void write_msg(struct console *con, const char *msg, unsigned int len)
 848 {
 849         int frag, left;
 850         unsigned long flags;
 851         struct netconsole_target *nt;
 852         const char *tmp;
 853
 854         if (oops_only && !oops_in_progress)
 855                 return;
 856         /* Avoid taking lock and disabling interrupts unnecessarily */
 857         if (list_empty(&target_list))
 858                 return;
 859
 860         spin_lock_irqsave(&target_list_lock, flags);
 861         list_for_each_entry(nt, &target_list, list) {
 862                 if (!nt->extended && nt->enabled && netif_running(nt->np.dev)) {
 863                         /*
 864                          * We nest this inside the for-each-target loop above
 865                          * so that we're able to get as much logging out to
 866                          * at least one target if we die inside here, instead
 867                          * of unnecessarily keeping all targets in lock-step.
 868                          */
 869                         tmp = msg;
 870                         for (left = len; left;) {
 871                                 frag = min(left, MAX_PRINT_CHUNK);
 872                                 netpoll_send_udp(&nt->np, tmp, frag);
 873                                 tmp += frag;
 874                                 left -= frag;
 875                         }
 876                 }
 877         }
 878         spin_unlock_irqrestore(&target_list_lock, flags);
 879 }
 880
 881 static struct console netconsole_ext = {
 882         .name   = "netcon_ext",
 883         .flags  = CON_EXTENDED, /* starts disabled, registered on first use */
 884         .write  = write_ext_msg,
 885 };
 886
 887 static struct console netconsole = {
 888         .name   = "netcon",
 889         .flags  = CON_ENABLED,
 890         .write  = write_msg,
 891 };
 892
 893 static int __init init_netconsole(void)
 894 {
 895         int err;
 896         struct netconsole_target *nt, *tmp;
 897         unsigned long flags;
 898         char *target_config;
 899         char *input = config;
 900
 901         if (strnlen(input, MAX_PARAM_LENGTH)) {
 902                 while ((target_config = strsep(&input, ";"))) {
 903                         nt = alloc_param_target(target_config);
 904                         if (IS_ERR(nt)) {
 905                                 err = PTR_ERR(nt);
 906                                 goto fail;
 907                         }
 908                         /* Dump existing printks when we register */
 909                         if (nt->extended)
 910                                 netconsole_ext.flags |= CON_PRINTBUFFER |
 911                                                         CON_ENABLED;
 912                         else
 913                                 netconsole.flags |= CON_PRINTBUFFER;
 914
 915                         spin_lock_irqsave(&target_list_lock, flags);
 916                         list_add(&nt->list, &target_list);
 917                         spin_unlock_irqrestore(&target_list_lock, flags);
 918                 }
 919         }
 920
 921         err = register_netdevice_notifier(&netconsole_netdev_notifier);
 922         if (err)
 923                 goto fail;
 924
 925         err = dynamic_netconsole_init();
 926         if (err)
 927                 goto undonotifier;
 928
 929         if (netconsole_ext.flags & CON_ENABLED)
 930                 register_console(&netconsole_ext);
 931         register_console(&netconsole);
 932         pr_info("network logging started\n");
 933
 934         return err;
 935
 936 undonotifier:
 937         unregister_netdevice_notifier(&netconsole_netdev_notifier);
 938
 939 fail:
 940         pr_err("cleaning up\n");
 941
 942         /*
 943          * Remove all targets and destroy them (only targets created
 944          * from the boot/module option exist here). Skipping the list
 945          * lock is safe here, and netpoll_cleanup() will sleep.
 946          */
 947         list_for_each_entry_safe(nt, tmp, &target_list, list) {
 948                 list_del(&nt->list);
 949                 free_param_target(nt);
 950         }
 951
 952         return err;
 953 }
 954
 955 static void __exit cleanup_netconsole(void)
 956 {
 957         struct netconsole_target *nt, *tmp;
 958
 959         unregister_console(&netconsole_ext);
 960         unregister_console(&netconsole);
 961         dynamic_netconsole_exit();
 962         unregister_netdevice_notifier(&netconsole_netdev_notifier);
 963
 964         /*
 965          * Targets created via configfs pin references on our module
 966          * and would first be rmdir(2)'ed from userspace. We reach
 967          * here only when they are already destroyed, and only those
 968          * created from the boot/module option are left, so remove and
 969          * destroy them. Skipping the list lock is safe here, and
 970          * netpoll_cleanup() will sleep.
 971          */
 972         list_for_each_entry_safe(nt, tmp, &target_list, list) {
 973                 list_del(&nt->list);
 974                 free_param_target(nt);
 975         }
 976 }
 977
 978 /*
 979  * Use late_initcall to ensure netconsole is
 980  * initialized after network device driver if built-in.
 981  *
 982  * late_initcall() and module_init() are identical if built as module.
 983  */
 984 late_initcall(init_netconsole);
 985 module_exit(cleanup_netconsole);