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/string.h>
44 #include <linux/netpoll.h>
45 #include <linux/inet.h>
46 #include <linux/configfs.h>
48 MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
49 MODULE_DESCRIPTION("Console driver for network interfaces");
50 MODULE_LICENSE("GPL");
52 #define MAX_PARAM_LENGTH 256
53 #define MAX_PRINT_CHUNK 1000
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]");
60 static int __init option_setup(char *opt)
62 strlcpy(config, opt, MAX_PARAM_LENGTH);
65 __setup("netconsole=", option_setup);
68 /* Linked list of all configured targets */
69 static LIST_HEAD(target_list);
71 /* This needs to be a spinlock because write_msg() cannot sleep */
72 static DEFINE_SPINLOCK(target_list_lock);
75 * struct netconsole_target - Represents a configured netconsole target.
76 * @list: Links this target into the target_list.
77 * @item: Links us into the configfs subsystem hierarchy.
78 * @enabled: On / off knob to enable / disable target.
79 * Visible from userspace (read-write).
80 * We maintain a strict 1:1 correspondence between this and
81 * whether the corresponding netpoll is active or inactive.
82 * Also, other parameters of a target may be modified at
83 * runtime only when it is disabled (enabled == 0).
84 * @np: The netpoll structure for this target.
85 * Contains the other userspace visible parameters:
86 * dev_name (read-write)
87 * local_port (read-write)
88 * remote_port (read-write)
89 * local_ip (read-write)
90 * remote_ip (read-write)
91 * local_mac (read-only)
92 * remote_mac (read-write)
94 struct netconsole_target {
95 struct list_head list;
96 #ifdef CONFIG_NETCONSOLE_DYNAMIC
97 struct config_item item;
103 #ifdef CONFIG_NETCONSOLE_DYNAMIC
105 static struct configfs_subsystem netconsole_subsys;
107 static int __init dynamic_netconsole_init(void)
109 config_group_init(&netconsole_subsys.su_group);
110 mutex_init(&netconsole_subsys.su_mutex);
111 return configfs_register_subsystem(&netconsole_subsys);
114 static void __exit dynamic_netconsole_exit(void)
116 configfs_unregister_subsystem(&netconsole_subsys);
120 * Targets that were created by parsing the boot/module option string
121 * do not exist in the configfs hierarchy (and have NULL names) and will
122 * never go away, so make these a no-op for them.
124 static void netconsole_target_get(struct netconsole_target *nt)
126 if (config_item_name(&nt->item))
127 config_item_get(&nt->item);
130 static void netconsole_target_put(struct netconsole_target *nt)
132 if (config_item_name(&nt->item))
133 config_item_put(&nt->item);
136 #else /* !CONFIG_NETCONSOLE_DYNAMIC */
138 static int __init dynamic_netconsole_init(void)
143 static void __exit dynamic_netconsole_exit(void)
148 * No danger of targets going away from under us when dynamic
149 * reconfigurability is off.
151 static void netconsole_target_get(struct netconsole_target *nt)
155 static void netconsole_target_put(struct netconsole_target *nt)
159 #endif /* CONFIG_NETCONSOLE_DYNAMIC */
161 /* Allocate new target (from boot/module param) and setup netpoll for it */
162 static struct netconsole_target *alloc_param_target(char *target_config)
165 struct netconsole_target *nt;
168 * Allocate and initialize with defaults.
169 * Note that these targets get their config_item fields zeroed-out.
171 nt = kzalloc(sizeof(*nt), GFP_KERNEL);
173 printk(KERN_ERR "netconsole: failed to allocate memory\n");
177 nt->np.name = "netconsole";
178 strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
179 nt->np.local_port = 6665;
180 nt->np.remote_port = 6666;
181 memset(nt->np.remote_mac, 0xff, ETH_ALEN);
183 /* Parse parameters and setup netpoll */
184 err = netpoll_parse_options(&nt->np, target_config);
188 err = netpoll_setup(&nt->np);
201 /* Cleanup netpoll for given target (from boot/module param) and free it */
202 static void free_param_target(struct netconsole_target *nt)
204 netpoll_cleanup(&nt->np);
208 #ifdef CONFIG_NETCONSOLE_DYNAMIC
211 * Our subsystem hierarchy is:
213 * /sys/kernel/config/netconsole/
228 struct netconsole_target_attr {
229 struct configfs_attribute attr;
230 ssize_t (*show)(struct netconsole_target *nt,
232 ssize_t (*store)(struct netconsole_target *nt,
237 static struct netconsole_target *to_target(struct config_item *item)
240 container_of(item, struct netconsole_target, item) :
245 * Attribute operations for netconsole_target.
248 static ssize_t show_enabled(struct netconsole_target *nt, char *buf)
250 return snprintf(buf, PAGE_SIZE, "%d\n", nt->enabled);
253 static ssize_t show_dev_name(struct netconsole_target *nt, char *buf)
255 return snprintf(buf, PAGE_SIZE, "%s\n", nt->np.dev_name);
258 static ssize_t show_local_port(struct netconsole_target *nt, char *buf)
260 return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.local_port);
263 static ssize_t show_remote_port(struct netconsole_target *nt, char *buf)
265 return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.remote_port);
268 static ssize_t show_local_ip(struct netconsole_target *nt, char *buf)
270 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip);
273 static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf)
275 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip);
278 static ssize_t show_local_mac(struct netconsole_target *nt, char *buf)
280 struct net_device *dev = nt->np.dev;
281 static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
283 return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast);
286 static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
288 return snprintf(buf, PAGE_SIZE, "%pM\n", nt->np.remote_mac);
292 * This one is special -- targets created through the configfs interface
293 * are not enabled (and the corresponding netpoll activated) by default.
294 * The user is expected to set the desired parameters first (which
295 * would enable him to dynamically add new netpoll targets for new
296 * network interfaces as and when they come up).
298 static ssize_t store_enabled(struct netconsole_target *nt,
305 err = kstrtoint(buf, 10, &enabled);
308 if (enabled < 0 || enabled > 1)
311 if (enabled) { /* 1 */
314 * Skip netpoll_parse_options() -- all the attributes are
315 * already configured via configfs. Just print them out.
317 netpoll_print_options(&nt->np);
319 err = netpoll_setup(&nt->np);
323 printk(KERN_INFO "netconsole: network logging started\n");
326 netpoll_cleanup(&nt->np);
329 nt->enabled = enabled;
331 return strnlen(buf, count);
334 static ssize_t store_dev_name(struct netconsole_target *nt,
341 printk(KERN_ERR "netconsole: target (%s) is enabled, "
342 "disable to update parameters\n",
343 config_item_name(&nt->item));
347 strlcpy(nt->np.dev_name, buf, IFNAMSIZ);
349 /* Get rid of possible trailing newline from echo(1) */
350 len = strnlen(nt->np.dev_name, IFNAMSIZ);
351 if (nt->np.dev_name[len - 1] == '\n')
352 nt->np.dev_name[len - 1] = '\0';
354 return strnlen(buf, count);
357 static ssize_t store_local_port(struct netconsole_target *nt,
364 printk(KERN_ERR "netconsole: target (%s) is enabled, "
365 "disable to update parameters\n",
366 config_item_name(&nt->item));
370 rv = kstrtou16(buf, 10, &nt->np.local_port);
373 return strnlen(buf, count);
376 static ssize_t store_remote_port(struct netconsole_target *nt,
383 printk(KERN_ERR "netconsole: target (%s) is enabled, "
384 "disable to update parameters\n",
385 config_item_name(&nt->item));
389 rv = kstrtou16(buf, 10, &nt->np.remote_port);
392 return strnlen(buf, count);
395 static ssize_t store_local_ip(struct netconsole_target *nt,
400 printk(KERN_ERR "netconsole: target (%s) is enabled, "
401 "disable to update parameters\n",
402 config_item_name(&nt->item));
406 nt->np.local_ip = in_aton(buf);
408 return strnlen(buf, count);
411 static ssize_t store_remote_ip(struct netconsole_target *nt,
416 printk(KERN_ERR "netconsole: target (%s) is enabled, "
417 "disable to update parameters\n",
418 config_item_name(&nt->item));
422 nt->np.remote_ip = in_aton(buf);
424 return strnlen(buf, count);
427 static ssize_t store_remote_mac(struct netconsole_target *nt,
431 u8 remote_mac[ETH_ALEN];
434 printk(KERN_ERR "netconsole: target (%s) is enabled, "
435 "disable to update parameters\n",
436 config_item_name(&nt->item));
440 if (!mac_pton(buf, remote_mac))
442 if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n')
444 memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
446 return strnlen(buf, count);
450 * Attribute definitions for netconsole_target.
453 #define NETCONSOLE_TARGET_ATTR_RO(_name) \
454 static struct netconsole_target_attr netconsole_target_##_name = \
455 __CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL)
457 #define NETCONSOLE_TARGET_ATTR_RW(_name) \
458 static struct netconsole_target_attr netconsole_target_##_name = \
459 __CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name)
461 NETCONSOLE_TARGET_ATTR_RW(enabled);
462 NETCONSOLE_TARGET_ATTR_RW(dev_name);
463 NETCONSOLE_TARGET_ATTR_RW(local_port);
464 NETCONSOLE_TARGET_ATTR_RW(remote_port);
465 NETCONSOLE_TARGET_ATTR_RW(local_ip);
466 NETCONSOLE_TARGET_ATTR_RW(remote_ip);
467 NETCONSOLE_TARGET_ATTR_RO(local_mac);
468 NETCONSOLE_TARGET_ATTR_RW(remote_mac);
470 static struct configfs_attribute *netconsole_target_attrs[] = {
471 &netconsole_target_enabled.attr,
472 &netconsole_target_dev_name.attr,
473 &netconsole_target_local_port.attr,
474 &netconsole_target_remote_port.attr,
475 &netconsole_target_local_ip.attr,
476 &netconsole_target_remote_ip.attr,
477 &netconsole_target_local_mac.attr,
478 &netconsole_target_remote_mac.attr,
483 * Item operations and type for netconsole_target.
486 static void netconsole_target_release(struct config_item *item)
488 kfree(to_target(item));
491 static ssize_t netconsole_target_attr_show(struct config_item *item,
492 struct configfs_attribute *attr,
495 ssize_t ret = -EINVAL;
496 struct netconsole_target *nt = to_target(item);
497 struct netconsole_target_attr *na =
498 container_of(attr, struct netconsole_target_attr, attr);
501 ret = na->show(nt, buf);
506 static ssize_t netconsole_target_attr_store(struct config_item *item,
507 struct configfs_attribute *attr,
511 ssize_t ret = -EINVAL;
512 struct netconsole_target *nt = to_target(item);
513 struct netconsole_target_attr *na =
514 container_of(attr, struct netconsole_target_attr, attr);
517 ret = na->store(nt, buf, count);
522 static struct configfs_item_operations netconsole_target_item_ops = {
523 .release = netconsole_target_release,
524 .show_attribute = netconsole_target_attr_show,
525 .store_attribute = netconsole_target_attr_store,
528 static struct config_item_type netconsole_target_type = {
529 .ct_attrs = netconsole_target_attrs,
530 .ct_item_ops = &netconsole_target_item_ops,
531 .ct_owner = THIS_MODULE,
535 * Group operations and type for netconsole_subsys.
538 static struct config_item *make_netconsole_target(struct config_group *group,
542 struct netconsole_target *nt;
545 * Allocate and initialize with defaults.
546 * Target is disabled at creation (enabled == 0).
548 nt = kzalloc(sizeof(*nt), GFP_KERNEL);
550 printk(KERN_ERR "netconsole: failed to allocate memory\n");
551 return ERR_PTR(-ENOMEM);
554 nt->np.name = "netconsole";
555 strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
556 nt->np.local_port = 6665;
557 nt->np.remote_port = 6666;
558 memset(nt->np.remote_mac, 0xff, ETH_ALEN);
560 /* Initialize the config_item member */
561 config_item_init_type_name(&nt->item, name, &netconsole_target_type);
563 /* Adding, but it is disabled */
564 spin_lock_irqsave(&target_list_lock, flags);
565 list_add(&nt->list, &target_list);
566 spin_unlock_irqrestore(&target_list_lock, flags);
571 static void drop_netconsole_target(struct config_group *group,
572 struct config_item *item)
575 struct netconsole_target *nt = to_target(item);
577 spin_lock_irqsave(&target_list_lock, flags);
579 spin_unlock_irqrestore(&target_list_lock, flags);
582 * The target may have never been enabled, or was manually disabled
583 * before being removed so netpoll may have already been cleaned up.
586 netpoll_cleanup(&nt->np);
588 config_item_put(&nt->item);
591 static struct configfs_group_operations netconsole_subsys_group_ops = {
592 .make_item = make_netconsole_target,
593 .drop_item = drop_netconsole_target,
596 static struct config_item_type netconsole_subsys_type = {
597 .ct_group_ops = &netconsole_subsys_group_ops,
598 .ct_owner = THIS_MODULE,
601 /* The netconsole configfs subsystem */
602 static struct configfs_subsystem netconsole_subsys = {
605 .ci_namebuf = "netconsole",
606 .ci_type = &netconsole_subsys_type,
611 #endif /* CONFIG_NETCONSOLE_DYNAMIC */
613 /* Handle network interface device notifications */
614 static int netconsole_netdev_event(struct notifier_block *this,
619 struct netconsole_target *nt;
620 struct net_device *dev = ptr;
621 bool stopped = false;
623 if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
624 event == NETDEV_RELEASE || event == NETDEV_JOIN))
627 spin_lock_irqsave(&target_list_lock, flags);
628 list_for_each_entry(nt, &target_list, list) {
629 netconsole_target_get(nt);
630 if (nt->np.dev == dev) {
632 case NETDEV_CHANGENAME:
633 strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
637 case NETDEV_UNREGISTER:
639 * rtnl_lock already held
642 spin_unlock_irqrestore(
645 __netpoll_cleanup(&nt->np);
646 spin_lock_irqsave(&target_list_lock,
650 netconsole_target_put(nt);
657 netconsole_target_put(nt);
659 spin_unlock_irqrestore(&target_list_lock, flags);
661 printk(KERN_INFO "netconsole: network logging stopped on "
662 "interface %s as it ", dev->name);
664 case NETDEV_UNREGISTER:
665 printk(KERN_CONT "unregistered\n");
668 printk(KERN_CONT "released slaves\n");
671 printk(KERN_CONT "is joining a master device\n");
680 static struct notifier_block netconsole_netdev_notifier = {
681 .notifier_call = netconsole_netdev_event,
684 static void write_msg(struct console *con, const char *msg, unsigned int len)
688 struct netconsole_target *nt;
691 /* Avoid taking lock and disabling interrupts unnecessarily */
692 if (list_empty(&target_list))
695 spin_lock_irqsave(&target_list_lock, flags);
696 list_for_each_entry(nt, &target_list, list) {
697 netconsole_target_get(nt);
698 if (nt->enabled && netif_running(nt->np.dev)) {
700 * We nest this inside the for-each-target loop above
701 * so that we're able to get as much logging out to
702 * at least one target if we die inside here, instead
703 * of unnecessarily keeping all targets in lock-step.
706 for (left = len; left;) {
707 frag = min(left, MAX_PRINT_CHUNK);
708 netpoll_send_udp(&nt->np, tmp, frag);
713 netconsole_target_put(nt);
715 spin_unlock_irqrestore(&target_list_lock, flags);
718 static struct console netconsole = {
720 .flags = CON_ENABLED,
724 static int __init init_netconsole(void)
727 struct netconsole_target *nt, *tmp;
730 char *input = config;
732 if (strnlen(input, MAX_PARAM_LENGTH)) {
733 while ((target_config = strsep(&input, ";"))) {
734 nt = alloc_param_target(target_config);
739 /* Dump existing printks when we register */
740 netconsole.flags |= CON_PRINTBUFFER;
742 spin_lock_irqsave(&target_list_lock, flags);
743 list_add(&nt->list, &target_list);
744 spin_unlock_irqrestore(&target_list_lock, flags);
748 err = register_netdevice_notifier(&netconsole_netdev_notifier);
752 err = dynamic_netconsole_init();
756 register_console(&netconsole);
757 printk(KERN_INFO "netconsole: network logging started\n");
762 unregister_netdevice_notifier(&netconsole_netdev_notifier);
765 printk(KERN_ERR "netconsole: cleaning up\n");
768 * Remove all targets and destroy them (only targets created
769 * from the boot/module option exist here). Skipping the list
770 * lock is safe here, and netpoll_cleanup() will sleep.
772 list_for_each_entry_safe(nt, tmp, &target_list, list) {
774 free_param_target(nt);
780 static void __exit cleanup_netconsole(void)
782 struct netconsole_target *nt, *tmp;
784 unregister_console(&netconsole);
785 dynamic_netconsole_exit();
786 unregister_netdevice_notifier(&netconsole_netdev_notifier);
789 * Targets created via configfs pin references on our module
790 * and would first be rmdir(2)'ed from userspace. We reach
791 * here only when they are already destroyed, and only those
792 * created from the boot/module option are left, so remove and
793 * destroy them. Skipping the list lock is safe here, and
794 * netpoll_cleanup() will sleep.
796 list_for_each_entry_safe(nt, tmp, &target_list, list) {
798 free_param_target(nt);
802 module_init(init_netconsole);
803 module_exit(cleanup_netconsole);