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