[linux-2.6-block.git] / drivers / net / netconsole.c

/*
 *  linux/drivers/net/netconsole.c
 *
 *  Copyright (C) 2001  Ingo Molnar <mingo@redhat.com>
 *
 *  This file contains the implementation of an IRQ-safe, crash-safe
 *  kernel console implementation that outputs kernel messages to the
 *  network.
 *
 * Modification history:
 *
 * 2001-09-17    started by Ingo Molnar.
 * 2003-08-11    2.6 port by Matt Mackall
 *               simplified options
 *               generic card hooks
 *               works non-modular
 * 2003-09-07    rewritten with netpoll api
 */

/****************************************************************
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2, or (at your option)
 *      any later version.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 ****************************************************************/

#include <linux/mm.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/console.h>
#include <linux/moduleparam.h>
#include <linux/string.h>
#include <linux/netpoll.h>

MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
MODULE_DESCRIPTION("Console driver for network interfaces");
MODULE_LICENSE("GPL");

#define MAX_PARAM_LENGTH	256
#define MAX_PRINT_CHUNK		1000

static char config[MAX_PARAM_LENGTH];
module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0);
MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]\n");

#ifndef	MODULE
static int __init option_setup(char *opt)
{
	strlcpy(config, opt, MAX_PARAM_LENGTH);
	return 1;
}
__setup("netconsole=", option_setup);
#endif	/* MODULE */

/* Linked list of all configured targets */
static LIST_HEAD(target_list);

/* This needs to be a spinlock because write_msg() cannot sleep */
static DEFINE_SPINLOCK(target_list_lock);

/**
 * struct netconsole_target - Represents a configured netconsole target.
 * @list:	Links this target into the target_list.
 * @np:		The netpoll structure for this target.
 */
struct netconsole_target {
	struct list_head	list;
	struct netpoll		np;
};

/* Allocate new target and setup netpoll for it */
static struct netconsole_target *alloc_target(char *target_config)
{
	int err = -ENOMEM;
	struct netconsole_target *nt;

	/* Allocate and initialize with defaults */
	nt = kzalloc(sizeof(*nt), GFP_KERNEL);
	if (!nt) {
		printk(KERN_ERR "netconsole: failed to allocate memory\n");
		goto fail;
	}

	nt->np.name = "netconsole";
	strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
	nt->np.local_port = 6665;
	nt->np.remote_port = 6666;
	memset(nt->np.remote_mac, 0xff, ETH_ALEN);

	/* Parse parameters and setup netpoll */
	err = netpoll_parse_options(&nt->np, target_config);
	if (err)
		goto fail;

	err = netpoll_setup(&nt->np);
	if (err)
		goto fail;

	return nt;

fail:
	kfree(nt);
	return ERR_PTR(err);
}

/* Cleanup netpoll for given target and free it */
static void free_target(struct netconsole_target *nt)
{
	netpoll_cleanup(&nt->np);
	kfree(nt);
}

/* Handle network interface device notifications */
static int netconsole_netdev_event(struct notifier_block *this,
				   unsigned long event,
				   void *ptr)
{
	unsigned long flags;
	struct netconsole_target *nt;
	struct net_device *dev = ptr;

	if (!(event == NETDEV_CHANGEADDR || event == NETDEV_CHANGENAME))
		goto done;

	spin_lock_irqsave(&target_list_lock, flags);
	list_for_each_entry(nt, &target_list, list) {
		if (nt->np.dev == dev) {
			switch (event) {
			case NETDEV_CHANGEADDR:
				memcpy(nt->np.local_mac, dev->dev_addr, ETH_ALEN);
				break;

			case NETDEV_CHANGENAME:
				strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
				break;
			}
		}
	}
	spin_unlock_irqrestore(&target_list_lock, flags);

done:
	return NOTIFY_DONE;
}

static struct notifier_block netconsole_netdev_notifier = {
	.notifier_call  = netconsole_netdev_event,
};

