2 * linux/drivers/net/netconsole.c
4 * Copyright (C) 2001 Ingo Molnar <mingo@redhat.com>
6 * This file contains the implementation of an IRQ-safe, crash-safe
7 * kernel console implementation that outputs kernel messages to the
10 * Modification history:
12 * 2001-09-17 started by Ingo Molnar.
13 * 2003-08-11 2.6 port by Matt Mackall
17 * 2003-09-07 rewritten with netpoll api
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)
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.
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.
35 ****************************************************************/
37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
52 MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
53 MODULE_DESCRIPTION("Console driver for network interfaces");
54 MODULE_LICENSE("GPL");
56 #define MAX_PARAM_LENGTH 256
57 #define MAX_PRINT_CHUNK 1000
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]");
63 static bool oops_only
= false;
64 module_param(oops_only
, bool, 0600);
65 MODULE_PARM_DESC(oops_only
, "Only log oops messages");
68 static int __init
option_setup(char *opt
)
70 strlcpy(config
, opt
, MAX_PARAM_LENGTH
);
73 __setup("netconsole=", option_setup
);
76 /* Linked list of all configured targets */
77 static LIST_HEAD(target_list
);
79 /* This needs to be a spinlock because write_msg() cannot sleep */
80 static DEFINE_SPINLOCK(target_list_lock
);
83 * Console driver for extended netconsoles. Registered on the first use to
84 * avoid unnecessarily enabling ext message formatting.
86 static struct console netconsole_ext
;
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)
108 struct netconsole_target
{
109 struct list_head list
;
110 #ifdef CONFIG_NETCONSOLE_DYNAMIC
111 struct config_item item
;
118 #ifdef CONFIG_NETCONSOLE_DYNAMIC
120 static struct configfs_subsystem netconsole_subsys
;
121 static DEFINE_MUTEX(dynamic_netconsole_mutex
);
123 static int __init
dynamic_netconsole_init(void)
125 config_group_init(&netconsole_subsys
.su_group
);
126 mutex_init(&netconsole_subsys
.su_mutex
);
127 return configfs_register_subsystem(&netconsole_subsys
);
130 static void __exit
dynamic_netconsole_exit(void)
132 configfs_unregister_subsystem(&netconsole_subsys
);
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.
140 static void netconsole_target_get(struct netconsole_target
*nt
)
142 if (config_item_name(&nt
->item
))
143 config_item_get(&nt
->item
);
146 static void netconsole_target_put(struct netconsole_target
*nt
)
148 if (config_item_name(&nt
->item
))
149 config_item_put(&nt
->item
);
152 #else /* !CONFIG_NETCONSOLE_DYNAMIC */
154 static int __init
dynamic_netconsole_init(void)
159 static void __exit
dynamic_netconsole_exit(void)
164 * No danger of targets going away from under us when dynamic
165 * reconfigurability is off.
167 static void netconsole_target_get(struct netconsole_target
*nt
)
171 static void netconsole_target_put(struct netconsole_target
*nt
)
175 #endif /* CONFIG_NETCONSOLE_DYNAMIC */
177 /* Allocate new target (from boot/module param) and setup netpoll for it */
178 static struct netconsole_target
*alloc_param_target(char *target_config
)
181 struct netconsole_target
*nt
;
184 * Allocate and initialize with defaults.
185 * Note that these targets get their config_item fields zeroed-out.
187 nt
= kzalloc(sizeof(*nt
), GFP_KERNEL
);
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
);
197 if (*target_config
== '+') {
202 /* Parse parameters and setup netpoll */
203 err
= netpoll_parse_options(&nt
->np
, target_config
);
207 err
= netpoll_setup(&nt
->np
);
220 /* Cleanup netpoll for given target (from boot/module param) and free it */
221 static void free_param_target(struct netconsole_target
*nt
)
223 netpoll_cleanup(&nt
->np
);
227 #ifdef CONFIG_NETCONSOLE_DYNAMIC
230 * Our subsystem hierarchy is:
232 * /sys/kernel/config/netconsole/
247 struct netconsole_target_attr
{
248 struct configfs_attribute attr
;
249 ssize_t (*show
)(struct netconsole_target
*nt
,
251 ssize_t (*store
)(struct netconsole_target
*nt
,
256 static struct netconsole_target
*to_target(struct config_item
*item
)
259 container_of(item
, struct netconsole_target
, item
) :
264 * Attribute operations for netconsole_target.
267 static ssize_t
show_enabled(struct netconsole_target
*nt
, char *buf
)
269 return snprintf(buf
, PAGE_SIZE
, "%d\n", nt
->enabled
);
272 static ssize_t
show_extended(struct netconsole_target
*nt
, char *buf
)
274 return snprintf(buf
, PAGE_SIZE
, "%d\n", nt
->extended
);
277 static ssize_t
show_dev_name(struct netconsole_target
*nt
, char *buf
)
279 return snprintf(buf
, PAGE_SIZE
, "%s\n", nt
->np
.dev_name
);
282 static ssize_t
show_local_port(struct netconsole_target
*nt
, char *buf
)
284 return snprintf(buf
, PAGE_SIZE
, "%d\n", nt
->np
.local_port
);
287 static ssize_t
show_remote_port(struct netconsole_target
*nt
, char *buf
)
289 return snprintf(buf
, PAGE_SIZE
, "%d\n", nt
->np
.remote_port
);
292 static ssize_t
show_local_ip(struct netconsole_target
*nt
, char *buf
)
295 return snprintf(buf
, PAGE_SIZE
, "%pI6c\n", &nt
->np
.local_ip
.in6
);
297 return snprintf(buf
, PAGE_SIZE
, "%pI4\n", &nt
->np
.local_ip
);
300 static ssize_t
show_remote_ip(struct netconsole_target
*nt
, char *buf
)
303 return snprintf(buf
, PAGE_SIZE
, "%pI6c\n", &nt
->np
.remote_ip
.in6
);
305 return snprintf(buf
, PAGE_SIZE
, "%pI4\n", &nt
->np
.remote_ip
);
308 static ssize_t
show_local_mac(struct netconsole_target
*nt
, char *buf
)
310 struct net_device
*dev
= nt
->np
.dev
;
311 static const u8 bcast
[ETH_ALEN
] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
313 return snprintf(buf
, PAGE_SIZE
, "%pM\n", dev
? dev
->dev_addr
: bcast
);
316 static ssize_t
show_remote_mac(struct netconsole_target
*nt
, char *buf
)
318 return snprintf(buf
, PAGE_SIZE
, "%pM\n", nt
->np
.remote_mac
);
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).
328 static ssize_t
store_enabled(struct netconsole_target
*nt
,
336 err
= kstrtoint(buf
, 10, &enabled
);
339 if (enabled
< 0 || enabled
> 1)
341 if ((bool)enabled
== nt
->enabled
) {
342 pr_info("network logging has already %s\n",
343 nt
->enabled
? "started" : "stopped");
347 if (enabled
) { /* true */
348 if (nt
->extended
&& !(netconsole_ext
.flags
& CON_ENABLED
)) {
349 netconsole_ext
.flags
|= CON_ENABLED
;
350 register_console(&netconsole_ext
);
354 * Skip netpoll_parse_options() -- all the attributes are
355 * already configured via configfs. Just print them out.
357 netpoll_print_options(&nt
->np
);
359 err
= netpoll_setup(&nt
->np
);
363 pr_info("netconsole: network logging started\n");
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
369 spin_lock_irqsave(&target_list_lock
, flags
);
371 spin_unlock_irqrestore(&target_list_lock
, flags
);
372 netpoll_cleanup(&nt
->np
);
375 nt
->enabled
= enabled
;
377 return strnlen(buf
, count
);
380 static ssize_t
store_extended(struct netconsole_target
*nt
,
388 pr_err("target (%s) is enabled, disable to update parameters\n",
389 config_item_name(&nt
->item
));
393 err
= kstrtoint(buf
, 10, &extended
);
396 if (extended
< 0 || extended
> 1)
399 nt
->extended
= extended
;
401 return strnlen(buf
, count
);
404 static ssize_t
store_dev_name(struct netconsole_target
*nt
,
411 pr_err("target (%s) is enabled, disable to update parameters\n",
412 config_item_name(&nt
->item
));
416 strlcpy(nt
->np
.dev_name
, buf
, IFNAMSIZ
);
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';
423 return strnlen(buf
, count
);
426 static ssize_t
store_local_port(struct netconsole_target
*nt
,
433 pr_err("target (%s) is enabled, disable to update parameters\n",
434 config_item_name(&nt
->item
));
438 rv
= kstrtou16(buf
, 10, &nt
->np
.local_port
);
441 return strnlen(buf
, count
);
444 static ssize_t
store_remote_port(struct netconsole_target
*nt
,
451 pr_err("target (%s) is enabled, disable to update parameters\n",
452 config_item_name(&nt
->item
));
456 rv
= kstrtou16(buf
, 10, &nt
->np
.remote_port
);
459 return strnlen(buf
, count
);
462 static ssize_t
store_local_ip(struct netconsole_target
*nt
,
467 pr_err("target (%s) is enabled, disable to update parameters\n",
468 config_item_name(&nt
->item
));
472 if (strnchr(buf
, count
, ':')) {
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
);
484 nt
->np
.local_ip
.ip
= in_aton(buf
);
489 return strnlen(buf
, count
);
492 static ssize_t
store_remote_ip(struct netconsole_target
*nt
,
497 pr_err("target (%s) is enabled, disable to update parameters\n",
498 config_item_name(&nt
->item
));
502 if (strnchr(buf
, count
, ':')) {
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
);
514 nt
->np
.remote_ip
.ip
= in_aton(buf
);
519 return strnlen(buf
, count
);
522 static ssize_t
store_remote_mac(struct netconsole_target
*nt
,
526 u8 remote_mac
[ETH_ALEN
];
529 pr_err("target (%s) is enabled, disable to update parameters\n",
530 config_item_name(&nt
->item
));
534 if (!mac_pton(buf
, remote_mac
))
536 if (buf
[3 * ETH_ALEN
- 1] && buf
[3 * ETH_ALEN
- 1] != '\n')
538 memcpy(nt
->np
.remote_mac
, remote_mac
, ETH_ALEN
);
540 return strnlen(buf
, count
);
544 * Attribute definitions for netconsole_target.
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)
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)
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
);
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
,
579 * Item operations and type for netconsole_target.
582 static void netconsole_target_release(struct config_item
*item
)
584 kfree(to_target(item
));
587 static ssize_t
netconsole_target_attr_show(struct config_item
*item
,
588 struct configfs_attribute
*attr
,
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
);
597 ret
= na
->show(nt
, buf
);
602 static ssize_t
netconsole_target_attr_store(struct config_item
*item
,
603 struct configfs_attribute
*attr
,
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
);
612 mutex_lock(&dynamic_netconsole_mutex
);
614 ret
= na
->store(nt
, buf
, count
);
615 mutex_unlock(&dynamic_netconsole_mutex
);
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
,
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
,
633 * Group operations and type for netconsole_subsys.
636 static struct config_item
*make_netconsole_target(struct config_group
*group
,
640 struct netconsole_target
*nt
;
643 * Allocate and initialize with defaults.
644 * Target is disabled at creation (!enabled).
646 nt
= kzalloc(sizeof(*nt
), GFP_KERNEL
);
648 return ERR_PTR(-ENOMEM
);
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
);
656 /* Initialize the config_item member */
657 config_item_init_type_name(&nt
->item
, name
, &netconsole_target_type
);
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
);
667 static void drop_netconsole_target(struct config_group
*group
,
668 struct config_item
*item
)
671 struct netconsole_target
*nt
= to_target(item
);
673 spin_lock_irqsave(&target_list_lock
, flags
);
675 spin_unlock_irqrestore(&target_list_lock
, flags
);
678 * The target may have never been enabled, or was manually disabled
679 * before being removed so netpoll may have already been cleaned up.
682 netpoll_cleanup(&nt
->np
);
684 config_item_put(&nt
->item
);
687 static struct configfs_group_operations netconsole_subsys_group_ops
= {
688 .make_item
= make_netconsole_target
,
689 .drop_item
= drop_netconsole_target
,
692 static struct config_item_type netconsole_subsys_type
= {
693 .ct_group_ops
= &netconsole_subsys_group_ops
,
694 .ct_owner
= THIS_MODULE
,
697 /* The netconsole configfs subsystem */
698 static struct configfs_subsystem netconsole_subsys
= {
701 .ci_namebuf
= "netconsole",
702 .ci_type
= &netconsole_subsys_type
,
707 #endif /* CONFIG_NETCONSOLE_DYNAMIC */
709 /* Handle network interface device notifications */
710 static int netconsole_netdev_event(struct notifier_block
*this,
711 unsigned long event
, void *ptr
)
714 struct netconsole_target
*nt
;
715 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
716 bool stopped
= false;
718 if (!(event
== NETDEV_CHANGENAME
|| event
== NETDEV_UNREGISTER
||
719 event
== NETDEV_RELEASE
|| event
== NETDEV_JOIN
))
722 spin_lock_irqsave(&target_list_lock
, flags
);
724 list_for_each_entry(nt
, &target_list
, list
) {
725 netconsole_target_get(nt
);
726 if (nt
->np
.dev
== dev
) {
728 case NETDEV_CHANGENAME
:
729 strlcpy(nt
->np
.dev_name
, dev
->name
, IFNAMSIZ
);
733 case NETDEV_UNREGISTER
:
734 /* rtnl_lock already held
735 * we might sleep in __netpoll_cleanup()
737 spin_unlock_irqrestore(&target_list_lock
, flags
);
739 __netpoll_cleanup(&nt
->np
);
741 spin_lock_irqsave(&target_list_lock
, flags
);
746 netconsole_target_put(nt
);
750 netconsole_target_put(nt
);
752 spin_unlock_irqrestore(&target_list_lock
, flags
);
754 const char *msg
= "had an event";
756 case NETDEV_UNREGISTER
:
757 msg
= "unregistered";
760 msg
= "released slaves";
763 msg
= "is joining a master device";
766 pr_info("network logging stopped on interface %s as it %s\n",
774 static struct notifier_block netconsole_netdev_notifier
= {
775 .notifier_call
= netconsole_netdev_event
,
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
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.
788 static void send_ext_msg_udp(struct netconsole_target
*nt
, const char *msg
,
791 static char buf
[MAX_PRINT_CHUNK
]; /* protected by target_list_lock */
792 const char *header
, *body
;
794 int header_len
, body_len
;
796 if (msg_len
<= MAX_PRINT_CHUNK
) {
797 netpoll_send_udp(&nt
->np
, msg
, msg_len
);
801 /* need to insert extra header fields, detect header and body */
803 body
= memchr(msg
, ';', msg_len
);
804 if (WARN_ON_ONCE(!body
))
807 header_len
= body
- header
;
808 body_len
= msg_len
- header_len
- 1;
812 * Transfer multiple chunks with the following extra header.
813 * "ncfrag=<byte-offset>/<total-bytes>"
815 memcpy(buf
, header
, header_len
);
817 while (offset
< body_len
) {
818 int this_header
= header_len
;
821 this_header
+= scnprintf(buf
+ this_header
,
822 sizeof(buf
) - this_header
,
823 ",ncfrag=%d/%d;", offset
, body_len
);
825 this_chunk
= min(body_len
- offset
,
826 MAX_PRINT_CHUNK
- this_header
);
827 if (WARN_ON_ONCE(this_chunk
<= 0))
830 memcpy(buf
+ this_header
, body
+ offset
, this_chunk
);
832 netpoll_send_udp(&nt
->np
, buf
, this_header
+ this_chunk
);
834 offset
+= this_chunk
;
838 static void write_ext_msg(struct console
*con
, const char *msg
,
841 struct netconsole_target
*nt
;
844 if ((oops_only
&& !oops_in_progress
) || list_empty(&target_list
))
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
);
854 static void write_msg(struct console
*con
, const char *msg
, unsigned int len
)
858 struct netconsole_target
*nt
;
861 if (oops_only
&& !oops_in_progress
)
863 /* Avoid taking lock and disabling interrupts unnecessarily */
864 if (list_empty(&target_list
))
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
)) {
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.
877 for (left
= len
; left
;) {
878 frag
= min(left
, MAX_PRINT_CHUNK
);
879 netpoll_send_udp(&nt
->np
, tmp
, frag
);
885 spin_unlock_irqrestore(&target_list_lock
, flags
);
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
,
894 static struct console netconsole
= {
896 .flags
= CON_ENABLED
,
900 static int __init
init_netconsole(void)
903 struct netconsole_target
*nt
, *tmp
;
906 char *input
= config
;
908 if (strnlen(input
, MAX_PARAM_LENGTH
)) {
909 while ((target_config
= strsep(&input
, ";"))) {
910 nt
= alloc_param_target(target_config
);
915 /* Dump existing printks when we register */
917 netconsole_ext
.flags
|= CON_PRINTBUFFER
|
920 netconsole
.flags
|= CON_PRINTBUFFER
;
922 spin_lock_irqsave(&target_list_lock
, flags
);
923 list_add(&nt
->list
, &target_list
);
924 spin_unlock_irqrestore(&target_list_lock
, flags
);
928 err
= register_netdevice_notifier(&netconsole_netdev_notifier
);
932 err
= dynamic_netconsole_init();
936 if (netconsole_ext
.flags
& CON_ENABLED
)
937 register_console(&netconsole_ext
);
938 register_console(&netconsole
);
939 pr_info("network logging started\n");
944 unregister_netdevice_notifier(&netconsole_netdev_notifier
);
947 pr_err("cleaning up\n");
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.
954 list_for_each_entry_safe(nt
, tmp
, &target_list
, list
) {
956 free_param_target(nt
);
962 static void __exit
cleanup_netconsole(void)
964 struct netconsole_target
*nt
, *tmp
;
966 unregister_console(&netconsole_ext
);
967 unregister_console(&netconsole
);
968 dynamic_netconsole_exit();
969 unregister_netdevice_notifier(&netconsole_netdev_notifier
);
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.
979 list_for_each_entry_safe(nt
, tmp
, &target_list
, list
) {
981 free_param_target(nt
);
986 * Use late_initcall to ensure netconsole is
987 * initialized after network device driver if built-in.
989 * late_initcall() and module_init() are identical if built as module.
991 late_initcall(init_netconsole
);
992 module_exit(cleanup_netconsole
);