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 <[email protected]>
   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 #include <linux/utsname.h>
  40 #include <linux/rtnetlink.h>
  41
  42 MODULE_AUTHOR("Matt Mackall <[email protected]>");
  43 MODULE_DESCRIPTION("Console driver for network interfaces");
  44 MODULE_LICENSE("GPL");
  45
  46 #define MAX_PARAM_LENGTH                256
  47 #define MAX_USERDATA_ENTRY_LENGTH       256
  48 #define MAX_USERDATA_VALUE_LENGTH       200
  49 /* The number 3 comes from userdata entry format characters (' ', '=', '\n') */
  50 #define MAX_USERDATA_NAME_LENGTH        (MAX_USERDATA_ENTRY_LENGTH - \
  51                                         MAX_USERDATA_VALUE_LENGTH - 3)
  52 #define MAX_USERDATA_ITEMS              16
  53 #define MAX_PRINT_CHUNK                 1000
  54
  55 static char config[MAX_PARAM_LENGTH];
  56 module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0);
  57 MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]");
  58
  59 static bool oops_only;
  60 module_param(oops_only, bool, 0600);
  61 MODULE_PARM_DESC(oops_only, "Only log oops messages");
  62
  63 #define NETCONSOLE_PARAM_TARGET_PREFIX "cmdline"
  64
  65 #ifndef MODULE
  66 static int __init option_setup(char *opt)
  67 {
  68         strscpy(config, opt, MAX_PARAM_LENGTH);
  69         return 1;
  70 }
  71 __setup("netconsole=", option_setup);
  72 #endif  /* MODULE */
  73
  74 /* Linked list of all configured targets */
  75 static LIST_HEAD(target_list);
  76 /* target_cleanup_list is used to track targets that need to be cleaned outside
  77  * of target_list_lock. It should be cleaned in the same function it is
  78  * populated.
  79  */
  80 static LIST_HEAD(target_cleanup_list);
  81
  82 /* This needs to be a spinlock because write_msg() cannot sleep */
  83 static DEFINE_SPINLOCK(target_list_lock);
  84 /* This needs to be a mutex because netpoll_cleanup might sleep */
  85 static DEFINE_MUTEX(target_cleanup_list_lock);
  86
  87 /*
  88  * Console driver for extended netconsoles.  Registered on the first use to
  89  * avoid unnecessarily enabling ext message formatting.
  90  */
  91 static struct console netconsole_ext;
  92
  93 /**
  94  * struct netconsole_target - Represents a configured netconsole target.
  95  * @list:       Links this target into the target_list.
  96  * @group:      Links us into the configfs subsystem hierarchy.
  97  * @userdata_group:     Links to the userdata configfs hierarchy
  98  * @userdata_complete:  Cached, formatted string of append
  99  * @userdata_length:    String length of userdata_complete
 100  * @enabled:    On / off knob to enable / disable target.
 101  *              Visible from userspace (read-write).
 102  *              We maintain a strict 1:1 correspondence between this and
 103  *              whether the corresponding netpoll is active or inactive.
 104  *              Also, other parameters of a target may be modified at
 105  *              runtime only when it is disabled (enabled == 0).
 106  * @extended:   Denotes whether console is extended or not.
 107  * @release:    Denotes whether kernel release version should be prepended
 108  *              to the message. Depends on extended console.
 109  * @np:         The netpoll structure for this target.
 110  *              Contains the other userspace visible parameters:
 111  *              dev_name        (read-write)
 112  *              local_port      (read-write)
 113  *              remote_port     (read-write)
 114  *              local_ip        (read-write)
 115  *              remote_ip       (read-write)
 116  *              local_mac       (read-only)
 117  *              remote_mac      (read-write)
 118  */
 119 struct netconsole_target {
 120         struct list_head        list;
 121 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
 122         struct config_group     group;
 123         struct config_group     userdata_group;
 124         char userdata_complete[MAX_USERDATA_ENTRY_LENGTH * MAX_USERDATA_ITEMS];
 125         size_t                  userdata_length;
 126 #endif
 127         bool                    enabled;
 128         bool                    extended;
 129         bool                    release;
 130         struct netpoll          np;
 131 };
 132
 133 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
 134
 135 static struct configfs_subsystem netconsole_subsys;
 136 static DEFINE_MUTEX(dynamic_netconsole_mutex);
 137
 138 static int __init dynamic_netconsole_init(void)
 139 {
 140         config_group_init(&netconsole_subsys.su_group);
 141         mutex_init(&netconsole_subsys.su_mutex);
 142         return configfs_register_subsystem(&netconsole_subsys);
 143 }
 144
 145 static void __exit dynamic_netconsole_exit(void)
 146 {
 147         configfs_unregister_subsystem(&netconsole_subsys);
 148 }
 149
 150 /*
 151  * Targets that were created by parsing the boot/module option string
 152  * do not exist in the configfs hierarchy (and have NULL names) and will
 153  * never go away, so make these a no-op for them.
 154  */
 155 static void netconsole_target_get(struct netconsole_target *nt)
 156 {
 157         if (config_item_name(&nt->group.cg_item))
 158                 config_group_get(&nt->group);
 159 }
 160
 161 static void netconsole_target_put(struct netconsole_target *nt)
 162 {
 163         if (config_item_name(&nt->group.cg_item))
 164                 config_group_put(&nt->group);
 165 }
 166
 167 #else   /* !CONFIG_NETCONSOLE_DYNAMIC */
 168
 169 static int __init dynamic_netconsole_init(void)
 170 {
 171         return 0;
 172 }
 173
 174 static void __exit dynamic_netconsole_exit(void)
 175 {
 176 }
 177
 178 /*
 179  * No danger of targets going away from under us when dynamic
 180  * reconfigurability is off.
 181  */
 182 static void netconsole_target_get(struct netconsole_target *nt)
 183 {
 184 }
 185
 186 static void netconsole_target_put(struct netconsole_target *nt)
 187 {
 188 }
 189
 190 static void populate_configfs_item(struct netconsole_target *nt,
 191                                    int cmdline_count)
 192 {
 193 }
 194 #endif  /* CONFIG_NETCONSOLE_DYNAMIC */
 195
 196 /* Allocate and initialize with defaults.
 197  * Note that these targets get their config_item fields zeroed-out.
 198  */
 199 static struct netconsole_target *alloc_and_init(void)
 200 {
 201         struct netconsole_target *nt;
 202
 203         nt = kzalloc(sizeof(*nt), GFP_KERNEL);
 204         if (!nt)
 205                 return nt;
 206
 207         if (IS_ENABLED(CONFIG_NETCONSOLE_EXTENDED_LOG))
 208                 nt->extended = true;
 209         if (IS_ENABLED(CONFIG_NETCONSOLE_PREPEND_RELEASE))
 210                 nt->release = true;
 211
 212         nt->np.name = "netconsole";
 213         strscpy(nt->np.dev_name, "eth0", IFNAMSIZ);
 214         nt->np.local_port = 6665;
 215         nt->np.remote_port = 6666;
 216         eth_broadcast_addr(nt->np.remote_mac);
 217
 218         return nt;
 219 }
 220
 221 /* Clean up every target in the cleanup_list and move the clean targets back to
 222  * the main target_list.
 223  */
 224 static void netconsole_process_cleanups_core(void)
 225 {
 226         struct netconsole_target *nt, *tmp;
 227         unsigned long flags;
 228
 229         /* The cleanup needs RTNL locked */
 230         ASSERT_RTNL();
 231
 232         mutex_lock(&target_cleanup_list_lock);
 233         list_for_each_entry_safe(nt, tmp, &target_cleanup_list, list) {
 234                 /* all entries in the cleanup_list needs to be disabled */
 235                 WARN_ON_ONCE(nt->enabled);
 236                 do_netpoll_cleanup(&nt->np);
 237                 /* moved the cleaned target to target_list. Need to hold both
 238                  * locks
 239                  */
 240                 spin_lock_irqsave(&target_list_lock, flags);
 241                 list_move(&nt->list, &target_list);
 242                 spin_unlock_irqrestore(&target_list_lock, flags);
 243         }
 244         WARN_ON_ONCE(!list_empty(&target_cleanup_list));
 245         mutex_unlock(&target_cleanup_list_lock);
 246 }
 247
 248 #ifdef  CONFIG_NETCONSOLE_DYNAMIC
 249
 250 /*
 251  * Our subsystem hierarchy is:
 252  *
 253  * /sys/kernel/config/netconsole/
 254  *                              |
 255  *                              <target>/
 256  *                              |       enabled
 257  *                              |       release
 258  *                              |       dev_name
 259  *                              |       local_port
 260  *                              |       remote_port
 261  *                              |       local_ip
 262  *                              |       remote_ip
 263  *                              |       local_mac
 264  *                              |       remote_mac
 265  *                              |       userdata/
 266  *                              |               <key>/
 267  *                              |                       value
 268  *                              |               ...
 269  *                              |
 270  *                              <target>/...
 271  */
 272
 273 static struct netconsole_target *to_target(struct config_item *item)
 274 {
 275         struct config_group *cfg_group;
 276
 277         cfg_group = to_config_group(item);
 278         if (!cfg_group)
 279                 return NULL;
 280         return container_of(to_config_group(item),
 281                             struct netconsole_target, group);
 282 }
 283
 284 /* Do the list cleanup with the rtnl lock hold.  rtnl lock is necessary because
 285  * netdev might be cleaned-up by calling __netpoll_cleanup(),
 286  */
 287 static void netconsole_process_cleanups(void)
 288 {
 289         /* rtnl lock is called here, because it has precedence over
 290          * target_cleanup_list_lock mutex and target_cleanup_list
 291          */
 292         rtnl_lock();
 293         netconsole_process_cleanups_core();
 294         rtnl_unlock();
 295 }
 296
 297 /* Get rid of possible trailing newline, returning the new length */
 298 static void trim_newline(char *s, size_t maxlen)
 299 {
 300         size_t len;
 301
 302         len = strnlen(s, maxlen);
 303         if (s[len - 1] == '\n')
 304                 s[len - 1] = '\0';
 305 }
 306
 307 /*
 308  * Attribute operations for netconsole_target.
 309  */
 310
 311 static ssize_t enabled_show(struct config_item *item, char *buf)
 312 {
 313         return sysfs_emit(buf, "%d\n", to_target(item)->enabled);
 314 }
 315
 316 static ssize_t extended_show(struct config_item *item, char *buf)
 317 {
 318         return sysfs_emit(buf, "%d\n", to_target(item)->extended);
 319 }
 320
 321 static ssize_t release_show(struct config_item *item, char *buf)
 322 {
 323         return sysfs_emit(buf, "%d\n", to_target(item)->release);
 324 }
 325
 326 static ssize_t dev_name_show(struct config_item *item, char *buf)
 327 {
 328         return sysfs_emit(buf, "%s\n", to_target(item)->np.dev_name);
 329 }
 330
 331 static ssize_t local_port_show(struct config_item *item, char *buf)
 332 {
 333         return sysfs_emit(buf, "%d\n", to_target(item)->np.local_port);
 334 }
 335
 336 static ssize_t remote_port_show(struct config_item *item, char *buf)
 337 {
 338         return sysfs_emit(buf, "%d\n", to_target(item)->np.remote_port);
 339 }
 340
 341 static ssize_t local_ip_show(struct config_item *item, char *buf)
 342 {
 343         struct netconsole_target *nt = to_target(item);
 344
 345         if (nt->np.ipv6)
 346                 return sysfs_emit(buf, "%pI6c\n", &nt->np.local_ip.in6);
 347         else
 348                 return sysfs_emit(buf, "%pI4\n", &nt->np.local_ip);
 349 }
 350
 351 static ssize_t remote_ip_show(struct config_item *item, char *buf)
 352 {
 353         struct netconsole_target *nt = to_target(item);
 354
 355         if (nt->np.ipv6)
 356                 return sysfs_emit(buf, "%pI6c\n", &nt->np.remote_ip.in6);
 357         else
 358                 return sysfs_emit(buf, "%pI4\n", &nt->np.remote_ip);
 359 }
 360
 361 static ssize_t local_mac_show(struct config_item *item, char *buf)
 362 {
 363         struct net_device *dev = to_target(item)->np.dev;
 364         static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 365
 366         return sysfs_emit(buf, "%pM\n", dev ? dev->dev_addr : bcast);
 367 }
 368
 369 static ssize_t remote_mac_show(struct config_item *item, char *buf)
 370 {
 371         return sysfs_emit(buf, "%pM\n", to_target(item)->np.remote_mac);
 372 }
 373
 374 /*
 375  * This one is special -- targets created through the configfs interface
 376  * are not enabled (and the corresponding netpoll activated) by default.
 377  * The user is expected to set the desired parameters first (which
 378  * would enable him to dynamically add new netpoll targets for new
 379  * network interfaces as and when they come up).
 380  */
 381 static ssize_t enabled_store(struct config_item *item,
 382                 const char *buf, size_t count)
 383 {
 384         struct netconsole_target *nt = to_target(item);
 385         unsigned long flags;
 386         bool enabled;
 387         ssize_t ret;
 388
 389         mutex_lock(&dynamic_netconsole_mutex);
 390         ret = kstrtobool(buf, &enabled);
 391         if (ret)
 392                 goto out_unlock;
 393
 394         ret = -EINVAL;
 395         if (enabled == nt->enabled) {
 396                 pr_info("network logging has already %s\n",
 397                         nt->enabled ? "started" : "stopped");
 398                 goto out_unlock;
 399         }
 400
 401         if (enabled) {  /* true */
 402                 if (nt->release && !nt->extended) {
 403                         pr_err("Not enabling netconsole. Release feature requires extended log message");
 404                         goto out_unlock;
 405                 }
 406
 407                 if (nt->extended && !console_is_registered(&netconsole_ext))
 408                         register_console(&netconsole_ext);
 409
 410                 /*
 411                  * Skip netpoll_parse_options() -- all the attributes are
 412                  * already configured via configfs. Just print them out.
 413                  */
 414                 netpoll_print_options(&nt->np);
 415
 416                 ret = netpoll_setup(&nt->np);
 417                 if (ret)
 418                         goto out_unlock;
 419
 420                 nt->enabled = true;
 421                 pr_info("network logging started\n");
 422         } else {        /* false */
 423                 /* We need to disable the netconsole before cleaning it up
 424                  * otherwise we might end up in write_msg() with
 425                  * nt->np.dev == NULL and nt->enabled == true
 426                  */
 427                 mutex_lock(&target_cleanup_list_lock);
 428                 spin_lock_irqsave(&target_list_lock, flags);
 429                 nt->enabled = false;
 430                 /* Remove the target from the list, while holding
 431                  * target_list_lock
 432                  */
 433                 list_move(&nt->list, &target_cleanup_list);
 434                 spin_unlock_irqrestore(&target_list_lock, flags);
 435                 mutex_unlock(&target_cleanup_list_lock);
 436         }
 437
 438         ret = strnlen(buf, count);
 439         /* Deferred cleanup */
 440         netconsole_process_cleanups();
 441 out_unlock:
 442         mutex_unlock(&dynamic_netconsole_mutex);
 443         return ret;
 444 }
 445
 446 static ssize_t release_store(struct config_item *item, const char *buf,
 447                              size_t count)
 448 {
 449         struct netconsole_target *nt = to_target(item);
 450         bool release;
 451         ssize_t ret;
 452
 453         mutex_lock(&dynamic_netconsole_mutex);
 454         if (nt->enabled) {
 455                 pr_err("target (%s) is enabled, disable to update parameters\n",
 456                        config_item_name(&nt->group.cg_item));
 457                 ret = -EINVAL;
 458                 goto out_unlock;
 459         }
 460
 461         ret = kstrtobool(buf, &release);
 462         if (ret)
 463                 goto out_unlock;
 464
 465         nt->release = release;
 466
 467         ret = strnlen(buf, count);
 468 out_unlock:
 469         mutex_unlock(&dynamic_netconsole_mutex);
 470         return ret;
 471 }
 472
 473 static ssize_t extended_store(struct config_item *item, const char *buf,
 474                 size_t count)
 475 {
 476         struct netconsole_target *nt = to_target(item);
 477         bool extended;
 478         ssize_t ret;
 479
 480         mutex_lock(&dynamic_netconsole_mutex);
 481         if (nt->enabled) {
 482                 pr_err("target (%s) is enabled, disable to update parameters\n",
 483                        config_item_name(&nt->group.cg_item));
 484                 ret = -EINVAL;
 485                 goto out_unlock;
 486         }
 487
 488         ret = kstrtobool(buf, &extended);
 489         if (ret)
 490                 goto out_unlock;
 491
 492         nt->extended = extended;
 493         ret = strnlen(buf, count);
 494 out_unlock:
 495         mutex_unlock(&dynamic_netconsole_mutex);
 496         return ret;
 497 }
 498
 499 static ssize_t dev_name_store(struct config_item *item, const char *buf,
 500                 size_t count)
 501 {
 502         struct netconsole_target *nt = to_target(item);
 503
 504         mutex_lock(&dynamic_netconsole_mutex);
 505         if (nt->enabled) {
 506                 pr_err("target (%s) is enabled, disable to update parameters\n",
 507                        config_item_name(&nt->group.cg_item));
 508                 mutex_unlock(&dynamic_netconsole_mutex);
 509                 return -EINVAL;
 510         }
 511
 512         strscpy(nt->np.dev_name, buf, IFNAMSIZ);
 513         trim_newline(nt->np.dev_name, IFNAMSIZ);
 514
 515         mutex_unlock(&dynamic_netconsole_mutex);
 516         return strnlen(buf, count);
 517 }
 518
 519 static ssize_t local_port_store(struct config_item *item, const char *buf,
 520                 size_t count)
 521 {
 522         struct netconsole_target *nt = to_target(item);
 523         ssize_t ret = -EINVAL;
 524
 525         mutex_lock(&dynamic_netconsole_mutex);
 526         if (nt->enabled) {
 527                 pr_err("target (%s) is enabled, disable to update parameters\n",
 528                        config_item_name(&nt->group.cg_item));
 529                 goto out_unlock;
 530         }
 531
 532         ret = kstrtou16(buf, 10, &nt->np.local_port);
 533         if (ret < 0)
 534                 goto out_unlock;
 535         ret = strnlen(buf, count);
 536 out_unlock:
 537         mutex_unlock(&dynamic_netconsole_mutex);
 538         return ret;
 539 }
 540
 541 static ssize_t remote_port_store(struct config_item *item,
 542                 const char *buf, size_t count)
 543 {
 544         struct netconsole_target *nt = to_target(item);
 545         ssize_t ret = -EINVAL;
 546
 547         mutex_lock(&dynamic_netconsole_mutex);
 548         if (nt->enabled) {
 549                 pr_err("target (%s) is enabled, disable to update parameters\n",
 550                        config_item_name(&nt->group.cg_item));
 551                 goto out_unlock;
 552         }
 553
 554         ret = kstrtou16(buf, 10, &nt->np.remote_port);
 555         if (ret < 0)
 556                 goto out_unlock;
 557         ret = strnlen(buf, count);
 558 out_unlock:
 559         mutex_unlock(&dynamic_netconsole_mutex);
 560         return ret;
 561 }
 562
 563 static ssize_t local_ip_store(struct config_item *item, const char *buf,
 564                 size_t count)
 565 {
 566         struct netconsole_target *nt = to_target(item);
 567         ssize_t ret = -EINVAL;
 568
 569         mutex_lock(&dynamic_netconsole_mutex);
 570         if (nt->enabled) {
 571                 pr_err("target (%s) is enabled, disable to update parameters\n",
 572                        config_item_name(&nt->group.cg_item));
 573                 goto out_unlock;
 574         }
 575
 576         if (strnchr(buf, count, ':')) {
 577                 const char *end;
 578
 579                 if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) {
 580                         if (*end && *end != '\n') {
 581                                 pr_err("invalid IPv6 address at: <%c>\n", *end);
 582                                 goto out_unlock;
 583                         }
 584                         nt->np.ipv6 = true;
 585                 } else
 586                         goto out_unlock;
 587         } else {
 588                 if (!nt->np.ipv6)
 589                         nt->np.local_ip.ip = in_aton(buf);
 590                 else
 591                         goto out_unlock;
 592         }
 593
 594         ret = strnlen(buf, count);
 595 out_unlock:
 596         mutex_unlock(&dynamic_netconsole_mutex);
 597         return ret;
 598 }
 599
 600 static ssize_t remote_ip_store(struct config_item *item, const char *buf,
 601                size_t count)
 602 {
 603         struct netconsole_target *nt = to_target(item);
 604         ssize_t ret = -EINVAL;
 605
 606         mutex_lock(&dynamic_netconsole_mutex);
 607         if (nt->enabled) {
 608                 pr_err("target (%s) is enabled, disable to update parameters\n",
 609                        config_item_name(&nt->group.cg_item));
 610                 goto out_unlock;
 611         }
 612
 613         if (strnchr(buf, count, ':')) {
 614                 const char *end;
 615
 616                 if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) {
 617                         if (*end && *end != '\n') {
 618                                 pr_err("invalid IPv6 address at: <%c>\n", *end);
 619                                 goto out_unlock;
 620                         }
 621                         nt->np.ipv6 = true;
 622                 } else
 623                         goto out_unlock;
 624         } else {
 625                 if (!nt->np.ipv6)
 626                         nt->np.remote_ip.ip = in_aton(buf);
 627                 else
 628                         goto out_unlock;
 629         }
 630
 631         ret = strnlen(buf, count);
 632 out_unlock:
 633         mutex_unlock(&dynamic_netconsole_mutex);
 634         return ret;
 635 }
 636
 637 static ssize_t remote_mac_store(struct config_item *item, const char *buf,
 638                 size_t count)
 639 {
 640         struct netconsole_target *nt = to_target(item);
 641         u8 remote_mac[ETH_ALEN];
 642         ssize_t ret = -EINVAL;
 643
 644         mutex_lock(&dynamic_netconsole_mutex);
 645         if (nt->enabled) {
 646                 pr_err("target (%s) is enabled, disable to update parameters\n",
 647                        config_item_name(&nt->group.cg_item));
 648                 goto out_unlock;
 649         }
 650
 651         if (!mac_pton(buf, remote_mac))
 652                 goto out_unlock;
 653         if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n')
 654                 goto out_unlock;
 655         memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
 656
 657         ret = strnlen(buf, count);
 658 out_unlock:
 659         mutex_unlock(&dynamic_netconsole_mutex);
 660         return ret;
 661 }
 662
 663 struct userdatum {
 664         struct config_item item;
 665         char value[MAX_USERDATA_VALUE_LENGTH];
 666 };
 667
 668 static struct userdatum *to_userdatum(struct config_item *item)
 669 {
 670         return container_of(item, struct userdatum, item);
 671 }
 672
 673 struct userdata {
 674         struct config_group group;
 675 };
 676
 677 static struct userdata *to_userdata(struct config_item *item)
 678 {
 679         return container_of(to_config_group(item), struct userdata, group);
 680 }
 681
 682 static struct netconsole_target *userdata_to_target(struct userdata *ud)
 683 {
 684         struct config_group *netconsole_group;
 685
 686         netconsole_group = to_config_group(ud->group.cg_item.ci_parent);
 687         return to_target(&netconsole_group->cg_item);
 688 }
 689
 690 static ssize_t userdatum_value_show(struct config_item *item, char *buf)
 691 {
 692         return sysfs_emit(buf, "%s\n", &(to_userdatum(item)->value[0]));
 693 }
 694
 695 static void update_userdata(struct netconsole_target *nt)
 696 {
 697         int complete_idx = 0, child_count = 0;
 698         struct list_head *entry;
 699
 700         /* Clear the current string in case the last userdatum was deleted */
 701         nt->userdata_length = 0;
 702         nt->userdata_complete[0] = 0;
 703
 704         list_for_each(entry, &nt->userdata_group.cg_children) {
 705                 struct userdatum *udm_item;
 706                 struct config_item *item;
 707
 708                 if (child_count >= MAX_USERDATA_ITEMS)
 709                         break;
 710                 child_count++;
 711
 712                 item = container_of(entry, struct config_item, ci_entry);
 713                 udm_item = to_userdatum(item);
 714
 715                 /* Skip userdata with no value set */
 716                 if (strnlen(udm_item->value, MAX_USERDATA_VALUE_LENGTH) == 0)
 717                         continue;
 718
 719                 /* This doesn't overflow userdata_complete since it will write
 720                  * one entry length (1/MAX_USERDATA_ITEMS long), entry count is
 721                  * checked to not exceed MAX items with child_count above
 722                  */
 723                 complete_idx += scnprintf(&nt->userdata_complete[complete_idx],
 724                                           MAX_USERDATA_ENTRY_LENGTH, " %s=%s\n",
 725                                           item->ci_name, udm_item->value);
 726         }
 727         nt->userdata_length = strnlen(nt->userdata_complete,
 728                                       sizeof(nt->userdata_complete));
 729 }
 730
 731 static ssize_t userdatum_value_store(struct config_item *item, const char *buf,
 732                                      size_t count)
 733 {
 734         struct userdatum *udm = to_userdatum(item);
 735         struct netconsole_target *nt;
 736         struct userdata *ud;
 737         ssize_t ret;
 738
 739         if (count > MAX_USERDATA_VALUE_LENGTH)
 740                 return -EMSGSIZE;
 741
 742         mutex_lock(&dynamic_netconsole_mutex);
 743
 744         ret = strscpy(udm->value, buf, sizeof(udm->value));
 745         if (ret < 0)
 746                 goto out_unlock;
 747         trim_newline(udm->value, sizeof(udm->value));
 748
 749         ud = to_userdata(item->ci_parent);
 750         nt = userdata_to_target(ud);
 751         update_userdata(nt);
 752         ret = count;
 753 out_unlock:
 754         mutex_unlock(&dynamic_netconsole_mutex);
 755         return ret;
 756 }
 757
 758 CONFIGFS_ATTR(userdatum_, value);
 759
 760 static struct configfs_attribute *userdatum_attrs[] = {
 761         &userdatum_attr_value,
 762         NULL,
 763 };
 764
 765 static void userdatum_release(struct config_item *item)
 766 {
 767         kfree(to_userdatum(item));
 768 }
 769
 770 static struct configfs_item_operations userdatum_ops = {
 771         .release = userdatum_release,
 772 };
 773
 774 static const struct config_item_type userdatum_type = {
 775         .ct_item_ops    = &userdatum_ops,
 776         .ct_attrs       = userdatum_attrs,
 777         .ct_owner       = THIS_MODULE,
 778 };
 779
 780 static struct config_item *userdatum_make_item(struct config_group *group,
 781                                                const char *name)
 782 {
 783         struct netconsole_target *nt;
 784         struct userdatum *udm;
 785         struct userdata *ud;
 786         size_t child_count;
 787
 788         if (strlen(name) > MAX_USERDATA_NAME_LENGTH)
 789                 return ERR_PTR(-ENAMETOOLONG);
 790
 791         ud = to_userdata(&group->cg_item);
 792         nt = userdata_to_target(ud);
 793         child_count = list_count_nodes(&nt->userdata_group.cg_children);
 794         if (child_count >= MAX_USERDATA_ITEMS)
 795                 return ERR_PTR(-ENOSPC);
 796
 797         udm = kzalloc(sizeof(*udm), GFP_KERNEL);
 798         if (!udm)
 799                 return ERR_PTR(-ENOMEM);
 800
 801         config_item_init_type_name(&udm->item, name, &userdatum_type);
 802         return &udm->item;
 803 }
 804
 805 static void userdatum_drop(struct config_group *group, struct config_item *item)
 806 {
 807         struct netconsole_target *nt;
 808         struct userdata *ud;
 809
 810         ud = to_userdata(&group->cg_item);
 811         nt = userdata_to_target(ud);
 812
 813         mutex_lock(&dynamic_netconsole_mutex);
 814         update_userdata(nt);
 815         config_item_put(item);
 816         mutex_unlock(&dynamic_netconsole_mutex);
 817 }
 818
 819 static struct configfs_attribute *userdata_attrs[] = {
 820         NULL,
 821 };
 822
 823 static struct configfs_group_operations userdata_ops = {
 824         .make_item              = userdatum_make_item,
 825         .drop_item              = userdatum_drop,
 826 };
 827
 828 static const struct config_item_type userdata_type = {
 829         .ct_item_ops    = &userdatum_ops,
 830         .ct_group_ops   = &userdata_ops,
 831         .ct_attrs       = userdata_attrs,
 832         .ct_owner       = THIS_MODULE,
 833 };
 834
 835 CONFIGFS_ATTR(, enabled);
 836 CONFIGFS_ATTR(, extended);
 837 CONFIGFS_ATTR(, dev_name);
 838 CONFIGFS_ATTR(, local_port);
 839 CONFIGFS_ATTR(, remote_port);
 840 CONFIGFS_ATTR(, local_ip);
 841 CONFIGFS_ATTR(, remote_ip);
 842 CONFIGFS_ATTR_RO(, local_mac);
 843 CONFIGFS_ATTR(, remote_mac);
 844 CONFIGFS_ATTR(, release);
 845
 846 static struct configfs_attribute *netconsole_target_attrs[] = {
 847         &attr_enabled,
 848         &attr_extended,
 849         &attr_release,
 850         &attr_dev_name,
 851         &attr_local_port,
 852         &attr_remote_port,
 853         &attr_local_ip,
 854         &attr_remote_ip,
 855         &attr_local_mac,
 856         &attr_remote_mac,
 857         NULL,
 858 };
 859
 860 /*
 861  * Item operations and type for netconsole_target.
 862  */
 863
 864 static void netconsole_target_release(struct config_item *item)
 865 {
 866         kfree(to_target(item));
 867 }
 868
 869 static struct configfs_item_operations netconsole_target_item_ops = {
 870         .release                = netconsole_target_release,
 871 };
 872
 873 static const struct config_item_type netconsole_target_type = {
 874         .ct_attrs               = netconsole_target_attrs,
 875         .ct_item_ops            = &netconsole_target_item_ops,
 876         .ct_owner               = THIS_MODULE,
 877 };
 878
 879 static void init_target_config_group(struct netconsole_target *nt,
 880                                      const char *name)
 881 {
 882         config_group_init_type_name(&nt->group, name, &netconsole_target_type);
 883         config_group_init_type_name(&nt->userdata_group, "userdata",
 884                                     &userdata_type);
 885         configfs_add_default_group(&nt->userdata_group, &nt->group);
 886 }
 887
 888 static struct netconsole_target *find_cmdline_target(const char *name)
 889 {
 890         struct netconsole_target *nt, *ret = NULL;
 891         unsigned long flags;
 892
 893         spin_lock_irqsave(&target_list_lock, flags);
 894         list_for_each_entry(nt, &target_list, list) {
 895                 if (!strcmp(nt->group.cg_item.ci_name, name)) {
 896                         ret = nt;
 897                         break;
 898                 }
 899         }
 900         spin_unlock_irqrestore(&target_list_lock, flags);
 901
 902         return ret;
 903 }
 904
 905 /*
 906  * Group operations and type for netconsole_subsys.
 907  */
 908
 909 static struct config_group *make_netconsole_target(struct config_group *group,
 910                                                    const char *name)
 911 {
 912         struct netconsole_target *nt;
 913         unsigned long flags;
 914
 915         /* Checking if a target by this name was created at boot time.  If so,
 916          * attach a configfs entry to that target.  This enables dynamic
 917          * control.
 918          */
 919         if (!strncmp(name, NETCONSOLE_PARAM_TARGET_PREFIX,
 920                      strlen(NETCONSOLE_PARAM_TARGET_PREFIX))) {
 921                 nt = find_cmdline_target(name);
 922                 if (nt) {
 923                         init_target_config_group(nt, name);
 924                         return &nt->group;
 925                 }
 926         }
 927
 928         nt = alloc_and_init();
 929         if (!nt)
 930                 return ERR_PTR(-ENOMEM);
 931
 932         /* Initialize the config_group member */
 933         init_target_config_group(nt, name);
 934
 935         /* Adding, but it is disabled */
 936         spin_lock_irqsave(&target_list_lock, flags);
 937         list_add(&nt->list, &target_list);
 938         spin_unlock_irqrestore(&target_list_lock, flags);
 939
 940         return &nt->group;
 941 }
 942
 943 static void drop_netconsole_target(struct config_group *group,
 944                                    struct config_item *item)
 945 {
 946         unsigned long flags;
 947         struct netconsole_target *nt = to_target(item);
 948
 949         spin_lock_irqsave(&target_list_lock, flags);
 950         list_del(&nt->list);
 951         spin_unlock_irqrestore(&target_list_lock, flags);
 952
 953         /*
 954          * The target may have never been enabled, or was manually disabled
 955          * before being removed so netpoll may have already been cleaned up.
 956          */
 957         if (nt->enabled)
 958                 netpoll_cleanup(&nt->np);
 959
 960         config_item_put(&nt->group.cg_item);
 961 }
 962
 963 static struct configfs_group_operations netconsole_subsys_group_ops = {
 964         .make_group     = make_netconsole_target,
 965         .drop_item      = drop_netconsole_target,
 966 };
 967
 968 static const struct config_item_type netconsole_subsys_type = {
 969         .ct_group_ops   = &netconsole_subsys_group_ops,
 970         .ct_owner       = THIS_MODULE,
 971 };
 972
 973 /* The netconsole configfs subsystem */
 974 static struct configfs_subsystem netconsole_subsys = {
 975         .su_group       = {
 976                 .cg_item        = {
 977                         .ci_namebuf     = "netconsole",
 978                         .ci_type        = &netconsole_subsys_type,
 979                 },
 980         },
 981 };
 982
 983 static void populate_configfs_item(struct netconsole_target *nt,
 984                                    int cmdline_count)
 985 {
 986         char target_name[16];
 987
 988         snprintf(target_name, sizeof(target_name), "%s%d",
 989                  NETCONSOLE_PARAM_TARGET_PREFIX, cmdline_count);
 990         init_target_config_group(nt, target_name);
 991 }
 992
 993 #endif  /* CONFIG_NETCONSOLE_DYNAMIC */
 994
 995 /* Handle network interface device notifications */
 996 static int netconsole_netdev_event(struct notifier_block *this,
 997                                    unsigned long event, void *ptr)
 998 {
 999         unsigned long flags;
1000         struct netconsole_target *nt, *tmp;
1001         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1002         bool stopped = false;
1003
1004         if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
1005               event == NETDEV_RELEASE || event == NETDEV_JOIN))
1006                 goto done;
1007
1008         mutex_lock(&target_cleanup_list_lock);
1009         spin_lock_irqsave(&target_list_lock, flags);
1010         list_for_each_entry_safe(nt, tmp, &target_list, list) {
1011                 netconsole_target_get(nt);
1012                 if (nt->np.dev == dev) {
1013                         switch (event) {
1014                         case NETDEV_CHANGENAME:
1015                                 strscpy(nt->np.dev_name, dev->name, IFNAMSIZ);
1016                                 break;
1017                         case NETDEV_RELEASE:
1018                         case NETDEV_JOIN:
1019                         case NETDEV_UNREGISTER:
1020                                 nt->enabled = false;
1021                                 list_move(&nt->list, &target_cleanup_list);
1022                                 stopped = true;
1023                         }
1024                 }
1025                 netconsole_target_put(nt);
1026         }
1027         spin_unlock_irqrestore(&target_list_lock, flags);
1028         mutex_unlock(&target_cleanup_list_lock);
1029
1030         if (stopped) {
1031                 const char *msg = "had an event";
1032
1033                 switch (event) {
1034                 case NETDEV_UNREGISTER:
1035                         msg = "unregistered";
1036                         break;
1037                 case NETDEV_RELEASE:
1038                         msg = "released slaves";
1039                         break;
1040                 case NETDEV_JOIN:
1041                         msg = "is joining a master device";
1042                         break;
1043                 }
1044                 pr_info("network logging stopped on interface %s as it %s\n",
1045                         dev->name, msg);
1046         }
1047
1048         /* Process target_cleanup_list entries. By the end, target_cleanup_list
1049          * should be empty
1050          */
1051         netconsole_process_cleanups_core();
1052
1053 done:
1054         return NOTIFY_DONE;
1055 }
1056
1057 static struct notifier_block netconsole_netdev_notifier = {
1058         .notifier_call  = netconsole_netdev_event,
1059 };
1060
1061 /**
1062  * send_ext_msg_udp - send extended log message to target
1063  * @nt: target to send message to
1064  * @msg: extended log message to send
1065  * @msg_len: length of message
1066  *
1067  * Transfer extended log @msg to @nt.  If @msg is longer than
1068  * MAX_PRINT_CHUNK, it'll be split and transmitted in multiple chunks with
1069  * ncfrag header field added to identify them.
1070  */
1071 static void send_ext_msg_udp(struct netconsole_target *nt, const char *msg,
1072                              int msg_len)
1073 {
1074         static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */
1075         const char *header, *body;
1076         int offset = 0;
1077         int header_len, body_len;
1078         const char *msg_ready = msg;
1079         const char *release;
1080         int release_len = 0;
1081         int userdata_len = 0;
1082         char *userdata = NULL;
1083
1084 #ifdef CONFIG_NETCONSOLE_DYNAMIC
1085         userdata = nt->userdata_complete;
1086         userdata_len = nt->userdata_length;
1087 #endif
1088
1089         if (nt->release) {
1090                 release = init_utsname()->release;
1091                 release_len = strlen(release) + 1;
1092         }
1093
1094         if (msg_len + release_len + userdata_len <= MAX_PRINT_CHUNK) {
1095                 /* No fragmentation needed */
1096                 if (nt->release) {
1097                         scnprintf(buf, MAX_PRINT_CHUNK, "%s,%s", release, msg);
1098                         msg_len += release_len;
1099                 } else {
1100                         memcpy(buf, msg, msg_len);
1101                 }
1102
1103                 if (userdata)
1104                         msg_len += scnprintf(&buf[msg_len],
1105                                              MAX_PRINT_CHUNK - msg_len,
1106                                              "%s", userdata);
1107
1108                 msg_ready = buf;
1109                 netpoll_send_udp(&nt->np, msg_ready, msg_len);
1110                 return;
1111         }
1112
1113         /* need to insert extra header fields, detect header and body */
1114         header = msg;
1115         body = memchr(msg, ';', msg_len);
1116         if (WARN_ON_ONCE(!body))
1117                 return;
1118
1119         header_len = body - header;
1120         body_len = msg_len - header_len - 1;
1121         body++;
1122
1123         /*
1124          * Transfer multiple chunks with the following extra header.
1125          * "ncfrag=<byte-offset>/<total-bytes>"
1126          */
1127         if (nt->release)
1128                 scnprintf(buf, MAX_PRINT_CHUNK, "%s,", release);
1129         memcpy(buf + release_len, header, header_len);
1130         header_len += release_len;
1131
1132         while (offset < body_len + userdata_len) {
1133                 int this_header = header_len;
1134                 int this_offset = 0;
1135                 int this_chunk = 0;
1136
1137                 this_header += scnprintf(buf + this_header,
1138                                          sizeof(buf) - this_header,
1139                                          ",ncfrag=%d/%d;", offset,
1140                                          body_len + userdata_len);
1141
1142                 /* Not all body data has been written yet */
1143                 if (offset < body_len) {
1144                         this_chunk = min(body_len - offset,
1145                                          MAX_PRINT_CHUNK - this_header);
1146                         if (WARN_ON_ONCE(this_chunk <= 0))
1147                                 return;
1148                         memcpy(buf + this_header, body + offset, this_chunk);
1149                         this_offset += this_chunk;
1150                 }
1151                 /* Body is fully written and there is pending userdata to write,
1152                  * append userdata in this chunk
1153                  */
1154                 if (offset + this_offset >= body_len &&
1155                     offset + this_offset < userdata_len + body_len) {
1156                         int sent_userdata = (offset + this_offset) - body_len;
1157                         int preceding_bytes = this_chunk + this_header;
1158
1159                         if (WARN_ON_ONCE(sent_userdata < 0))
1160                                 return;
1161
1162                         this_chunk = min(userdata_len - sent_userdata,
1163                                          MAX_PRINT_CHUNK - preceding_bytes);
1164                         if (WARN_ON_ONCE(this_chunk <= 0))
1165                                 return;
1166                         memcpy(buf + this_header + this_offset,
1167                                userdata + sent_userdata,
1168                                this_chunk);
1169                         this_offset += this_chunk;
1170                 }
1171
1172                 netpoll_send_udp(&nt->np, buf, this_header + this_offset);
1173                 offset += this_offset;
1174         }
1175 }
1176
1177 static void write_ext_msg(struct console *con, const char *msg,
1178                           unsigned int len)
1179 {
1180         struct netconsole_target *nt;
1181         unsigned long flags;
1182
1183         if ((oops_only && !oops_in_progress) || list_empty(&target_list))
1184                 return;
1185
1186         spin_lock_irqsave(&target_list_lock, flags);
1187         list_for_each_entry(nt, &target_list, list)
1188                 if (nt->extended && nt->enabled && netif_running(nt->np.dev))
1189                         send_ext_msg_udp(nt, msg, len);
1190         spin_unlock_irqrestore(&target_list_lock, flags);
1191 }
1192
1193 static void write_msg(struct console *con, const char *msg, unsigned int len)
1194 {
1195         int frag, left;
1196         unsigned long flags;
1197         struct netconsole_target *nt;
1198         const char *tmp;
1199
1200         if (oops_only && !oops_in_progress)
1201                 return;
1202         /* Avoid taking lock and disabling interrupts unnecessarily */
1203         if (list_empty(&target_list))
1204                 return;
1205
1206         spin_lock_irqsave(&target_list_lock, flags);
1207         list_for_each_entry(nt, &target_list, list) {
1208                 if (!nt->extended && nt->enabled && netif_running(nt->np.dev)) {
1209                         /*
1210                          * We nest this inside the for-each-target loop above
1211                          * so that we're able to get as much logging out to
1212                          * at least one target if we die inside here, instead
1213                          * of unnecessarily keeping all targets in lock-step.
1214                          */
1215                         tmp = msg;
1216                         for (left = len; left;) {
1217                                 frag = min(left, MAX_PRINT_CHUNK);
1218                                 netpoll_send_udp(&nt->np, tmp, frag);
1219                                 tmp += frag;
1220                                 left -= frag;
1221                         }
1222                 }
1223         }
1224         spin_unlock_irqrestore(&target_list_lock, flags);
1225 }
1226
1227 /* Allocate new target (from boot/module param) and setup netpoll for it */
1228 static struct netconsole_target *alloc_param_target(char *target_config,
1229                                                     int cmdline_count)
1230 {
1231         struct netconsole_target *nt;
1232         int err;
1233
1234         nt = alloc_and_init();
1235         if (!nt) {
1236                 err = -ENOMEM;
1237                 goto fail;
1238         }
1239
1240         if (*target_config == '+') {
1241                 nt->extended = true;
1242                 target_config++;
1243         }
1244
1245         if (*target_config == 'r') {
1246                 if (!nt->extended) {
1247                         pr_err("Netconsole configuration error. Release feature requires extended log message");
1248                         err = -EINVAL;
1249                         goto fail;
1250                 }
1251                 nt->release = true;
1252                 target_config++;
1253         }
1254
1255         /* Parse parameters and setup netpoll */
1256         err = netpoll_parse_options(&nt->np, target_config);
1257         if (err)
1258                 goto fail;
1259
1260         err = netpoll_setup(&nt->np);
1261         if (err) {
1262                 pr_err("Not enabling netconsole for %s%d. Netpoll setup failed\n",
1263                        NETCONSOLE_PARAM_TARGET_PREFIX, cmdline_count);
1264                 if (!IS_ENABLED(CONFIG_NETCONSOLE_DYNAMIC))
1265                         /* only fail if dynamic reconfiguration is set,
1266                          * otherwise, keep the target in the list, but disabled.
1267                          */
1268                         goto fail;
1269         } else {
1270                 nt->enabled = true;
1271         }
1272         populate_configfs_item(nt, cmdline_count);
1273
1274         return nt;
1275
1276 fail:
1277         kfree(nt);
1278         return ERR_PTR(err);
1279 }
1280
1281 /* Cleanup netpoll for given target (from boot/module param) and free it */
1282 static void free_param_target(struct netconsole_target *nt)
1283 {
1284         netpoll_cleanup(&nt->np);
1285         kfree(nt);
1286 }
1287
1288 static struct console netconsole_ext = {
1289         .name   = "netcon_ext",
1290         .flags  = CON_ENABLED | CON_EXTENDED,
1291         .write  = write_ext_msg,
1292 };
1293
1294 static struct console netconsole = {
1295         .name   = "netcon",
1296         .flags  = CON_ENABLED,
1297         .write  = write_msg,
1298 };
1299
1300 static int __init init_netconsole(void)
1301 {
1302         int err;
1303         struct netconsole_target *nt, *tmp;
1304         unsigned int count = 0;
1305         bool extended = false;
1306         unsigned long flags;
1307         char *target_config;
1308         char *input = config;
1309
1310         if (strnlen(input, MAX_PARAM_LENGTH)) {
1311                 while ((target_config = strsep(&input, ";"))) {
1312                         nt = alloc_param_target(target_config, count);
1313                         if (IS_ERR(nt)) {
1314                                 if (IS_ENABLED(CONFIG_NETCONSOLE_DYNAMIC))
1315                                         continue;
1316                                 err = PTR_ERR(nt);
1317                                 goto fail;
1318                         }
1319                         /* Dump existing printks when we register */
1320                         if (nt->extended) {
1321                                 extended = true;
1322                                 netconsole_ext.flags |= CON_PRINTBUFFER;
1323                         } else {
1324                                 netconsole.flags |= CON_PRINTBUFFER;
1325                         }
1326
1327                         spin_lock_irqsave(&target_list_lock, flags);
1328                         list_add(&nt->list, &target_list);
1329                         spin_unlock_irqrestore(&target_list_lock, flags);
1330                         count++;
1331                 }
1332         }
1333
1334         err = register_netdevice_notifier(&netconsole_netdev_notifier);
1335         if (err)
1336                 goto fail;
1337
1338         err = dynamic_netconsole_init();
1339         if (err)
1340                 goto undonotifier;
1341
1342         if (extended)
1343                 register_console(&netconsole_ext);
1344         register_console(&netconsole);
1345         pr_info("network logging started\n");
1346
1347         return err;
1348
1349 undonotifier:
1350         unregister_netdevice_notifier(&netconsole_netdev_notifier);
1351
1352 fail:
1353         pr_err("cleaning up\n");
1354
1355         /*
1356          * Remove all targets and destroy them (only targets created
1357          * from the boot/module option exist here). Skipping the list
1358          * lock is safe here, and netpoll_cleanup() will sleep.
1359          */
1360         list_for_each_entry_safe(nt, tmp, &target_list, list) {
1361                 list_del(&nt->list);
1362                 free_param_target(nt);
1363         }
1364
1365         return err;
1366 }
1367
1368 static void __exit cleanup_netconsole(void)
1369 {
1370         struct netconsole_target *nt, *tmp;
1371
1372         if (console_is_registered(&netconsole_ext))
1373                 unregister_console(&netconsole_ext);
1374         unregister_console(&netconsole);
1375         dynamic_netconsole_exit();
1376         unregister_netdevice_notifier(&netconsole_netdev_notifier);
1377
1378         /*
1379          * Targets created via configfs pin references on our module
1380          * and would first be rmdir(2)'ed from userspace. We reach
1381          * here only when they are already destroyed, and only those
1382          * created from the boot/module option are left, so remove and
1383          * destroy them. Skipping the list lock is safe here, and
1384          * netpoll_cleanup() will sleep.
1385          */
1386         list_for_each_entry_safe(nt, tmp, &target_list, list) {
1387                 list_del(&nt->list);
1388                 free_param_target(nt);
1389         }
1390 }
1391
1392 /*
1393  * Use late_initcall to ensure netconsole is
1394  * initialized after network device driver if built-in.
1395  *
1396  * late_initcall() and module_init() are identical if built as module.
1397  */
1398 late_initcall(init_netconsole);
1399 module_exit(cleanup_netconsole);