static void write_msg(struct console *con, const char *msg, unsigned int len)
{
	int frag, left;
	unsigned long flags;
	struct netconsole_target *nt;
	const char *tmp;

	/* Avoid taking lock and disabling interrupts unnecessarily */
	if (list_empty(&target_list))
		return;

	spin_lock_irqsave(&target_list_lock, flags);
	list_for_each_entry(nt, &target_list, list) {
		if (netif_running(nt->np.dev)) {
			/*
			 * We nest this inside the for-each-target loop above
			 * so that we're able to get as much logging out to
			 * at least one target if we die inside here, instead
			 * of unnecessarily keeping all targets in lock-step.
			 */
			tmp = msg;
			for (left = len; left;) {
				frag = min(left, MAX_PRINT_CHUNK);
				netpoll_send_udp(&nt->np, tmp, frag);
				tmp += frag;
				left -= frag;
			}
		}
	}
	spin_unlock_irqrestore(&target_list_lock, flags);
}

static struct console netconsole = {
	.name	= "netcon",
	.flags	= CON_ENABLED | CON_PRINTBUFFER,
	.write	= write_msg,
};

static int __init init_netconsole(void)
{
	int err = 0;
	struct netconsole_target *nt, *tmp;
	unsigned long flags;
	char *target_config;
	char *input = config;

	if (!strnlen(input, MAX_PARAM_LENGTH)) {
		printk(KERN_INFO "netconsole: not configured, aborting\n");
		goto out;
	}

	while ((target_config = strsep(&input, ";"))) {
		nt = alloc_target(target_config);
		if (IS_ERR(nt)) {
			err = PTR_ERR(nt);
			goto fail;
		}
		spin_lock_irqsave(&target_list_lock, flags);
		list_add(&nt->list, &target_list);
		spin_unlock_irqrestore(&target_list_lock, flags);
	}

	err = register_netdevice_notifier(&netconsole_netdev_notifier);
	if (err)
		goto fail;

	register_console(&netconsole);
	printk(KERN_INFO "netconsole: network logging started\n");

out:
	return err;

fail:
	printk(KERN_ERR "netconsole: cleaning up\n");

	/*
	 * Remove all targets and destroy them. Skipping the list
	 * lock is safe here, and netpoll_cleanup() will sleep.
	 */
	list_for_each_entry_safe(nt, tmp, &target_list, list) {
		list_del(&nt->list);
		free_target(nt);
	}

	return err;
}

static void __exit cleanup_netconsole(void)
{
	struct netconsole_target *nt, *tmp;

	unregister_console(&netconsole);
	unregister_netdevice_notifier(&netconsole_netdev_notifier);

	/*
	 * Remove all targets and destroy them. Skipping the list
	 * lock is safe here, and netpoll_cleanup() will sleep.
	 */
	list_for_each_entry_safe(nt, tmp, &target_list, list) {
		list_del(&nt->list);
		free_target(nt);
	}
}

module_init(init_netconsole);
module_exit(cleanup_netconsole);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/drivers/net/netconsole.c
	3	*
	4	* Copyright (C) 2001 Ingo Molnar <mingo@redhat.com>
	5	*
	6	* This file contains the implementation of an IRQ-safe, crash-safe
	7	* kernel console implementation that outputs kernel messages to the
	8	* network.
	9	*
	10	* Modification history:
	11	*
	12	* 2001-09-17 started by Ingo Molnar.
	13	* 2003-08-11 2.6 port by Matt Mackall
	14	* simplified options
	15	* generic card hooks
	16	* works non-modular
	17	* 2003-09-07 rewritten with netpoll api
	18	*/
	19
	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)
	24	* any later version.
	25	*
	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.
	30	*
	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.
	34	*
	35	****************************************************************/
	36
	37	#include <linux/mm.h>
1da177e4 LT	38	#include <linux/init.h>
	39	#include <linux/module.h>
	40	#include <linux/console.h>
1da177e4 LT	41	#include <linux/moduleparam.h>
1da177e4 LT	42	#include <linux/string.h>
1da177e4 LT	43	#include <linux/netpoll.h>
	44
	45	MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
	46	MODULE_DESCRIPTION("Console driver for network interfaces");
	47	MODULE_LICENSE("GPL");
	48
