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);