/*
   *  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/slab.h>

  #include <linux/console.h>

  #include <linux/moduleparam.h>
  #include <linux/string.h>

  #include <linux/netpoll.h>

  #include <linux/inet.h>
  #include <linux/configfs.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]");

  #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.

   * @item:	Links us into the configfs subsystem hierarchy.
   * @enabled:	On / off knob to enable / disable target.
   *		Visible from userspace (read-write).
   *		We maintain a strict 1:1 correspondence between this and
   *		whether the corresponding netpoll is active or inactive.
   *		Also, other parameters of a target may be modified at
   *		runtime only when it is disabled (enabled == 0).

   * @np:		The netpoll structure for this target.

   *		Contains the other userspace visible parameters:
   *		dev_name	(read-write)
   *		local_port	(read-write)
   *		remote_port	(read-write)
   *		local_ip	(read-write)
   *		remote_ip	(read-write)
   *		local_mac	(read-only)
   *		remote_mac	(read-write)

   */
  struct netconsole_target {

  	struct list_head	list;

  #ifdef	CONFIG_NETCONSOLE_DYNAMIC
  	struct config_item	item;
  #endif
  	int			enabled;

  	struct netpoll		np;
  };

  #ifdef	CONFIG_NETCONSOLE_DYNAMIC
  
  static struct configfs_subsystem netconsole_subsys;
  
  static int __init dynamic_netconsole_init(void)
  {
  	config_group_init(&netconsole_subsys.su_group);
  	mutex_init(&netconsole_subsys.su_mutex);
  	return configfs_register_subsystem(&netconsole_subsys);
  }
  
  static void __exit dynamic_netconsole_exit(void)
  {
  	configfs_unregister_subsystem(&netconsole_subsys);
  }
  
  /*
   * Targets that were created by parsing the boot/module option string
   * do not exist in the configfs hierarchy (and have NULL names) and will
   * never go away, so make these a no-op for them.
   */
  static void netconsole_target_get(struct netconsole_target *nt)
  {
  	if (config_item_name(&nt->item))
  		config_item_get(&nt->item);
  }
  
  static void netconsole_target_put(struct netconsole_target *nt)
  {
  	if (config_item_name(&nt->item))
  		config_item_put(&nt->item);
  }
  
  #else	/* !CONFIG_NETCONSOLE_DYNAMIC */
  
  static int __init dynamic_netconsole_init(void)
  {
  	return 0;
  }
  
  static void __exit dynamic_netconsole_exit(void)
  {
  }
  
  /*
   * No danger of targets going away from under us when dynamic
   * reconfigurability is off.
   */
  static void netconsole_target_get(struct netconsole_target *nt)
  {
  }
  
  static void netconsole_target_put(struct netconsole_target *nt)
  {
  }
  
  #endif	/* CONFIG_NETCONSOLE_DYNAMIC */
  
  /* Allocate new target (from boot/module param) and setup netpoll for it */
  static struct netconsole_target *alloc_param_target(char *target_config)

  {
  	int err = -ENOMEM;
  	struct netconsole_target *nt;

  	/*
  	 * Allocate and initialize with defaults.
  	 * Note that these targets get their config_item fields zeroed-out.
  	 */

  	nt = kzalloc(sizeof(*nt), GFP_KERNEL);
  	if (!nt) {
  		printk(KERN_ERR "netconsole: failed to allocate memory
  ");
  		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;

  	nt->enabled = 1;

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

  /* Cleanup netpoll for given target (from boot/module param) and free it */
  static void free_param_target(struct netconsole_target *nt)

  {
  	netpoll_cleanup(&nt->np);
  	kfree(nt);
  }

  #ifdef	CONFIG_NETCONSOLE_DYNAMIC
  
  /*
   * Our subsystem hierarchy is:
   *
   * /sys/kernel/config/netconsole/
   *				|
   *				<target>/
   *				|	enabled
   *				|	dev_name
   *				|	local_port
   *				|	remote_port
   *				|	local_ip
   *				|	remote_ip
   *				|	local_mac
   *				|	remote_mac
   *				|
   *				<target>/...
   */
  
  struct netconsole_target_attr {
  	struct configfs_attribute	attr;
  	ssize_t				(*show)(struct netconsole_target *nt,
  						char *buf);
  	ssize_t				(*store)(struct netconsole_target *nt,
  						 const char *buf,
  						 size_t count);
  };
  
  static struct netconsole_target *to_target(struct config_item *item)
  {
  	return item ?
  		container_of(item, struct netconsole_target, item) :
  		NULL;
  }
  
  /*

   * Attribute operations for netconsole_target.
   */
  
  static ssize_t show_enabled(struct netconsole_target *nt, char *buf)
  {
  	return snprintf(buf, PAGE_SIZE, "%d
  ", nt->enabled);
  }
  
  static ssize_t show_dev_name(struct netconsole_target *nt, char *buf)
  {
  	return snprintf(buf, PAGE_SIZE, "%s
  ", nt->np.dev_name);
  }
  
  static ssize_t show_local_port(struct netconsole_target *nt, char *buf)
  {
  	return snprintf(buf, PAGE_SIZE, "%d
  ", nt->np.local_port);
  }
  
  static ssize_t show_remote_port(struct netconsole_target *nt, char *buf)
  {
  	return snprintf(buf, PAGE_SIZE, "%d
  ", nt->np.remote_port);
  }
  
  static ssize_t show_local_ip(struct netconsole_target *nt, char *buf)
  {

  	return snprintf(buf, PAGE_SIZE, "%pI4
  ", &nt->np.local_ip);

  }
  
  static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf)
  {

  	return snprintf(buf, PAGE_SIZE, "%pI4
  ", &nt->np.remote_ip);

  }
  
  static ssize_t show_local_mac(struct netconsole_target *nt, char *buf)
  {

  	struct net_device *dev = nt->np.dev;

  	static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

  	return snprintf(buf, PAGE_SIZE, "%pM
  ", dev ? dev->dev_addr : bcast);

  }
  
  static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
  {

  	return snprintf(buf, PAGE_SIZE, "%pM
  ", nt->np.remote_mac);

  }
  
  /*
   * This one is special -- targets created through the configfs interface
   * are not enabled (and the corresponding netpoll activated) by default.
   * The user is expected to set the desired parameters first (which
   * would enable him to dynamically add new netpoll targets for new
   * network interfaces as and when they come up).
   */
  static ssize_t store_enabled(struct netconsole_target *nt,
  			     const char *buf,
  			     size_t count)
  {

  	int enabled;

  	int err;

  	err = kstrtoint(buf, 10, &enabled);
  	if (err < 0)
  		return err;
  	if (enabled < 0 || enabled > 1)
  		return -EINVAL;

  	if (enabled == nt->enabled) {
  		printk(KERN_INFO "netconsole: network logging has already %s
  ",
  				nt->enabled ? "started" : "stopped");
  		return -EINVAL;
  	}

  
  	if (enabled) {	/* 1 */
  
  		/*
  		 * Skip netpoll_parse_options() -- all the attributes are
  		 * already configured via configfs. Just print them out.
  		 */
  		netpoll_print_options(&nt->np);
  
  		err = netpoll_setup(&nt->np);
  		if (err)
  			return err;
  
  		printk(KERN_INFO "netconsole: network logging started
  ");
  
  	} else {	/* 0 */
  		netpoll_cleanup(&nt->np);
  	}
  
  	nt->enabled = enabled;
  
  	return strnlen(buf, count);
  }
  
  static ssize_t store_dev_name(struct netconsole_target *nt,
  			      const char *buf,
  			      size_t count)
  {
  	size_t len;
  
  	if (nt->enabled) {
  		printk(KERN_ERR "netconsole: target (%s) is enabled, "
  				"disable to update parameters
  ",
  				config_item_name(&nt->item));
  		return -EINVAL;
  	}
  
  	strlcpy(nt->np.dev_name, buf, IFNAMSIZ);
  
  	/* Get rid of possible trailing newline from echo(1) */
  	len = strnlen(nt->np.dev_name, IFNAMSIZ);
  	if (nt->np.dev_name[len - 1] == '
  ')
  		nt->np.dev_name[len - 1] = '\0';
  
  	return strnlen(buf, count);
  }
  
  static ssize_t store_local_port(struct netconsole_target *nt,
  				const char *buf,
  				size_t count)
  {

  	int rv;

  
  	if (nt->enabled) {
  		printk(KERN_ERR "netconsole: target (%s) is enabled, "
  				"disable to update parameters
  ",
  				config_item_name(&nt->item));
  		return -EINVAL;
  	}

  	rv = kstrtou16(buf, 10, &nt->np.local_port);
  	if (rv < 0)
  		return rv;

  	return strnlen(buf, count);
  }
  
  static ssize_t store_remote_port(struct netconsole_target *nt,
  				 const char *buf,
  				 size_t count)
  {

  	int rv;

  
  	if (nt->enabled) {
  		printk(KERN_ERR "netconsole: target (%s) is enabled, "
  				"disable to update parameters
  ",
  				config_item_name(&nt->item));
  		return -EINVAL;
  	}

  	rv = kstrtou16(buf, 10, &nt->np.remote_port);
  	if (rv < 0)
  		return rv;

  	return strnlen(buf, count);
  }
  
  static ssize_t store_local_ip(struct netconsole_target *nt,
  			      const char *buf,
  			      size_t count)
  {
  	if (nt->enabled) {
  		printk(KERN_ERR "netconsole: target (%s) is enabled, "
  				"disable to update parameters
  ",
  				config_item_name(&nt->item));
  		return -EINVAL;
  	}

  	nt->np.local_ip = in_aton(buf);

  
  	return strnlen(buf, count);
  }
  
  static ssize_t store_remote_ip(struct netconsole_target *nt,
  			       const char *buf,
  			       size_t count)
  {
  	if (nt->enabled) {
  		printk(KERN_ERR "netconsole: target (%s) is enabled, "
  				"disable to update parameters
  ",
  				config_item_name(&nt->item));
  		return -EINVAL;
  	}

  	nt->np.remote_ip = in_aton(buf);

  
  	return strnlen(buf, count);
  }
  
  static ssize_t store_remote_mac(struct netconsole_target *nt,
  				const char *buf,
  				size_t count)
  {
  	u8 remote_mac[ETH_ALEN];

  
  	if (nt->enabled) {
  		printk(KERN_ERR "netconsole: target (%s) is enabled, "
  				"disable to update parameters
  ",
  				config_item_name(&nt->item));
  		return -EINVAL;
  	}

  	if (!mac_pton(buf, remote_mac))
  		return -EINVAL;
  	if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '
  ')
  		return -EINVAL;

  	memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
  
  	return strnlen(buf, count);

  }
  
  /*
   * Attribute definitions for netconsole_target.
   */
  
  #define NETCONSOLE_TARGET_ATTR_RO(_name)				\
  static struct netconsole_target_attr netconsole_target_##_name =	\
  	__CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL)
  
  #define NETCONSOLE_TARGET_ATTR_RW(_name)				\
  static struct netconsole_target_attr netconsole_target_##_name =	\
  	__CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name)
  
  NETCONSOLE_TARGET_ATTR_RW(enabled);
  NETCONSOLE_TARGET_ATTR_RW(dev_name);
  NETCONSOLE_TARGET_ATTR_RW(local_port);
  NETCONSOLE_TARGET_ATTR_RW(remote_port);
  NETCONSOLE_TARGET_ATTR_RW(local_ip);
  NETCONSOLE_TARGET_ATTR_RW(remote_ip);
  NETCONSOLE_TARGET_ATTR_RO(local_mac);
  NETCONSOLE_TARGET_ATTR_RW(remote_mac);
  
  static struct configfs_attribute *netconsole_target_attrs[] = {
  	&netconsole_target_enabled.attr,
  	&netconsole_target_dev_name.attr,
  	&netconsole_target_local_port.attr,
  	&netconsole_target_remote_port.attr,
  	&netconsole_target_local_ip.attr,
  	&netconsole_target_remote_ip.attr,
  	&netconsole_target_local_mac.attr,
  	&netconsole_target_remote_mac.attr,
  	NULL,
  };
  
  /*
   * Item operations and type for netconsole_target.
   */
  
  static void netconsole_target_release(struct config_item *item)
  {
  	kfree(to_target(item));
  }
  
  static ssize_t netconsole_target_attr_show(struct config_item *item,
  					   struct configfs_attribute *attr,
  					   char *buf)
  {
  	ssize_t ret = -EINVAL;
  	struct netconsole_target *nt = to_target(item);
  	struct netconsole_target_attr *na =
  		container_of(attr, struct netconsole_target_attr, attr);
  
  	if (na->show)
  		ret = na->show(nt, buf);
  
  	return ret;
  }
  
  static ssize_t netconsole_target_attr_store(struct config_item *item,
  					    struct configfs_attribute *attr,
  					    const char *buf,
  					    size_t count)
  {
  	ssize_t ret = -EINVAL;
  	struct netconsole_target *nt = to_target(item);
  	struct netconsole_target_attr *na =
  		container_of(attr, struct netconsole_target_attr, attr);
  
  	if (na->store)
  		ret = na->store(nt, buf, count);
  
  	return ret;
  }
  
  static struct configfs_item_operations netconsole_target_item_ops = {
  	.release		= netconsole_target_release,
  	.show_attribute		= netconsole_target_attr_show,
  	.store_attribute	= netconsole_target_attr_store,
  };
  
  static struct config_item_type netconsole_target_type = {
  	.ct_attrs		= netconsole_target_attrs,
  	.ct_item_ops		= &netconsole_target_item_ops,
  	.ct_owner		= THIS_MODULE,
  };
  
  /*
   * Group operations and type for netconsole_subsys.
   */

  static struct config_item *make_netconsole_target(struct config_group *group,
  						  const char *name)

  {
  	unsigned long flags;
  	struct netconsole_target *nt;
  
  	/*
  	 * Allocate and initialize with defaults.
  	 * Target is disabled at creation (enabled == 0).
  	 */
  	nt = kzalloc(sizeof(*nt), GFP_KERNEL);
  	if (!nt) {
  		printk(KERN_ERR "netconsole: failed to allocate memory
  ");

  		return ERR_PTR(-ENOMEM);

  	}
  
  	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);
  
  	/* Initialize the config_item member */
  	config_item_init_type_name(&nt->item, name, &netconsole_target_type);
  
  	/* Adding, but it is disabled */
  	spin_lock_irqsave(&target_list_lock, flags);
  	list_add(&nt->list, &target_list);
  	spin_unlock_irqrestore(&target_list_lock, flags);

  	return &nt->item;

  }
  
  static void drop_netconsole_target(struct config_group *group,
  				   struct config_item *item)
  {
  	unsigned long flags;
  	struct netconsole_target *nt = to_target(item);
  
  	spin_lock_irqsave(&target_list_lock, flags);
  	list_del(&nt->list);
  	spin_unlock_irqrestore(&target_list_lock, flags);
  
  	/*
  	 * The target may have never been enabled, or was manually disabled
  	 * before being removed so netpoll may have already been cleaned up.
  	 */
  	if (nt->enabled)
  		netpoll_cleanup(&nt->np);
  
  	config_item_put(&nt->item);
  }
  
  static struct configfs_group_operations netconsole_subsys_group_ops = {
  	.make_item	= make_netconsole_target,
  	.drop_item	= drop_netconsole_target,
  };
  
  static struct config_item_type netconsole_subsys_type = {
  	.ct_group_ops	= &netconsole_subsys_group_ops,
  	.ct_owner	= THIS_MODULE,
  };
  
  /* The netconsole configfs subsystem */
  static struct configfs_subsystem netconsole_subsys = {
  	.su_group	= {
  		.cg_item	= {
  			.ci_namebuf	= "netconsole",
  			.ci_type	= &netconsole_subsys_type,
  		},
  	},
  };
  
  #endif	/* CONFIG_NETCONSOLE_DYNAMIC */

  /* 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;

  	bool stopped = false;

  	if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||

  	      event == NETDEV_RELEASE || event == NETDEV_JOIN))

  		goto done;
  
  	spin_lock_irqsave(&target_list_lock, flags);
  	list_for_each_entry(nt, &target_list, list) {

  		netconsole_target_get(nt);

  		if (nt->np.dev == dev) {
  			switch (event) {

  			case NETDEV_CHANGENAME:
  				strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
  				break;

  			case NETDEV_RELEASE:

  			case NETDEV_JOIN:

  			case NETDEV_UNREGISTER:

  				/*
  				 * rtnl_lock already held
  				 */
  				if (nt->np.dev) {

  					spin_unlock_irqrestore(
  							      &target_list_lock,
  							      flags);

  					__netpoll_cleanup(&nt->np);

  					spin_lock_irqsave(&target_list_lock,
  							  flags);

  					dev_put(nt->np.dev);
  					nt->np.dev = NULL;

  					netconsole_target_put(nt);

  				}

  				nt->enabled = 0;

  				stopped = true;

  				break;

  			}

  		}

  		netconsole_target_put(nt);

  	}

  	spin_unlock_irqrestore(&target_list_lock, flags);

  	if (stopped) {

  		printk(KERN_INFO "netconsole: network logging stopped on "

  		       "interface %s as it ", dev->name);
  		switch (event) {
  		case NETDEV_UNREGISTER:
  			printk(KERN_CONT "unregistered
  ");
  			break;

  		case NETDEV_RELEASE:

  			printk(KERN_CONT "released slaves
  ");
  			break;
  		case NETDEV_JOIN:
  			printk(KERN_CONT "is joining a master device
  ");
  			break;
  		}
  	}

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

  		netconsole_target_get(nt);
  		if (nt->enabled && 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;
  			}

  		}

  		netconsole_target_put(nt);

  	}

  	spin_unlock_irqrestore(&target_list_lock, flags);

  }
  
  static struct console netconsole = {

  	.name	= "netcon",

  	.flags	= CON_ENABLED,

  	.write	= write_msg,

  };

  static int __init init_netconsole(void)

  {

  	int err;

  	struct netconsole_target *nt, *tmp;
  	unsigned long flags;
  	char *target_config;
  	char *input = config;

  	if (strnlen(input, MAX_PARAM_LENGTH)) {
  		while ((target_config = strsep(&input, ";"))) {
  			nt = alloc_param_target(target_config);
  			if (IS_ERR(nt)) {
  				err = PTR_ERR(nt);
  				goto fail;
  			}

  			/* Dump existing printks when we register */
  			netconsole.flags |= CON_PRINTBUFFER;

  			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;

  	err = dynamic_netconsole_init();
  	if (err)
  		goto undonotifier;

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

  	return err;

  undonotifier:
  	unregister_netdevice_notifier(&netconsole_netdev_notifier);

  fail:
  	printk(KERN_ERR "netconsole: cleaning up
  ");
  
  	/*

  	 * Remove all targets and destroy them (only targets created
  	 * from the boot/module option exist here). 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_param_target(nt);

  	}
  
  	return err;

  }

  static void __exit cleanup_netconsole(void)

  {

  	struct netconsole_target *nt, *tmp;

  	unregister_console(&netconsole);

  	dynamic_netconsole_exit();

  	unregister_netdevice_notifier(&netconsole_netdev_notifier);

  
  	/*

  	 * Targets created via configfs pin references on our module
  	 * and would first be rmdir(2)'ed from userspace. We reach
  	 * here only when they are already destroyed, and only those
  	 * created from the boot/module option are left, so remove 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_param_target(nt);

  	}

  }

  /*
   * Use late_initcall to ensure netconsole is
   * initialized after network device driver if built-in.
   *
   * late_initcall() and module_init() are identical if built as module.
   */
  late_initcall(init_netconsole);

  module_exit(cleanup_netconsole);