drivers/scsi/fcoe/fcoe_transport.c - kernel/msm-4.9 - Gitiles

 /*
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
  * version 2, as published by the Free Software Foundation.
  *
  * This program is distributed in the hope 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.,
  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Maintained at www.Open-FCoE.org
  */

 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/netdevice.h>
 #include <linux/errno.h>
 #include <linux/crc32.h>
 #include <scsi/libfcoe.h>

 #include "libfcoe.h"

 MODULE_AUTHOR("Open-FCoE.org");
 MODULE_DESCRIPTION("FIP discovery protocol and FCoE transport for FCoE HBAs");
 MODULE_LICENSE("GPL v2");

 static int fcoe_transport_create(const char *, struct kernel_param *);
 static int fcoe_transport_destroy(const char *, struct kernel_param *);
 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp);
 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *device);
 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *device);
 static int fcoe_transport_enable(const char *, struct kernel_param *);
 static int fcoe_transport_disable(const char *, struct kernel_param *);
 static int libfcoe_device_notification(struct notifier_block *notifier,
 				    ulong event, void *ptr);

 static LIST_HEAD(fcoe_transports);
 static DEFINE_MUTEX(ft_mutex);
 static LIST_HEAD(fcoe_netdevs);
 static DEFINE_MUTEX(fn_mutex);

 unsigned int libfcoe_debug_logging;
 module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");

 module_param_call(show, NULL, fcoe_transport_show, NULL, S_IRUSR);
 __MODULE_PARM_TYPE(show, "string");
 MODULE_PARM_DESC(show, " Show attached FCoE transports");

 module_param_call(create, fcoe_transport_create, NULL,
 		  (void *)FIP_MODE_FABRIC, S_IWUSR);
 __MODULE_PARM_TYPE(create, "string");
 MODULE_PARM_DESC(create, " Creates fcoe instance on a ethernet interface");

 module_param_call(create_vn2vn, fcoe_transport_create, NULL,
 		  (void *)FIP_MODE_VN2VN, S_IWUSR);
 __MODULE_PARM_TYPE(create_vn2vn, "string");
 MODULE_PARM_DESC(create_vn2vn, " Creates a VN_node to VN_node FCoE instance "
 		 "on an Ethernet interface");

 module_param_call(destroy, fcoe_transport_destroy, NULL, NULL, S_IWUSR);
 __MODULE_PARM_TYPE(destroy, "string");
 MODULE_PARM_DESC(destroy, " Destroys fcoe instance on a ethernet interface");

 module_param_call(enable, fcoe_transport_enable, NULL, NULL, S_IWUSR);
 __MODULE_PARM_TYPE(enable, "string");
 MODULE_PARM_DESC(enable, " Enables fcoe on a ethernet interface.");

 module_param_call(disable, fcoe_transport_disable, NULL, NULL, S_IWUSR);
 __MODULE_PARM_TYPE(disable, "string");
 MODULE_PARM_DESC(disable, " Disables fcoe on a ethernet interface.");

 /* notification function for packets from net device */
 static struct notifier_block libfcoe_notifier = {
 	.notifier_call = libfcoe_device_notification,
 };

 void __fcoe_get_lesb(struct fc_lport *lport,
 		     struct fc_els_lesb *fc_lesb,
 		     struct net_device *netdev)
 {
 	unsigned int cpu;
 	u32 lfc, vlfc, mdac;
 	struct fcoe_dev_stats *devst;
 	struct fcoe_fc_els_lesb *lesb;
 	struct rtnl_link_stats64 temp;

 	lfc = 0;
 	vlfc = 0;
 	mdac = 0;
 	lesb = (struct fcoe_fc_els_lesb *)fc_lesb;
 	memset(lesb, 0, sizeof(*lesb));
 	for_each_possible_cpu(cpu) {
 		devst = per_cpu_ptr(lport->dev_stats, cpu);
 		lfc += devst->LinkFailureCount;
 		vlfc += devst->VLinkFailureCount;
 		mdac += devst->MissDiscAdvCount;
 	}
 	lesb->lesb_link_fail = htonl(lfc);
 	lesb->lesb_vlink_fail = htonl(vlfc);
 	lesb->lesb_miss_fka = htonl(mdac);
 	lesb->lesb_fcs_error =
 			htonl(dev_get_stats(netdev, &temp)->rx_crc_errors);
 }
 EXPORT_SYMBOL_GPL(__fcoe_get_lesb);

 void fcoe_wwn_to_str(u64 wwn, char *buf, int len)
 {
 	u8 wwpn[8];

 	u64_to_wwn(wwn, wwpn);
 	snprintf(buf, len, "%02x%02x%02x%02x%02x%02x%02x%02x",
 		 wwpn[0], wwpn[1], wwpn[2], wwpn[3],
 		 wwpn[4], wwpn[5], wwpn[6], wwpn[7]);
 }
 EXPORT_SYMBOL_GPL(fcoe_wwn_to_str);

 /**
  * fcoe_validate_vport_create() - Validate a vport before creating it
  * @vport: NPIV port to be created
  *
  * This routine is meant to add validation for a vport before creating it
  * via fcoe_vport_create().
  * Current validations are:
  *      - WWPN supplied is unique for given lport
  */
 int fcoe_validate_vport_create(struct fc_vport *vport)
 {
 	struct Scsi_Host *shost = vport_to_shost(vport);
 	struct fc_lport *n_port = shost_priv(shost);
 	struct fc_lport *vn_port;
 	int rc = 0;
 	char buf[32];

 	mutex_lock(&n_port->lp_mutex);

 	fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
 	/* Check if the wwpn is not same as that of the lport */
 	if (!memcmp(&n_port->wwpn, &vport->port_name, sizeof(u64))) {
 		LIBFCOE_TRANSPORT_DBG("vport WWPN 0x%s is same as that of the "
 				      "base port WWPN\n", buf);
 		rc = -EINVAL;
 		goto out;
 	}

 	/* Check if there is any existing vport with same wwpn */
 	list_for_each_entry(vn_port, &n_port->vports, list) {
 		if (!memcmp(&vn_port->wwpn, &vport->port_name, sizeof(u64))) {
 			LIBFCOE_TRANSPORT_DBG("vport with given WWPN 0x%s "
 					      "already exists\n", buf);
 			rc = -EINVAL;
 			break;
 		}
 	}
 out:
 	mutex_unlock(&n_port->lp_mutex);
 	return rc;
 }
 EXPORT_SYMBOL_GPL(fcoe_validate_vport_create);

 /**
  * fcoe_get_wwn() - Get the world wide name from LLD if it supports it
  * @netdev: the associated net device
  * @wwn: the output WWN
  * @type: the type of WWN (WWPN or WWNN)
  *
  * Returns: 0 for success
  */
 int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
 {
 	const struct net_device_ops *ops = netdev->netdev_ops;

 	if (ops->ndo_fcoe_get_wwn)
 		return ops->ndo_fcoe_get_wwn(netdev, wwn, type);
 	return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(fcoe_get_wwn);

 /**
  * fcoe_fc_crc() - Calculates the CRC for a given frame
  * @fp: The frame to be checksumed
  *
  * This uses crc32() routine to calculate the CRC for a frame
  *
  * Return: The 32 bit CRC value
  */
 u32 fcoe_fc_crc(struct fc_frame *fp)
 {
 	struct sk_buff *skb = fp_skb(fp);
 	struct skb_frag_struct *frag;
 	unsigned char *data;
 	unsigned long off, len, clen;
 	u32 crc;
 	unsigned i;

 	crc = crc32(~0, skb->data, skb_headlen(skb));

 	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 		frag = &skb_shinfo(skb)->frags[i];
 		off = frag->page_offset;
 		len = skb_frag_size(frag);
 		while (len > 0) {
 			clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
 			data = kmap_atomic(
 				skb_frag_page(frag) + (off >> PAGE_SHIFT));
 			crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
 			kunmap_atomic(data);
 			off += clen;
 			len -= clen;
 		}
 	}
 	return crc;
 }
 EXPORT_SYMBOL_GPL(fcoe_fc_crc);

 /**
  * fcoe_start_io() - Start FCoE I/O
  * @skb: The packet to be transmitted
  *
  * This routine is called from the net device to start transmitting
  * FCoE packets.
  *
  * Returns: 0 for success
  */
 int fcoe_start_io(struct sk_buff *skb)
 {
 	struct sk_buff *nskb;
 	int rc;

 	nskb = skb_clone(skb, GFP_ATOMIC);
 	if (!nskb)
 		return -ENOMEM;
 	rc = dev_queue_xmit(nskb);
 	if (rc != 0)
 		return rc;
 	kfree_skb(skb);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(fcoe_start_io);


 /**
  * fcoe_clean_pending_queue() - Dequeue a skb and free it
  * @lport: The local port to dequeue a skb on
  */
 void fcoe_clean_pending_queue(struct fc_lport *lport)
 {
 	struct fcoe_port  *port = lport_priv(lport);
 	struct sk_buff *skb;

 	spin_lock_bh(&port->fcoe_pending_queue.lock);
 	while ((skb = __skb_dequeue(&port->fcoe_pending_queue)) != NULL) {
 		spin_unlock_bh(&port->fcoe_pending_queue.lock);
 		kfree_skb(skb);
 		spin_lock_bh(&port->fcoe_pending_queue.lock);
 	}
 	spin_unlock_bh(&port->fcoe_pending_queue.lock);
 }
 EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue);

 /**
  * fcoe_check_wait_queue() - Attempt to clear the transmit backlog
  * @lport: The local port whose backlog is to be cleared
  *
  * This empties the wait_queue, dequeues the head of the wait_queue queue
  * and calls fcoe_start_io() for each packet. If all skb have been
  * transmitted it returns the qlen. If an error occurs it restores
  * wait_queue (to try again later) and returns -1.
  *
  * The wait_queue is used when the skb transmit fails. The failed skb
  * will go in the wait_queue which will be emptied by the timer function or
  * by the next skb transmit.
  */
 void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb)
 {
 	struct fcoe_port *port = lport_priv(lport);
 	int rc;

 	spin_lock_bh(&port->fcoe_pending_queue.lock);

 	if (skb)
 		__skb_queue_tail(&port->fcoe_pending_queue, skb);

 	if (port->fcoe_pending_queue_active)
 		goto out;
 	port->fcoe_pending_queue_active = 1;

 	while (port->fcoe_pending_queue.qlen) {
 		/* keep qlen > 0 until fcoe_start_io succeeds */
 		port->fcoe_pending_queue.qlen++;
 		skb = __skb_dequeue(&port->fcoe_pending_queue);

 		spin_unlock_bh(&port->fcoe_pending_queue.lock);
 		rc = fcoe_start_io(skb);
 		spin_lock_bh(&port->fcoe_pending_queue.lock);

 		if (rc) {
 			__skb_queue_head(&port->fcoe_pending_queue, skb);
 			/* undo temporary increment above */
 			port->fcoe_pending_queue.qlen--;
 			break;
 		}
 		/* undo temporary increment above */
 		port->fcoe_pending_queue.qlen--;
 	}

 	if (port->fcoe_pending_queue.qlen < port->min_queue_depth)
 		lport->qfull = 0;
 	if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer))
 		mod_timer(&port->timer, jiffies + 2);
 	port->fcoe_pending_queue_active = 0;
 out:
 	if (port->fcoe_pending_queue.qlen > port->max_queue_depth)
 		lport->qfull = 1;
 	spin_unlock_bh(&port->fcoe_pending_queue.lock);
 }
 EXPORT_SYMBOL_GPL(fcoe_check_wait_queue);

 /**
  * fcoe_queue_timer() - The fcoe queue timer
  * @lport: The local port
  *
  * Calls fcoe_check_wait_queue on timeout
  */
 void fcoe_queue_timer(ulong lport)
 {
 	fcoe_check_wait_queue((struct fc_lport *)lport, NULL);
 }
 EXPORT_SYMBOL_GPL(fcoe_queue_timer);

 /**
  * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC
  * @skb:  The packet to be transmitted
  * @tlen: The total length of the trailer
  * @fps:  The fcoe context
  *
  * This routine allocates a page for frame trailers. The page is re-used if
  * there is enough room left on it for the current trailer. If there isn't
  * enough buffer left a new page is allocated for the trailer. Reference to
  * the page from this function as well as the skbs using the page fragments
  * ensure that the page is freed at the appropriate time.
  *
  * Returns: 0 for success
  */
 int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen,
 			   struct fcoe_percpu_s *fps)
 {
 	struct page *page;

 	page = fps->crc_eof_page;
 	if (!page) {
 		page = alloc_page(GFP_ATOMIC);
 		if (!page)
 			return -ENOMEM;

 		fps->crc_eof_page = page;
 		fps->crc_eof_offset = 0;
 	}

 	get_page(page);
 	skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page,
 			   fps->crc_eof_offset, tlen);
 	skb->len += tlen;
 	skb->data_len += tlen;
 	skb->truesize += tlen;
 	fps->crc_eof_offset += sizeof(struct fcoe_crc_eof);

 	if (fps->crc_eof_offset >= PAGE_SIZE) {
 		fps->crc_eof_page = NULL;
 		fps->crc_eof_offset = 0;
 		put_page(page);
 	}

 	return 0;
 }
 EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof);

 /**
  * fcoe_transport_lookup - find an fcoe transport that matches a netdev
  * @netdev: The netdev to look for from all attached transports
  *
  * Returns : ptr to the fcoe transport that supports this netdev or NULL
  * if not found.
  *
  * The ft_mutex should be held when this is called
  */
 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *netdev)
 {
 	struct fcoe_transport *ft = NULL;

 	list_for_each_entry(ft, &fcoe_transports, list)
 		if (ft->match && ft->match(netdev))
 			return ft;
 	return NULL;
 }

 /**
  * fcoe_transport_attach - Attaches an FCoE transport
  * @ft: The fcoe transport to be attached
  *
  * Returns : 0 for success
  */
 int fcoe_transport_attach(struct fcoe_transport *ft)
 {
 	int rc = 0;

 	mutex_lock(&ft_mutex);
 	if (ft->attached) {
 		LIBFCOE_TRANSPORT_DBG("transport %s already attached\n",
 				       ft->name);
 		rc = -EEXIST;
 		goto out_attach;
 	}

 	/* Add default transport to the tail */
 	if (strcmp(ft->name, FCOE_TRANSPORT_DEFAULT))
 		list_add(&ft->list, &fcoe_transports);
 	else
 		list_add_tail(&ft->list, &fcoe_transports);

 	ft->attached = true;
 	LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name);

 out_attach:
 	mutex_unlock(&ft_mutex);
 	return rc;
 }
 EXPORT_SYMBOL(fcoe_transport_attach);

 /**
  * fcoe_transport_detach - Detaches an FCoE transport
  * @ft: The fcoe transport to be attached
  *
  * Returns : 0 for success
  */
 int fcoe_transport_detach(struct fcoe_transport *ft)
 {
 	int rc = 0;
 	struct fcoe_netdev_mapping *nm = NULL, *tmp;

 	mutex_lock(&ft_mutex);
 	if (!ft->attached) {
 		LIBFCOE_TRANSPORT_DBG("transport %s already detached\n",
 			ft->name);
 		rc = -ENODEV;
 		goto out_attach;
 	}

 	/* remove netdev mapping for this transport as it is going away */
 	mutex_lock(&fn_mutex);
 	list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
 		if (nm->ft == ft) {
 			LIBFCOE_TRANSPORT_DBG("transport %s going away, "
 				"remove its netdev mapping for %s\n",
 				ft->name, nm->netdev->name);
 			list_del(&nm->list);
 			kfree(nm);
 		}
 	}
 	mutex_unlock(&fn_mutex);

 	list_del(&ft->list);
 	ft->attached = false;
 	LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name);

 out_attach:
 	mutex_unlock(&ft_mutex);
 	return rc;

 }
 EXPORT_SYMBOL(fcoe_transport_detach);

 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp)
 {
 	int i, j;
 	struct fcoe_transport *ft = NULL;

 	i = j = sprintf(buffer, "Attached FCoE transports:");
 	mutex_lock(&ft_mutex);
 	list_for_each_entry(ft, &fcoe_transports, list) {
 		if (i >= PAGE_SIZE - IFNAMSIZ)
 			break;
 		i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
 	}
 	mutex_unlock(&ft_mutex);
 	if (i == j)
 		i += snprintf(&buffer[i], IFNAMSIZ, "none");
 	return i;
 }

 static int __init fcoe_transport_init(void)
 {
 	register_netdevice_notifier(&libfcoe_notifier);
 	return 0;
 }

 static int __exit fcoe_transport_exit(void)
 {
 	struct fcoe_transport *ft;

 	unregister_netdevice_notifier(&libfcoe_notifier);
 	mutex_lock(&ft_mutex);
 	list_for_each_entry(ft, &fcoe_transports, list)
 		printk(KERN_ERR "FCoE transport %s is still attached!\n",
 		      ft->name);
 	mutex_unlock(&ft_mutex);
 	return 0;
 }


 static int fcoe_add_netdev_mapping(struct net_device *netdev,
 					struct fcoe_transport *ft)
 {
 	struct fcoe_netdev_mapping *nm;

 	nm = kmalloc(sizeof(*nm), GFP_KERNEL);
 	if (!nm) {
 		printk(KERN_ERR "Unable to allocate netdev_mapping");
 		return -ENOMEM;
 	}

 	nm->netdev = netdev;
 	nm->ft = ft;

 	mutex_lock(&fn_mutex);
 	list_add(&nm->list, &fcoe_netdevs);
 	mutex_unlock(&fn_mutex);
 	return 0;
 }


 static void fcoe_del_netdev_mapping(struct net_device *netdev)
 {
 	struct fcoe_netdev_mapping *nm = NULL, *tmp;

 	mutex_lock(&fn_mutex);
 	list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
 		if (nm->netdev == netdev) {
 			list_del(&nm->list);
 			kfree(nm);
 			mutex_unlock(&fn_mutex);
 			return;
 		}
 	}
 	mutex_unlock(&fn_mutex);
 }


 /**
  * fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which
  * it was created
  *
  * Returns : ptr to the fcoe transport that supports this netdev or NULL
  * if not found.
  *
  * The ft_mutex should be held when this is called
  */
 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *netdev)
 {
 	struct fcoe_transport *ft = NULL;
 	struct fcoe_netdev_mapping *nm;

 	mutex_lock(&fn_mutex);
 	list_for_each_entry(nm, &fcoe_netdevs, list) {
 		if (netdev == nm->netdev) {
 			ft = nm->ft;
 			mutex_unlock(&fn_mutex);
 			return ft;
 		}
 	}

 	mutex_unlock(&fn_mutex);
 	return NULL;
 }

 /**
  * fcoe_if_to_netdev() - Parse a name buffer to get a net device
  * @buffer: The name of the net device
  *
  * Returns: NULL or a ptr to net_device
  */
 static struct net_device *fcoe_if_to_netdev(const char *buffer)
 {
 	char *cp;
 	char ifname[IFNAMSIZ + 2];

 	if (buffer) {
 		strlcpy(ifname, buffer, IFNAMSIZ);
 		cp = ifname + strlen(ifname);
 		while (--cp >= ifname && *cp == '\n')
 			*cp = '\0';
 		return dev_get_by_name(&init_net, ifname);
 	}
 	return NULL;
 }

 /**
  * libfcoe_device_notification() - Handler for net device events
  * @notifier: The context of the notification
  * @event:    The type of event
  * @ptr:      The net device that the event was on
  *
  * This function is called by the Ethernet driver in case of link change event.
  *
  * Returns: 0 for success
  */
 static int libfcoe_device_notification(struct notifier_block *notifier,
 				    ulong event, void *ptr)
 {
 	struct net_device *netdev = ptr;

 	switch (event) {
 	case NETDEV_UNREGISTER:
 		LIBFCOE_TRANSPORT_DBG("NETDEV_UNREGISTER %s\n",
 				      netdev->name);
 		fcoe_del_netdev_mapping(netdev);
 		break;
 	}
 	return NOTIFY_OK;
 }


 /**
  * fcoe_transport_create() - Create a fcoe interface
  * @buffer: The name of the Ethernet interface to create on
  * @kp:	    The associated kernel param
  *
  * Called from sysfs. This holds the ft_mutex while calling the
  * registered fcoe transport's create function.
  *
  * Returns: 0 for success
  */
 static int fcoe_transport_create(const char *buffer, struct kernel_param *kp)
 {
 	int rc = -ENODEV;
 	struct net_device *netdev = NULL;
 	struct fcoe_transport *ft = NULL;
 	enum fip_state fip_mode = (enum fip_state)(long)kp->arg;

 	mutex_lock(&ft_mutex);

 	netdev = fcoe_if_to_netdev(buffer);
 	if (!netdev) {
 		LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
 		goto out_nodev;
 	}

 	ft = fcoe_netdev_map_lookup(netdev);
 	if (ft) {
 		LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
 				      "FCoE instance on %s.\n",
 				      ft->name, netdev->name);
 		rc = -EEXIST;
 		goto out_putdev;
 	}

 	ft = fcoe_transport_lookup(netdev);
 	if (!ft) {
 		LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 				      netdev->name);
 		goto out_putdev;
 	}

 	rc = fcoe_add_netdev_mapping(netdev, ft);
 	if (rc) {
 		LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
 				      "for FCoE transport %s for %s.\n",
 				      ft->name, netdev->name);
 		goto out_putdev;
 	}

 	/* pass to transport create */
 	rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV;
 	if (rc)
 		fcoe_del_netdev_mapping(netdev);

 	LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n",
 			      ft->name, (rc) ? "failed" : "succeeded",
 			      netdev->name);

 out_putdev:
 	dev_put(netdev);
 out_nodev:
 	mutex_unlock(&ft_mutex);
 	return rc;
 }

 /**
  * fcoe_transport_destroy() - Destroy a FCoE interface
  * @buffer: The name of the Ethernet interface to be destroyed
  * @kp:	    The associated kernel parameter
  *
  * Called from sysfs. This holds the ft_mutex while calling the
  * registered fcoe transport's destroy function.
  *
  * Returns: 0 for success
  */
 static int fcoe_transport_destroy(const char *buffer, struct kernel_param *kp)
 {
 	int rc = -ENODEV;
 	struct net_device *netdev = NULL;
 	struct fcoe_transport *ft = NULL;

 	mutex_lock(&ft_mutex);

 	netdev = fcoe_if_to_netdev(buffer);
 	if (!netdev) {
 		LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
 		goto out_nodev;
 	}

 	ft = fcoe_netdev_map_lookup(netdev);
 	if (!ft) {
 		LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 				      netdev->name);
 		goto out_putdev;
 	}

 	/* pass to transport destroy */
 	rc = ft->destroy ? ft->destroy(netdev) : -ENODEV;
 	fcoe_del_netdev_mapping(netdev);
 	LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
 			      ft->name, (rc) ? "failed" : "succeeded",
 			      netdev->name);

 out_putdev:
 	dev_put(netdev);
 out_nodev:
 	mutex_unlock(&ft_mutex);
 	return rc;
 }

 /**
  * fcoe_transport_disable() - Disables a FCoE interface
  * @buffer: The name of the Ethernet interface to be disabled
  * @kp:	    The associated kernel parameter
  *
  * Called from sysfs.
  *
  * Returns: 0 for success
  */
 static int fcoe_transport_disable(const char *buffer, struct kernel_param *kp)
 {
 	int rc = -ENODEV;
 	struct net_device *netdev = NULL;
 	struct fcoe_transport *ft = NULL;

 	mutex_lock(&ft_mutex);

 	netdev = fcoe_if_to_netdev(buffer);
 	if (!netdev)
 		goto out_nodev;

 	ft = fcoe_netdev_map_lookup(netdev);
 	if (!ft)
 		goto out_putdev;

 	rc = ft->disable ? ft->disable(netdev) : -ENODEV;

 out_putdev:
 	dev_put(netdev);
 out_nodev:
 	mutex_unlock(&ft_mutex);

 	if (rc == -ERESTARTSYS)
 		return restart_syscall();
 	else
 		return rc;
 }

 /**
  * fcoe_transport_enable() - Enables a FCoE interface
  * @buffer: The name of the Ethernet interface to be enabled
  * @kp:     The associated kernel parameter
  *
  * Called from sysfs.
  *
  * Returns: 0 for success
  */
 static int fcoe_transport_enable(const char *buffer, struct kernel_param *kp)
 {
 	int rc = -ENODEV;
 	struct net_device *netdev = NULL;
 	struct fcoe_transport *ft = NULL;

 	mutex_lock(&ft_mutex);

 	netdev = fcoe_if_to_netdev(buffer);
 	if (!netdev)
 		goto out_nodev;

 	ft = fcoe_netdev_map_lookup(netdev);
 	if (!ft)
 		goto out_putdev;

 	rc = ft->enable ? ft->enable(netdev) : -ENODEV;

 out_putdev:
 	dev_put(netdev);
 out_nodev:
 	mutex_unlock(&ft_mutex);
 	return rc;
 }

 /**
  * libfcoe_init() - Initialization routine for libfcoe.ko
  */
 static int __init libfcoe_init(void)
 {
 	int rc = 0;

 	rc = fcoe_transport_init();
 	if (rc)
 		return rc;

 	rc = fcoe_sysfs_setup();
 	if (rc)
 		fcoe_transport_exit();

 	return rc;
 }
 module_init(libfcoe_init);

 /**
  * libfcoe_exit() - Tear down libfcoe.ko
  */
 static void __exit libfcoe_exit(void)
 {
 	fcoe_sysfs_teardown();
 	fcoe_transport_exit();
 }
 module_exit(libfcoe_exit);
	/*
	* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify it
	* under the terms and conditions of the GNU General Public License,
	* version 2, as published by the Free Software Foundation.
	*
	* This program is distributed in the hope 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.,
	* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Maintained at www.Open-FCoE.org
	*/

	#include <linux/types.h>
	#include <linux/module.h>
	#include <linux/kernel.h>
	#include <linux/list.h>
	#include <linux/netdevice.h>
	#include <linux/errno.h>
	#include <linux/crc32.h>
	#include <scsi/libfcoe.h>

	#include "libfcoe.h"

	MODULE_AUTHOR("Open-FCoE.org");
	MODULE_DESCRIPTION("FIP discovery protocol and FCoE transport for FCoE HBAs");
	MODULE_LICENSE("GPL v2");

	static int fcoe_transport_create(const char , struct kernel_param );
	static int fcoe_transport_destroy(const char , struct kernel_param );
	static int fcoe_transport_show(char buffer, const struct kernel_param kp);
	static struct fcoe_transport fcoe_transport_lookup(struct net_device device);
	static struct fcoe_transport fcoe_netdev_map_lookup(struct net_device device);
	static int fcoe_transport_enable(const char , struct kernel_param );
	static int fcoe_transport_disable(const char , struct kernel_param );
	static int libfcoe_device_notification(struct notifier_block *notifier,
	ulong event, void *ptr);

	static LIST_HEAD(fcoe_transports);
	static DEFINE_MUTEX(ft_mutex);
	static LIST_HEAD(fcoe_netdevs);
	static DEFINE_MUTEX(fn_mutex);

	unsigned int libfcoe_debug_logging;
	module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO\|S_IWUSR);
	MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");

	module_param_call(show, NULL, fcoe_transport_show, NULL, S_IRUSR);
	__MODULE_PARM_TYPE(show, "string");
	MODULE_PARM_DESC(show, " Show attached FCoE transports");

	module_param_call(create, fcoe_transport_create, NULL,
	(void *)FIP_MODE_FABRIC, S_IWUSR);
	__MODULE_PARM_TYPE(create, "string");
	MODULE_PARM_DESC(create, " Creates fcoe instance on a ethernet interface");

	module_param_call(create_vn2vn, fcoe_transport_create, NULL,
	(void *)FIP_MODE_VN2VN, S_IWUSR);
	__MODULE_PARM_TYPE(create_vn2vn, "string");
	MODULE_PARM_DESC(create_vn2vn, " Creates a VN_node to VN_node FCoE instance "
	"on an Ethernet interface");

	module_param_call(destroy, fcoe_transport_destroy, NULL, NULL, S_IWUSR);
	__MODULE_PARM_TYPE(destroy, "string");
	MODULE_PARM_DESC(destroy, " Destroys fcoe instance on a ethernet interface");

	module_param_call(enable, fcoe_transport_enable, NULL, NULL, S_IWUSR);
	__MODULE_PARM_TYPE(enable, "string");
	MODULE_PARM_DESC(enable, " Enables fcoe on a ethernet interface.");

	module_param_call(disable, fcoe_transport_disable, NULL, NULL, S_IWUSR);
	__MODULE_PARM_TYPE(disable, "string");
	MODULE_PARM_DESC(disable, " Disables fcoe on a ethernet interface.");

	/* notification function for packets from net device */
	static struct notifier_block libfcoe_notifier = {
	.notifier_call = libfcoe_device_notification,
	};

	void __fcoe_get_lesb(struct fc_lport *lport,
	struct fc_els_lesb *fc_lesb,
	struct net_device *netdev)
	{
	unsigned int cpu;
	u32 lfc, vlfc, mdac;
	struct fcoe_dev_stats *devst;
	struct fcoe_fc_els_lesb *lesb;
	struct rtnl_link_stats64 temp;

	lfc = 0;
	vlfc = 0;
	mdac = 0;
	lesb = (struct fcoe_fc_els_lesb *)fc_lesb;
	memset(lesb, 0, sizeof(*lesb));
	for_each_possible_cpu(cpu) {
	devst = per_cpu_ptr(lport->dev_stats, cpu);
	lfc += devst->LinkFailureCount;
	vlfc += devst->VLinkFailureCount;
	mdac += devst->MissDiscAdvCount;
	}
	lesb->lesb_link_fail = htonl(lfc);
	lesb->lesb_vlink_fail = htonl(vlfc);
	lesb->lesb_miss_fka = htonl(mdac);
	lesb->lesb_fcs_error =
	htonl(dev_get_stats(netdev, &temp)->rx_crc_errors);
	}
	EXPORT_SYMBOL_GPL(__fcoe_get_lesb);

	void fcoe_wwn_to_str(u64 wwn, char *buf, int len)
	{
	u8 wwpn[8];

	u64_to_wwn(wwn, wwpn);
	snprintf(buf, len, "%02x%02x%02x%02x%02x%02x%02x%02x",
	wwpn[0], wwpn[1], wwpn[2], wwpn[3],
	wwpn[4], wwpn[5], wwpn[6], wwpn[7]);
	}
	EXPORT_SYMBOL_GPL(fcoe_wwn_to_str);

	/**
	* fcoe_validate_vport_create() - Validate a vport before creating it
	* @vport: NPIV port to be created
	*
	* This routine is meant to add validation for a vport before creating it
	* via fcoe_vport_create().
	* Current validations are:
	* - WWPN supplied is unique for given lport
	*/
	int fcoe_validate_vport_create(struct fc_vport *vport)
	{
	struct Scsi_Host *shost = vport_to_shost(vport);
	struct fc_lport *n_port = shost_priv(shost);
	struct fc_lport *vn_port;
	int rc = 0;
	char buf[32];

	mutex_lock(&n_port->lp_mutex);

	fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
	/* Check if the wwpn is not same as that of the lport */
	if (!memcmp(&n_port->wwpn, &vport->port_name, sizeof(u64))) {
	LIBFCOE_TRANSPORT_DBG("vport WWPN 0x%s is same as that of the "
	"base port WWPN\n", buf);
	rc = -EINVAL;
	goto out;
	}

	/* Check if there is any existing vport with same wwpn */
	list_for_each_entry(vn_port, &n_port->vports, list) {
	if (!memcmp(&vn_port->wwpn, &vport->port_name, sizeof(u64))) {
	LIBFCOE_TRANSPORT_DBG("vport with given WWPN 0x%s "
	"already exists\n", buf);
	rc = -EINVAL;
	break;
	}
	}
	out:
	mutex_unlock(&n_port->lp_mutex);
	return rc;
	}
	EXPORT_SYMBOL_GPL(fcoe_validate_vport_create);

	/**
	* fcoe_get_wwn() - Get the world wide name from LLD if it supports it
	* @netdev: the associated net device
	* @wwn: the output WWN
	* @type: the type of WWN (WWPN or WWNN)
	*
	* Returns: 0 for success
	*/
	int fcoe_get_wwn(struct net_device netdev, u64 wwn, int type)
	{
	const struct net_device_ops *ops = netdev->netdev_ops;

	if (ops->ndo_fcoe_get_wwn)
	return ops->ndo_fcoe_get_wwn(netdev, wwn, type);
	return -EINVAL;
	}
	EXPORT_SYMBOL_GPL(fcoe_get_wwn);

	/**
	* fcoe_fc_crc() - Calculates the CRC for a given frame
	* @fp: The frame to be checksumed
	*
	* This uses crc32() routine to calculate the CRC for a frame
	*
	* Return: The 32 bit CRC value
	*/
	u32 fcoe_fc_crc(struct fc_frame *fp)
	{
	struct sk_buff *skb = fp_skb(fp);
	struct skb_frag_struct *frag;
	unsigned char *data;
	unsigned long off, len, clen;
	u32 crc;
	unsigned i;

	crc = crc32(~0, skb->data, skb_headlen(skb));

	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
	frag = &skb_shinfo(skb)->frags[i];
	off = frag->page_offset;
	len = skb_frag_size(frag);
	while (len > 0) {
	clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
	data = kmap_atomic(
	skb_frag_page(frag) + (off >> PAGE_SHIFT));
	crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
	kunmap_atomic(data);
	off += clen;
	len -= clen;
	}
	}
	return crc;
	}
	EXPORT_SYMBOL_GPL(fcoe_fc_crc);

	/**
	* fcoe_start_io() - Start FCoE I/O
	* @skb: The packet to be transmitted
	*
	* This routine is called from the net device to start transmitting
	* FCoE packets.
	*
	* Returns: 0 for success
	*/
	int fcoe_start_io(struct sk_buff *skb)
	{
	struct sk_buff *nskb;
	int rc;

	nskb = skb_clone(skb, GFP_ATOMIC);
	if (!nskb)
	return -ENOMEM;
	rc = dev_queue_xmit(nskb);
	if (rc != 0)
	return rc;
	kfree_skb(skb);
	return 0;
	}
	EXPORT_SYMBOL_GPL(fcoe_start_io);


	/**
	* fcoe_clean_pending_queue() - Dequeue a skb and free it
	* @lport: The local port to dequeue a skb on
	*/
	void fcoe_clean_pending_queue(struct fc_lport *lport)
	{
	struct fcoe_port *port = lport_priv(lport);
	struct sk_buff *skb;

	spin_lock_bh(&port->fcoe_pending_queue.lock);
	while ((skb = __skb_dequeue(&port->fcoe_pending_queue)) != NULL) {
	spin_unlock_bh(&port->fcoe_pending_queue.lock);
	kfree_skb(skb);
	spin_lock_bh(&port->fcoe_pending_queue.lock);
	}
	spin_unlock_bh(&port->fcoe_pending_queue.lock);
	}
	EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue);

	/**
	* fcoe_check_wait_queue() - Attempt to clear the transmit backlog
	* @lport: The local port whose backlog is to be cleared
	*
	* This empties the wait_queue, dequeues the head of the wait_queue queue
	* and calls fcoe_start_io() for each packet. If all skb have been
	* transmitted it returns the qlen. If an error occurs it restores
	* wait_queue (to try again later) and returns -1.
	*
	* The wait_queue is used when the skb transmit fails. The failed skb
	* will go in the wait_queue which will be emptied by the timer function or
	* by the next skb transmit.
	*/
	void fcoe_check_wait_queue(struct fc_lport lport, struct sk_buff skb)
	{
	struct fcoe_port *port = lport_priv(lport);
	int rc;

	spin_lock_bh(&port->fcoe_pending_queue.lock);

	if (skb)
	__skb_queue_tail(&port->fcoe_pending_queue, skb);

	if (port->fcoe_pending_queue_active)
	goto out;
	port->fcoe_pending_queue_active = 1;

	while (port->fcoe_pending_queue.qlen) {
	/* keep qlen > 0 until fcoe_start_io succeeds */
	port->fcoe_pending_queue.qlen++;
	skb = __skb_dequeue(&port->fcoe_pending_queue);

	spin_unlock_bh(&port->fcoe_pending_queue.lock);
	rc = fcoe_start_io(skb);
	spin_lock_bh(&port->fcoe_pending_queue.lock);

	if (rc) {
	__skb_queue_head(&port->fcoe_pending_queue, skb);
	/* undo temporary increment above */
	port->fcoe_pending_queue.qlen--;
	break;
	}
	/* undo temporary increment above */
	port->fcoe_pending_queue.qlen--;
	}

	if (port->fcoe_pending_queue.qlen < port->min_queue_depth)
	lport->qfull = 0;
	if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer))
	mod_timer(&port->timer, jiffies + 2);
	port->fcoe_pending_queue_active = 0;
	out:
	if (port->fcoe_pending_queue.qlen > port->max_queue_depth)
	lport->qfull = 1;
	spin_unlock_bh(&port->fcoe_pending_queue.lock);
	}
	EXPORT_SYMBOL_GPL(fcoe_check_wait_queue);

	/**
	* fcoe_queue_timer() - The fcoe queue timer
	* @lport: The local port
	*
	* Calls fcoe_check_wait_queue on timeout
	*/
	void fcoe_queue_timer(ulong lport)
	{
	fcoe_check_wait_queue((struct fc_lport *)lport, NULL);
	}
	EXPORT_SYMBOL_GPL(fcoe_queue_timer);

	/**
	* fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC
	* @skb: The packet to be transmitted
	* @tlen: The total length of the trailer
	* @fps: The fcoe context
	*
	* This routine allocates a page for frame trailers. The page is re-used if
	* there is enough room left on it for the current trailer. If there isn't
	* enough buffer left a new page is allocated for the trailer. Reference to
	* the page from this function as well as the skbs using the page fragments
	* ensure that the page is freed at the appropriate time.
	*
	* Returns: 0 for success
	*/
	int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen,
	struct fcoe_percpu_s *fps)
	{
	struct page *page;

	page = fps->crc_eof_page;
	if (!page) {
	page = alloc_page(GFP_ATOMIC);
	if (!page)
	return -ENOMEM;

	fps->crc_eof_page = page;
	fps->crc_eof_offset = 0;
	}

	get_page(page);
	skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page,
	fps->crc_eof_offset, tlen);
	skb->len += tlen;
	skb->data_len += tlen;
	skb->truesize += tlen;
	fps->crc_eof_offset += sizeof(struct fcoe_crc_eof);

	if (fps->crc_eof_offset >= PAGE_SIZE) {
	fps->crc_eof_page = NULL;
	fps->crc_eof_offset = 0;
	put_page(page);
	}

	return 0;
	}
	EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof);

	/**
	* fcoe_transport_lookup - find an fcoe transport that matches a netdev
	* @netdev: The netdev to look for from all attached transports
	*
	* Returns : ptr to the fcoe transport that supports this netdev or NULL
	* if not found.
	*
	* The ft_mutex should be held when this is called
	*/
	static struct fcoe_transport fcoe_transport_lookup(struct net_device netdev)
	{
	struct fcoe_transport *ft = NULL;

	list_for_each_entry(ft, &fcoe_transports, list)
	if (ft->match && ft->match(netdev))
	return ft;
	return NULL;
	}

	/**
	* fcoe_transport_attach - Attaches an FCoE transport
	* @ft: The fcoe transport to be attached
	*
	* Returns : 0 for success
	*/
	int fcoe_transport_attach(struct fcoe_transport *ft)
	{
	int rc = 0;

	mutex_lock(&ft_mutex);
	if (ft->attached) {
	LIBFCOE_TRANSPORT_DBG("transport %s already attached\n",
	ft->name);
	rc = -EEXIST;
	goto out_attach;
	}

	/* Add default transport to the tail */
	if (strcmp(ft->name, FCOE_TRANSPORT_DEFAULT))
	list_add(&ft->list, &fcoe_transports);
	else
	list_add_tail(&ft->list, &fcoe_transports);

	ft->attached = true;
	LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name);

	out_attach:
	mutex_unlock(&ft_mutex);
	return rc;
	}
	EXPORT_SYMBOL(fcoe_transport_attach);

	/**
	* fcoe_transport_detach - Detaches an FCoE transport
	* @ft: The fcoe transport to be attached
	*
	* Returns : 0 for success
	*/
	int fcoe_transport_detach(struct fcoe_transport *ft)
	{
	int rc = 0;
	struct fcoe_netdev_mapping nm = NULL, tmp;

	mutex_lock(&ft_mutex);
	if (!ft->attached) {
	LIBFCOE_TRANSPORT_DBG("transport %s already detached\n",
	ft->name);
	rc = -ENODEV;
	goto out_attach;
	}

	/* remove netdev mapping for this transport as it is going away */
	mutex_lock(&fn_mutex);
	list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
	if (nm->ft == ft) {
	LIBFCOE_TRANSPORT_DBG("transport %s going away, "
	"remove its netdev mapping for %s\n",
	ft->name, nm->netdev->name);
	list_del(&nm->list);
	kfree(nm);
	}
	}
	mutex_unlock(&fn_mutex);

	list_del(&ft->list);
	ft->attached = false;
	LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name);

	out_attach:
	mutex_unlock(&ft_mutex);
	return rc;

	}
	EXPORT_SYMBOL(fcoe_transport_detach);

	static int fcoe_transport_show(char buffer, const struct kernel_param kp)
	{
	int i, j;
	struct fcoe_transport *ft = NULL;

	i = j = sprintf(buffer, "Attached FCoE transports:");
	mutex_lock(&ft_mutex);
	list_for_each_entry(ft, &fcoe_transports, list) {
	if (i >= PAGE_SIZE - IFNAMSIZ)
	break;
	i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
	}
	mutex_unlock(&ft_mutex);
	if (i == j)
	i += snprintf(&buffer[i], IFNAMSIZ, "none");
	return i;
	}

	static int __init fcoe_transport_init(void)
	{
	register_netdevice_notifier(&libfcoe_notifier);
	return 0;
	}

	static int __exit fcoe_transport_exit(void)
	{
	struct fcoe_transport *ft;

	unregister_netdevice_notifier(&libfcoe_notifier);
	mutex_lock(&ft_mutex);
	list_for_each_entry(ft, &fcoe_transports, list)
	printk(KERN_ERR "FCoE transport %s is still attached!\n",
	ft->name);
	mutex_unlock(&ft_mutex);
	return 0;
	}


	static int fcoe_add_netdev_mapping(struct net_device *netdev,
	struct fcoe_transport *ft)
	{
	struct fcoe_netdev_mapping *nm;

	nm = kmalloc(sizeof(*nm), GFP_KERNEL);
	if (!nm) {
	printk(KERN_ERR "Unable to allocate netdev_mapping");
	return -ENOMEM;
	}

	nm->netdev = netdev;
	nm->ft = ft;

	mutex_lock(&fn_mutex);
	list_add(&nm->list, &fcoe_netdevs);
	mutex_unlock(&fn_mutex);
	return 0;
	}


	static void fcoe_del_netdev_mapping(struct net_device *netdev)
	{
	struct fcoe_netdev_mapping nm = NULL, tmp;

	mutex_lock(&fn_mutex);
	list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
	if (nm->netdev == netdev) {
	list_del(&nm->list);
	kfree(nm);
	mutex_unlock(&fn_mutex);
	return;
	}
	}
	mutex_unlock(&fn_mutex);
	}


	/**
	* fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which
	* it was created
	*
	* Returns : ptr to the fcoe transport that supports this netdev or NULL
	* if not found.
	*
	* The ft_mutex should be held when this is called
	*/
	static struct fcoe_transport fcoe_netdev_map_lookup(struct net_device netdev)
	{
	struct fcoe_transport *ft = NULL;
	struct fcoe_netdev_mapping *nm;

	mutex_lock(&fn_mutex);
	list_for_each_entry(nm, &fcoe_netdevs, list) {
	if (netdev == nm->netdev) {
	ft = nm->ft;
	mutex_unlock(&fn_mutex);
	return ft;
	}
	}

	mutex_unlock(&fn_mutex);
	return NULL;
	}

	/**
	* fcoe_if_to_netdev() - Parse a name buffer to get a net device
	* @buffer: The name of the net device
	*
	* Returns: NULL or a ptr to net_device
	*/
	static struct net_device fcoe_if_to_netdev(const char buffer)
	{
	char *cp;
	char ifname[IFNAMSIZ + 2];

	if (buffer) {
	strlcpy(ifname, buffer, IFNAMSIZ);
	cp = ifname + strlen(ifname);
	while (--cp >= ifname && *cp == '\n')
	*cp = '\0';
	return dev_get_by_name(&init_net, ifname);
	}
	return NULL;
	}

	/**
	* libfcoe_device_notification() - Handler for net device events
	* @notifier: The context of the notification
	* @event: The type of event
	* @ptr: The net device that the event was on
	*
	* This function is called by the Ethernet driver in case of link change event.
	*
	* Returns: 0 for success
	*/
	static int libfcoe_device_notification(struct notifier_block *notifier,
	ulong event, void *ptr)
	{
	struct net_device *netdev = ptr;

	switch (event) {
	case NETDEV_UNREGISTER:
	LIBFCOE_TRANSPORT_DBG("NETDEV_UNREGISTER %s\n",
	netdev->name);
	fcoe_del_netdev_mapping(netdev);
	break;
	}
	return NOTIFY_OK;
	}


	/**
	* fcoe_transport_create() - Create a fcoe interface
	* @buffer: The name of the Ethernet interface to create on
	* @kp: The associated kernel param
	*
	* Called from sysfs. This holds the ft_mutex while calling the
	* registered fcoe transport's create function.
	*
	* Returns: 0 for success
	*/
	static int fcoe_transport_create(const char buffer, struct kernel_param kp)
	{
	int rc = -ENODEV;
	struct net_device *netdev = NULL;
	struct fcoe_transport *ft = NULL;
	enum fip_state fip_mode = (enum fip_state)(long)kp->arg;

	mutex_lock(&ft_mutex);

	netdev = fcoe_if_to_netdev(buffer);
	if (!netdev) {
	LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
	goto out_nodev;
	}

	ft = fcoe_netdev_map_lookup(netdev);
	if (ft) {
	LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
	"FCoE instance on %s.\n",
	ft->name, netdev->name);
	rc = -EEXIST;
	goto out_putdev;
	}

	ft = fcoe_transport_lookup(netdev);
	if (!ft) {
	LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
	netdev->name);
	goto out_putdev;
	}

	rc = fcoe_add_netdev_mapping(netdev, ft);
	if (rc) {
	LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
	"for FCoE transport %s for %s.\n",
	ft->name, netdev->name);
	goto out_putdev;
	}

	/* pass to transport create */
	rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV;
	if (rc)
	fcoe_del_netdev_mapping(netdev);

	LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n",
	ft->name, (rc) ? "failed" : "succeeded",
	netdev->name);

	out_putdev:
	dev_put(netdev);
	out_nodev:
	mutex_unlock(&ft_mutex);
	return rc;
	}

	/**
	* fcoe_transport_destroy() - Destroy a FCoE interface
	* @buffer: The name of the Ethernet interface to be destroyed
	* @kp: The associated kernel parameter
	*
	* Called from sysfs. This holds the ft_mutex while calling the
	* registered fcoe transport's destroy function.
	*
	* Returns: 0 for success
	*/
	static int fcoe_transport_destroy(const char buffer, struct kernel_param kp)
	{
	int rc = -ENODEV;
	struct net_device *netdev = NULL;
	struct fcoe_transport *ft = NULL;

	mutex_lock(&ft_mutex);

	netdev = fcoe_if_to_netdev(buffer);
	if (!netdev) {
	LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
	goto out_nodev;
	}

	ft = fcoe_netdev_map_lookup(netdev);
	if (!ft) {
	LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
	netdev->name);
	goto out_putdev;
	}

	/* pass to transport destroy */
	rc = ft->destroy ? ft->destroy(netdev) : -ENODEV;
	fcoe_del_netdev_mapping(netdev);
	LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
	ft->name, (rc) ? "failed" : "succeeded",
	netdev->name);

	out_putdev:
	dev_put(netdev);
	out_nodev:
	mutex_unlock(&ft_mutex);
	return rc;
	}

	/**
	* fcoe_transport_disable() - Disables a FCoE interface
	* @buffer: The name of the Ethernet interface to be disabled
	* @kp: The associated kernel parameter
	*
	* Called from sysfs.
	*
	* Returns: 0 for success
	*/
	static int fcoe_transport_disable(const char buffer, struct kernel_param kp)
	{
	int rc = -ENODEV;
	struct net_device *netdev = NULL;
	struct fcoe_transport *ft = NULL;

	mutex_lock(&ft_mutex);

	netdev = fcoe_if_to_netdev(buffer);
	if (!netdev)
	goto out_nodev;

	ft = fcoe_netdev_map_lookup(netdev);
	if (!ft)
	goto out_putdev;

	rc = ft->disable ? ft->disable(netdev) : -ENODEV;

	out_putdev:
	dev_put(netdev);
	out_nodev:
	mutex_unlock(&ft_mutex);

	if (rc == -ERESTARTSYS)
	return restart_syscall();
	else
	return rc;
	}

	/**
	* fcoe_transport_enable() - Enables a FCoE interface
	* @buffer: The name of the Ethernet interface to be enabled
	* @kp: The associated kernel parameter
	*
	* Called from sysfs.
	*
	* Returns: 0 for success
	*/
	static int fcoe_transport_enable(const char buffer, struct kernel_param kp)
	{
	int rc = -ENODEV;
	struct net_device *netdev = NULL;
	struct fcoe_transport *ft = NULL;

	mutex_lock(&ft_mutex);

	netdev = fcoe_if_to_netdev(buffer);
	if (!netdev)
	goto out_nodev;

	ft = fcoe_netdev_map_lookup(netdev);
	if (!ft)
	goto out_putdev;

	rc = ft->enable ? ft->enable(netdev) : -ENODEV;

	out_putdev:
	dev_put(netdev);
	out_nodev:
	mutex_unlock(&ft_mutex);
	return rc;
	}

	/**
	* libfcoe_init() - Initialization routine for libfcoe.ko
	*/
	static int __init libfcoe_init(void)
	{
	int rc = 0;

	rc = fcoe_transport_init();
	if (rc)
	return rc;

	rc = fcoe_sysfs_setup();
	if (rc)
	fcoe_transport_exit();

	return rc;
	}
	module_init(libfcoe_init);

	/**
	* libfcoe_exit() - Tear down libfcoe.ko
	*/
	static void __exit libfcoe_exit(void)
	{
	fcoe_sysfs_teardown();
	fcoe_transport_exit();
	}
	module_exit(libfcoe_exit);