d39badf0 SS	49	#define MAX_PARAM_LENGTH 256
	50	#define MAX_PRINT_CHUNK 1000
	51
	52	static char config[MAX_PARAM_LENGTH];
	53	module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0);
1da177e4 LT	54	MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]\n");
1da177e4 LT	55
d2b60881 SS	56	#ifndef MODULE
	57	static int __init option_setup(char *opt)
	58	{
	59	strlcpy(config, opt, MAX_PARAM_LENGTH);
	60	return 1;
	61	}
	62	__setup("netconsole=", option_setup);
	63	#endif /* MODULE */
	64
b5427c27 SS	65	/* Linked list of all configured targets */
	66	static LIST_HEAD(target_list);
	67
	68	/* This needs to be a spinlock because write_msg() cannot sleep */
	69	static DEFINE_SPINLOCK(target_list_lock);
	70
df180e36 SS	71	/**
df180e36 SS	72	* struct netconsole_target - Represents a configured netconsole target.
b5427c27	73	* @list: Links this target into the target_list.
df180e36 SS	74	* @np: The netpoll structure for this target.
	75	*/
	76	struct netconsole_target {
b5427c27	77	struct list_head list;
df180e36 SS	78	struct netpoll np;
	79	};
	80
b5427c27 SS	81	/* Allocate new target and setup netpoll for it */
	82	static struct netconsole_target alloc_target(char target_config)
	83	{
	84	int err = -ENOMEM;
	85	struct netconsole_target *nt;
	86
	87	/* Allocate and initialize with defaults */
	88	nt = kzalloc(sizeof(*nt), GFP_KERNEL);
	89	if (!nt) {
	90	printk(KERN_ERR "netconsole: failed to allocate memory\n");
	91	goto fail;
	92	}
	93
	94	nt->np.name = "netconsole";
	95	strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
	96	nt->np.local_port = 6665;
	97	nt->np.remote_port = 6666;
	98	memset(nt->np.remote_mac, 0xff, ETH_ALEN);
	99
	100	/* Parse parameters and setup netpoll */
	101	err = netpoll_parse_options(&nt->np, target_config);
	102	if (err)
	103	goto fail;
	104
	105	err = netpoll_setup(&nt->np);
	106	if (err)
	107	goto fail;
	108
	109	return nt;
	110
	111	fail:
	112	kfree(nt);
	113	return ERR_PTR(err);
	114	}
	115
	116	/* Cleanup netpoll for given target and free it */
	117	static void free_target(struct netconsole_target *nt)
	118	{
	119	netpoll_cleanup(&nt->np);
	120	kfree(nt);
	121	}
1da177e4	122
17951f34 SS	123	/* Handle network interface device notifications */
	124	static int netconsole_netdev_event(struct notifier_block *this,
	125	unsigned long event,
	126	void *ptr)
	127	{
b5427c27 SS	128	unsigned long flags;
b5427c27 SS	129	struct netconsole_target *nt;
17951f34	130	struct net_device *dev = ptr;
17951f34	131
b5427c27 SS	132	if (!(event == NETDEV_CHANGEADDR \|\| event == NETDEV_CHANGENAME))
	133	goto done;
	134
	135	spin_lock_irqsave(&target_list_lock, flags);
	136	list_for_each_entry(nt, &target_list, list) {
	137	if (nt->np.dev == dev) {
	138	switch (event) {
	139	case NETDEV_CHANGEADDR:
	140	memcpy(nt->np.local_mac, dev->dev_addr, ETH_ALEN);
	141	break;
17951f34	142
b5427c27 SS	143	case NETDEV_CHANGENAME:
	144	strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
	145	break;
	146	}
17951f34 SS	147	}
17951f34 SS	148	}
b5427c27	149	spin_unlock_irqrestore(&target_list_lock, flags);
17951f34	150
b5427c27	151	done:
17951f34 SS	152	return NOTIFY_DONE;
	153	}
	154
	155	static struct notifier_block netconsole_netdev_notifier = {
	156	.notifier_call = netconsole_netdev_event,
	157	};
	158
