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 ****************************************************************/
38 #include <linux/init.h>
39 #include <linux/module.h>
40 #include <linux/slab.h>
41 #include <linux/console.h>
42 #include <linux/moduleparam.h>
43 #include <linux/kernel.h>
44 #include <linux/string.h>
45 #include <linux/netpoll.h>
46 #include <linux/inet.h>
47 #include <linux/configfs.h>
49 MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
50 MODULE_DESCRIPTION("Console driver for network interfaces");
51 MODULE_LICENSE("GPL");
53 #define MAX_PARAM_LENGTH 256
54 #define MAX_PRINT_CHUNK 1000
56 static char config
[MAX_PARAM_LENGTH
];
57 module_param_string(netconsole
, config
, MAX_PARAM_LENGTH
, 0);
58 MODULE_PARM_DESC(netconsole
, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]");
60 static bool oops_only
= false;
61 module_param(oops_only
, bool, 0600);
62 MODULE_PARM_DESC(oops_only
, "Only log oops messages");
65 static int __init
option_setup(char *opt
)
67 strlcpy(config
, opt
, MAX_PARAM_LENGTH
);
70 __setup("netconsole=", option_setup
);
73 /* Linked list of all configured targets */
74 static LIST_HEAD(target_list
);
76 /* This needs to be a spinlock because write_msg() cannot sleep */
77 static DEFINE_SPINLOCK(target_list_lock
);
80 * struct netconsole_target - Represents a configured netconsole target.
81 * @list: Links this target into the target_list.
82 * @item: Links us into the configfs subsystem hierarchy.
83 * @enabled: On / off knob to enable / disable target.
84 * Visible from userspace (read-write).
85 * We maintain a strict 1:1 correspondence between this and
86 * whether the corresponding netpoll is active or inactive.
87 * Also, other parameters of a target may be modified at
88 * runtime only when it is disabled (enabled == 0).
89 * @np: The netpoll structure for this target.
90 * Contains the other userspace visible parameters:
91 * dev_name (read-write)
92 * local_port (read-write)
93 * remote_port (read-write)
94 * local_ip (read-write)
95 * remote_ip (read-write)
96 * local_mac (read-only)
97 * remote_mac (read-write)
99 struct netconsole_target
{
100 struct list_head list
;
101 #ifdef CONFIG_NETCONSOLE_DYNAMIC
102 struct config_item item
;
109 #ifdef CONFIG_NETCONSOLE_DYNAMIC
111 static struct configfs_subsystem netconsole_subsys
;
113 static int __init
dynamic_netconsole_init(void)
115 config_group_init(&netconsole_subsys
.su_group
);
116 mutex_init(&netconsole_subsys
.su_mutex
);
117 return configfs_register_subsystem(&netconsole_subsys
);
120 static void __exit
dynamic_netconsole_exit(void)
122 configfs_unregister_subsystem(&netconsole_subsys
);
126 * Targets that were created by parsing the boot/module option string
127 * do not exist in the configfs hierarchy (and have NULL names) and will
128 * never go away, so make these a no-op for them.
130 static void netconsole_target_get(struct netconsole_target
*nt
)
132 if (config_item_name(&nt
->item
))
133 config_item_get(&nt
->item
);
136 static void netconsole_target_put(struct netconsole_target
*nt
)
138 if (config_item_name(&nt
->item
))
139 config_item_put(&nt
->item
);
142 #else /* !CONFIG_NETCONSOLE_DYNAMIC */
144 static int __init
dynamic_netconsole_init(void)
149 static void __exit
dynamic_netconsole_exit(void)
154 * No danger of targets going away from under us when dynamic
155 * reconfigurability is off.
157 static void netconsole_target_get(struct netconsole_target
*nt
)
161 static void netconsole_target_put(struct netconsole_target
*nt
)
165 #endif /* CONFIG_NETCONSOLE_DYNAMIC */
167 /* Allocate new target (from boot/module param) and setup netpoll for it */
168 static struct netconsole_target
*alloc_param_target(char *target_config
)
171 struct netconsole_target
*nt
;
174 * Allocate and initialize with defaults.
175 * Note that these targets get their config_item fields zeroed-out.
177 nt
= kzalloc(sizeof(*nt
), GFP_KERNEL
);
181 nt
->np
.name
= "netconsole";
182 strlcpy(nt
->np
.dev_name
, "eth0", IFNAMSIZ
);
183 nt
->np
.local_port
= 6665;
184 nt
->np
.remote_port
= 6666;
185 mutex_init(&nt
->mutex
);
186 memset(nt
->np
.remote_mac
, 0xff, ETH_ALEN
);
188 /* Parse parameters and setup netpoll */
189 err
= netpoll_parse_options(&nt
->np
, target_config
);
193 err
= netpoll_setup(&nt
->np
);
206 /* Cleanup netpoll for given target (from boot/module param) and free it */
207 static void free_param_target(struct netconsole_target
*nt
)
209 netpoll_cleanup(&nt
->np
);
213 #ifdef CONFIG_NETCONSOLE_DYNAMIC
216 * Our subsystem hierarchy is:
218 * /sys/kernel/config/netconsole/
233 struct netconsole_target_attr
{
234 struct configfs_attribute attr
;
235 ssize_t (*show
)(struct netconsole_target
*nt
,
237 ssize_t (*store
)(struct netconsole_target
*nt
,
242 static struct netconsole_target
*to_target(struct config_item
*item
)
245 container_of(item
, struct netconsole_target
, item
) :
250 * Attribute operations for netconsole_target.
253 static ssize_t
show_enabled(struct netconsole_target
*nt
, char *buf
)
255 return snprintf(buf
, PAGE_SIZE
, "%d\n", nt
->enabled
);
258 static ssize_t
show_dev_name(struct netconsole_target
*nt
, char *buf
)
260 return snprintf(buf
, PAGE_SIZE
, "%s\n", nt
->np
.dev_name
);
263 static ssize_t
show_local_port(struct netconsole_target
*nt
, char *buf
)
265 return snprintf(buf
, PAGE_SIZE
, "%d\n", nt
->np
.local_port
);
268 static ssize_t
show_remote_port(struct netconsole_target
*nt
, char *buf
)
270 return snprintf(buf
, PAGE_SIZE
, "%d\n", nt
->np
.remote_port
);
273 static ssize_t
show_local_ip(struct netconsole_target
*nt
, char *buf
)
276 return snprintf(buf
, PAGE_SIZE
, "%pI6c\n", &nt
->np
.local_ip
.in6
);
278 return snprintf(buf
, PAGE_SIZE
, "%pI4\n", &nt
->np
.local_ip
);
281 static ssize_t
show_remote_ip(struct netconsole_target
*nt
, char *buf
)
284 return snprintf(buf
, PAGE_SIZE
, "%pI6c\n", &nt
->np
.remote_ip
.in6
);
286 return snprintf(buf
, PAGE_SIZE
, "%pI4\n", &nt
->np
.remote_ip
);
289 static ssize_t
show_local_mac(struct netconsole_target
*nt
, char *buf
)
291 struct net_device
*dev
= nt
->np
.dev
;
292 static const u8 bcast
[ETH_ALEN
] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
294 return snprintf(buf
, PAGE_SIZE
, "%pM\n", dev
? dev
->dev_addr
: bcast
);
297 static ssize_t
show_remote_mac(struct netconsole_target
*nt
, char *buf
)
299 return snprintf(buf
, PAGE_SIZE
, "%pM\n", nt
->np
.remote_mac
);
303 * This one is special -- targets created through the configfs interface
304 * are not enabled (and the corresponding netpoll activated) by default.
305 * The user is expected to set the desired parameters first (which
306 * would enable him to dynamically add new netpoll targets for new
307 * network interfaces as and when they come up).
309 static ssize_t
store_enabled(struct netconsole_target
*nt
,
317 err
= kstrtoint(buf
, 10, &enabled
);
320 if (enabled
< 0 || enabled
> 1)
322 if (enabled
== nt
->enabled
) {
323 printk(KERN_INFO
"netconsole: network logging has already %s\n",
324 nt
->enabled
? "started" : "stopped");
328 if (enabled
) { /* 1 */
330 * Skip netpoll_parse_options() -- all the attributes are
331 * already configured via configfs. Just print them out.
333 netpoll_print_options(&nt
->np
);
335 err
= netpoll_setup(&nt
->np
);
339 printk(KERN_INFO
"netconsole: network logging started\n");
341 /* We need to disable the netconsole before cleaning it up
342 * otherwise we might end up in write_msg() with
343 * nt->np.dev == NULL and nt->enabled == 1
345 spin_lock_irqsave(&target_list_lock
, flags
);
347 spin_unlock_irqrestore(&target_list_lock
, flags
);
348 netpoll_cleanup(&nt
->np
);
351 nt
->enabled
= enabled
;
353 return strnlen(buf
, count
);
356 static ssize_t
store_dev_name(struct netconsole_target
*nt
,
363 printk(KERN_ERR
"netconsole: target (%s) is enabled, "
364 "disable to update parameters\n",
365 config_item_name(&nt
->item
));
369 strlcpy(nt
->np
.dev_name
, buf
, IFNAMSIZ
);
371 /* Get rid of possible trailing newline from echo(1) */
372 len
= strnlen(nt
->np
.dev_name
, IFNAMSIZ
);
373 if (nt
->np
.dev_name
[len
- 1] == '\n')
374 nt
->np
.dev_name
[len
- 1] = '\0';
376 return strnlen(buf
, count
);
379 static ssize_t
store_local_port(struct netconsole_target
*nt
,
386 printk(KERN_ERR
"netconsole: target (%s) is enabled, "
387 "disable to update parameters\n",
388 config_item_name(&nt
->item
));
392 rv
= kstrtou16(buf
, 10, &nt
->np
.local_port
);
395 return strnlen(buf
, count
);
398 static ssize_t
store_remote_port(struct netconsole_target
*nt
,
405 printk(KERN_ERR
"netconsole: target (%s) is enabled, "
406 "disable to update parameters\n",
407 config_item_name(&nt
->item
));
411 rv
= kstrtou16(buf
, 10, &nt
->np
.remote_port
);
414 return strnlen(buf
, count
);
417 static ssize_t
store_local_ip(struct netconsole_target
*nt
,
422 printk(KERN_ERR
"netconsole: target (%s) is enabled, "
423 "disable to update parameters\n",
424 config_item_name(&nt
->item
));
428 if (strnchr(buf
, count
, ':')) {
430 if (in6_pton(buf
, count
, nt
->np
.local_ip
.in6
.s6_addr
, -1, &end
) > 0) {
431 if (*end
&& *end
!= '\n') {
432 printk(KERN_ERR
"netconsole: invalid IPv6 address at: <%c>\n", *end
);
440 nt
->np
.local_ip
.ip
= in_aton(buf
);
445 return strnlen(buf
, count
);
448 static ssize_t
store_remote_ip(struct netconsole_target
*nt
,
453 printk(KERN_ERR
"netconsole: target (%s) is enabled, "
454 "disable to update parameters\n",
455 config_item_name(&nt
->item
));
459 if (strnchr(buf
, count
, ':')) {
461 if (in6_pton(buf
, count
, nt
->np
.remote_ip
.in6
.s6_addr
, -1, &end
) > 0) {
462 if (*end
&& *end
!= '\n') {
463 printk(KERN_ERR
"netconsole: invalid IPv6 address at: <%c>\n", *end
);
471 nt
->np
.remote_ip
.ip
= in_aton(buf
);
476 return strnlen(buf
, count
);
479 static ssize_t
store_remote_mac(struct netconsole_target
*nt
,
483 u8 remote_mac
[ETH_ALEN
];
486 printk(KERN_ERR
"netconsole: target (%s) is enabled, "
487 "disable to update parameters\n",
488 config_item_name(&nt
->item
));
492 if (!mac_pton(buf
, remote_mac
))
494 if (buf
[3 * ETH_ALEN
- 1] && buf
[3 * ETH_ALEN
- 1] != '\n')
496 memcpy(nt
->np
.remote_mac
, remote_mac
, ETH_ALEN
);
498 return strnlen(buf
, count
);
502 * Attribute definitions for netconsole_target.
505 #define NETCONSOLE_TARGET_ATTR_RO(_name) \
506 static struct netconsole_target_attr netconsole_target_##_name = \
507 __CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL)
509 #define NETCONSOLE_TARGET_ATTR_RW(_name) \
510 static struct netconsole_target_attr netconsole_target_##_name = \
511 __CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name)
513 NETCONSOLE_TARGET_ATTR_RW(enabled
);
514 NETCONSOLE_TARGET_ATTR_RW(dev_name
);
515 NETCONSOLE_TARGET_ATTR_RW(local_port
);
516 NETCONSOLE_TARGET_ATTR_RW(remote_port
);
517 NETCONSOLE_TARGET_ATTR_RW(local_ip
);
518 NETCONSOLE_TARGET_ATTR_RW(remote_ip
);
519 NETCONSOLE_TARGET_ATTR_RO(local_mac
);
520 NETCONSOLE_TARGET_ATTR_RW(remote_mac
);
522 static struct configfs_attribute
*netconsole_target_attrs
[] = {
523 &netconsole_target_enabled
.attr
,
524 &netconsole_target_dev_name
.attr
,
525 &netconsole_target_local_port
.attr
,
526 &netconsole_target_remote_port
.attr
,
527 &netconsole_target_local_ip
.attr
,
528 &netconsole_target_remote_ip
.attr
,
529 &netconsole_target_local_mac
.attr
,
530 &netconsole_target_remote_mac
.attr
,
535 * Item operations and type for netconsole_target.
538 static void netconsole_target_release(struct config_item
*item
)
540 kfree(to_target(item
));
543 static ssize_t
netconsole_target_attr_show(struct config_item
*item
,
544 struct configfs_attribute
*attr
,
547 ssize_t ret
= -EINVAL
;
548 struct netconsole_target
*nt
= to_target(item
);
549 struct netconsole_target_attr
*na
=
550 container_of(attr
, struct netconsole_target_attr
, attr
);
553 ret
= na
->show(nt
, buf
);
558 static ssize_t
netconsole_target_attr_store(struct config_item
*item
,
559 struct configfs_attribute
*attr
,
563 ssize_t ret
= -EINVAL
;
564 struct netconsole_target
*nt
= to_target(item
);
565 struct netconsole_target_attr
*na
=
566 container_of(attr
, struct netconsole_target_attr
, attr
);
568 mutex_lock(&nt
->mutex
);
570 ret
= na
->store(nt
, buf
, count
);
571 mutex_unlock(&nt
->mutex
);
576 static struct configfs_item_operations netconsole_target_item_ops
= {
577 .release
= netconsole_target_release
,
578 .show_attribute
= netconsole_target_attr_show
,
579 .store_attribute
= netconsole_target_attr_store
,
582 static struct config_item_type netconsole_target_type
= {
583 .ct_attrs
= netconsole_target_attrs
,
584 .ct_item_ops
= &netconsole_target_item_ops
,
585 .ct_owner
= THIS_MODULE
,
589 * Group operations and type for netconsole_subsys.
592 static struct config_item
*make_netconsole_target(struct config_group
*group
,
596 struct netconsole_target
*nt
;
599 * Allocate and initialize with defaults.
600 * Target is disabled at creation (enabled == 0).
602 nt
= kzalloc(sizeof(*nt
), GFP_KERNEL
);
604 return ERR_PTR(-ENOMEM
);
606 nt
->np
.name
= "netconsole";
607 strlcpy(nt
->np
.dev_name
, "eth0", IFNAMSIZ
);
608 nt
->np
.local_port
= 6665;
609 nt
->np
.remote_port
= 6666;
610 mutex_init(&nt
->mutex
);
611 memset(nt
->np
.remote_mac
, 0xff, ETH_ALEN
);
613 /* Initialize the config_item member */
614 config_item_init_type_name(&nt
->item
, name
, &netconsole_target_type
);
616 /* Adding, but it is disabled */
617 spin_lock_irqsave(&target_list_lock
, flags
);
618 list_add(&nt
->list
, &target_list
);
619 spin_unlock_irqrestore(&target_list_lock
, flags
);
624 static void drop_netconsole_target(struct config_group
*group
,
625 struct config_item
*item
)
628 struct netconsole_target
*nt
= to_target(item
);
630 spin_lock_irqsave(&target_list_lock
, flags
);
632 spin_unlock_irqrestore(&target_list_lock
, flags
);
635 * The target may have never been enabled, or was manually disabled
636 * before being removed so netpoll may have already been cleaned up.
639 netpoll_cleanup(&nt
->np
);
641 config_item_put(&nt
->item
);
644 static struct configfs_group_operations netconsole_subsys_group_ops
= {
645 .make_item
= make_netconsole_target
,
646 .drop_item
= drop_netconsole_target
,
649 static struct config_item_type netconsole_subsys_type
= {
650 .ct_group_ops
= &netconsole_subsys_group_ops
,
651 .ct_owner
= THIS_MODULE
,
654 /* The netconsole configfs subsystem */
655 static struct configfs_subsystem netconsole_subsys
= {
658 .ci_namebuf
= "netconsole",
659 .ci_type
= &netconsole_subsys_type
,
664 #endif /* CONFIG_NETCONSOLE_DYNAMIC */
666 /* Handle network interface device notifications */
667 static int netconsole_netdev_event(struct notifier_block
*this,
668 unsigned long event
, void *ptr
)
671 struct netconsole_target
*nt
;
672 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
673 bool stopped
= false;
675 if (!(event
== NETDEV_CHANGENAME
|| event
== NETDEV_UNREGISTER
||
676 event
== NETDEV_RELEASE
|| event
== NETDEV_JOIN
))
679 spin_lock_irqsave(&target_list_lock
, flags
);
681 list_for_each_entry(nt
, &target_list
, list
) {
682 netconsole_target_get(nt
);
683 if (nt
->np
.dev
== dev
) {
685 case NETDEV_CHANGENAME
:
686 strlcpy(nt
->np
.dev_name
, dev
->name
, IFNAMSIZ
);
690 case NETDEV_UNREGISTER
:
691 /* rtnl_lock already held
692 * we might sleep in __netpoll_cleanup()
694 spin_unlock_irqrestore(&target_list_lock
, flags
);
696 __netpoll_cleanup(&nt
->np
);
698 spin_lock_irqsave(&target_list_lock
, flags
);
703 netconsole_target_put(nt
);
707 netconsole_target_put(nt
);
709 spin_unlock_irqrestore(&target_list_lock
, flags
);
711 printk(KERN_INFO
"netconsole: network logging stopped on "
712 "interface %s as it ", dev
->name
);
714 case NETDEV_UNREGISTER
:
715 printk(KERN_CONT
"unregistered\n");
718 printk(KERN_CONT
"released slaves\n");
721 printk(KERN_CONT
"is joining a master device\n");
730 static struct notifier_block netconsole_netdev_notifier
= {
731 .notifier_call
= netconsole_netdev_event
,
734 static void write_msg(struct console
*con
, const char *msg
, unsigned int len
)
738 struct netconsole_target
*nt
;
741 if (oops_only
&& !oops_in_progress
)
743 /* Avoid taking lock and disabling interrupts unnecessarily */
744 if (list_empty(&target_list
))
747 spin_lock_irqsave(&target_list_lock
, flags
);
748 list_for_each_entry(nt
, &target_list
, list
) {
749 netconsole_target_get(nt
);
750 if (nt
->enabled
&& netif_running(nt
->np
.dev
)) {
752 * We nest this inside the for-each-target loop above
753 * so that we're able to get as much logging out to
754 * at least one target if we die inside here, instead
755 * of unnecessarily keeping all targets in lock-step.
758 for (left
= len
; left
;) {
759 frag
= min(left
, MAX_PRINT_CHUNK
);
760 netpoll_send_udp(&nt
->np
, tmp
, frag
);
765 netconsole_target_put(nt
);
767 spin_unlock_irqrestore(&target_list_lock
, flags
);
770 static struct console netconsole
= {
772 .flags
= CON_ENABLED
,
776 static int __init
init_netconsole(void)
779 struct netconsole_target
*nt
, *tmp
;
782 char *input
= config
;
784 if (strnlen(input
, MAX_PARAM_LENGTH
)) {
785 while ((target_config
= strsep(&input
, ";"))) {
786 nt
= alloc_param_target(target_config
);
791 /* Dump existing printks when we register */
792 netconsole
.flags
|= CON_PRINTBUFFER
;
794 spin_lock_irqsave(&target_list_lock
, flags
);
795 list_add(&nt
->list
, &target_list
);
796 spin_unlock_irqrestore(&target_list_lock
, flags
);
800 err
= register_netdevice_notifier(&netconsole_netdev_notifier
);
804 err
= dynamic_netconsole_init();
808 register_console(&netconsole
);
809 printk(KERN_INFO
"netconsole: network logging started\n");
814 unregister_netdevice_notifier(&netconsole_netdev_notifier
);
817 printk(KERN_ERR
"netconsole: cleaning up\n");
820 * Remove all targets and destroy them (only targets created
821 * from the boot/module option exist here). Skipping the list
822 * lock is safe here, and netpoll_cleanup() will sleep.
824 list_for_each_entry_safe(nt
, tmp
, &target_list
, list
) {
826 free_param_target(nt
);
832 static void __exit
cleanup_netconsole(void)
834 struct netconsole_target
*nt
, *tmp
;
836 unregister_console(&netconsole
);
837 dynamic_netconsole_exit();
838 unregister_netdevice_notifier(&netconsole_netdev_notifier
);
841 * Targets created via configfs pin references on our module
842 * and would first be rmdir(2)'ed from userspace. We reach
843 * here only when they are already destroyed, and only those
844 * created from the boot/module option are left, so remove and
845 * destroy them. Skipping the list lock is safe here, and
846 * netpoll_cleanup() will sleep.
848 list_for_each_entry_safe(nt
, tmp
, &target_list
, list
) {
850 free_param_target(nt
);
855 * Use late_initcall to ensure netconsole is
856 * initialized after network device driver if built-in.
858 * late_initcall() and module_init() are identical if built as module.
860 late_initcall(init_netconsole
);
861 module_exit(cleanup_netconsole
);