PageRenderTime 94ms CodeModel.GetById 37ms app.highlight 51ms RepoModel.GetById 2ms app.codeStats 0ms

/drivers/net/netconsole.c

https://gitlab.com/TeamCarbonXtreme/android_kernel_samsung_bcm21553-common
C | 824 lines | 533 code | 139 blank | 152 comment | 58 complexity | 0c7399c1929cd33582414ed072123590 MD5 | raw file
  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>
 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>
 47
 48MODULE_AUTHOR("Maintainer: Matt Mackall <mpm@selenic.com>");
 49MODULE_DESCRIPTION("Console driver for network interfaces");
 50MODULE_LICENSE("GPL");
 51
 52#define MAX_PARAM_LENGTH	256
 53#define MAX_PRINT_CHUNK		1000
 54
 55static char config[MAX_PARAM_LENGTH];
 56module_param_string(netconsole, config, MAX_PARAM_LENGTH, 0);
 57MODULE_PARM_DESC(netconsole, " netconsole=[src-port]@[src-ip]/[dev],[tgt-port]@<tgt-ip>/[tgt-macaddr]");
 58
 59#ifndef	MODULE
 60static int __init option_setup(char *opt)
 61{
 62	strlcpy(config, opt, MAX_PARAM_LENGTH);
 63	return 1;
 64}
 65__setup("netconsole=", option_setup);
 66#endif	/* MODULE */
 67
 68/* Linked list of all configured targets */
 69static LIST_HEAD(target_list);
 70
 71/* This needs to be a spinlock because write_msg() cannot sleep */
 72static DEFINE_SPINLOCK(target_list_lock);
 73
 74/**
 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)
 93 */
 94struct netconsole_target {
 95	struct list_head	list;
 96#ifdef	CONFIG_NETCONSOLE_DYNAMIC
 97	struct config_item	item;
 98#endif
 99	int			enabled;
100	struct netpoll		np;
101};
102
103#ifdef	CONFIG_NETCONSOLE_DYNAMIC
104
105static struct configfs_subsystem netconsole_subsys;
106
107static int __init dynamic_netconsole_init(void)
108{
109	config_group_init(&netconsole_subsys.su_group);
110	mutex_init(&netconsole_subsys.su_mutex);
111	return configfs_register_subsystem(&netconsole_subsys);
112}
113
114static void __exit dynamic_netconsole_exit(void)
115{
116	configfs_unregister_subsystem(&netconsole_subsys);
117}
118
119/*
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.
123 */
124static void netconsole_target_get(struct netconsole_target *nt)
125{
126	if (config_item_name(&nt->item))
127		config_item_get(&nt->item);
128}
129
130static void netconsole_target_put(struct netconsole_target *nt)
131{
132	if (config_item_name(&nt->item))
133		config_item_put(&nt->item);
134}
135
136#else	/* !CONFIG_NETCONSOLE_DYNAMIC */
137
138static int __init dynamic_netconsole_init(void)
139{
140	return 0;
141}
142
143static void __exit dynamic_netconsole_exit(void)
144{
145}
146
147/*
148 * No danger of targets going away from under us when dynamic
149 * reconfigurability is off.
150 */
151static void netconsole_target_get(struct netconsole_target *nt)
152{
153}
154
155static void netconsole_target_put(struct netconsole_target *nt)
156{
157}
158
159#endif	/* CONFIG_NETCONSOLE_DYNAMIC */
160
161/* Allocate new target (from boot/module param) and setup netpoll for it */
162static struct netconsole_target *alloc_param_target(char *target_config)
163{
164	int err = -ENOMEM;
165	struct netconsole_target *nt;
166
167	/*
168	 * Allocate and initialize with defaults.
169	 * Note that these targets get their config_item fields zeroed-out.
170	 */
171	nt = kzalloc(sizeof(*nt), GFP_KERNEL);
172	if (!nt) {
173		printk(KERN_ERR "netconsole: failed to allocate memory\n");
174		goto fail;
175	}
176
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);
182
183	/* Parse parameters and setup netpoll */
184	err = netpoll_parse_options(&nt->np, target_config);
185	if (err)
186		goto fail;
187
188	err = netpoll_setup(&nt->np);
189	if (err)
190		goto fail;
191
192	nt->enabled = 1;
193
194	return nt;
195
196fail:
197	kfree(nt);
198	return ERR_PTR(err);
199}
200
201/* Cleanup netpoll for given target (from boot/module param) and free it */
202static void free_param_target(struct netconsole_target *nt)
203{
204	netpoll_cleanup(&nt->np);
205	kfree(nt);
206}
207
208#ifdef	CONFIG_NETCONSOLE_DYNAMIC
209
210/*
211 * Our subsystem hierarchy is:
212 *
213 * /sys/kernel/config/netconsole/
214 *				|
215 *				<target>/
216 *				|	enabled
217 *				|	dev_name
218 *				|	local_port
219 *				|	remote_port
220 *				|	local_ip
221 *				|	remote_ip
222 *				|	local_mac
223 *				|	remote_mac
224 *				|
225 *				<target>/...
226 */
227
228struct netconsole_target_attr {
229	struct configfs_attribute	attr;
230	ssize_t				(*show)(struct netconsole_target *nt,
231						char *buf);
232	ssize_t				(*store)(struct netconsole_target *nt,
233						 const char *buf,
234						 size_t count);
235};
236
237static struct netconsole_target *to_target(struct config_item *item)
238{
239	return item ?
240		container_of(item, struct netconsole_target, item) :
241		NULL;
242}
243
244/*
245 * Wrapper over simple_strtol (base 10) with sanity and range checking.
246 * We return (signed) long only because we may want to return errors.
247 * Do not use this to convert numbers that are allowed to be negative.
248 */
249static long strtol10_check_range(const char *cp, long min, long max)
250{
251	long ret;
252	char *p = (char *) cp;
253
254	WARN_ON(min < 0);
255	WARN_ON(max < min);
256
257	ret = simple_strtol(p, &p, 10);
258
259	if (*p && (*p != '\n')) {
260		printk(KERN_ERR "netconsole: invalid input\n");
261		return -EINVAL;
262	}
263	if ((ret < min) || (ret > max)) {
264		printk(KERN_ERR "netconsole: input %ld must be between "
265				"%ld and %ld\n", ret, min, max);
266		return -EINVAL;
267	}
268
269	return ret;
270}
271
272/*
273 * Attribute operations for netconsole_target.
274 */
275
276static ssize_t show_enabled(struct netconsole_target *nt, char *buf)
277{
278	return snprintf(buf, PAGE_SIZE, "%d\n", nt->enabled);
279}
280
281static ssize_t show_dev_name(struct netconsole_target *nt, char *buf)
282{
283	return snprintf(buf, PAGE_SIZE, "%s\n", nt->np.dev_name);
284}
285
286static ssize_t show_local_port(struct netconsole_target *nt, char *buf)
287{
288	return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.local_port);
289}
290
291static ssize_t show_remote_port(struct netconsole_target *nt, char *buf)
292{
293	return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.remote_port);
294}
295
296static ssize_t show_local_ip(struct netconsole_target *nt, char *buf)
297{
298	return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip);
299}
300
301static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf)
302{
303	return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip);
304}
305
306static ssize_t show_local_mac(struct netconsole_target *nt, char *buf)
307{
308	struct net_device *dev = nt->np.dev;
309	static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
310
311	return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast);
312}
313
314static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
315{
316	return snprintf(buf, PAGE_SIZE, "%pM\n", nt->np.remote_mac);
317}
318
319/*
320 * This one is special -- targets created through the configfs interface
321 * are not enabled (and the corresponding netpoll activated) by default.
322 * The user is expected to set the desired parameters first (which
323 * would enable him to dynamically add new netpoll targets for new
324 * network interfaces as and when they come up).
325 */
326static ssize_t store_enabled(struct netconsole_target *nt,
327			     const char *buf,
328			     size_t count)
329{
330	int err;
331	long enabled;
332
333	enabled = strtol10_check_range(buf, 0, 1);
334	if (enabled < 0)
335		return enabled;
336
337	if (enabled) {	/* 1 */
338
339		/*
340		 * Skip netpoll_parse_options() -- all the attributes are
341		 * already configured via configfs. Just print them out.
342		 */
343		netpoll_print_options(&nt->np);
344
345		err = netpoll_setup(&nt->np);
346		if (err)
347			return err;
348
349		printk(KERN_INFO "netconsole: network logging started\n");
350
351	} else {	/* 0 */
352		netpoll_cleanup(&nt->np);
353	}
354
355	nt->enabled = enabled;
356
357	return strnlen(buf, count);
358}
359
360static ssize_t store_dev_name(struct netconsole_target *nt,
361			      const char *buf,
362			      size_t count)
363{
364	size_t len;
365
366	if (nt->enabled) {
367		printk(KERN_ERR "netconsole: target (%s) is enabled, "
368				"disable to update parameters\n",
369				config_item_name(&nt->item));
370		return -EINVAL;
371	}
372
373	strlcpy(nt->np.dev_name, buf, IFNAMSIZ);
374
375	/* Get rid of possible trailing newline from echo(1) */
376	len = strnlen(nt->np.dev_name, IFNAMSIZ);
377	if (nt->np.dev_name[len - 1] == '\n')
378		nt->np.dev_name[len - 1] = '\0';
379
380	return strnlen(buf, count);
381}
382
383static ssize_t store_local_port(struct netconsole_target *nt,
384				const char *buf,
385				size_t count)
386{
387	long local_port;
388#define __U16_MAX	((__u16) ~0U)
389
390	if (nt->enabled) {
391		printk(KERN_ERR "netconsole: target (%s) is enabled, "
392				"disable to update parameters\n",
393				config_item_name(&nt->item));
394		return -EINVAL;
395	}
396
397	local_port = strtol10_check_range(buf, 0, __U16_MAX);
398	if (local_port < 0)
399		return local_port;
400
401	nt->np.local_port = local_port;
402
403	return strnlen(buf, count);
404}
405
406static ssize_t store_remote_port(struct netconsole_target *nt,
407				 const char *buf,
408				 size_t count)
409{
410	long remote_port;
411#define __U16_MAX	((__u16) ~0U)
412
413	if (nt->enabled) {
414		printk(KERN_ERR "netconsole: target (%s) is enabled, "
415				"disable to update parameters\n",
416				config_item_name(&nt->item));
417		return -EINVAL;
418	}
419
420	remote_port = strtol10_check_range(buf, 0, __U16_MAX);
421	if (remote_port < 0)
422		return remote_port;
423
424	nt->np.remote_port = remote_port;
425
426	return strnlen(buf, count);
427}
428
429static ssize_t store_local_ip(struct netconsole_target *nt,
430			      const char *buf,
431			      size_t count)
432{
433	if (nt->enabled) {
434		printk(KERN_ERR "netconsole: target (%s) is enabled, "
435				"disable to update parameters\n",
436				config_item_name(&nt->item));
437		return -EINVAL;
438	}
439
440	nt->np.local_ip = in_aton(buf);
441
442	return strnlen(buf, count);
443}
444
445static ssize_t store_remote_ip(struct netconsole_target *nt,
446			       const char *buf,
447			       size_t count)
448{
449	if (nt->enabled) {
450		printk(KERN_ERR "netconsole: target (%s) is enabled, "
451				"disable to update parameters\n",
452				config_item_name(&nt->item));
453		return -EINVAL;
454	}
455
456	nt->np.remote_ip = in_aton(buf);
457
458	return strnlen(buf, count);
459}
460
461static ssize_t store_remote_mac(struct netconsole_target *nt,
462				const char *buf,
463				size_t count)
464{
465	u8 remote_mac[ETH_ALEN];
466	char *p = (char *) buf;
467	int i;
468
469	if (nt->enabled) {
470		printk(KERN_ERR "netconsole: target (%s) is enabled, "
471				"disable to update parameters\n",
472				config_item_name(&nt->item));
473		return -EINVAL;
474	}
475
476	for (i = 0; i < ETH_ALEN - 1; i++) {
477		remote_mac[i] = simple_strtoul(p, &p, 16);
478		if (*p != ':')
479			goto invalid;
480		p++;
481	}
482	remote_mac[ETH_ALEN - 1] = simple_strtoul(p, &p, 16);
483	if (*p && (*p != '\n'))
484		goto invalid;
485
486	memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
487
488	return strnlen(buf, count);
489
490invalid:
491	printk(KERN_ERR "netconsole: invalid input\n");
492	return -EINVAL;
493}
494
495/*
496 * Attribute definitions for netconsole_target.
497 */
498
499#define NETCONSOLE_TARGET_ATTR_RO(_name)				\
500static struct netconsole_target_attr netconsole_target_##_name =	\
501	__CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL)
502
503#define NETCONSOLE_TARGET_ATTR_RW(_name)				\
504static struct netconsole_target_attr netconsole_target_##_name =	\
505	__CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name)
506
507NETCONSOLE_TARGET_ATTR_RW(enabled);
508NETCONSOLE_TARGET_ATTR_RW(dev_name);
509NETCONSOLE_TARGET_ATTR_RW(local_port);
510NETCONSOLE_TARGET_ATTR_RW(remote_port);
511NETCONSOLE_TARGET_ATTR_RW(local_ip);
512NETCONSOLE_TARGET_ATTR_RW(remote_ip);
513NETCONSOLE_TARGET_ATTR_RO(local_mac);
514NETCONSOLE_TARGET_ATTR_RW(remote_mac);
515
516static struct configfs_attribute *netconsole_target_attrs[] = {
517	&netconsole_target_enabled.attr,
518	&netconsole_target_dev_name.attr,
519	&netconsole_target_local_port.attr,
520	&netconsole_target_remote_port.attr,
521	&netconsole_target_local_ip.attr,
522	&netconsole_target_remote_ip.attr,
523	&netconsole_target_local_mac.attr,
524	&netconsole_target_remote_mac.attr,
525	NULL,
526};
527
528/*
529 * Item operations and type for netconsole_target.
530 */
531
532static void netconsole_target_release(struct config_item *item)
533{
534	kfree(to_target(item));
535}
536
537static ssize_t netconsole_target_attr_show(struct config_item *item,
538					   struct configfs_attribute *attr,
539					   char *buf)
540{
541	ssize_t ret = -EINVAL;
542	struct netconsole_target *nt = to_target(item);
543	struct netconsole_target_attr *na =
544		container_of(attr, struct netconsole_target_attr, attr);
545
546	if (na->show)
547		ret = na->show(nt, buf);
548
549	return ret;
550}
551
552static ssize_t netconsole_target_attr_store(struct config_item *item,
553					    struct configfs_attribute *attr,
554					    const char *buf,
555					    size_t count)
556{
557	ssize_t ret = -EINVAL;
558	struct netconsole_target *nt = to_target(item);
559	struct netconsole_target_attr *na =
560		container_of(attr, struct netconsole_target_attr, attr);
561
562	if (na->store)
563		ret = na->store(nt, buf, count);
564
565	return ret;
566}
567
568static struct configfs_item_operations netconsole_target_item_ops = {
569	.release		= netconsole_target_release,
570	.show_attribute		= netconsole_target_attr_show,
571	.store_attribute	= netconsole_target_attr_store,
572};
573
574static struct config_item_type netconsole_target_type = {
575	.ct_attrs		= netconsole_target_attrs,
576	.ct_item_ops		= &netconsole_target_item_ops,
577	.ct_owner		= THIS_MODULE,
578};
579
580/*
581 * Group operations and type for netconsole_subsys.
582 */
583
584static struct config_item *make_netconsole_target(struct config_group *group,
585						  const char *name)
586{
587	unsigned long flags;
588	struct netconsole_target *nt;
589
590	/*
591	 * Allocate and initialize with defaults.
592	 * Target is disabled at creation (enabled == 0).
593	 */
594	nt = kzalloc(sizeof(*nt), GFP_KERNEL);
595	if (!nt) {
596		printk(KERN_ERR "netconsole: failed to allocate memory\n");
597		return ERR_PTR(-ENOMEM);
598	}
599
600	nt->np.name = "netconsole";
601	strlcpy(nt->np.dev_name, "eth0", IFNAMSIZ);
602	nt->np.local_port = 6665;
603	nt->np.remote_port = 6666;
604	memset(nt->np.remote_mac, 0xff, ETH_ALEN);
605
606	/* Initialize the config_item member */
607	config_item_init_type_name(&nt->item, name, &netconsole_target_type);
608
609	/* Adding, but it is disabled */
610	spin_lock_irqsave(&target_list_lock, flags);
611	list_add(&nt->list, &target_list);
612	spin_unlock_irqrestore(&target_list_lock, flags);
613
614	return &nt->item;
615}
616
617static void drop_netconsole_target(struct config_group *group,
618				   struct config_item *item)
619{
620	unsigned long flags;
621	struct netconsole_target *nt = to_target(item);
622
623	spin_lock_irqsave(&target_list_lock, flags);
624	list_del(&nt->list);
625	spin_unlock_irqrestore(&target_list_lock, flags);
626
627	/*
628	 * The target may have never been enabled, or was manually disabled
629	 * before being removed so netpoll may have already been cleaned up.
630	 */
631	if (nt->enabled)
632		netpoll_cleanup(&nt->np);
633
634	config_item_put(&nt->item);
635}
636
637static struct configfs_group_operations netconsole_subsys_group_ops = {
638	.make_item	= make_netconsole_target,
639	.drop_item	= drop_netconsole_target,
640};
641
642static struct config_item_type netconsole_subsys_type = {
643	.ct_group_ops	= &netconsole_subsys_group_ops,
644	.ct_owner	= THIS_MODULE,
645};
646
647/* The netconsole configfs subsystem */
648static struct configfs_subsystem netconsole_subsys = {
649	.su_group	= {
650		.cg_item	= {
651			.ci_namebuf	= "netconsole",
652			.ci_type	= &netconsole_subsys_type,
653		},
654	},
655};
656
657#endif	/* CONFIG_NETCONSOLE_DYNAMIC */
658
659/* Handle network interface device notifications */
660static int netconsole_netdev_event(struct notifier_block *this,
661				   unsigned long event,
662				   void *ptr)
663{
664	unsigned long flags;
665	struct netconsole_target *nt;
666	struct net_device *dev = ptr;
667
668	if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
669	      event == NETDEV_BONDING_DESLAVE || event == NETDEV_GOING_DOWN))
670		goto done;
671
672	spin_lock_irqsave(&target_list_lock, flags);
673	list_for_each_entry(nt, &target_list, list) {
674		netconsole_target_get(nt);
675		if (nt->np.dev == dev) {
676			switch (event) {
677			case NETDEV_CHANGENAME:
678				strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
679				break;
680			case NETDEV_UNREGISTER:
681				netpoll_cleanup(&nt->np);
682				/* Fall through */
683			case NETDEV_GOING_DOWN:
684			case NETDEV_BONDING_DESLAVE:
685				nt->enabled = 0;
686				break;
687			}
688		}
689		netconsole_target_put(nt);
690	}
691	spin_unlock_irqrestore(&target_list_lock, flags);
692	if (event == NETDEV_UNREGISTER || event == NETDEV_BONDING_DESLAVE)
693		printk(KERN_INFO "netconsole: network logging stopped, "
694			"interface %s %s\n",  dev->name,
695			event == NETDEV_UNREGISTER ? "unregistered" : "released slaves");
696
697done:
698	return NOTIFY_DONE;
699}
700
701static struct notifier_block netconsole_netdev_notifier = {
702	.notifier_call  = netconsole_netdev_event,
703};
704
705static void write_msg(struct console *con, const char *msg, unsigned int len)
706{
707	int frag, left;
708	unsigned long flags;
709	struct netconsole_target *nt;
710	const char *tmp;
711
712	/* Avoid taking lock and disabling interrupts unnecessarily */
713	if (list_empty(&target_list))
714		return;
715
716	spin_lock_irqsave(&target_list_lock, flags);
717	list_for_each_entry(nt, &target_list, list) {
718		netconsole_target_get(nt);
719		if (nt->enabled && netif_running(nt->np.dev)) {
720			/*
721			 * We nest this inside the for-each-target loop above
722			 * so that we're able to get as much logging out to
723			 * at least one target if we die inside here, instead
724			 * of unnecessarily keeping all targets in lock-step.
725			 */
726			tmp = msg;
727			for (left = len; left;) {
728				frag = min(left, MAX_PRINT_CHUNK);
729				netpoll_send_udp(&nt->np, tmp, frag);
730				tmp += frag;
731				left -= frag;
732			}
733		}
734		netconsole_target_put(nt);
735	}
736	spin_unlock_irqrestore(&target_list_lock, flags);
737}
738
739static struct console netconsole = {
740	.name	= "netcon",
741	.flags	= CON_ENABLED,
742	.write	= write_msg,
743};
744
745static int __init init_netconsole(void)
746{
747	int err;
748	struct netconsole_target *nt, *tmp;
749	unsigned long flags;
750	char *target_config;
751	char *input = config;
752
753	if (strnlen(input, MAX_PARAM_LENGTH)) {
754		while ((target_config = strsep(&input, ";"))) {
755			nt = alloc_param_target(target_config);
756			if (IS_ERR(nt)) {
757				err = PTR_ERR(nt);
758				goto fail;
759			}
760			/* Dump existing printks when we register */
761			netconsole.flags |= CON_PRINTBUFFER;
762
763			spin_lock_irqsave(&target_list_lock, flags);
764			list_add(&nt->list, &target_list);
765			spin_unlock_irqrestore(&target_list_lock, flags);
766		}
767	}
768
769	err = register_netdevice_notifier(&netconsole_netdev_notifier);
770	if (err)
771		goto fail;
772
773	err = dynamic_netconsole_init();
774	if (err)
775		goto undonotifier;
776
777	register_console(&netconsole);
778	printk(KERN_INFO "netconsole: network logging started\n");
779
780	return err;
781
782undonotifier:
783	unregister_netdevice_notifier(&netconsole_netdev_notifier);
784
785fail:
786	printk(KERN_ERR "netconsole: cleaning up\n");
787
788	/*
789	 * Remove all targets and destroy them (only targets created
790	 * from the boot/module option exist here). Skipping the list
791	 * lock is safe here, and netpoll_cleanup() will sleep.
792	 */
793	list_for_each_entry_safe(nt, tmp, &target_list, list) {
794		list_del(&nt->list);
795		free_param_target(nt);
796	}
797
798	return err;
799}
800
801static void __exit cleanup_netconsole(void)
802{
803	struct netconsole_target *nt, *tmp;
804
805	unregister_console(&netconsole);
806	dynamic_netconsole_exit();
807	unregister_netdevice_notifier(&netconsole_netdev_notifier);
808
809	/*
810	 * Targets created via configfs pin references on our module
811	 * and would first be rmdir(2)'ed from userspace. We reach
812	 * here only when they are already destroyed, and only those
813	 * created from the boot/module option are left, so remove and
814	 * destroy them. Skipping the list lock is safe here, and
815	 * netpoll_cleanup() will sleep.
816	 */
817	list_for_each_entry_safe(nt, tmp, &target_list, list) {
818		list_del(&nt->list);
819		free_param_target(nt);
820	}
821}
822
823module_init(init_netconsole);
824module_exit(cleanup_netconsole);