2008-12-10 00:10:24 +01:00
|
|
|
/*
|
|
|
|
* Copyright(c) 2007 - 2008 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/module.h>
|
|
|
|
#include <linux/version.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <linux/if_vlan.h>
|
|
|
|
#include <linux/crc32.h>
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/sysfs.h>
|
|
|
|
#include <linux/ctype.h>
|
|
|
|
#include <scsi/scsi_tcq.h>
|
|
|
|
#include <scsi/scsicam.h>
|
|
|
|
#include <scsi/scsi_transport.h>
|
|
|
|
#include <scsi/scsi_transport_fc.h>
|
|
|
|
#include <net/rtnetlink.h>
|
|
|
|
|
|
|
|
#include <scsi/fc/fc_encaps.h>
|
2009-03-17 19:42:40 +01:00
|
|
|
#include <scsi/fc/fc_fip.h>
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
#include <scsi/libfc.h>
|
|
|
|
#include <scsi/fc_frame.h>
|
|
|
|
#include <scsi/libfcoe.h>
|
|
|
|
|
2009-03-17 19:42:24 +01:00
|
|
|
#include "fcoe.h"
|
2009-03-27 17:06:31 +01:00
|
|
|
|
2008-12-10 00:10:24 +01:00
|
|
|
MODULE_AUTHOR("Open-FCoE.org");
|
|
|
|
MODULE_DESCRIPTION("FCoE");
|
2009-03-17 19:42:13 +01:00
|
|
|
MODULE_LICENSE("GPL v2");
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
/* fcoe host list */
|
|
|
|
LIST_HEAD(fcoe_hostlist);
|
|
|
|
DEFINE_RWLOCK(fcoe_hostlist_lock);
|
2009-03-17 19:41:35 +01:00
|
|
|
DEFINE_PER_CPU(struct fcoe_percpu_s, fcoe_percpu);
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-04-22 01:27:36 +02:00
|
|
|
/* Function Prototypes */
|
2009-03-17 19:42:24 +01:00
|
|
|
static int fcoe_reset(struct Scsi_Host *shost);
|
|
|
|
static int fcoe_xmit(struct fc_lport *, struct fc_frame *);
|
|
|
|
static int fcoe_rcv(struct sk_buff *, struct net_device *,
|
|
|
|
struct packet_type *, struct net_device *);
|
|
|
|
static int fcoe_percpu_receive_thread(void *arg);
|
|
|
|
static void fcoe_clean_pending_queue(struct fc_lport *lp);
|
|
|
|
static void fcoe_percpu_clean(struct fc_lport *lp);
|
|
|
|
static int fcoe_link_ok(struct fc_lport *lp);
|
|
|
|
|
|
|
|
static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *);
|
|
|
|
static int fcoe_hostlist_add(const struct fc_lport *);
|
|
|
|
static int fcoe_hostlist_remove(const struct fc_lport *);
|
|
|
|
|
2009-05-06 19:52:34 +02:00
|
|
|
static void fcoe_check_wait_queue(struct fc_lport *, struct sk_buff *);
|
2008-12-10 00:10:24 +01:00
|
|
|
static int fcoe_device_notification(struct notifier_block *, ulong, void *);
|
|
|
|
static void fcoe_dev_setup(void);
|
|
|
|
static void fcoe_dev_cleanup(void);
|
|
|
|
|
|
|
|
/* notification function from net device */
|
|
|
|
static struct notifier_block fcoe_notifier = {
|
|
|
|
.notifier_call = fcoe_device_notification,
|
|
|
|
};
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
static struct scsi_transport_template *scsi_transport_fcoe_sw;
|
|
|
|
|
|
|
|
struct fc_function_template fcoe_transport_function = {
|
|
|
|
.show_host_node_name = 1,
|
|
|
|
.show_host_port_name = 1,
|
|
|
|
.show_host_supported_classes = 1,
|
|
|
|
.show_host_supported_fc4s = 1,
|
|
|
|
.show_host_active_fc4s = 1,
|
|
|
|
.show_host_maxframe_size = 1,
|
|
|
|
|
|
|
|
.show_host_port_id = 1,
|
|
|
|
.show_host_supported_speeds = 1,
|
|
|
|
.get_host_speed = fc_get_host_speed,
|
|
|
|
.show_host_speed = 1,
|
|
|
|
.show_host_port_type = 1,
|
|
|
|
.get_host_port_state = fc_get_host_port_state,
|
|
|
|
.show_host_port_state = 1,
|
|
|
|
.show_host_symbolic_name = 1,
|
|
|
|
|
|
|
|
.dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
|
|
|
|
.show_rport_maxframe_size = 1,
|
|
|
|
.show_rport_supported_classes = 1,
|
|
|
|
|
|
|
|
.show_host_fabric_name = 1,
|
|
|
|
.show_starget_node_name = 1,
|
|
|
|
.show_starget_port_name = 1,
|
|
|
|
.show_starget_port_id = 1,
|
|
|
|
.set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
|
|
|
|
.show_rport_dev_loss_tmo = 1,
|
|
|
|
.get_fc_host_stats = fc_get_host_stats,
|
|
|
|
.issue_fc_host_lip = fcoe_reset,
|
|
|
|
|
|
|
|
.terminate_rport_io = fc_rport_terminate_io,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct scsi_host_template fcoe_shost_template = {
|
|
|
|
.module = THIS_MODULE,
|
|
|
|
.name = "FCoE Driver",
|
|
|
|
.proc_name = FCOE_NAME,
|
|
|
|
.queuecommand = fc_queuecommand,
|
|
|
|
.eh_abort_handler = fc_eh_abort,
|
|
|
|
.eh_device_reset_handler = fc_eh_device_reset,
|
|
|
|
.eh_host_reset_handler = fc_eh_host_reset,
|
|
|
|
.slave_alloc = fc_slave_alloc,
|
|
|
|
.change_queue_depth = fc_change_queue_depth,
|
|
|
|
.change_queue_type = fc_change_queue_type,
|
|
|
|
.this_id = -1,
|
|
|
|
.cmd_per_lun = 32,
|
|
|
|
.can_queue = FCOE_MAX_OUTSTANDING_COMMANDS,
|
|
|
|
.use_clustering = ENABLE_CLUSTERING,
|
|
|
|
.sg_tablesize = SG_ALL,
|
|
|
|
.max_sectors = 0xffff,
|
|
|
|
};
|
|
|
|
|
2009-05-17 14:33:08 +02:00
|
|
|
/**
|
|
|
|
* fcoe_fip_recv - handle a received FIP frame.
|
|
|
|
* @skb: the receive skb
|
|
|
|
* @dev: associated &net_device
|
|
|
|
* @ptype: the &packet_type structure which was used to register this handler.
|
|
|
|
* @orig_dev: original receive &net_device, in case @dev is a bond.
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
|
|
|
*/
|
|
|
|
static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *dev,
|
|
|
|
struct packet_type *ptype,
|
|
|
|
struct net_device *orig_dev)
|
|
|
|
{
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
|
|
|
|
fc = container_of(ptype, struct fcoe_softc, fip_packet_type);
|
|
|
|
fcoe_ctlr_recv(&fc->ctlr, skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_fip_send() - send an Ethernet-encapsulated FIP frame.
|
|
|
|
* @fip: FCoE controller.
|
|
|
|
* @skb: FIP Packet.
|
|
|
|
*/
|
|
|
|
static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
|
|
|
|
{
|
2009-07-30 02:05:45 +02:00
|
|
|
skb->dev = fcoe_from_ctlr(fip)->netdev;
|
2009-05-17 14:33:08 +02:00
|
|
|
dev_queue_xmit(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_update_src_mac() - Update Ethernet MAC filters.
|
|
|
|
* @fip: FCoE controller.
|
|
|
|
* @old: Unicast MAC address to delete if the MAC is non-zero.
|
|
|
|
* @new: Unicast MAC address to add.
|
|
|
|
*
|
|
|
|
* Remove any previously-set unicast MAC filter.
|
|
|
|
* Add secondary FCoE MAC address filter for our OUI.
|
|
|
|
*/
|
|
|
|
static void fcoe_update_src_mac(struct fcoe_ctlr *fip, u8 *old, u8 *new)
|
|
|
|
{
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
|
|
|
|
fc = fcoe_from_ctlr(fip);
|
|
|
|
rtnl_lock();
|
|
|
|
if (!is_zero_ether_addr(old))
|
2009-07-30 02:05:45 +02:00
|
|
|
dev_unicast_delete(fc->netdev, old);
|
|
|
|
dev_unicast_add(fc->netdev, new);
|
2009-05-17 14:33:08 +02:00
|
|
|
rtnl_unlock();
|
|
|
|
}
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
/**
|
|
|
|
* fcoe_lport_config() - sets up the fc_lport
|
|
|
|
* @lp: ptr to the fc_lport
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
|
|
|
*/
|
|
|
|
static int fcoe_lport_config(struct fc_lport *lp)
|
|
|
|
{
|
|
|
|
lp->link_up = 0;
|
|
|
|
lp->qfull = 0;
|
|
|
|
lp->max_retry_count = 3;
|
2009-05-01 19:01:26 +02:00
|
|
|
lp->max_rport_retry_count = 3;
|
2009-03-27 17:06:31 +01:00
|
|
|
lp->e_d_tov = 2 * 1000; /* FC-FS default */
|
|
|
|
lp->r_a_tov = 2 * 2 * 1000;
|
|
|
|
lp->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
|
|
|
|
FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
|
|
|
|
|
|
|
|
fc_lport_init_stats(lp);
|
|
|
|
|
|
|
|
/* lport fc_lport related configuration */
|
|
|
|
fc_lport_config(lp);
|
|
|
|
|
|
|
|
/* offload related configuration */
|
|
|
|
lp->crc_offload = 0;
|
|
|
|
lp->seq_offload = 0;
|
|
|
|
lp->lro_enabled = 0;
|
|
|
|
lp->lro_xid = 0;
|
|
|
|
lp->lso_max = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-17 14:33:08 +02:00
|
|
|
/**
|
|
|
|
* fcoe_netdev_cleanup() - clean up netdev configurations
|
|
|
|
* @fc: ptr to the fcoe_softc
|
|
|
|
*/
|
|
|
|
void fcoe_netdev_cleanup(struct fcoe_softc *fc)
|
|
|
|
{
|
|
|
|
u8 flogi_maddr[ETH_ALEN];
|
|
|
|
|
|
|
|
/* Don't listen for Ethernet packets anymore */
|
|
|
|
dev_remove_pack(&fc->fcoe_packet_type);
|
|
|
|
dev_remove_pack(&fc->fip_packet_type);
|
|
|
|
|
|
|
|
/* Delete secondary MAC addresses */
|
|
|
|
rtnl_lock();
|
|
|
|
memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
|
2009-07-30 02:05:45 +02:00
|
|
|
dev_unicast_delete(fc->netdev, flogi_maddr);
|
2009-05-17 14:33:08 +02:00
|
|
|
if (!is_zero_ether_addr(fc->ctlr.data_src_addr))
|
2009-07-30 02:05:45 +02:00
|
|
|
dev_unicast_delete(fc->netdev, fc->ctlr.data_src_addr);
|
2009-05-17 14:33:28 +02:00
|
|
|
if (fc->ctlr.spma)
|
2009-07-30 02:05:45 +02:00
|
|
|
dev_unicast_delete(fc->netdev, fc->ctlr.ctl_src_addr);
|
|
|
|
dev_mc_delete(fc->netdev, FIP_ALL_ENODE_MACS, ETH_ALEN, 0);
|
2009-05-17 14:33:08 +02:00
|
|
|
rtnl_unlock();
|
|
|
|
}
|
|
|
|
|
2009-05-06 19:52:40 +02:00
|
|
|
/**
|
|
|
|
* fcoe_queue_timer() - fcoe queue timer
|
|
|
|
* @lp: the fc_lport pointer
|
|
|
|
*
|
|
|
|
* Calls fcoe_check_wait_queue on timeout
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void fcoe_queue_timer(ulong lp)
|
|
|
|
{
|
|
|
|
fcoe_check_wait_queue((struct fc_lport *)lp, NULL);
|
|
|
|
}
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
/**
|
|
|
|
* fcoe_netdev_config() - Set up netdev for SW FCoE
|
|
|
|
* @lp : ptr to the fc_lport
|
|
|
|
* @netdev : ptr to the associated netdevice struct
|
|
|
|
*
|
|
|
|
* Must be called after fcoe_lport_config() as it will use lport mutex
|
|
|
|
*
|
|
|
|
* Returns : 0 for success
|
|
|
|
*/
|
|
|
|
static int fcoe_netdev_config(struct fc_lport *lp, struct net_device *netdev)
|
|
|
|
{
|
|
|
|
u32 mfs;
|
|
|
|
u64 wwnn, wwpn;
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
u8 flogi_maddr[ETH_ALEN];
|
2009-05-17 14:33:28 +02:00
|
|
|
struct netdev_hw_addr *ha;
|
2009-03-27 17:06:31 +01:00
|
|
|
|
|
|
|
/* Setup lport private data to point to fcoe softc */
|
|
|
|
fc = lport_priv(lp);
|
2009-03-17 19:42:40 +01:00
|
|
|
fc->ctlr.lp = lp;
|
2009-07-30 02:05:45 +02:00
|
|
|
fc->netdev = netdev;
|
2009-03-27 17:06:31 +01:00
|
|
|
|
|
|
|
/* Do not support for bonding device */
|
2009-07-30 02:05:45 +02:00
|
|
|
if ((netdev->priv_flags & IFF_MASTER_ALB) ||
|
|
|
|
(netdev->priv_flags & IFF_SLAVE_INACTIVE) ||
|
|
|
|
(netdev->priv_flags & IFF_MASTER_8023AD)) {
|
2009-03-27 17:06:31 +01:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine max frame size based on underlying device and optional
|
|
|
|
* user-configured limit. If the MFS is too low, fcoe_link_ok()
|
|
|
|
* will return 0, so do this first.
|
|
|
|
*/
|
2009-07-30 02:05:45 +02:00
|
|
|
mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
|
|
|
|
sizeof(struct fcoe_crc_eof));
|
2009-03-27 17:06:31 +01:00
|
|
|
if (fc_set_mfs(lp, mfs))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* offload features support */
|
2009-07-30 02:05:45 +02:00
|
|
|
if (netdev->features & NETIF_F_SG)
|
2009-03-27 17:06:31 +01:00
|
|
|
lp->sg_supp = 1;
|
|
|
|
|
|
|
|
if (netdev->features & NETIF_F_FCOE_CRC) {
|
|
|
|
lp->crc_offload = 1;
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Supports FCCRC offload\n");
|
2009-03-27 17:06:31 +01:00
|
|
|
}
|
|
|
|
if (netdev->features & NETIF_F_FSO) {
|
|
|
|
lp->seq_offload = 1;
|
|
|
|
lp->lso_max = netdev->gso_max_size;
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Supports LSO for max len 0x%x\n",
|
|
|
|
lp->lso_max);
|
2009-03-27 17:06:31 +01:00
|
|
|
}
|
|
|
|
if (netdev->fcoe_ddp_xid) {
|
|
|
|
lp->lro_enabled = 1;
|
|
|
|
lp->lro_xid = netdev->fcoe_ddp_xid;
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Supports LRO for max xid 0x%x\n",
|
|
|
|
lp->lro_xid);
|
2009-03-27 17:06:31 +01:00
|
|
|
}
|
|
|
|
skb_queue_head_init(&fc->fcoe_pending_queue);
|
|
|
|
fc->fcoe_pending_queue_active = 0;
|
2009-05-06 19:52:40 +02:00
|
|
|
setup_timer(&fc->timer, fcoe_queue_timer, (unsigned long)lp);
|
2009-03-27 17:06:31 +01:00
|
|
|
|
2009-05-17 14:33:28 +02:00
|
|
|
/* look for SAN MAC address, if multiple SAN MACs exist, only
|
|
|
|
* use the first one for SPMA */
|
|
|
|
rcu_read_lock();
|
|
|
|
for_each_dev_addr(netdev, ha) {
|
|
|
|
if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&
|
2009-07-30 02:03:50 +02:00
|
|
|
(is_valid_ether_addr(ha->addr))) {
|
2009-05-17 14:33:28 +02:00
|
|
|
memcpy(fc->ctlr.ctl_src_addr, ha->addr, ETH_ALEN);
|
|
|
|
fc->ctlr.spma = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
/* setup Source Mac Address */
|
2009-05-17 14:33:28 +02:00
|
|
|
if (!fc->ctlr.spma)
|
2009-07-30 02:05:45 +02:00
|
|
|
memcpy(fc->ctlr.ctl_src_addr, netdev->dev_addr,
|
|
|
|
fc->netdev->addr_len);
|
2009-03-27 17:06:31 +01:00
|
|
|
|
2009-07-30 02:05:45 +02:00
|
|
|
wwnn = fcoe_wwn_from_mac(netdev->dev_addr, 1, 0);
|
2009-03-27 17:06:31 +01:00
|
|
|
fc_set_wwnn(lp, wwnn);
|
|
|
|
/* XXX - 3rd arg needs to be vlan id */
|
2009-07-30 02:05:45 +02:00
|
|
|
wwpn = fcoe_wwn_from_mac(netdev->dev_addr, 2, 0);
|
2009-03-27 17:06:31 +01:00
|
|
|
fc_set_wwpn(lp, wwpn);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add FCoE MAC address as second unicast MAC address
|
|
|
|
* or enter promiscuous mode if not capable of listening
|
|
|
|
* for multiple unicast MACs.
|
|
|
|
*/
|
|
|
|
rtnl_lock();
|
|
|
|
memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
|
2009-07-30 02:05:45 +02:00
|
|
|
dev_unicast_add(netdev, flogi_maddr);
|
2009-05-17 14:33:28 +02:00
|
|
|
if (fc->ctlr.spma)
|
2009-07-30 02:05:45 +02:00
|
|
|
dev_unicast_add(netdev, fc->ctlr.ctl_src_addr);
|
|
|
|
dev_mc_add(netdev, FIP_ALL_ENODE_MACS, ETH_ALEN, 0);
|
2009-03-27 17:06:31 +01:00
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* setup the receive function from ethernet driver
|
|
|
|
* on the ethertype for the given device
|
|
|
|
*/
|
|
|
|
fc->fcoe_packet_type.func = fcoe_rcv;
|
|
|
|
fc->fcoe_packet_type.type = __constant_htons(ETH_P_FCOE);
|
2009-07-30 02:05:45 +02:00
|
|
|
fc->fcoe_packet_type.dev = netdev;
|
2009-03-27 17:06:31 +01:00
|
|
|
dev_add_pack(&fc->fcoe_packet_type);
|
|
|
|
|
2009-05-17 14:33:08 +02:00
|
|
|
fc->fip_packet_type.func = fcoe_fip_recv;
|
|
|
|
fc->fip_packet_type.type = htons(ETH_P_FIP);
|
2009-07-30 02:05:45 +02:00
|
|
|
fc->fip_packet_type.dev = netdev;
|
2009-05-17 14:33:08 +02:00
|
|
|
dev_add_pack(&fc->fip_packet_type);
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_shost_config() - Sets up fc_lport->host
|
|
|
|
* @lp : ptr to the fc_lport
|
|
|
|
* @shost : ptr to the associated scsi host
|
|
|
|
* @dev : device associated to scsi host
|
|
|
|
*
|
|
|
|
* Must be called after fcoe_lport_config() and fcoe_netdev_config()
|
|
|
|
*
|
|
|
|
* Returns : 0 for success
|
|
|
|
*/
|
|
|
|
static int fcoe_shost_config(struct fc_lport *lp, struct Scsi_Host *shost,
|
|
|
|
struct device *dev)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
/* lport scsi host config */
|
|
|
|
lp->host = shost;
|
|
|
|
|
|
|
|
lp->host->max_lun = FCOE_MAX_LUN;
|
|
|
|
lp->host->max_id = FCOE_MAX_FCP_TARGET;
|
|
|
|
lp->host->max_channel = 0;
|
|
|
|
lp->host->transportt = scsi_transport_fcoe_sw;
|
|
|
|
|
|
|
|
/* add the new host to the SCSI-ml */
|
|
|
|
rc = scsi_add_host(lp->host, dev);
|
|
|
|
if (rc) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(fcoe_netdev(lp), "fcoe_shost_config: "
|
|
|
|
"error on scsi_add_host\n");
|
2009-03-27 17:06:31 +01:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
sprintf(fc_host_symbolic_name(lp->host), "%s v%s over %s",
|
|
|
|
FCOE_NAME, FCOE_VERSION,
|
|
|
|
fcoe_netdev(lp)->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-30 02:05:21 +02:00
|
|
|
/*
|
|
|
|
* fcoe_oem_match() - match for read types IO
|
|
|
|
* @fp: the fc_frame for new IO.
|
|
|
|
*
|
|
|
|
* Returns : true for read types IO, otherwise returns false.
|
|
|
|
*/
|
|
|
|
bool fcoe_oem_match(struct fc_frame *fp)
|
|
|
|
{
|
|
|
|
return fc_fcp_is_read(fr_fsp(fp));
|
|
|
|
}
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
/**
|
|
|
|
* fcoe_em_config() - allocates em for this lport
|
|
|
|
* @lp: the port that em is to allocated for
|
|
|
|
*
|
2009-07-30 02:05:15 +02:00
|
|
|
* Called with write fcoe_hostlist_lock held.
|
|
|
|
*
|
2009-03-27 17:06:31 +01:00
|
|
|
* Returns : 0 on success
|
|
|
|
*/
|
|
|
|
static inline int fcoe_em_config(struct fc_lport *lp)
|
|
|
|
{
|
2009-07-30 02:05:21 +02:00
|
|
|
struct fcoe_softc *fc = lport_priv(lp);
|
|
|
|
struct fcoe_softc *oldfc = NULL;
|
2009-07-30 02:05:45 +02:00
|
|
|
struct net_device *old_real_dev, *cur_real_dev;
|
2009-07-30 02:05:21 +02:00
|
|
|
u16 min_xid = FCOE_MIN_XID;
|
|
|
|
u16 max_xid = FCOE_MAX_XID;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if need to allocate an em instance for
|
|
|
|
* offload exchange ids to be shared across all VN_PORTs/lport.
|
|
|
|
*/
|
|
|
|
if (!lp->lro_enabled || !lp->lro_xid || (lp->lro_xid >= max_xid)) {
|
|
|
|
lp->lro_xid = 0;
|
|
|
|
goto skip_oem;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reuse existing offload em instance in case
|
2009-07-30 02:05:45 +02:00
|
|
|
* it is already allocated on real eth device
|
2009-07-30 02:05:21 +02:00
|
|
|
*/
|
2009-07-30 02:05:45 +02:00
|
|
|
if (fc->netdev->priv_flags & IFF_802_1Q_VLAN)
|
|
|
|
cur_real_dev = vlan_dev_real_dev(fc->netdev);
|
|
|
|
else
|
|
|
|
cur_real_dev = fc->netdev;
|
|
|
|
|
2009-07-30 02:05:21 +02:00
|
|
|
list_for_each_entry(oldfc, &fcoe_hostlist, list) {
|
2009-07-30 02:05:45 +02:00
|
|
|
if (oldfc->netdev->priv_flags & IFF_802_1Q_VLAN)
|
|
|
|
old_real_dev = vlan_dev_real_dev(oldfc->netdev);
|
|
|
|
else
|
|
|
|
old_real_dev = oldfc->netdev;
|
|
|
|
|
|
|
|
if (cur_real_dev == old_real_dev) {
|
2009-07-30 02:05:21 +02:00
|
|
|
fc->oem = oldfc->oem;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fc->oem) {
|
|
|
|
if (!fc_exch_mgr_add(lp, fc->oem, fcoe_oem_match)) {
|
|
|
|
printk(KERN_ERR "fcoe_em_config: failed to add "
|
|
|
|
"offload em:%p on interface:%s\n",
|
2009-07-30 02:05:45 +02:00
|
|
|
fc->oem, fc->netdev->name);
|
2009-07-30 02:05:21 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fc->oem = fc_exch_mgr_alloc(lp, FC_CLASS_3,
|
|
|
|
FCOE_MIN_XID, lp->lro_xid,
|
|
|
|
fcoe_oem_match);
|
|
|
|
if (!fc->oem) {
|
|
|
|
printk(KERN_ERR "fcoe_em_config: failed to allocate "
|
|
|
|
"em for offload exches on interface:%s\n",
|
2009-07-30 02:05:45 +02:00
|
|
|
fc->netdev->name);
|
2009-07-30 02:05:21 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Exclude offload EM xid range from next EM xid range.
|
|
|
|
*/
|
|
|
|
min_xid += lp->lro_xid + 1;
|
|
|
|
|
|
|
|
skip_oem:
|
|
|
|
if (!fc_exch_mgr_alloc(lp, FC_CLASS_3, min_xid, max_xid, NULL)) {
|
|
|
|
printk(KERN_ERR "fcoe_em_config: failed to "
|
2009-07-30 02:05:45 +02:00
|
|
|
"allocate em on interface %s\n", fc->netdev->name);
|
2009-03-27 17:06:31 +01:00
|
|
|
return -ENOMEM;
|
2009-07-30 02:05:21 +02:00
|
|
|
}
|
2009-03-27 17:06:31 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_if_destroy() - FCoE software HBA tear-down function
|
|
|
|
* @netdev: ptr to the associated net_device
|
|
|
|
*
|
|
|
|
* Returns: 0 if link is OK for use by FCoE.
|
|
|
|
*/
|
|
|
|
static int fcoe_if_destroy(struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct fc_lport *lp = NULL;
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
|
|
|
|
BUG_ON(!netdev);
|
|
|
|
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
|
2009-03-27 17:06:31 +01:00
|
|
|
|
|
|
|
lp = fcoe_hostlist_lookup(netdev);
|
|
|
|
if (!lp)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
fc = lport_priv(lp);
|
|
|
|
|
|
|
|
/* Logout of the fabric */
|
|
|
|
fc_fabric_logoff(lp);
|
|
|
|
|
|
|
|
/* Remove the instance from fcoe's list */
|
|
|
|
fcoe_hostlist_remove(lp);
|
|
|
|
|
2009-05-17 14:33:08 +02:00
|
|
|
/* clean up netdev configurations */
|
|
|
|
fcoe_netdev_cleanup(fc);
|
|
|
|
|
|
|
|
/* tear-down the FCoE controller */
|
2009-03-17 19:42:40 +01:00
|
|
|
fcoe_ctlr_destroy(&fc->ctlr);
|
2009-03-27 17:06:31 +01:00
|
|
|
|
2009-07-30 02:04:17 +02:00
|
|
|
/* Free queued packets for the per-CPU receive threads */
|
|
|
|
fcoe_percpu_clean(lp);
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
/* Cleanup the fc_lport */
|
|
|
|
fc_lport_destroy(lp);
|
|
|
|
fc_fcp_destroy(lp);
|
|
|
|
|
|
|
|
/* Detach from the scsi-ml */
|
|
|
|
fc_remove_host(lp->host);
|
|
|
|
scsi_remove_host(lp->host);
|
|
|
|
|
|
|
|
/* There are no more rports or I/O, free the EM */
|
[SCSI] fcoe, fnic, libfc: modifies current code paths to use EM anchor list
Modifies current code to use EM anchor list in EM allocation, EM free,
EM reset, exch allocation and exch lookup code paths.
1. Modifies fc_exch_mgr_alloc to accept EM match function and then
have allocated EM added to the lport using fc_exch_mgr_add API
while also updating EM kref for newly added EM.
2. Updates fc_exch_mgr_free API to accept only lport pointer instead
EM and then have this API free all EMs of the lport from EM anchor
list.
3. Removes single lport pointer link from the EM, which was used in
associating lport pointer in newly allocated exchange. Instead have
lport pointer passed along new exchange allocation call path and
then store passed lport pointer in newly allocated exchange, this
will allow a single EM instance to be used across more than one
lport and used in EM reset to reset only lport specific exchanges.
4. Modifies fc_exch_mgr_reset to reset all EMs from the EM anchor list
of the lport, adds additional exch lport pointer (ep->lp) check for
shared EM case to reset exchange specific to a lport requested reset.
5. Updates exch allocation API fc_exch_alloc to use EM anchor list and
its anchor match func pointer. The fc_exch_alloc will walk the list
of EMs until it finds a match, a match will be either null match
func pointer or call to match function returning true value.
6. Updates fc_exch_recv to accept incoming frame on local port using
only lport pointer and frame pointer without specifying EM instance
of incoming frame. Instead modified fc_exch_recv to locate EM for the
incoming frame by matching xid of incoming frame against a EM xid range.
This change was required to use EM list in libfc Rx path and after this
change the lport fc_exch_mgr pointer emp is not needed anymore, so
removed emp pointer.
7. Updates fnic for removed lport emp pointer and above modified libfc APIs
fc_exch_recv, fc_exch_mgr_alloc and fc_exch_mgr_free.
8. Removes exch_get and exch_put from libfc_function_template as these
are no longer needed with EM anchor list and its match function use.
Also removes its default function fc_exch_get.
A defect this patch introduced regarding the libfc initialization order in
the fnic driver was fixed by Joe Eykholt <jeykholt@cisco.com>.
Signed-off-by: Vasu Dev <vasu.dev@intel.com>
Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2009-07-30 02:05:10 +02:00
|
|
|
fc_exch_mgr_free(lp);
|
2009-03-27 17:06:31 +01:00
|
|
|
|
|
|
|
/* Free existing skbs */
|
|
|
|
fcoe_clean_pending_queue(lp);
|
|
|
|
|
2009-05-06 19:52:40 +02:00
|
|
|
/* Stop the timer */
|
|
|
|
del_timer_sync(&fc->timer);
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
/* Free memory used by statistical counters */
|
|
|
|
fc_lport_free_stats(lp);
|
|
|
|
|
|
|
|
/* Release the net_device and Scsi_Host */
|
2009-07-30 02:05:45 +02:00
|
|
|
dev_put(netdev);
|
2009-03-27 17:06:31 +01:00
|
|
|
scsi_host_put(lp->host);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fcoe_ddp_setup - calls LLD's ddp_setup through net_device
|
|
|
|
* @lp: the corresponding fc_lport
|
|
|
|
* @xid: the exchange id for this ddp transfer
|
|
|
|
* @sgl: the scatterlist describing this transfer
|
|
|
|
* @sgc: number of sg items
|
|
|
|
*
|
|
|
|
* Returns : 0 no ddp
|
|
|
|
*/
|
|
|
|
static int fcoe_ddp_setup(struct fc_lport *lp, u16 xid,
|
|
|
|
struct scatterlist *sgl, unsigned int sgc)
|
|
|
|
{
|
|
|
|
struct net_device *n = fcoe_netdev(lp);
|
|
|
|
|
|
|
|
if (n->netdev_ops && n->netdev_ops->ndo_fcoe_ddp_setup)
|
|
|
|
return n->netdev_ops->ndo_fcoe_ddp_setup(n, xid, sgl, sgc);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fcoe_ddp_done - calls LLD's ddp_done through net_device
|
|
|
|
* @lp: the corresponding fc_lport
|
|
|
|
* @xid: the exchange id for this ddp transfer
|
|
|
|
*
|
|
|
|
* Returns : the length of data that have been completed by ddp
|
|
|
|
*/
|
|
|
|
static int fcoe_ddp_done(struct fc_lport *lp, u16 xid)
|
|
|
|
{
|
|
|
|
struct net_device *n = fcoe_netdev(lp);
|
|
|
|
|
|
|
|
if (n->netdev_ops && n->netdev_ops->ndo_fcoe_ddp_done)
|
|
|
|
return n->netdev_ops->ndo_fcoe_ddp_done(n, xid);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct libfc_function_template fcoe_libfc_fcn_templ = {
|
|
|
|
.frame_send = fcoe_xmit,
|
|
|
|
.ddp_setup = fcoe_ddp_setup,
|
|
|
|
.ddp_done = fcoe_ddp_done,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_if_create() - this function creates the fcoe interface
|
|
|
|
* @netdev: pointer the associated netdevice
|
|
|
|
*
|
|
|
|
* Creates fc_lport struct and scsi_host for lport, configures lport
|
|
|
|
* and starts fabric login.
|
|
|
|
*
|
|
|
|
* Returns : 0 on success
|
|
|
|
*/
|
|
|
|
static int fcoe_if_create(struct net_device *netdev)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
struct fc_lport *lp = NULL;
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
|
|
|
|
BUG_ON(!netdev);
|
|
|
|
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Create Interface\n");
|
2009-03-27 17:06:31 +01:00
|
|
|
|
|
|
|
lp = fcoe_hostlist_lookup(netdev);
|
|
|
|
if (lp)
|
|
|
|
return -EEXIST;
|
|
|
|
|
2009-03-17 19:42:29 +01:00
|
|
|
shost = libfc_host_alloc(&fcoe_shost_template,
|
|
|
|
sizeof(struct fcoe_softc));
|
2009-03-27 17:06:31 +01:00
|
|
|
if (!shost) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Could not allocate host structure\n");
|
2009-03-27 17:06:31 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
lp = shost_priv(shost);
|
|
|
|
fc = lport_priv(lp);
|
|
|
|
|
|
|
|
/* configure fc_lport, e.g., em */
|
|
|
|
rc = fcoe_lport_config(lp);
|
|
|
|
if (rc) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Could not configure lport for the "
|
|
|
|
"interface\n");
|
2009-03-27 17:06:31 +01:00
|
|
|
goto out_host_put;
|
|
|
|
}
|
|
|
|
|
2009-03-17 19:42:40 +01:00
|
|
|
/*
|
|
|
|
* Initialize FIP.
|
|
|
|
*/
|
|
|
|
fcoe_ctlr_init(&fc->ctlr);
|
|
|
|
fc->ctlr.send = fcoe_fip_send;
|
|
|
|
fc->ctlr.update_mac = fcoe_update_src_mac;
|
|
|
|
|
2009-05-17 14:33:08 +02:00
|
|
|
/* configure lport network properties */
|
|
|
|
rc = fcoe_netdev_config(lp, netdev);
|
|
|
|
if (rc) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Could not configure netdev for the "
|
|
|
|
"interface\n");
|
2009-05-17 14:33:08 +02:00
|
|
|
goto out_netdev_cleanup;
|
|
|
|
}
|
2009-03-17 19:42:40 +01:00
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
/* configure lport scsi host properties */
|
|
|
|
rc = fcoe_shost_config(lp, shost, &netdev->dev);
|
|
|
|
if (rc) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Could not configure shost for the "
|
|
|
|
"interface\n");
|
2009-05-17 14:33:08 +02:00
|
|
|
goto out_netdev_cleanup;
|
2009-03-27 17:06:31 +01:00
|
|
|
}
|
|
|
|
|
2009-07-30 02:05:00 +02:00
|
|
|
/* Initialize the library */
|
|
|
|
rc = fcoe_libfc_config(lp, &fcoe_libfc_fcn_templ);
|
2009-03-27 17:06:31 +01:00
|
|
|
if (rc) {
|
2009-07-30 02:05:00 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Could not configure libfc for the "
|
2009-06-11 00:30:59 +02:00
|
|
|
"interface\n");
|
2009-07-30 02:05:00 +02:00
|
|
|
goto out_lp_destroy;
|
2009-03-27 17:06:31 +01:00
|
|
|
}
|
|
|
|
|
2009-07-30 02:05:15 +02:00
|
|
|
/*
|
|
|
|
* fcoe_em_alloc() and fcoe_hostlist_add() both
|
|
|
|
* need to be atomic under fcoe_hostlist_lock
|
|
|
|
* since fcoe_em_alloc() looks for an existing EM
|
|
|
|
* instance on host list updated by fcoe_hostlist_add().
|
|
|
|
*/
|
|
|
|
write_lock(&fcoe_hostlist_lock);
|
2009-07-30 02:05:00 +02:00
|
|
|
/* lport exch manager allocation */
|
|
|
|
rc = fcoe_em_config(lp);
|
2009-03-27 17:06:31 +01:00
|
|
|
if (rc) {
|
2009-07-30 02:05:00 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Could not configure the EM for the "
|
2009-06-11 00:30:59 +02:00
|
|
|
"interface\n");
|
2009-03-27 17:06:31 +01:00
|
|
|
goto out_lp_destroy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add to lports list */
|
|
|
|
fcoe_hostlist_add(lp);
|
2009-07-30 02:05:15 +02:00
|
|
|
write_unlock(&fcoe_hostlist_lock);
|
2009-03-27 17:06:31 +01:00
|
|
|
|
|
|
|
lp->boot_time = jiffies;
|
|
|
|
|
|
|
|
fc_fabric_login(lp);
|
|
|
|
|
2009-03-17 19:42:40 +01:00
|
|
|
if (!fcoe_link_ok(lp))
|
|
|
|
fcoe_ctlr_link_up(&fc->ctlr);
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
dev_hold(netdev);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
out_lp_destroy:
|
[SCSI] fcoe, fnic, libfc: modifies current code paths to use EM anchor list
Modifies current code to use EM anchor list in EM allocation, EM free,
EM reset, exch allocation and exch lookup code paths.
1. Modifies fc_exch_mgr_alloc to accept EM match function and then
have allocated EM added to the lport using fc_exch_mgr_add API
while also updating EM kref for newly added EM.
2. Updates fc_exch_mgr_free API to accept only lport pointer instead
EM and then have this API free all EMs of the lport from EM anchor
list.
3. Removes single lport pointer link from the EM, which was used in
associating lport pointer in newly allocated exchange. Instead have
lport pointer passed along new exchange allocation call path and
then store passed lport pointer in newly allocated exchange, this
will allow a single EM instance to be used across more than one
lport and used in EM reset to reset only lport specific exchanges.
4. Modifies fc_exch_mgr_reset to reset all EMs from the EM anchor list
of the lport, adds additional exch lport pointer (ep->lp) check for
shared EM case to reset exchange specific to a lport requested reset.
5. Updates exch allocation API fc_exch_alloc to use EM anchor list and
its anchor match func pointer. The fc_exch_alloc will walk the list
of EMs until it finds a match, a match will be either null match
func pointer or call to match function returning true value.
6. Updates fc_exch_recv to accept incoming frame on local port using
only lport pointer and frame pointer without specifying EM instance
of incoming frame. Instead modified fc_exch_recv to locate EM for the
incoming frame by matching xid of incoming frame against a EM xid range.
This change was required to use EM list in libfc Rx path and after this
change the lport fc_exch_mgr pointer emp is not needed anymore, so
removed emp pointer.
7. Updates fnic for removed lport emp pointer and above modified libfc APIs
fc_exch_recv, fc_exch_mgr_alloc and fc_exch_mgr_free.
8. Removes exch_get and exch_put from libfc_function_template as these
are no longer needed with EM anchor list and its match function use.
Also removes its default function fc_exch_get.
A defect this patch introduced regarding the libfc initialization order in
the fnic driver was fixed by Joe Eykholt <jeykholt@cisco.com>.
Signed-off-by: Vasu Dev <vasu.dev@intel.com>
Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2009-07-30 02:05:10 +02:00
|
|
|
fc_exch_mgr_free(lp);
|
2009-05-17 14:33:08 +02:00
|
|
|
out_netdev_cleanup:
|
|
|
|
fcoe_netdev_cleanup(fc);
|
2009-03-27 17:06:31 +01:00
|
|
|
out_host_put:
|
|
|
|
scsi_host_put(lp->host);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_if_init() - attach to scsi transport
|
|
|
|
*
|
|
|
|
* Returns : 0 on success
|
|
|
|
*/
|
|
|
|
static int __init fcoe_if_init(void)
|
|
|
|
{
|
|
|
|
/* attach to scsi transport */
|
|
|
|
scsi_transport_fcoe_sw =
|
|
|
|
fc_attach_transport(&fcoe_transport_function);
|
|
|
|
|
|
|
|
if (!scsi_transport_fcoe_sw) {
|
2009-06-11 00:30:59 +02:00
|
|
|
printk(KERN_ERR "fcoe: Failed to attach to the FC transport\n");
|
2009-03-27 17:06:31 +01:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_if_exit() - detach from scsi transport
|
|
|
|
*
|
|
|
|
* Returns : 0 on success
|
|
|
|
*/
|
|
|
|
int __exit fcoe_if_exit(void)
|
|
|
|
{
|
|
|
|
fc_release_transport(scsi_transport_fcoe_sw);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-17 19:41:46 +01:00
|
|
|
/**
|
|
|
|
* fcoe_percpu_thread_create() - Create a receive thread for an online cpu
|
|
|
|
* @cpu: cpu index for the online cpu
|
|
|
|
*/
|
|
|
|
static void fcoe_percpu_thread_create(unsigned int cpu)
|
|
|
|
{
|
|
|
|
struct fcoe_percpu_s *p;
|
|
|
|
struct task_struct *thread;
|
|
|
|
|
|
|
|
p = &per_cpu(fcoe_percpu, cpu);
|
|
|
|
|
|
|
|
thread = kthread_create(fcoe_percpu_receive_thread,
|
|
|
|
(void *)p, "fcoethread/%d", cpu);
|
|
|
|
|
|
|
|
if (likely(!IS_ERR(p->thread))) {
|
|
|
|
kthread_bind(thread, cpu);
|
|
|
|
wake_up_process(thread);
|
|
|
|
|
|
|
|
spin_lock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
p->thread = thread;
|
|
|
|
spin_unlock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_percpu_thread_destroy() - removes the rx thread for the given cpu
|
|
|
|
* @cpu: cpu index the rx thread is to be removed
|
|
|
|
*
|
|
|
|
* Destroys a per-CPU Rx thread. Any pending skbs are moved to the
|
|
|
|
* current CPU's Rx thread. If the thread being destroyed is bound to
|
|
|
|
* the CPU processing this context the skbs will be freed.
|
|
|
|
*/
|
|
|
|
static void fcoe_percpu_thread_destroy(unsigned int cpu)
|
|
|
|
{
|
|
|
|
struct fcoe_percpu_s *p;
|
|
|
|
struct task_struct *thread;
|
|
|
|
struct page *crc_eof;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
struct fcoe_percpu_s *p0;
|
|
|
|
unsigned targ_cpu = smp_processor_id();
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_DBG("Destroying receive thread for CPU %d\n", cpu);
|
2009-03-17 19:41:46 +01:00
|
|
|
|
|
|
|
/* Prevent any new skbs from being queued for this CPU. */
|
|
|
|
p = &per_cpu(fcoe_percpu, cpu);
|
|
|
|
spin_lock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
thread = p->thread;
|
|
|
|
p->thread = NULL;
|
|
|
|
crc_eof = p->crc_eof_page;
|
|
|
|
p->crc_eof_page = NULL;
|
|
|
|
p->crc_eof_offset = 0;
|
|
|
|
spin_unlock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
|
|
* Don't bother moving the skb's if this context is running
|
|
|
|
* on the same CPU that is having its thread destroyed. This
|
|
|
|
* can easily happen when the module is removed.
|
|
|
|
*/
|
|
|
|
if (cpu != targ_cpu) {
|
|
|
|
p0 = &per_cpu(fcoe_percpu, targ_cpu);
|
|
|
|
spin_lock_bh(&p0->fcoe_rx_list.lock);
|
|
|
|
if (p0->thread) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_DBG("Moving frames from CPU %d to CPU %d\n",
|
|
|
|
cpu, targ_cpu);
|
2009-03-17 19:41:46 +01:00
|
|
|
|
|
|
|
while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
|
|
|
|
__skb_queue_tail(&p0->fcoe_rx_list, skb);
|
|
|
|
spin_unlock_bh(&p0->fcoe_rx_list.lock);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The targeted CPU is not initialized and cannot accept
|
|
|
|
* new skbs. Unlock the targeted CPU and drop the skbs
|
|
|
|
* on the CPU that is going offline.
|
|
|
|
*/
|
|
|
|
while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
|
|
|
|
kfree_skb(skb);
|
|
|
|
spin_unlock_bh(&p0->fcoe_rx_list.lock);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* This scenario occurs when the module is being removed
|
|
|
|
* and all threads are being destroyed. skbs will continue
|
|
|
|
* to be shifted from the CPU thread that is being removed
|
|
|
|
* to the CPU thread associated with the CPU that is processing
|
|
|
|
* the module removal. Once there is only one CPU Rx thread it
|
|
|
|
* will reach this case and we will drop all skbs and later
|
|
|
|
* stop the thread.
|
|
|
|
*/
|
|
|
|
spin_lock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
|
|
|
|
kfree_skb(skb);
|
|
|
|
spin_unlock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
/*
|
2009-04-22 01:27:36 +02:00
|
|
|
* This a non-SMP scenario where the singular Rx thread is
|
2009-03-17 19:41:46 +01:00
|
|
|
* being removed. Free all skbs and stop the thread.
|
|
|
|
*/
|
|
|
|
spin_lock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
|
|
|
|
kfree_skb(skb);
|
|
|
|
spin_unlock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (thread)
|
|
|
|
kthread_stop(thread);
|
|
|
|
|
|
|
|
if (crc_eof)
|
|
|
|
put_page(crc_eof);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fcoe_cpu_callback() - fcoe cpu hotplug event callback
|
|
|
|
* @nfb: callback data block
|
|
|
|
* @action: event triggering the callback
|
|
|
|
* @hcpu: index for the cpu of this event
|
|
|
|
*
|
|
|
|
* This creates or destroys per cpu data for fcoe
|
|
|
|
*
|
|
|
|
* Returns NOTIFY_OK always.
|
|
|
|
*/
|
|
|
|
static int fcoe_cpu_callback(struct notifier_block *nfb,
|
|
|
|
unsigned long action, void *hcpu)
|
|
|
|
{
|
|
|
|
unsigned cpu = (unsigned long)hcpu;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case CPU_ONLINE:
|
|
|
|
case CPU_ONLINE_FROZEN:
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_DBG("CPU %x online: Create Rx thread\n", cpu);
|
2009-03-17 19:41:46 +01:00
|
|
|
fcoe_percpu_thread_create(cpu);
|
|
|
|
break;
|
|
|
|
case CPU_DEAD:
|
|
|
|
case CPU_DEAD_FROZEN:
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_DBG("CPU %x offline: Remove Rx thread\n", cpu);
|
2009-03-17 19:41:46 +01:00
|
|
|
fcoe_percpu_thread_destroy(cpu);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block fcoe_cpu_notifier = {
|
|
|
|
.notifier_call = fcoe_cpu_callback,
|
|
|
|
};
|
|
|
|
|
2008-12-10 00:10:24 +01:00
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_rcv() - this is the fcoe receive function called by NET_RX_SOFTIRQ
|
2008-12-10 00:10:24 +01:00
|
|
|
* @skb: the receive skb
|
|
|
|
* @dev: associated net device
|
|
|
|
* @ptype: context
|
2009-04-22 01:27:36 +02:00
|
|
|
* @olddev: last device
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
|
|
|
* this function will receive the packet and build fc frame and pass it up
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
|
|
|
|
struct packet_type *ptype, struct net_device *olddev)
|
|
|
|
{
|
|
|
|
struct fc_lport *lp;
|
|
|
|
struct fcoe_rcv_info *fr;
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
struct fc_frame_header *fh;
|
|
|
|
struct fcoe_percpu_s *fps;
|
[SCSI] fcoe, libfc: fully makes use of per cpu exch pool and then removes em_lock
1. Updates fcoe_rcv() to queue incoming frames to the fcoe per
cpu thread on which this frame's exch was originated and simply
use current cpu for request exch not originated by initiator.
It is redundant to add this code under CONFIG_SMP, so removes
CONFIG_SMP uses around this code.
2. Updates fc_exch_em_alloc, fc_exch_delete, fc_exch_find to use
per cpu exch pools, here fc_exch_delete is rename of older
fc_exch_mgr_delete_ep since ep/exch are now deleted in pools
of EM and so brief new name is sufficient and better name.
Updates these functions to map exch id to their index into exch
pool using fc_cpu_mask, fc_cpu_order and EM min_xid.
This mapping is as per detailed explanation about this in
last patch and basically this is just as lower fc_cpu_mask
bits of exch id as cpu number and upper bit sum of EM min_xid
and exch index in pool.
Uses pool next_index to keep track of exch allocation from
pool along with pool_max_index as upper bound of exches array
in pool.
3. Adds exch pool ptr to fc_exch to free exch to its pool in
fc_exch_delete.
4. Updates fc_exch_mgr_reset to reset all exch pools of an EM,
this required adding fc_exch_pool_reset func to reset exches
in pool and then have fc_exch_mgr_reset call fc_exch_pool_reset
for each pool within each EM for a lport.
5. Removes no longer needed exches array, em_lock, next_xid, and
total_exches from struct fc_exch_mgr, these are not needed after
use of per cpu exch pool, also removes not used max_read,
last_read from struct fc_exch_mgr.
6. Updates locking notes for exch pool lock with fc_exch lock and
uses pool lock in exch allocation, lookup and reset.
Signed-off-by: Vasu Dev <vasu.dev@intel.com>
Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2009-08-25 22:58:53 +02:00
|
|
|
unsigned int cpu;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
fc = container_of(ptype, struct fcoe_softc, fcoe_packet_type);
|
2009-03-17 19:42:40 +01:00
|
|
|
lp = fc->ctlr.lp;
|
2008-12-10 00:10:24 +01:00
|
|
|
if (unlikely(lp == NULL)) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(dev, "Cannot find hba structure");
|
2008-12-10 00:10:24 +01:00
|
|
|
goto err2;
|
|
|
|
}
|
2009-03-17 19:42:40 +01:00
|
|
|
if (!lp->link_up)
|
|
|
|
goto err2;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(dev, "skb_info: len:%d data_len:%d head:%p "
|
|
|
|
"data:%p tail:%p end:%p sum:%d dev:%s",
|
|
|
|
skb->len, skb->data_len, skb->head, skb->data,
|
|
|
|
skb_tail_pointer(skb), skb_end_pointer(skb),
|
|
|
|
skb->csum, skb->dev ? skb->dev->name : "<NULL>");
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
/* check for FCOE packet type */
|
|
|
|
if (unlikely(eth_hdr(skb)->h_proto != htons(ETH_P_FCOE))) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(dev, "Wrong FC type frame");
|
2008-12-10 00:10:24 +01:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for minimum frame length, and make sure required FCoE
|
|
|
|
* and FC headers are pulled into the linear data area.
|
|
|
|
*/
|
|
|
|
if (unlikely((skb->len < FCOE_MIN_FRAME) ||
|
|
|
|
!pskb_may_pull(skb, FCOE_HEADER_LEN)))
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
skb_set_transport_header(skb, sizeof(struct fcoe_hdr));
|
|
|
|
fh = (struct fc_frame_header *) skb_transport_header(skb);
|
|
|
|
|
|
|
|
fr = fcoe_dev_from_skb(skb);
|
|
|
|
fr->fr_dev = lp;
|
|
|
|
fr->ptype = ptype;
|
2009-03-17 19:41:35 +01:00
|
|
|
|
2008-12-10 00:10:24 +01:00
|
|
|
/*
|
[SCSI] fcoe, libfc: fully makes use of per cpu exch pool and then removes em_lock
1. Updates fcoe_rcv() to queue incoming frames to the fcoe per
cpu thread on which this frame's exch was originated and simply
use current cpu for request exch not originated by initiator.
It is redundant to add this code under CONFIG_SMP, so removes
CONFIG_SMP uses around this code.
2. Updates fc_exch_em_alloc, fc_exch_delete, fc_exch_find to use
per cpu exch pools, here fc_exch_delete is rename of older
fc_exch_mgr_delete_ep since ep/exch are now deleted in pools
of EM and so brief new name is sufficient and better name.
Updates these functions to map exch id to their index into exch
pool using fc_cpu_mask, fc_cpu_order and EM min_xid.
This mapping is as per detailed explanation about this in
last patch and basically this is just as lower fc_cpu_mask
bits of exch id as cpu number and upper bit sum of EM min_xid
and exch index in pool.
Uses pool next_index to keep track of exch allocation from
pool along with pool_max_index as upper bound of exches array
in pool.
3. Adds exch pool ptr to fc_exch to free exch to its pool in
fc_exch_delete.
4. Updates fc_exch_mgr_reset to reset all exch pools of an EM,
this required adding fc_exch_pool_reset func to reset exches
in pool and then have fc_exch_mgr_reset call fc_exch_pool_reset
for each pool within each EM for a lport.
5. Removes no longer needed exches array, em_lock, next_xid, and
total_exches from struct fc_exch_mgr, these are not needed after
use of per cpu exch pool, also removes not used max_read,
last_read from struct fc_exch_mgr.
6. Updates locking notes for exch pool lock with fc_exch lock and
uses pool lock in exch allocation, lookup and reset.
Signed-off-by: Vasu Dev <vasu.dev@intel.com>
Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2009-08-25 22:58:53 +02:00
|
|
|
* In case the incoming frame's exchange is originated from
|
|
|
|
* the initiator, then received frame's exchange id is ANDed
|
|
|
|
* with fc_cpu_mask bits to get the same cpu on which exchange
|
|
|
|
* was originated, otherwise just use the current cpu.
|
2008-12-10 00:10:24 +01:00
|
|
|
*/
|
[SCSI] fcoe, libfc: fully makes use of per cpu exch pool and then removes em_lock
1. Updates fcoe_rcv() to queue incoming frames to the fcoe per
cpu thread on which this frame's exch was originated and simply
use current cpu for request exch not originated by initiator.
It is redundant to add this code under CONFIG_SMP, so removes
CONFIG_SMP uses around this code.
2. Updates fc_exch_em_alloc, fc_exch_delete, fc_exch_find to use
per cpu exch pools, here fc_exch_delete is rename of older
fc_exch_mgr_delete_ep since ep/exch are now deleted in pools
of EM and so brief new name is sufficient and better name.
Updates these functions to map exch id to their index into exch
pool using fc_cpu_mask, fc_cpu_order and EM min_xid.
This mapping is as per detailed explanation about this in
last patch and basically this is just as lower fc_cpu_mask
bits of exch id as cpu number and upper bit sum of EM min_xid
and exch index in pool.
Uses pool next_index to keep track of exch allocation from
pool along with pool_max_index as upper bound of exches array
in pool.
3. Adds exch pool ptr to fc_exch to free exch to its pool in
fc_exch_delete.
4. Updates fc_exch_mgr_reset to reset all exch pools of an EM,
this required adding fc_exch_pool_reset func to reset exches
in pool and then have fc_exch_mgr_reset call fc_exch_pool_reset
for each pool within each EM for a lport.
5. Removes no longer needed exches array, em_lock, next_xid, and
total_exches from struct fc_exch_mgr, these are not needed after
use of per cpu exch pool, also removes not used max_read,
last_read from struct fc_exch_mgr.
6. Updates locking notes for exch pool lock with fc_exch lock and
uses pool lock in exch allocation, lookup and reset.
Signed-off-by: Vasu Dev <vasu.dev@intel.com>
Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2009-08-25 22:58:53 +02:00
|
|
|
if (ntoh24(fh->fh_f_ctl) & FC_FC_EX_CTX)
|
|
|
|
cpu = ntohs(fh->fh_ox_id) & fc_cpu_mask;
|
|
|
|
else
|
|
|
|
cpu = smp_processor_id();
|
2009-03-17 19:41:35 +01:00
|
|
|
|
2009-03-17 19:41:46 +01:00
|
|
|
fps = &per_cpu(fcoe_percpu, cpu);
|
2008-12-10 00:10:24 +01:00
|
|
|
spin_lock_bh(&fps->fcoe_rx_list.lock);
|
2009-03-17 19:41:46 +01:00
|
|
|
if (unlikely(!fps->thread)) {
|
|
|
|
/*
|
|
|
|
* The targeted CPU is not ready, let's target
|
|
|
|
* the first CPU now. For non-SMP systems this
|
|
|
|
* will check the same CPU twice.
|
|
|
|
*/
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(dev, "CPU is online, but no receive thread "
|
|
|
|
"ready for incoming skb- using first online "
|
|
|
|
"CPU.\n");
|
2009-03-17 19:41:46 +01:00
|
|
|
|
|
|
|
spin_unlock_bh(&fps->fcoe_rx_list.lock);
|
|
|
|
cpu = first_cpu(cpu_online_map);
|
|
|
|
fps = &per_cpu(fcoe_percpu, cpu);
|
|
|
|
spin_lock_bh(&fps->fcoe_rx_list.lock);
|
|
|
|
if (!fps->thread) {
|
|
|
|
spin_unlock_bh(&fps->fcoe_rx_list.lock);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We now have a valid CPU that we're targeting for
|
|
|
|
* this skb. We also have this receive thread locked,
|
|
|
|
* so we're free to queue skbs into it's queue.
|
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
__skb_queue_tail(&fps->fcoe_rx_list, skb);
|
|
|
|
if (fps->fcoe_rx_list.qlen == 1)
|
|
|
|
wake_up_process(fps->thread);
|
|
|
|
|
|
|
|
spin_unlock_bh(&fps->fcoe_rx_list.lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err:
|
2009-04-01 00:51:50 +02:00
|
|
|
fc_lport_get_stats(lp)->ErrorFrames++;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
err2:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_start_io() - pass to netdev to start xmit for fcoe
|
2008-12-10 00:10:24 +01:00
|
|
|
* @skb: the skb to be xmitted
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static inline int fcoe_start_io(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
skb_get(skb);
|
|
|
|
rc = dev_queue_xmit(skb);
|
|
|
|
if (rc != 0)
|
|
|
|
return rc;
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-04-22 01:27:36 +02:00
|
|
|
* fcoe_get_paged_crc_eof() - in case we need to alloc a page for crc_eof
|
2008-12-10 00:10:24 +01:00
|
|
|
* @skb: the skb to be xmitted
|
|
|
|
* @tlen: total len
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen)
|
|
|
|
{
|
|
|
|
struct fcoe_percpu_s *fps;
|
|
|
|
struct page *page;
|
|
|
|
|
2009-03-17 19:41:35 +01:00
|
|
|
fps = &get_cpu_var(fcoe_percpu);
|
2008-12-10 00:10:24 +01:00
|
|
|
page = fps->crc_eof_page;
|
|
|
|
if (!page) {
|
|
|
|
page = alloc_page(GFP_ATOMIC);
|
|
|
|
if (!page) {
|
2009-03-17 19:41:35 +01:00
|
|
|
put_cpu_var(fcoe_percpu);
|
2008-12-10 00:10:24 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
fps->crc_eof_page = page;
|
2009-03-17 19:41:46 +01:00
|
|
|
fps->crc_eof_offset = 0;
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2009-03-17 19:41:35 +01:00
|
|
|
put_cpu_var(fcoe_percpu);
|
2008-12-10 00:10:24 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_fc_crc() - calculates FC CRC in this fcoe skb
|
2009-04-22 01:27:36 +02:00
|
|
|
* @fp: the fc_frame containing data to be checksummed
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
|
|
|
* This uses crc32() to calculate the crc for fc frame
|
|
|
|
* Return : 32 bit crc
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
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 = frag->size;
|
|
|
|
while (len > 0) {
|
|
|
|
clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
|
|
|
|
data = kmap_atomic(frag->page + (off >> PAGE_SHIFT),
|
|
|
|
KM_SKB_DATA_SOFTIRQ);
|
|
|
|
crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
|
|
|
|
kunmap_atomic(data, KM_SKB_DATA_SOFTIRQ);
|
|
|
|
off += clen;
|
|
|
|
len -= clen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_xmit() - FCoE frame transmit function
|
2008-12-10 00:10:24 +01:00
|
|
|
* @lp: the associated local port
|
|
|
|
* @fp: the fc_frame to be transmitted
|
|
|
|
*
|
|
|
|
* Return : 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
|
|
|
|
{
|
2009-05-06 19:52:34 +02:00
|
|
|
int wlen;
|
2008-12-10 00:10:24 +01:00
|
|
|
u32 crc;
|
|
|
|
struct ethhdr *eh;
|
|
|
|
struct fcoe_crc_eof *cp;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct fcoe_dev_stats *stats;
|
|
|
|
struct fc_frame_header *fh;
|
|
|
|
unsigned int hlen; /* header length implies the version */
|
|
|
|
unsigned int tlen; /* trailer length */
|
|
|
|
unsigned int elen; /* eth header, may include vlan */
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
u8 sof, eof;
|
|
|
|
struct fcoe_hdr *hp;
|
|
|
|
|
|
|
|
WARN_ON((fr_len(fp) % sizeof(u32)) != 0);
|
|
|
|
|
2009-02-27 19:55:55 +01:00
|
|
|
fc = lport_priv(lp);
|
2008-12-10 00:10:24 +01:00
|
|
|
fh = fc_frame_header_get(fp);
|
2009-03-17 19:42:40 +01:00
|
|
|
skb = fp_skb(fp);
|
|
|
|
wlen = skb->len / FCOE_WORD_TO_BYTE;
|
|
|
|
|
|
|
|
if (!lp->link_up) {
|
2009-04-22 01:27:25 +02:00
|
|
|
kfree_skb(skb);
|
2009-03-17 19:42:40 +01:00
|
|
|
return 0;
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
|
2009-03-17 19:42:40 +01:00
|
|
|
if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ) &&
|
|
|
|
fcoe_ctlr_els_send(&fc->ctlr, skb))
|
|
|
|
return 0;
|
|
|
|
|
2008-12-10 00:10:24 +01:00
|
|
|
sof = fr_sof(fp);
|
|
|
|
eof = fr_eof(fp);
|
|
|
|
|
2009-05-06 19:52:46 +02:00
|
|
|
elen = sizeof(struct ethhdr);
|
2008-12-10 00:10:24 +01:00
|
|
|
hlen = sizeof(struct fcoe_hdr);
|
|
|
|
tlen = sizeof(struct fcoe_crc_eof);
|
|
|
|
wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;
|
|
|
|
|
|
|
|
/* crc offload */
|
|
|
|
if (likely(lp->crc_offload)) {
|
2009-02-27 23:07:15 +01:00
|
|
|
skb->ip_summed = CHECKSUM_PARTIAL;
|
2008-12-10 00:10:24 +01:00
|
|
|
skb->csum_start = skb_headroom(skb);
|
|
|
|
skb->csum_offset = skb->len;
|
|
|
|
crc = 0;
|
|
|
|
} else {
|
|
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
|
|
crc = fcoe_fc_crc(fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* copy fc crc and eof to the skb buff */
|
|
|
|
if (skb_is_nonlinear(skb)) {
|
|
|
|
skb_frag_t *frag;
|
|
|
|
if (fcoe_get_paged_crc_eof(skb, tlen)) {
|
2009-02-27 19:56:22 +01:00
|
|
|
kfree_skb(skb);
|
2008-12-10 00:10:24 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
frag = &skb_shinfo(skb)->frags[skb_shinfo(skb)->nr_frags - 1];
|
|
|
|
cp = kmap_atomic(frag->page, KM_SKB_DATA_SOFTIRQ)
|
|
|
|
+ frag->page_offset;
|
|
|
|
} else {
|
|
|
|
cp = (struct fcoe_crc_eof *)skb_put(skb, tlen);
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(cp, 0, sizeof(*cp));
|
|
|
|
cp->fcoe_eof = eof;
|
|
|
|
cp->fcoe_crc32 = cpu_to_le32(~crc);
|
|
|
|
|
|
|
|
if (skb_is_nonlinear(skb)) {
|
|
|
|
kunmap_atomic(cp, KM_SKB_DATA_SOFTIRQ);
|
|
|
|
cp = NULL;
|
|
|
|
}
|
|
|
|
|
2009-04-22 01:27:36 +02:00
|
|
|
/* adjust skb network/transport offsets to match mac/fcoe/fc */
|
2008-12-10 00:10:24 +01:00
|
|
|
skb_push(skb, elen + hlen);
|
|
|
|
skb_reset_mac_header(skb);
|
|
|
|
skb_reset_network_header(skb);
|
|
|
|
skb->mac_len = elen;
|
2009-02-27 23:06:37 +01:00
|
|
|
skb->protocol = htons(ETH_P_FCOE);
|
2009-07-30 02:05:45 +02:00
|
|
|
skb->dev = fc->netdev;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
/* fill up mac and fcoe headers */
|
|
|
|
eh = eth_hdr(skb);
|
|
|
|
eh->h_proto = htons(ETH_P_FCOE);
|
2009-03-17 19:42:40 +01:00
|
|
|
if (fc->ctlr.map_dest)
|
2008-12-10 00:10:24 +01:00
|
|
|
fc_fcoe_set_mac(eh->h_dest, fh->fh_d_id);
|
|
|
|
else
|
|
|
|
/* insert GW address */
|
2009-03-17 19:42:40 +01:00
|
|
|
memcpy(eh->h_dest, fc->ctlr.dest_addr, ETH_ALEN);
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-03-17 19:42:40 +01:00
|
|
|
if (unlikely(fc->ctlr.flogi_oxid != FC_XID_UNKNOWN))
|
|
|
|
memcpy(eh->h_source, fc->ctlr.ctl_src_addr, ETH_ALEN);
|
2008-12-10 00:10:24 +01:00
|
|
|
else
|
2009-03-17 19:42:40 +01:00
|
|
|
memcpy(eh->h_source, fc->ctlr.data_src_addr, ETH_ALEN);
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
hp = (struct fcoe_hdr *)(eh + 1);
|
|
|
|
memset(hp, 0, sizeof(*hp));
|
|
|
|
if (FC_FCOE_VER)
|
|
|
|
FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
|
|
|
|
hp->fcoe_sof = sof;
|
|
|
|
|
2009-02-27 23:07:15 +01:00
|
|
|
/* fcoe lso, mss is in max_payload which is non-zero for FCP data */
|
|
|
|
if (lp->seq_offload && fr_max_payload(fp)) {
|
|
|
|
skb_shinfo(skb)->gso_type = SKB_GSO_FCOE;
|
|
|
|
skb_shinfo(skb)->gso_size = fr_max_payload(fp);
|
|
|
|
} else {
|
|
|
|
skb_shinfo(skb)->gso_type = 0;
|
|
|
|
skb_shinfo(skb)->gso_size = 0;
|
|
|
|
}
|
2008-12-10 00:10:24 +01:00
|
|
|
/* update tx stats: regardless if LLD fails */
|
2009-04-01 00:51:50 +02:00
|
|
|
stats = fc_lport_get_stats(lp);
|
|
|
|
stats->TxFrames++;
|
|
|
|
stats->TxWords += wlen;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
/* send down to lld */
|
|
|
|
fr_dev(fp) = lp;
|
|
|
|
if (fc->fcoe_pending_queue.qlen)
|
2009-05-06 19:52:34 +02:00
|
|
|
fcoe_check_wait_queue(lp, skb);
|
|
|
|
else if (fcoe_start_io(skb))
|
|
|
|
fcoe_check_wait_queue(lp, skb);
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-27 19:55:45 +01:00
|
|
|
/**
|
|
|
|
* fcoe_percpu_receive_thread() - recv thread per cpu
|
2008-12-10 00:10:24 +01:00
|
|
|
* @arg: ptr to the fcoe per cpu struct
|
|
|
|
*
|
|
|
|
* Return: 0 for success
|
|
|
|
*/
|
|
|
|
int fcoe_percpu_receive_thread(void *arg)
|
|
|
|
{
|
|
|
|
struct fcoe_percpu_s *p = arg;
|
|
|
|
u32 fr_len;
|
|
|
|
struct fc_lport *lp;
|
|
|
|
struct fcoe_rcv_info *fr;
|
|
|
|
struct fcoe_dev_stats *stats;
|
|
|
|
struct fc_frame_header *fh;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct fcoe_crc_eof crc_eof;
|
|
|
|
struct fc_frame *fp;
|
|
|
|
u8 *mac = NULL;
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
struct fcoe_hdr *hp;
|
|
|
|
|
2009-02-27 19:56:38 +01:00
|
|
|
set_user_nice(current, -20);
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
while (!kthread_should_stop()) {
|
|
|
|
|
|
|
|
spin_lock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
while ((skb = __skb_dequeue(&p->fcoe_rx_list)) == NULL) {
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
spin_unlock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
schedule();
|
|
|
|
set_current_state(TASK_RUNNING);
|
|
|
|
if (kthread_should_stop())
|
|
|
|
return 0;
|
|
|
|
spin_lock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&p->fcoe_rx_list.lock);
|
|
|
|
fr = fcoe_dev_from_skb(skb);
|
|
|
|
lp = fr->fr_dev;
|
|
|
|
if (unlikely(lp == NULL)) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(skb->dev, "Invalid HBA Structure");
|
2008-12-10 00:10:24 +01:00
|
|
|
kfree_skb(skb);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(skb->dev, "skb_info: len:%d data_len:%d "
|
|
|
|
"head:%p data:%p tail:%p end:%p sum:%d dev:%s",
|
|
|
|
skb->len, skb->data_len,
|
|
|
|
skb->head, skb->data, skb_tail_pointer(skb),
|
|
|
|
skb_end_pointer(skb), skb->csum,
|
|
|
|
skb->dev ? skb->dev->name : "<NULL>");
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Save source MAC address before discarding header.
|
|
|
|
*/
|
|
|
|
fc = lport_priv(lp);
|
|
|
|
if (skb_is_nonlinear(skb))
|
|
|
|
skb_linearize(skb); /* not ideal */
|
2009-03-17 19:42:40 +01:00
|
|
|
mac = eth_hdr(skb)->h_source;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Frame length checks and setting up the header pointers
|
|
|
|
* was done in fcoe_rcv already.
|
|
|
|
*/
|
|
|
|
hp = (struct fcoe_hdr *) skb_network_header(skb);
|
|
|
|
fh = (struct fc_frame_header *) skb_transport_header(skb);
|
|
|
|
|
2009-04-01 00:51:50 +02:00
|
|
|
stats = fc_lport_get_stats(lp);
|
2008-12-10 00:10:24 +01:00
|
|
|
if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
|
2009-04-01 00:51:50 +02:00
|
|
|
if (stats->ErrorFrames < 5)
|
2009-06-11 00:30:59 +02:00
|
|
|
printk(KERN_WARNING "fcoe: FCoE version "
|
2009-04-01 00:51:50 +02:00
|
|
|
"mismatch: The frame has "
|
|
|
|
"version %x, but the "
|
|
|
|
"initiator supports version "
|
|
|
|
"%x\n", FC_FCOE_DECAPS_VER(hp),
|
|
|
|
FC_FCOE_VER);
|
|
|
|
stats->ErrorFrames++;
|
2008-12-10 00:10:24 +01:00
|
|
|
kfree_skb(skb);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb_pull(skb, sizeof(struct fcoe_hdr));
|
|
|
|
fr_len = skb->len - sizeof(struct fcoe_crc_eof);
|
|
|
|
|
2009-04-01 00:51:50 +02:00
|
|
|
stats->RxFrames++;
|
|
|
|
stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
fp = (struct fc_frame *)skb;
|
|
|
|
fc_frame_init(fp);
|
|
|
|
fr_dev(fp) = lp;
|
|
|
|
fr_sof(fp) = hp->fcoe_sof;
|
|
|
|
|
|
|
|
/* Copy out the CRC and EOF trailer for access */
|
|
|
|
if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof))) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
fr_eof(fp) = crc_eof.fcoe_eof;
|
|
|
|
fr_crc(fp) = crc_eof.fcoe_crc32;
|
|
|
|
if (pskb_trim(skb, fr_len)) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only check CRC if no offload is available and if it is
|
|
|
|
* it's solicited data, in which case, the FCP layer would
|
|
|
|
* check it during the copy.
|
|
|
|
*/
|
2009-02-27 23:07:31 +01:00
|
|
|
if (lp->crc_offload && skb->ip_summed == CHECKSUM_UNNECESSARY)
|
2008-12-10 00:10:24 +01:00
|
|
|
fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
|
|
|
|
else
|
|
|
|
fr_flags(fp) |= FCPHF_CRC_UNCHECKED;
|
|
|
|
|
|
|
|
fh = fc_frame_header_get(fp);
|
|
|
|
if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA &&
|
|
|
|
fh->fh_type == FC_TYPE_FCP) {
|
[SCSI] fcoe, fnic, libfc: modifies current code paths to use EM anchor list
Modifies current code to use EM anchor list in EM allocation, EM free,
EM reset, exch allocation and exch lookup code paths.
1. Modifies fc_exch_mgr_alloc to accept EM match function and then
have allocated EM added to the lport using fc_exch_mgr_add API
while also updating EM kref for newly added EM.
2. Updates fc_exch_mgr_free API to accept only lport pointer instead
EM and then have this API free all EMs of the lport from EM anchor
list.
3. Removes single lport pointer link from the EM, which was used in
associating lport pointer in newly allocated exchange. Instead have
lport pointer passed along new exchange allocation call path and
then store passed lport pointer in newly allocated exchange, this
will allow a single EM instance to be used across more than one
lport and used in EM reset to reset only lport specific exchanges.
4. Modifies fc_exch_mgr_reset to reset all EMs from the EM anchor list
of the lport, adds additional exch lport pointer (ep->lp) check for
shared EM case to reset exchange specific to a lport requested reset.
5. Updates exch allocation API fc_exch_alloc to use EM anchor list and
its anchor match func pointer. The fc_exch_alloc will walk the list
of EMs until it finds a match, a match will be either null match
func pointer or call to match function returning true value.
6. Updates fc_exch_recv to accept incoming frame on local port using
only lport pointer and frame pointer without specifying EM instance
of incoming frame. Instead modified fc_exch_recv to locate EM for the
incoming frame by matching xid of incoming frame against a EM xid range.
This change was required to use EM list in libfc Rx path and after this
change the lport fc_exch_mgr pointer emp is not needed anymore, so
removed emp pointer.
7. Updates fnic for removed lport emp pointer and above modified libfc APIs
fc_exch_recv, fc_exch_mgr_alloc and fc_exch_mgr_free.
8. Removes exch_get and exch_put from libfc_function_template as these
are no longer needed with EM anchor list and its match function use.
Also removes its default function fc_exch_get.
A defect this patch introduced regarding the libfc initialization order in
the fnic driver was fixed by Joe Eykholt <jeykholt@cisco.com>.
Signed-off-by: Vasu Dev <vasu.dev@intel.com>
Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2009-07-30 02:05:10 +02:00
|
|
|
fc_exch_recv(lp, fp);
|
2008-12-10 00:10:24 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (fr_flags(fp) & FCPHF_CRC_UNCHECKED) {
|
|
|
|
if (le32_to_cpu(fr_crc(fp)) !=
|
|
|
|
~crc32(~0, skb->data, fr_len)) {
|
2009-06-11 00:30:59 +02:00
|
|
|
if (stats->InvalidCRCCount < 5)
|
2008-12-10 00:10:24 +01:00
|
|
|
printk(KERN_WARNING "fcoe: dropping "
|
|
|
|
"frame with CRC error\n");
|
|
|
|
stats->InvalidCRCCount++;
|
|
|
|
stats->ErrorFrames++;
|
|
|
|
fc_frame_free(fp);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
|
|
|
|
}
|
2009-03-17 19:42:40 +01:00
|
|
|
if (unlikely(fc->ctlr.flogi_oxid != FC_XID_UNKNOWN) &&
|
|
|
|
fcoe_ctlr_recv_flogi(&fc->ctlr, fp, mac)) {
|
|
|
|
fc_frame_free(fp);
|
|
|
|
continue;
|
|
|
|
}
|
[SCSI] fcoe, fnic, libfc: modifies current code paths to use EM anchor list
Modifies current code to use EM anchor list in EM allocation, EM free,
EM reset, exch allocation and exch lookup code paths.
1. Modifies fc_exch_mgr_alloc to accept EM match function and then
have allocated EM added to the lport using fc_exch_mgr_add API
while also updating EM kref for newly added EM.
2. Updates fc_exch_mgr_free API to accept only lport pointer instead
EM and then have this API free all EMs of the lport from EM anchor
list.
3. Removes single lport pointer link from the EM, which was used in
associating lport pointer in newly allocated exchange. Instead have
lport pointer passed along new exchange allocation call path and
then store passed lport pointer in newly allocated exchange, this
will allow a single EM instance to be used across more than one
lport and used in EM reset to reset only lport specific exchanges.
4. Modifies fc_exch_mgr_reset to reset all EMs from the EM anchor list
of the lport, adds additional exch lport pointer (ep->lp) check for
shared EM case to reset exchange specific to a lport requested reset.
5. Updates exch allocation API fc_exch_alloc to use EM anchor list and
its anchor match func pointer. The fc_exch_alloc will walk the list
of EMs until it finds a match, a match will be either null match
func pointer or call to match function returning true value.
6. Updates fc_exch_recv to accept incoming frame on local port using
only lport pointer and frame pointer without specifying EM instance
of incoming frame. Instead modified fc_exch_recv to locate EM for the
incoming frame by matching xid of incoming frame against a EM xid range.
This change was required to use EM list in libfc Rx path and after this
change the lport fc_exch_mgr pointer emp is not needed anymore, so
removed emp pointer.
7. Updates fnic for removed lport emp pointer and above modified libfc APIs
fc_exch_recv, fc_exch_mgr_alloc and fc_exch_mgr_free.
8. Removes exch_get and exch_put from libfc_function_template as these
are no longer needed with EM anchor list and its match function use.
Also removes its default function fc_exch_get.
A defect this patch introduced regarding the libfc initialization order in
the fnic driver was fixed by Joe Eykholt <jeykholt@cisco.com>.
Signed-off-by: Vasu Dev <vasu.dev@intel.com>
Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2009-07-30 02:05:10 +02:00
|
|
|
fc_exch_recv(lp, fp);
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-04-22 01:27:36 +02:00
|
|
|
* fcoe_check_wait_queue() - attempt to clear the transmit backlog
|
|
|
|
* @lp: the fc_lport
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
|
|
|
* This empties the wait_queue, dequeue the head of the wait_queue queue
|
|
|
|
* and calls fcoe_start_io() for each packet, if all skb have been
|
2009-02-27 19:56:27 +01:00
|
|
|
* transmitted, return qlen or -1 if a error occurs, then restore
|
2009-04-22 01:27:36 +02:00
|
|
|
* wait_queue and try again later.
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
|
|
|
* The wait_queue is used when the skb transmit fails. skb will go
|
2009-04-22 01:27:36 +02:00
|
|
|
* in the wait_queue which will be emptied by the timer function or
|
2008-12-10 00:10:24 +01:00
|
|
|
* by the next skb transmit.
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2009-05-06 19:52:34 +02:00
|
|
|
static void fcoe_check_wait_queue(struct fc_lport *lp, struct sk_buff *skb)
|
2008-12-10 00:10:24 +01:00
|
|
|
{
|
2009-02-27 19:56:32 +01:00
|
|
|
struct fcoe_softc *fc = lport_priv(lp);
|
2009-05-06 19:52:34 +02:00
|
|
|
int rc;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
spin_lock_bh(&fc->fcoe_pending_queue.lock);
|
2009-05-06 19:52:34 +02:00
|
|
|
|
|
|
|
if (skb)
|
|
|
|
__skb_queue_tail(&fc->fcoe_pending_queue, skb);
|
|
|
|
|
2009-02-27 19:56:27 +01:00
|
|
|
if (fc->fcoe_pending_queue_active)
|
|
|
|
goto out;
|
|
|
|
fc->fcoe_pending_queue_active = 1;
|
2009-02-27 19:56:32 +01:00
|
|
|
|
|
|
|
while (fc->fcoe_pending_queue.qlen) {
|
|
|
|
/* keep qlen > 0 until fcoe_start_io succeeds */
|
|
|
|
fc->fcoe_pending_queue.qlen++;
|
|
|
|
skb = __skb_dequeue(&fc->fcoe_pending_queue);
|
|
|
|
|
|
|
|
spin_unlock_bh(&fc->fcoe_pending_queue.lock);
|
|
|
|
rc = fcoe_start_io(skb);
|
|
|
|
spin_lock_bh(&fc->fcoe_pending_queue.lock);
|
|
|
|
|
|
|
|
if (rc) {
|
|
|
|
__skb_queue_head(&fc->fcoe_pending_queue, skb);
|
|
|
|
/* undo temporary increment above */
|
|
|
|
fc->fcoe_pending_queue.qlen--;
|
|
|
|
break;
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
2009-02-27 19:56:32 +01:00
|
|
|
/* undo temporary increment above */
|
|
|
|
fc->fcoe_pending_queue.qlen--;
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
2009-02-27 19:56:32 +01:00
|
|
|
|
|
|
|
if (fc->fcoe_pending_queue.qlen < FCOE_LOW_QUEUE_DEPTH)
|
|
|
|
lp->qfull = 0;
|
2009-05-06 19:52:40 +02:00
|
|
|
if (fc->fcoe_pending_queue.qlen && !timer_pending(&fc->timer))
|
|
|
|
mod_timer(&fc->timer, jiffies + 2);
|
2009-02-27 19:56:27 +01:00
|
|
|
fc->fcoe_pending_queue_active = 0;
|
|
|
|
out:
|
2009-05-06 19:52:34 +02:00
|
|
|
if (fc->fcoe_pending_queue.qlen > FCOE_MAX_QUEUE_DEPTH)
|
|
|
|
lp->qfull = 1;
|
2008-12-10 00:10:24 +01:00
|
|
|
spin_unlock_bh(&fc->fcoe_pending_queue.lock);
|
2009-05-06 19:52:34 +02:00
|
|
|
return;
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_dev_setup() - setup link change notification interface
|
|
|
|
*/
|
2009-04-28 06:49:31 +02:00
|
|
|
static void fcoe_dev_setup(void)
|
2008-12-10 00:10:24 +01:00
|
|
|
{
|
|
|
|
register_netdevice_notifier(&fcoe_notifier);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-04-28 06:49:31 +02:00
|
|
|
* fcoe_dev_cleanup() - cleanup link change notification interface
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static void fcoe_dev_cleanup(void)
|
|
|
|
{
|
|
|
|
unregister_netdevice_notifier(&fcoe_notifier);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_device_notification() - netdev event notification callback
|
2008-12-10 00:10:24 +01:00
|
|
|
* @notifier: context of the notification
|
|
|
|
* @event: type of event
|
|
|
|
* @ptr: fixed array for output parsed ifname
|
|
|
|
*
|
|
|
|
* This function is called by the ethernet driver in case of link change event
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static int fcoe_device_notification(struct notifier_block *notifier,
|
|
|
|
ulong event, void *ptr)
|
|
|
|
{
|
|
|
|
struct fc_lport *lp = NULL;
|
2009-07-30 02:05:45 +02:00
|
|
|
struct net_device *netdev = ptr;
|
2008-12-10 00:10:24 +01:00
|
|
|
struct fcoe_softc *fc;
|
|
|
|
struct fcoe_dev_stats *stats;
|
2009-03-17 19:42:40 +01:00
|
|
|
u32 link_possible = 1;
|
2008-12-10 00:10:24 +01:00
|
|
|
u32 mfs;
|
|
|
|
int rc = NOTIFY_OK;
|
|
|
|
|
|
|
|
read_lock(&fcoe_hostlist_lock);
|
|
|
|
list_for_each_entry(fc, &fcoe_hostlist, list) {
|
2009-07-30 02:05:45 +02:00
|
|
|
if (fc->netdev == netdev) {
|
2009-03-17 19:42:40 +01:00
|
|
|
lp = fc->ctlr.lp;
|
2008-12-10 00:10:24 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock(&fcoe_hostlist_lock);
|
|
|
|
if (lp == NULL) {
|
|
|
|
rc = NOTIFY_DONE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case NETDEV_DOWN:
|
|
|
|
case NETDEV_GOING_DOWN:
|
2009-03-17 19:42:40 +01:00
|
|
|
link_possible = 0;
|
2008-12-10 00:10:24 +01:00
|
|
|
break;
|
|
|
|
case NETDEV_UP:
|
|
|
|
case NETDEV_CHANGE:
|
|
|
|
break;
|
|
|
|
case NETDEV_CHANGEMTU:
|
2009-07-30 02:05:45 +02:00
|
|
|
mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
|
|
|
|
sizeof(struct fcoe_crc_eof));
|
2008-12-10 00:10:24 +01:00
|
|
|
if (mfs >= FC_MIN_MAX_FRAME)
|
|
|
|
fc_set_mfs(lp, mfs);
|
|
|
|
break;
|
|
|
|
case NETDEV_REGISTER:
|
|
|
|
break;
|
|
|
|
default:
|
2009-07-30 02:05:45 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Unknown event %ld "
|
2009-06-11 00:30:59 +02:00
|
|
|
"from netdev netlink\n", event);
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
2009-03-17 19:42:40 +01:00
|
|
|
if (link_possible && !fcoe_link_ok(lp))
|
|
|
|
fcoe_ctlr_link_up(&fc->ctlr);
|
|
|
|
else if (fcoe_ctlr_link_down(&fc->ctlr)) {
|
|
|
|
stats = fc_lport_get_stats(lp);
|
|
|
|
stats->LinkFailureCount++;
|
|
|
|
fcoe_clean_pending_queue(lp);
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_if_to_netdev() - parse a name buffer to get netdev
|
2008-12-10 00:10:24 +01:00
|
|
|
* @buffer: incoming buffer to be copied
|
|
|
|
*
|
2009-04-22 01:27:36 +02:00
|
|
|
* Returns: NULL or ptr to net_device
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-04-22 01:27:36 +02:00
|
|
|
* fcoe_netdev_to_module_owner() - finds out the driver module of the netdev
|
2008-12-10 00:10:24 +01:00
|
|
|
* @netdev: the target netdev
|
|
|
|
*
|
|
|
|
* Returns: ptr to the struct module, NULL for failure
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2009-02-27 19:55:50 +01:00
|
|
|
static struct module *
|
|
|
|
fcoe_netdev_to_module_owner(const struct net_device *netdev)
|
2008-12-10 00:10:24 +01:00
|
|
|
{
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
if (!netdev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dev = netdev->dev.parent;
|
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!dev->driver)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return dev->driver->owner;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_ethdrv_get() - Hold the Ethernet driver
|
2008-12-10 00:10:24 +01:00
|
|
|
* @netdev: the target netdev
|
|
|
|
*
|
2009-02-27 19:55:45 +01:00
|
|
|
* Holds the Ethernet driver module by try_module_get() for
|
|
|
|
* the corresponding netdev.
|
|
|
|
*
|
2009-04-22 01:27:36 +02:00
|
|
|
* Returns: 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static int fcoe_ethdrv_get(const struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct module *owner;
|
|
|
|
|
|
|
|
owner = fcoe_netdev_to_module_owner(netdev);
|
|
|
|
if (owner) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Hold driver module %s\n",
|
|
|
|
module_name(owner));
|
2008-12-10 00:10:24 +01:00
|
|
|
return try_module_get(owner);
|
|
|
|
}
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_ethdrv_put() - Release the Ethernet driver
|
2008-12-10 00:10:24 +01:00
|
|
|
* @netdev: the target netdev
|
|
|
|
*
|
2009-02-27 19:55:45 +01:00
|
|
|
* Releases the Ethernet driver module by module_put for
|
|
|
|
* the corresponding netdev.
|
|
|
|
*
|
2009-04-22 01:27:36 +02:00
|
|
|
* Returns: 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static int fcoe_ethdrv_put(const struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct module *owner;
|
|
|
|
|
|
|
|
owner = fcoe_netdev_to_module_owner(netdev);
|
|
|
|
if (owner) {
|
2009-06-11 00:30:59 +02:00
|
|
|
FCOE_NETDEV_DBG(netdev, "Release driver module %s\n",
|
|
|
|
module_name(owner));
|
2008-12-10 00:10:24 +01:00
|
|
|
module_put(owner);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_destroy() - handles the destroy from sysfs
|
2009-04-22 01:27:36 +02:00
|
|
|
* @buffer: expected to be an eth if name
|
2008-12-10 00:10:24 +01:00
|
|
|
* @kp: associated kernel param
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static int fcoe_destroy(const char *buffer, struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
struct net_device *netdev;
|
|
|
|
|
|
|
|
netdev = fcoe_if_to_netdev(buffer);
|
|
|
|
if (!netdev) {
|
|
|
|
rc = -ENODEV;
|
|
|
|
goto out_nodev;
|
|
|
|
}
|
|
|
|
/* look for existing lport */
|
|
|
|
if (!fcoe_hostlist_lookup(netdev)) {
|
|
|
|
rc = -ENODEV;
|
|
|
|
goto out_putdev;
|
|
|
|
}
|
2009-03-27 17:06:31 +01:00
|
|
|
rc = fcoe_if_destroy(netdev);
|
2008-12-10 00:10:24 +01:00
|
|
|
if (rc) {
|
2009-06-11 00:30:59 +02:00
|
|
|
printk(KERN_ERR "fcoe: Failed to destroy interface (%s)\n",
|
2008-12-10 00:10:24 +01:00
|
|
|
netdev->name);
|
|
|
|
rc = -EIO;
|
|
|
|
goto out_putdev;
|
|
|
|
}
|
|
|
|
fcoe_ethdrv_put(netdev);
|
|
|
|
rc = 0;
|
|
|
|
out_putdev:
|
|
|
|
dev_put(netdev);
|
|
|
|
out_nodev:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_create() - Handles the create call from sysfs
|
2009-04-22 01:27:36 +02:00
|
|
|
* @buffer: expected to be an eth if name
|
2008-12-10 00:10:24 +01:00
|
|
|
* @kp: associated kernel param
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static int fcoe_create(const char *buffer, struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
struct net_device *netdev;
|
|
|
|
|
|
|
|
netdev = fcoe_if_to_netdev(buffer);
|
|
|
|
if (!netdev) {
|
|
|
|
rc = -ENODEV;
|
|
|
|
goto out_nodev;
|
|
|
|
}
|
|
|
|
/* look for existing lport */
|
|
|
|
if (fcoe_hostlist_lookup(netdev)) {
|
|
|
|
rc = -EEXIST;
|
|
|
|
goto out_putdev;
|
|
|
|
}
|
|
|
|
fcoe_ethdrv_get(netdev);
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
rc = fcoe_if_create(netdev);
|
2008-12-10 00:10:24 +01:00
|
|
|
if (rc) {
|
2009-06-11 00:30:59 +02:00
|
|
|
printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
|
2008-12-10 00:10:24 +01:00
|
|
|
netdev->name);
|
|
|
|
fcoe_ethdrv_put(netdev);
|
|
|
|
rc = -EIO;
|
|
|
|
goto out_putdev;
|
|
|
|
}
|
|
|
|
rc = 0;
|
|
|
|
out_putdev:
|
|
|
|
dev_put(netdev);
|
|
|
|
out_nodev:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_param_call(create, fcoe_create, NULL, NULL, S_IWUSR);
|
|
|
|
__MODULE_PARM_TYPE(create, "string");
|
|
|
|
MODULE_PARM_DESC(create, "Create fcoe port using net device passed in.");
|
|
|
|
module_param_call(destroy, fcoe_destroy, NULL, NULL, S_IWUSR);
|
|
|
|
__MODULE_PARM_TYPE(destroy, "string");
|
|
|
|
MODULE_PARM_DESC(destroy, "Destroy fcoe port");
|
|
|
|
|
2009-02-27 19:55:45 +01:00
|
|
|
/**
|
|
|
|
* fcoe_link_ok() - Check if link is ok for the fc_lport
|
2008-12-10 00:10:24 +01:00
|
|
|
* @lp: ptr to the fc_lport
|
|
|
|
*
|
|
|
|
* Any permanently-disqualifying conditions have been previously checked.
|
|
|
|
* This also updates the speed setting, which may change with link for 100/1000.
|
|
|
|
*
|
|
|
|
* This function should probably be checking for PAUSE support at some point
|
|
|
|
* in the future. Currently Per-priority-pause is not determinable using
|
|
|
|
* ethtool, so we shouldn't be restrictive until that problem is resolved.
|
|
|
|
*
|
|
|
|
* Returns: 0 if link is OK for use by FCoE.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int fcoe_link_ok(struct fc_lport *lp)
|
|
|
|
{
|
2009-02-27 19:55:55 +01:00
|
|
|
struct fcoe_softc *fc = lport_priv(lp);
|
2009-07-30 02:05:45 +02:00
|
|
|
struct net_device *dev = fc->netdev;
|
2008-12-10 00:10:24 +01:00
|
|
|
struct ethtool_cmd ecmd = { ETHTOOL_GSET };
|
|
|
|
|
2009-07-30 02:04:01 +02:00
|
|
|
if ((dev->flags & IFF_UP) && netif_carrier_ok(dev) &&
|
|
|
|
(!dev_ethtool_get_settings(dev, &ecmd))) {
|
|
|
|
lp->link_supported_speeds &=
|
|
|
|
~(FC_PORTSPEED_1GBIT | FC_PORTSPEED_10GBIT);
|
|
|
|
if (ecmd.supported & (SUPPORTED_1000baseT_Half |
|
|
|
|
SUPPORTED_1000baseT_Full))
|
|
|
|
lp->link_supported_speeds |= FC_PORTSPEED_1GBIT;
|
|
|
|
if (ecmd.supported & SUPPORTED_10000baseT_Full)
|
|
|
|
lp->link_supported_speeds |=
|
|
|
|
FC_PORTSPEED_10GBIT;
|
|
|
|
if (ecmd.speed == SPEED_1000)
|
|
|
|
lp->link_speed = FC_PORTSPEED_1GBIT;
|
|
|
|
if (ecmd.speed == SPEED_10000)
|
|
|
|
lp->link_speed = FC_PORTSPEED_10GBIT;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-07-30 02:04:01 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -1;
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
|
2009-02-27 19:55:45 +01:00
|
|
|
/**
|
|
|
|
* fcoe_percpu_clean() - Clear the pending skbs for an lport
|
2008-12-10 00:10:24 +01:00
|
|
|
* @lp: the fc_lport
|
|
|
|
*/
|
|
|
|
void fcoe_percpu_clean(struct fc_lport *lp)
|
|
|
|
{
|
|
|
|
struct fcoe_percpu_s *pp;
|
|
|
|
struct fcoe_rcv_info *fr;
|
|
|
|
struct sk_buff_head *list;
|
|
|
|
struct sk_buff *skb, *next;
|
|
|
|
struct sk_buff *head;
|
2009-03-17 19:41:35 +01:00
|
|
|
unsigned int cpu;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-03-17 19:41:35 +01:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
pp = &per_cpu(fcoe_percpu, cpu);
|
|
|
|
spin_lock_bh(&pp->fcoe_rx_list.lock);
|
|
|
|
list = &pp->fcoe_rx_list;
|
|
|
|
head = list->next;
|
|
|
|
for (skb = head; skb != (struct sk_buff *)list;
|
|
|
|
skb = next) {
|
|
|
|
next = skb->next;
|
|
|
|
fr = fcoe_dev_from_skb(skb);
|
|
|
|
if (fr->fr_dev == lp) {
|
|
|
|
__skb_unlink(skb, list);
|
|
|
|
kfree_skb(skb);
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
}
|
2009-03-17 19:41:35 +01:00
|
|
|
spin_unlock_bh(&pp->fcoe_rx_list.lock);
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_clean_pending_queue() - Dequeue a skb and free it
|
2008-12-10 00:10:24 +01:00
|
|
|
* @lp: the corresponding fc_lport
|
|
|
|
*
|
|
|
|
* Returns: none
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
void fcoe_clean_pending_queue(struct fc_lport *lp)
|
|
|
|
{
|
|
|
|
struct fcoe_softc *fc = lport_priv(lp);
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
spin_lock_bh(&fc->fcoe_pending_queue.lock);
|
|
|
|
while ((skb = __skb_dequeue(&fc->fcoe_pending_queue)) != NULL) {
|
|
|
|
spin_unlock_bh(&fc->fcoe_pending_queue.lock);
|
|
|
|
kfree_skb(skb);
|
|
|
|
spin_lock_bh(&fc->fcoe_pending_queue.lock);
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&fc->fcoe_pending_queue.lock);
|
|
|
|
}
|
|
|
|
|
2009-02-27 19:55:45 +01:00
|
|
|
/**
|
|
|
|
* fcoe_reset() - Resets the fcoe
|
2008-12-10 00:10:24 +01:00
|
|
|
* @shost: shost the reset is from
|
|
|
|
*
|
|
|
|
* Returns: always 0
|
|
|
|
*/
|
|
|
|
int fcoe_reset(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
struct fc_lport *lport = shost_priv(shost);
|
|
|
|
fc_lport_reset(lport);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-27 19:55:45 +01:00
|
|
|
/**
|
|
|
|
* fcoe_hostlist_lookup_softc() - find the corresponding lport by a given device
|
2009-04-22 01:27:36 +02:00
|
|
|
* @dev: this is currently ptr to net_device
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
2009-07-30 02:05:15 +02:00
|
|
|
* Called with fcoe_hostlist_lock held.
|
|
|
|
*
|
2008-12-10 00:10:24 +01:00
|
|
|
* Returns: NULL or the located fcoe_softc
|
|
|
|
*/
|
2009-02-27 19:55:50 +01:00
|
|
|
static struct fcoe_softc *
|
|
|
|
fcoe_hostlist_lookup_softc(const struct net_device *dev)
|
2008-12-10 00:10:24 +01:00
|
|
|
{
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
|
|
|
|
list_for_each_entry(fc, &fcoe_hostlist, list) {
|
2009-07-30 02:05:45 +02:00
|
|
|
if (fc->netdev == dev)
|
2008-12-10 00:10:24 +01:00
|
|
|
return fc;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-02-27 19:55:45 +01:00
|
|
|
/**
|
|
|
|
* fcoe_hostlist_lookup() - Find the corresponding lport by netdev
|
2008-12-10 00:10:24 +01:00
|
|
|
* @netdev: ptr to net_device
|
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
|
|
|
*/
|
|
|
|
struct fc_lport *fcoe_hostlist_lookup(const struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
|
2009-07-30 02:05:15 +02:00
|
|
|
read_lock(&fcoe_hostlist_lock);
|
2008-12-10 00:10:24 +01:00
|
|
|
fc = fcoe_hostlist_lookup_softc(netdev);
|
2009-07-30 02:05:15 +02:00
|
|
|
read_unlock(&fcoe_hostlist_lock);
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-03-17 19:42:40 +01:00
|
|
|
return (fc) ? fc->ctlr.lp : NULL;
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
|
2009-02-27 19:55:45 +01:00
|
|
|
/**
|
|
|
|
* fcoe_hostlist_add() - Add a lport to lports list
|
2009-04-22 01:27:36 +02:00
|
|
|
* @lp: ptr to the fc_lport to be added
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
2009-07-30 02:05:15 +02:00
|
|
|
* Called with write fcoe_hostlist_lock held.
|
|
|
|
*
|
2008-12-10 00:10:24 +01:00
|
|
|
* Returns: 0 for success
|
|
|
|
*/
|
|
|
|
int fcoe_hostlist_add(const struct fc_lport *lp)
|
|
|
|
{
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
|
|
|
|
fc = fcoe_hostlist_lookup_softc(fcoe_netdev(lp));
|
|
|
|
if (!fc) {
|
2009-02-27 19:55:55 +01:00
|
|
|
fc = lport_priv(lp);
|
2008-12-10 00:10:24 +01:00
|
|
|
list_add_tail(&fc->list, &fcoe_hostlist);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-27 19:55:45 +01:00
|
|
|
/**
|
|
|
|
* fcoe_hostlist_remove() - remove a lport from lports list
|
2009-04-22 01:27:36 +02:00
|
|
|
* @lp: ptr to the fc_lport to be removed
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
|
|
|
* Returns: 0 for success
|
|
|
|
*/
|
|
|
|
int fcoe_hostlist_remove(const struct fc_lport *lp)
|
|
|
|
{
|
|
|
|
struct fcoe_softc *fc;
|
|
|
|
|
2009-07-30 02:05:15 +02:00
|
|
|
write_lock_bh(&fcoe_hostlist_lock);
|
2008-12-10 00:10:24 +01:00
|
|
|
fc = fcoe_hostlist_lookup_softc(fcoe_netdev(lp));
|
|
|
|
BUG_ON(!fc);
|
|
|
|
list_del(&fc->list);
|
|
|
|
write_unlock_bh(&fcoe_hostlist_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_init() - fcoe module loading initialization
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
|
|
|
* Returns 0 on success, negative on failure
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static int __init fcoe_init(void)
|
|
|
|
{
|
2009-03-17 19:41:30 +01:00
|
|
|
unsigned int cpu;
|
2009-03-17 19:41:46 +01:00
|
|
|
int rc = 0;
|
2008-12-10 00:10:24 +01:00
|
|
|
struct fcoe_percpu_s *p;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&fcoe_hostlist);
|
|
|
|
rwlock_init(&fcoe_hostlist_lock);
|
|
|
|
|
2009-03-17 19:41:30 +01:00
|
|
|
for_each_possible_cpu(cpu) {
|
2009-03-17 19:41:35 +01:00
|
|
|
p = &per_cpu(fcoe_percpu, cpu);
|
2009-03-17 19:41:30 +01:00
|
|
|
skb_queue_head_init(&p->fcoe_rx_list);
|
|
|
|
}
|
|
|
|
|
2009-03-17 19:41:46 +01:00
|
|
|
for_each_online_cpu(cpu)
|
|
|
|
fcoe_percpu_thread_create(cpu);
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-03-17 19:41:46 +01:00
|
|
|
/* Initialize per CPU interrupt thread */
|
|
|
|
rc = register_hotcpu_notifier(&fcoe_cpu_notifier);
|
|
|
|
if (rc)
|
|
|
|
goto out_free;
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-03-17 19:41:46 +01:00
|
|
|
/* Setup link change notification */
|
2008-12-10 00:10:24 +01:00
|
|
|
fcoe_dev_setup();
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
fcoe_if_init();
|
2008-12-10 00:10:24 +01:00
|
|
|
|
|
|
|
return 0;
|
2009-03-17 19:41:46 +01:00
|
|
|
|
|
|
|
out_free:
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
fcoe_percpu_thread_destroy(cpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
module_init(fcoe_init);
|
|
|
|
|
|
|
|
/**
|
2009-02-27 19:55:45 +01:00
|
|
|
* fcoe_exit() - fcoe module unloading cleanup
|
2008-12-10 00:10:24 +01:00
|
|
|
*
|
|
|
|
* Returns 0 on success, negative on failure
|
2009-02-27 19:55:45 +01:00
|
|
|
*/
|
2008-12-10 00:10:24 +01:00
|
|
|
static void __exit fcoe_exit(void)
|
|
|
|
{
|
2009-03-17 19:41:35 +01:00
|
|
|
unsigned int cpu;
|
2008-12-10 00:10:24 +01:00
|
|
|
struct fcoe_softc *fc, *tmp;
|
|
|
|
|
|
|
|
fcoe_dev_cleanup();
|
|
|
|
|
2009-03-27 17:03:29 +01:00
|
|
|
/* releases the associated fcoe hosts */
|
2008-12-10 00:10:24 +01:00
|
|
|
list_for_each_entry_safe(fc, tmp, &fcoe_hostlist, list)
|
2009-07-30 02:05:45 +02:00
|
|
|
fcoe_if_destroy(fc->netdev);
|
2008-12-10 00:10:24 +01:00
|
|
|
|
2009-03-17 19:41:46 +01:00
|
|
|
unregister_hotcpu_notifier(&fcoe_cpu_notifier);
|
|
|
|
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
fcoe_percpu_thread_destroy(cpu);
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
|
2009-03-27 17:06:31 +01:00
|
|
|
/* detach from scsi transport */
|
|
|
|
fcoe_if_exit();
|
2008-12-10 00:10:24 +01:00
|
|
|
}
|
|
|
|
module_exit(fcoe_exit);
|