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 struct netconsole_target_attr {
 248         struct configfs_attribute       attr;
 249         ssize_t                         (*show)(struct netconsole_target *nt,
 250                                                 char *buf);
 251         ssize_t                         (*store)(struct netconsole_target *nt,
 252                                                  const char *buf,
 253                                                  size_t count);
 254 };
 255
 256 static struct netconsole_target *to_target(struct config_item *item)
 257 {
 258         return item ?
 259                 container_of(item, struct netconsole_target, item) :
 260                 NULL;
 261 }
 262
 263 /*
 264  * Attribute operations for netconsole_target.
 265  */
 266
 267 static ssize_t show_enabled(struct netconsole_target *nt, char *buf)
 268 {
 269         return snprintf(buf, PAGE_SIZE, "%d\n", nt->enabled);
 270 }
 271
 272 static ssize_t show_extended(struct netconsole_target *nt, char *buf)
 273 {
 274         return snprintf(buf, PAGE_SIZE, "%d\n", nt->extended);
 275 }
 276
 277 static ssize_t show_dev_name(struct netconsole_target *nt, char *buf)
 278 {
 279         return snprintf(buf, PAGE_SIZE, "%s\n", nt->np.dev_name);
 280 }
 281
 282 static ssize_t show_local_port(struct netconsole_target *nt, char *buf)
 283 {
 284         return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.local_port);
 285 }
 286
 287 static ssize_t show_remote_port(struct netconsole_target *nt, char *buf)
 288 {
 289         return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.remote_port);
 290 }
 291
 292 static ssize_t show_local_ip(struct netconsole_target *nt, char *buf)
 293 {
 294         if (nt->np.ipv6)
 295                 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.local_ip.in6);
 296         else
 297                 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip);
 298 }
 299
 300 static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf)
 301 {
 302         if (nt->np.ipv6)
 303                 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.remote_ip.in6);
 304         else
 305                 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip);
 306 }
 307
 308 static ssize_t show_local_mac(struct netconsole_target *nt, char *buf)
 309 {
 310         struct net_device *dev = nt->np.dev;
 311         static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 312
 313         return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast);
 314 }
 315
 316 static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
 317 {
 318         return snprintf(buf, PAGE_SIZE, "%pM\n", nt->np.remote_mac);
 319 }
 320
 321 /*
 322  * This one is special -- targets created through the configfs interface
 323  * are not enabled (and the corresponding netpoll activated) by default.
 324  * The user is expected to set the desired parameters first (which
 325  * would enable him to dynamically add new netpoll targets for new
 326  * network interfaces as and when they come up).
 327  */
 328 static ssize_t store_enabled(struct netconsole_target *nt,
 329                              const char *buf,
 330                              size_t count)
 331 {
 332         unsigned long flags;
 333         int enabled;
 334         int err;
 335
 336         err = kstrtoint(buf, 10, &enabled);
 337         if (err < 0)
 338                 return err;
 339         if (enabled < 0 || enabled > 1)
 340                 return -EINVAL;
 341         if ((bool)enabled == nt->enabled) {
 342                 pr_info("network logging has already %s\n",
 343                         nt->enabled ? "started" : "stopped");
 344                 return -EINVAL;
 345         }
 346
 347         if (enabled) {  /* true */
 348                 if (nt->extended && !(netconsole_ext.flags & CON_ENABLED)) {
 349                         netconsole_ext.flags |= CON_ENABLED;
 350                         register_console(&netconsole_ext);
 351                 }
 352
 353                 /*
 354                  * Skip netpoll_parse_options() -- all the attributes are
 355                  * already configured via configfs. Just print them out.
 356                  */
 357                 netpoll_print_options(&nt->np);
 358
 359                 err = netpoll_setup(&nt->np);
 360                 if (err)
 361                         return err;
 362
 363                 pr_info("netconsole: network logging started\n");
 364         } else {        /* false */
 365                 /* We need to disable the netconsole before cleaning it up
 366                  * otherwise we might end up in write_msg() with
 367                  * nt->np.dev == NULL and nt->enabled == true
 368                  */
 369                 spin_lock_irqsave(&target_list_lock, flags);
 370                 nt->enabled = false;
 371                 spin_unlock_irqrestore(&target_list_lock, flags);
 372                 netpoll_cleanup(&nt->np);
 373         }
 374
 375         nt->enabled = enabled;
 376
 377         return strnlen(buf, count);
 378 }
 379
 380 static ssize_t store_extended(struct netconsole_target *nt,
 381                               const char *buf,
 382                               size_t count)
 383 {
 384         int extended;
 385         int err;
 386
 387         if (nt->enabled) {
 388                 pr_err("target (%s) is enabled, disable to update parameters\n",
 389                        config_item_name(&nt->item));
 390                 return -EINVAL;
 391         }
 392
 393         err = kstrtoint(buf, 10, &extended);
 394         if (err < 0)
 395                 return err;
 396         if (extended < 0 || extended > 1)
 397                 return -EINVAL;
 398
 399         nt->extended = extended;
 400
 401         return strnlen(buf, count);
 402 }
 403
 404 static ssize_t store_dev_name(struct netconsole_target *nt,
 405                               const char *buf,
 406                               size_t count)
 407 {
 408         size_t len;
 409
 410         if (nt->enabled) {
 411                 pr_err("target (%s) is enabled, disable to update parameters\n",
 412                        config_item_name(&nt->item));
 413                 return -EINVAL;
 414         }
 415
 416         strlcpy(nt->np.dev_name, buf, IFNAMSIZ);
 417
 418         /* Get rid of possible trailing newline from echo(1) */
 419         len = strnlen(nt->np.dev_name, IFNAMSIZ);
 420         if (nt->np.dev_name[len - 1] == '\n')
 421                 nt->np.dev_name[len - 1] = '\0';
 422
 423         return strnlen(buf, count);
 424 }
 425
 426 static ssize_t store_local_port(struct netconsole_target *nt,
 427                                 const char *buf,
 428                                 size_t count)
 429 {
 430         int rv;
 431
 432         if (nt->enabled) {
 433                 pr_err("target (%s) is enabled, disable to update parameters\n",
 434                        config_item_name(&nt->item));
 435                 return -EINVAL;
 436         }
 437
 438         rv = kstrtou16(buf, 10, &nt->np.local_port);
 439         if (rv < 0)
 440                 return rv;
 441         return strnlen(buf, count);
 442 }
 443
 444 static ssize_t store_remote_port(struct netconsole_target *nt,
 445                                  const char *buf,
 446                                  size_t count)
 447 {
 448         int rv;
 449
 450         if (nt->enabled) {
 451                 pr_err("target (%s) is enabled, disable to update parameters\n",
 452                        config_item_name(&nt->item));
 453                 return -EINVAL;
 454         }
 455
 456         rv = kstrtou16(buf, 10, &nt->np.remote_port);
 457         if (rv < 0)
 458                 return rv;
 459         return strnlen(buf, count);
 460 }
 461
 462 static ssize_t store_local_ip(struct netconsole_target *nt,
 463                               const char *buf,
 464                               size_t count)
 465 {
 466         if (nt->enabled) {
 467                 pr_err("target (%s) is enabled, disable to update parameters\n",
 468                        config_item_name(&nt->item));
 469                 return -EINVAL;
 470         }
 471
 472         if (strnchr(buf, count, ':')) {
 473                 const char *end;
 474                 if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) {
 475                         if (*end && *end != '\n') {
 476                                 pr_err("invalid IPv6 address at: <%c>\n", *end);
 477                                 return -EINVAL;
 478                         }
 479                         nt->np.ipv6 = true;
 480                 } else
 481                         return -EINVAL;
 482         } else {
 483                 if (!nt->np.ipv6) {
 484                         nt->np.local_ip.ip = in_aton(buf);
 485                 } else
 486                         return -EINVAL;
 487         }
 488
 489         return strnlen(buf, count);
 490 }
 491
 492 static ssize_t store_remote_ip(struct netconsole_target *nt,
 493                                const char *buf,
 494                                size_t count)
 495 {
 496         if (nt->enabled) {
 497                 pr_err("target (%s) is enabled, disable to update parameters\n",
 498                        config_item_name(&nt->item));
 499                 return -EINVAL;
 500         }
 501
 502         if (strnchr(buf, count, ':')) {
 503                 const char *end;
 504                 if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) {
 505                         if (*end && *end != '\n') {
 506                                 pr_err("invalid IPv6 address at: <%c>\n", *end);
 507                                 return -EINVAL;
 508                         }
 509                         nt->np.ipv6 = true;
 510                 } else
 511                         return -EINVAL;
 512         } else {
 513                 if (!nt->np.ipv6) {
 514                         nt->np.remote_ip.ip = in_aton(buf);
 515                 } else
 516                         return -EINVAL;
 517         }
 518
 519         return strnlen(buf, count);
 520 }
 521
 522 static ssize_t store_remote_mac(struct netconsole_target *nt,
 523                                 const char *buf,
 524                                 size_t count)
 525 {
 526         u8 remote_mac[ETH_ALEN];
 527
 528         if (nt->enabled) {
 529                 pr_err("target (%s) is enabled, disable to update parameters\n",
 530                        config_item_name(&nt->item));
 531                 return -EINVAL;
 532         }
 533
 534         if (!mac_pton(buf, remote_mac))
 535                 return -EINVAL;
 536         if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n')
 537                 return -EINVAL;
 538         memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
 539
 540         return strnlen(buf, count);
 541 }
 542
 543 /*
 544  * Attribute definitions for netconsole_target.
 545  */
 546
 547 #define NETCONSOLE_TARGET_ATTR_RO(_name)                                \
 548 static struct netconsole_target_attr netconsole_target_##_name =        \
 549         __CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL)
 550
 551 #define NETCONSOLE_TARGET_ATTR_RW(_name)                                \
 552 static struct netconsole_target_attr netconsole_target_##_name =        \
 553         __CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name)
 554
 555 NETCONSOLE_TARGET_ATTR_RW(enabled);
 556 NETCONSOLE_TARGET_ATTR_RW(extended);
 557 NETCONSOLE_TARGET_ATTR_RW(dev_name);
 558 NETCONSOLE_TARGET_ATTR_RW(local_port);
 559 NETCONSOLE_TARGET_ATTR_RW(remote_port);
 560 NETCONSOLE_TARGET_ATTR_RW(local_ip);
 561 NETCONSOLE_TARGET_ATTR_RW(remote_ip);
 562 NETCONSOLE_TARGET_ATTR_RO(local_mac);
 563 NETCONSOLE_TARGET_ATTR_RW(remote_mac);
 564
 565 static struct configfs_attribute *netconsole_target_attrs[] = {
 566         &netconsole_target_enabled.attr,
 567         &netconsole_target_extended.attr,
 568         &netconsole_target_dev_name.attr,
 569         &netconsole_target_local_port.attr,
 570         &netconsole_target_remote_port.attr,
 571         &netconsole_target_local_ip.attr,
 572         &netconsole_target_remote_ip.attr,
 573         &netconsole_target_local_mac.attr,
 574         &netconsole_target_remote_mac.attr,
 575         NULL,
 576 };
 577
 578 /*
 579  * Item operations and type for netconsole_target.
 580  */
 581
 582 static void netconsole_target_release(struct config_item *item)
 583 {
 584         kfree(to_target(item));
 585 }
 586
 587 static ssize_t netconsole_target_attr_show(struct config_item *item,
 588                                            struct configfs_attribute *attr,
 589                                            char *buf)
 590 {
 591         ssize_t ret = -EINVAL;
 592         struct netconsole_target *nt = to_target(item);
 593         struct netconsole_target_attr *na =
 594                 container_of(attr, struct netconsole_target_attr, attr);
 595
 596         if (na->show)
 597                 ret = na->show(nt, buf);
 598
 599         return ret;
 600 }
 601
 602 static ssize_t netconsole_target_attr_store(struct config_item *item,
 603                                             struct configfs_attribute *attr,
 604                                             const char *buf,
 605                                             size_t count)
 606 {
 607         ssize_t ret = -EINVAL;
 608         struct netconsole_target *nt = to_target(item);
 609         struct netconsole_target_attr *na =
 610                 container_of(attr, struct netconsole_target_attr, attr);
 611
 612         mutex_lock(&dynamic_netconsole_mutex);
 613         if (na->store)
 614                 ret = na->store(nt, buf, count);
 615         mutex_unlock(&dynamic_netconsole_mutex);
 616
 617         return ret;
 618 }
 619
 620 static struct configfs_item_operations netconsole_target_item_ops = {
 621         .release                = netconsole_target_release,
 622         .show_attribute         = netconsole_target_attr_show,
 623         .store_attribute        = netconsole_target_attr_store,
 624 };
 625
 626 static struct config_item_type netconsole_target_type = {
 627         .ct_attrs               = netconsole_target_attrs,
 628         .ct_item_ops            = &netconsole_target_item_ops,
 629         .ct_owner               = THIS_MODULE,
 630 };
 631
 632 /*
 633  * Group operations and type for netconsole_subsys.
 634  */
 635
 636 static struct config_item *make_netconsole_target(struct config_group *group,
 637                                                   const char *name)
 638 {
 639         unsigned long flags;
 640         struct netconsole_target *nt;
 641
 642         /*
 643          * Allocate and initialize with defaults.
 644          * Target is disabled at creation (!enabled).
 645          */
 646         nt = kzalloc(sizeof(*nt), GFP_KERNEL);
 647         if (!nt)
 648                 return ERR_PTR(-ENOMEM);
 649
 650         nt->np.name = "netconsole";
 651         strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
 652         nt->np.local_port = 6665;
 653         nt->np.remote_port = 6666;
 654         eth_broadcast_addr(nt->np.remote_mac);
 655
 656         /* Initialize the config_item member */
 657         config_item_init_type_name(&nt->item, name, &netconsole_target_type);
 658
 659         /* Adding, but it is disabled */
 660         spin_lock_irqsave(&target_list_lock, flags);
 661         list_add(&nt->list, &target_list);
 662         spin_unlock_irqrestore(&target_list_lock, flags);
 663
 664         return &nt->item;
 665 }
 666
 667 static void drop_netconsole_target(struct config_group *group,
 668                                    struct config_item *item)
 669 {
 670         unsigned long flags;
 671         struct netconsole_target *nt = to_target(item);
 672
 673         spin_lock_irqsave(&target_list_lock, flags);
 674         list_del(&nt->list);
 675         spin_unlock_irqrestore(&target_list_lock, flags);
 676
 677         /*
 678          * The target may have never been enabled, or was manually disabled
 679          * before being removed so netpoll may have already been cleaned up.
 680          */
 681         if (nt->enabled)
 682                 netpoll_cleanup(&nt->np);
 683
 684         config_item_put(&nt->item);
 685 }
 686
 687 static struct configfs_group_operations netconsole_subsys_group_ops = {
 688         .make_item      = make_netconsole_target,
 689         .drop_item      = drop_netconsole_target,
 690 };
 691
 692 static struct config_item_type netconsole_subsys_type = {
 693         .ct_group_ops   = &netconsole_subsys_group_ops,
 694         .ct_owner       = THIS_MODULE,
 695 };
 696
 697 /* The netconsole configfs subsystem */
 698 static struct configfs_subsystem netconsole_subsys = {
 699         .su_group       = {
 700                 .cg_item        = {
 701                         .ci_namebuf     = "netconsole",
 702                         .ci_type        = &netconsole_subsys_type,
 703                 },
 704         },
 705 };
 706
 707 #endif  /* CONFIG_NETCONSOLE_DYNAMIC */
 708
 709 /* Handle network interface device notifications */
 710 static int netconsole_netdev_event(struct notifier_block *this,
 711                                    unsigned long event, void *ptr)
 712 {
 713         unsigned long flags;
 714         struct netconsole_target *nt;
 715         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 716         bool stopped = false;
 717
 718         if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
 719               event == NETDEV_RELEASE || event == NETDEV_JOIN))
 720                 goto done;
 721
 722         spin_lock_irqsave(&target_list_lock, flags);
 723 restart:
 724         list_for_each_entry(nt, &target_list, list) {
 725                 netconsole_target_get(nt);
 726                 if (nt->np.dev == dev) {
 727                         switch (event) {
 728                         case NETDEV_CHANGENAME:
 729                                 strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
 730                                 break;
 731                         case NETDEV_RELEASE:
 732                         case NETDEV_JOIN:
 733                         case NETDEV_UNREGISTER:
 734                                 /* rtnl_lock already held
 735                                  * we might sleep in __netpoll_cleanup()
 736                                  */
 737                                 spin_unlock_irqrestore(&target_list_lock, flags);
 738
 739                                 __netpoll_cleanup(&nt->np);
 740
 741                                 spin_lock_irqsave(&target_list_lock, flags);
 742                                 dev_put(nt->np.dev);
 743                                 nt->np.dev = NULL;
 744                                 nt->enabled = false;
 745                                 stopped = true;
 746                                 netconsole_target_put(nt);
 747                                 goto restart;
 748                         }
 749                 }
 750                 netconsole_target_put(nt);
 751         }
 752         spin_unlock_irqrestore(&target_list_lock, flags);
 753         if (stopped) {
 754                 const char *msg = "had an event";
 755                 switch (event) {
 756                 case NETDEV_UNREGISTER:
 757                         msg = "unregistered";
 758                         break;
 759                 case NETDEV_RELEASE:
 760                         msg = "released slaves";
 761                         break;
 762                 case NETDEV_JOIN:
 763                         msg = "is joining a master device";
 764                         break;
 765                 }
 766                 pr_info("network logging stopped on interface %s as it %s\n",
 767                         dev->name, msg);
 768         }
 769
 770 done:
 771         return NOTIFY_DONE;
 772 }
 773
 774 static struct notifier_block netconsole_netdev_notifier = {
 775         .notifier_call  = netconsole_netdev_event,
 776 };
 777
 778 /**
 779  * send_ext_msg_udp - send extended log message to target
 780  * @nt: target to send message to
 781  * @msg: extended log message to send
 782  * @msg_len: length of message
 783  *
 784  * Transfer extended log @msg to @nt.  If @msg is longer than
 785  * MAX_PRINT_CHUNK, it'll be split and transmitted in multiple chunks with
 786  * ncfrag header field added to identify them.
 787  */
 788 static void send_ext_msg_udp(struct netconsole_target *nt, const char *msg,
 789                              int msg_len)
 790 {
 791         static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */
 792         const char *header, *body;
 793         int offset = 0;
 794         int header_len, body_len;
 795
 796         if (msg_len <= MAX_PRINT_CHUNK) {
 797                 netpoll_send_udp(&nt->np, msg, msg_len);
 798                 return;
 799         }
 800
 801         /* need to insert extra header fields, detect header and body */
 802         header = msg;
 803         body = memchr(msg, ';', msg_len);
 804         if (WARN_ON_ONCE(!body))
 805                 return;
 806
 807         header_len = body - header;
 808         body_len = msg_len - header_len - 1;
 809         body++;
 810
 811         /*
 812          * Transfer multiple chunks with the following extra header.
 813          * "ncfrag=<byte-offset>/<total-bytes>"
 814          */
 815         memcpy(buf, header, header_len);
 816
 817         while (offset < body_len) {
 818                 int this_header = header_len;
 819                 int this_chunk;
 820
 821                 this_header += scnprintf(buf + this_header,
 822                                          sizeof(buf) - this_header,
 823                                          ",ncfrag=%d/%d;", offset, body_len);
 824
 825                 this_chunk = min(body_len - offset,
 826                                  MAX_PRINT_CHUNK - this_header);
 827                 if (WARN_ON_ONCE(this_chunk <= 0))
 828                         return;
 829
 830                 memcpy(buf + this_header, body + offset, this_chunk);
 831
 832                 netpoll_send_udp(&nt->np, buf, this_header + this_chunk);
 833
 834                 offset += this_chunk;
 835         }
 836 }
 837
 838 static void write_ext_msg(struct console *con, const char *msg,
 839                           unsigned int len)
 840 {
 841         struct netconsole_target *nt;
 842         unsigned long flags;
 843
 844         if ((oops_only && !oops_in_progress) || list_empty(&target_list))
 845                 return;
 846
 847         spin_lock_irqsave(&target_list_lock, flags);
 848         list_for_each_entry(nt, &target_list, list)
 849                 if (nt->extended && nt->enabled && netif_running(nt->np.dev))
 850                         send_ext_msg_udp(nt, msg, len);
 851         spin_unlock_irqrestore(&target_list_lock, flags);
 852 }
 853
 854 static void write_msg(struct console *con, const char *msg, unsigned int len)
 855 {
 856         int frag, left;
 857         unsigned long flags;
 858         struct netconsole_target *nt;
 859         const char *tmp;
 860
 861         if (oops_only && !oops_in_progress)
 862                 return;
 863         /* Avoid taking lock and disabling interrupts unnecessarily */
 864         if (list_empty(&target_list))
 865                 return;
 866
 867         spin_lock_irqsave(&target_list_lock, flags);
 868         list_for_each_entry(nt, &target_list, list) {
 869                 if (!nt->extended && nt->enabled && netif_running(nt->np.dev)) {
 870                         /*
 871                          * We nest this inside the for-each-target loop above
 872                          * so that we're able to get as much logging out to
 873                          * at least one target if we die inside here, instead
 874                          * of unnecessarily keeping all targets in lock-step.
 875                          */
 876                         tmp = msg;
 877                         for (left = len; left;) {
 878                                 frag = min(left, MAX_PRINT_CHUNK);
 879                                 netpoll_send_udp(&nt->np, tmp, frag);
 880                                 tmp += frag;
 881                                 left -= frag;
 882                         }
 883                 }
 884         }
 885         spin_unlock_irqrestore(&target_list_lock, flags);
 886 }
 887
 888 static struct console netconsole_ext = {
 889         .name   = "netcon_ext",
 890         .flags  = CON_EXTENDED, /* starts disabled, registered on first use */
 891         .write  = write_ext_msg,
 892 };
 893
 894 static struct console netconsole = {
 895         .name   = "netcon",
 896         .flags  = CON_ENABLED,
 897         .write  = write_msg,
 898 };
 899
 900 static int __init init_netconsole(void)
 901 {
 902         int err;
 903         struct netconsole_target *nt, *tmp;
 904         unsigned long flags;
 905         char *target_config;
 906         char *input = config;
 907
 908         if (strnlen(input, MAX_PARAM_LENGTH)) {
 909                 while ((target_config = strsep(&input, ";"))) {
 910                         nt = alloc_param_target(target_config);
 911                         if (IS_ERR(nt)) {
 912                                 err = PTR_ERR(nt);
 913                                 goto fail;
 914                         }
 915                         /* Dump existing printks when we register */
 916                         if (nt->extended)
 917                                 netconsole_ext.flags |= CON_PRINTBUFFER |
 918                                                         CON_ENABLED;
 919                         else
 920                                 netconsole.flags |= CON_PRINTBUFFER;
 921
 922                         spin_lock_irqsave(&target_list_lock, flags);
 923                         list_add(&nt->list, &target_list);
 924                         spin_unlock_irqrestore(&target_list_lock, flags);
 925                 }
 926         }
 927
 928         err = register_netdevice_notifier(&netconsole_netdev_notifier);
 929         if (err)
 930                 goto fail;
 931
 932         err = dynamic_netconsole_init();
 933         if (err)
 934                 goto undonotifier;
 935
 936         if (netconsole_ext.flags & CON_ENABLED)
 937                 register_console(&netconsole_ext);
 938         register_console(&netconsole);
 939         pr_info("network logging started\n");
 940
 941         return err;
 942
 943 undonotifier:
 944         unregister_netdevice_notifier(&netconsole_netdev_notifier);
 945
 946 fail:
 947         pr_err("cleaning up\n");
 948
 949         /*
 950          * Remove all targets and destroy them (only targets created
 951          * from the boot/module option exist here). Skipping the list
 952          * lock is safe here, and netpoll_cleanup() will sleep.
 953          */
 954         list_for_each_entry_safe(nt, tmp, &target_list, list) {
 955                 list_del(&nt->list);
 956                 free_param_target(nt);
 957         }
 958
 959         return err;
 960 }
 961
 962 static void __exit cleanup_netconsole(void)
 963 {
 964         struct netconsole_target *nt, *tmp;
 965
 966         unregister_console(&netconsole_ext);
 967         unregister_console(&netconsole);
 968         dynamic_netconsole_exit();
 969         unregister_netdevice_notifier(&netconsole_netdev_notifier);
 970
 971         /*
 972          * Targets created via configfs pin references on our module
 973          * and would first be rmdir(2)'ed from userspace. We reach
 974          * here only when they are already destroyed, and only those
 975          * created from the boot/module option are left, so remove and
 976          * destroy them. Skipping the list lock is safe here, and
 977          * netpoll_cleanup() will sleep.
 978          */
 979         list_for_each_entry_safe(nt, tmp, &target_list, list) {
 980                 list_del(&nt->list);
 981                 free_param_target(nt);
 982         }
 983 }
 984
 985 /*
 986  * Use late_initcall to ensure netconsole is
 987  * initialized after network device driver if built-in.
 988  *
 989  * late_initcall() and module_init() are identical if built as module.
 990  */
 991 late_initcall(init_netconsole);
 992 module_exit(cleanup_netconsole);