1da177e4 LT	159	static void write_msg(struct console con, const char msg, unsigned int len)
	160	{
	161	int frag, left;
	162	unsigned long flags;
b5427c27 SS	163	struct netconsole_target *nt;
	164	const char *tmp;
	165
	166	/* Avoid taking lock and disabling interrupts unnecessarily */
	167	if (list_empty(&target_list))
	168	return;
	169
	170	spin_lock_irqsave(&target_list_lock, flags);
	171	list_for_each_entry(nt, &target_list, list) {
	172	if (netif_running(nt->np.dev)) {
	173	/*
	174	* We nest this inside the for-each-target loop above
	175	* so that we're able to get as much logging out to
	176	* at least one target if we die inside here, instead
	177	* of unnecessarily keeping all targets in lock-step.
	178	*/
	179	tmp = msg;
	180	for (left = len; left;) {
	181	frag = min(left, MAX_PRINT_CHUNK);
	182	netpoll_send_udp(&nt->np, tmp, frag);
	183	tmp += frag;
	184	left -= frag;
	185	}
0cc120be	186	}
1da177e4	187	}
b5427c27	188	spin_unlock_irqrestore(&target_list_lock, flags);
1da177e4 LT	189	}
	190
	191	static struct console netconsole = {
d39badf0 SS	192	.name = "netcon",
	193	.flags = CON_ENABLED \| CON_PRINTBUFFER,
	194	.write = write_msg,
1da177e4 LT	195	};
1da177e4 LT	196
d39badf0	197	static int __init init_netconsole(void)
1da177e4	198	{
d39badf0	199	int err = 0;
b5427c27 SS	200	struct netconsole_target nt, tmp;
	201	unsigned long flags;
	202	char *target_config;
	203	char *input = config;
b41848b6	204
b5427c27	205	if (!strnlen(input, MAX_PARAM_LENGTH)) {
d39badf0 SS	206	printk(KERN_INFO "netconsole: not configured, aborting\n");
d39badf0 SS	207	goto out;
1da177e4 LT	208	}
1da177e4 LT	209
b5427c27 SS	210	while ((target_config = strsep(&input, ";"))) {
	211	nt = alloc_target(target_config);
	212	if (IS_ERR(nt)) {
	213	err = PTR_ERR(nt);
	214	goto fail;
	215	}
	216	spin_lock_irqsave(&target_list_lock, flags);
	217	list_add(&nt->list, &target_list);
	218	spin_unlock_irqrestore(&target_list_lock, flags);
	219	}
1da177e4	220
17951f34 SS	221	err = register_netdevice_notifier(&netconsole_netdev_notifier);
17951f34 SS	222	if (err)
b5427c27	223	goto fail;
17951f34	224
1da177e4 LT	225	register_console(&netconsole);
1da177e4 LT	226	printk(KERN_INFO "netconsole: network logging started\n");
d39badf0 SS	227
	228	out:
	229	return err;
b5427c27 SS	230
	231	fail:
	232	printk(KERN_ERR "netconsole: cleaning up\n");
	233
	234	/*
	235	* Remove all targets and destroy them. Skipping the list
	236	* lock is safe here, and netpoll_cleanup() will sleep.
	237	*/
	238	list_for_each_entry_safe(nt, tmp, &target_list, list) {
	239	list_del(&nt->list);
	240	free_target(nt);
	241	}
	242
	243	return err;
1da177e4 LT	244	}
1da177e4 LT	245
d39badf0	246	static void __exit cleanup_netconsole(void)
1da177e4	247	{
b5427c27	248	struct netconsole_target nt, tmp;
df180e36	249
1da177e4	250	unregister_console(&netconsole);
17951f34	251	unregister_netdevice_notifier(&netconsole_netdev_notifier);
b5427c27 SS	252
	253	/*
	254	* Remove all targets and destroy them. Skipping the list
	255	* lock is safe here, and netpoll_cleanup() will sleep.
	256	*/
	257	list_for_each_entry_safe(nt, tmp, &target_list, list) {
	258	list_del(&nt->list);
	259	free_target(nt);
	260	}
1da177e4 LT	261	}
	262
	263	module_init(init_netconsole);
	264	module_exit(cleanup_netconsole);