drivers/net/netconsole.c

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