fcoe.c 48.4 KB
Newer Older
1
/*
2
 * Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
 *
 * 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>
40
#include <scsi/fc/fc_fip.h>
41 42 43 44 45

#include <scsi/libfc.h>
#include <scsi/fc_frame.h>
#include <scsi/libfcoe.h>

46
#include "fcoe.h"
47

48 49
MODULE_AUTHOR("Open-FCoE.org");
MODULE_DESCRIPTION("FCoE");
50
MODULE_LICENSE("GPL v2");
51

52 53 54 55 56 57
/* Performance tuning parameters for fcoe */
static unsigned int fcoe_ddp_min;
module_param_named(ddp_min, fcoe_ddp_min, uint, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(ddp_min, "Minimum I/O size in bytes for "	\
		 "Direct Data Placement (DDP).");

58 59 60
/* fcoe host list */
LIST_HEAD(fcoe_hostlist);
DEFINE_RWLOCK(fcoe_hostlist_lock);
61
DEFINE_PER_CPU(struct fcoe_percpu_s, fcoe_percpu);
62

63
/* Function Prototypes */
64 65 66 67 68 69 70 71 72 73 74 75 76
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 *);

77
static void fcoe_check_wait_queue(struct fc_lport *, struct sk_buff *);
78 79 80 81 82 83 84 85 86
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,
};

87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
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,
};

141 142 143 144 145 146 147 148 149 150 151 152 153
/**
 * 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)
{
154
	struct fcoe_interface *fcoe;
155

156
	fcoe = container_of(ptype, struct fcoe_interface, fip_packet_type);
157
	fcoe_ctlr_recv(&fcoe->ctlr, skb);
158 159 160 161 162 163 164 165 166 167
	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)
{
168
	skb->dev = fcoe_from_ctlr(fip)->netdev;
169 170 171 172 173 174 175 176 177 178 179 180 181 182
	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)
{
183 184
	struct fcoe_interface *fcoe;

185
	fcoe = fcoe_from_ctlr(fip);
186 187
	rtnl_lock();
	if (!is_zero_ether_addr(old))
188 189
		dev_unicast_delete(fcoe->netdev, old);
	dev_unicast_add(fcoe->netdev, new);
190 191 192
	rtnl_unlock();
}

193 194 195 196 197 198 199 200 201 202 203
/**
 * 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;
204
	lp->max_rport_retry_count = 3;
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
	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;
}

225 226
/**
 * fcoe_netdev_cleanup() - clean up netdev configurations
227
 * @port: ptr to the fcoe_port
228
 */
229
void fcoe_netdev_cleanup(struct fcoe_port *port)
230 231
{
	u8 flogi_maddr[ETH_ALEN];
232
	struct fcoe_interface *fcoe = port->fcoe;
233 234

	/* Don't listen for Ethernet packets anymore */
235 236
	dev_remove_pack(&fcoe->fcoe_packet_type);
	dev_remove_pack(&fcoe->fip_packet_type);
237 238 239 240

	/* Delete secondary MAC addresses */
	rtnl_lock();
	memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
241
	dev_unicast_delete(fcoe->netdev, flogi_maddr);
242 243 244 245
	if (!is_zero_ether_addr(fcoe->ctlr.data_src_addr))
		dev_unicast_delete(fcoe->netdev, fcoe->ctlr.data_src_addr);
	if (fcoe->ctlr.spma)
		dev_unicast_delete(fcoe->netdev, fcoe->ctlr.ctl_src_addr);
246
	dev_mc_delete(fcoe->netdev, FIP_ALL_ENODE_MACS, ETH_ALEN, 0);
247 248 249
	rtnl_unlock();
}

V
Vasu Dev 已提交
250 251 252 253 254 255 256 257 258 259 260 261
/**
 * 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);
}

262 263 264 265 266 267 268 269 270 271 272 273 274
/**
 * 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;
275
	struct fcoe_interface *fcoe;
276
	struct fcoe_port *port;
277
	u8 flogi_maddr[ETH_ALEN];
V
Vasu Dev 已提交
278
	struct netdev_hw_addr *ha;
279 280

	/* Setup lport private data to point to fcoe softc */
281
	port = lport_priv(lp);
282
	fcoe = port->fcoe;
283
	fcoe->ctlr.lp = lp;
284
	fcoe->netdev = netdev;
285 286

	/* Do not support for bonding device */
287 288 289
	if ((netdev->priv_flags & IFF_MASTER_ALB) ||
	    (netdev->priv_flags & IFF_SLAVE_INACTIVE) ||
	    (netdev->priv_flags & IFF_MASTER_8023AD)) {
290 291 292 293 294 295 296 297
		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.
	 */
298 299
	mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
			     sizeof(struct fcoe_crc_eof));
300 301 302 303
	if (fc_set_mfs(lp, mfs))
		return -EINVAL;

	/* offload features support */
304
	if (netdev->features & NETIF_F_SG)
305 306 307 308
		lp->sg_supp = 1;

	if (netdev->features & NETIF_F_FCOE_CRC) {
		lp->crc_offload = 1;
309
		FCOE_NETDEV_DBG(netdev, "Supports FCCRC offload\n");
310 311 312 313
	}
	if (netdev->features & NETIF_F_FSO) {
		lp->seq_offload = 1;
		lp->lso_max = netdev->gso_max_size;
314 315
		FCOE_NETDEV_DBG(netdev, "Supports LSO for max len 0x%x\n",
				lp->lso_max);
316 317 318 319
	}
	if (netdev->fcoe_ddp_xid) {
		lp->lro_enabled = 1;
		lp->lro_xid = netdev->fcoe_ddp_xid;
320 321
		FCOE_NETDEV_DBG(netdev, "Supports LRO for max xid 0x%x\n",
				lp->lro_xid);
322
	}
323 324 325
	skb_queue_head_init(&port->fcoe_pending_queue);
	port->fcoe_pending_queue_active = 0;
	setup_timer(&port->timer, fcoe_queue_timer, (unsigned long)lp);
326

V
Vasu Dev 已提交
327 328 329 330 331
	/* 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) &&
332 333 334
		    (is_valid_ether_addr(fcoe->ctlr.ctl_src_addr))) {
			memcpy(fcoe->ctlr.ctl_src_addr, ha->addr, ETH_ALEN);
			fcoe->ctlr.spma = 1;
V
Vasu Dev 已提交
335 336 337 338 339
			break;
		}
	}
	rcu_read_unlock();

340
	/* setup Source Mac Address */
341 342
	if (!fcoe->ctlr.spma)
		memcpy(fcoe->ctlr.ctl_src_addr, netdev->dev_addr,
343
		       netdev->addr_len);
344

345
	wwnn = fcoe_wwn_from_mac(netdev->dev_addr, 1, 0);
346 347
	fc_set_wwnn(lp, wwnn);
	/* XXX - 3rd arg needs to be vlan id */
348
	wwpn = fcoe_wwn_from_mac(netdev->dev_addr, 2, 0);
349 350 351 352 353 354 355 356 357
	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);
358
	dev_unicast_add(netdev, flogi_maddr);
359 360
	if (fcoe->ctlr.spma)
		dev_unicast_add(netdev, fcoe->ctlr.ctl_src_addr);
361
	dev_mc_add(netdev, FIP_ALL_ENODE_MACS, ETH_ALEN, 0);
362 363 364 365 366 367
	rtnl_unlock();

	/*
	 * setup the receive function from ethernet driver
	 * on the ethertype for the given device
	 */
368 369 370 371
	fcoe->fcoe_packet_type.func = fcoe_rcv;
	fcoe->fcoe_packet_type.type = __constant_htons(ETH_P_FCOE);
	fcoe->fcoe_packet_type.dev = netdev;
	dev_add_pack(&fcoe->fcoe_packet_type);
372

373 374 375 376
	fcoe->fip_packet_type.func = fcoe_fip_recv;
	fcoe->fip_packet_type.type = htons(ETH_P_FIP);
	fcoe->fip_packet_type.dev = netdev;
	dev_add_pack(&fcoe->fip_packet_type);
377

378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
	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) {
407 408
		FCOE_NETDEV_DBG(fcoe_netdev(lp), "fcoe_shost_config: "
				"error on scsi_add_host\n");
409 410 411 412 413 414 415 416 417
		return rc;
	}
	sprintf(fc_host_symbolic_name(lp->host), "%s v%s over %s",
		FCOE_NAME, FCOE_VERSION,
		fcoe_netdev(lp)->name);

	return 0;
}

418 419 420 421 422 423 424 425
/*
 * 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)
{
426 427
	return fc_fcp_is_read(fr_fsp(fp)) &&
		(fr_fsp(fp)->data_len > fcoe_ddp_min);
428 429
}

430 431
/**
 * fcoe_em_config() - allocates em for this lport
432
 * @lp: the fcoe that em is to allocated for
433
 *
434 435
 * Called with write fcoe_hostlist_lock held.
 *
436 437 438 439
 * Returns : 0 on success
 */
static inline int fcoe_em_config(struct fc_lport *lp)
{
440
	struct fcoe_port *port = lport_priv(lp);
441 442 443
	struct fcoe_port *oldport = NULL;
	struct fcoe_interface *fcoe = port->fcoe;
	struct fcoe_interface *oldfcoe = NULL;
444
	struct net_device *old_real_dev, *cur_real_dev;
445 446 447 448 449 450 451 452 453 454 455 456 457 458
	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
459
	 * it is already allocated on real eth device
460
	 */
461 462
	if (fcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
		cur_real_dev = vlan_dev_real_dev(fcoe->netdev);
463
	else
464
		cur_real_dev = fcoe->netdev;
465

466 467 468 469
	list_for_each_entry(oldfcoe, &fcoe_hostlist, list) {
		oldport = oldfcoe->priv;
		if (oldfcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
			old_real_dev = vlan_dev_real_dev(oldfcoe->netdev);
470
		else
471
			old_real_dev = oldfcoe->netdev;
472 473

		if (cur_real_dev == old_real_dev) {
474
			port->oem = oldport->oem;
475 476 477 478
			break;
		}
	}

479 480
	if (port->oem) {
		if (!fc_exch_mgr_add(lp, port->oem, fcoe_oem_match)) {
481 482
			printk(KERN_ERR "fcoe_em_config: failed to add "
			       "offload em:%p on interface:%s\n",
483
			       port->oem, fcoe->netdev->name);
484 485 486
			return -ENOMEM;
		}
	} else {
487
		port->oem = fc_exch_mgr_alloc(lp, FC_CLASS_3,
488 489
					    FCOE_MIN_XID, lp->lro_xid,
					    fcoe_oem_match);
490
		if (!port->oem) {
491 492
			printk(KERN_ERR "fcoe_em_config: failed to allocate "
			       "em for offload exches on interface:%s\n",
493
			       fcoe->netdev->name);
494 495 496 497 498 499 500 501 502 503 504 505
			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 "
506
		       "allocate em on interface %s\n", fcoe->netdev->name);
507
		return -ENOMEM;
508
	}
509 510 511 512 513 514

	return 0;
}

/**
 * fcoe_if_destroy() - FCoE software HBA tear-down function
515
 * @lport: fc_lport to destroy
516
 */
517
static void fcoe_if_destroy(struct fc_lport *lport)
518
{
519 520
	struct fcoe_port *port = lport_priv(lport);
	struct fcoe_interface *fcoe = port->fcoe;
521
	struct net_device *netdev = fcoe->netdev;
522

523
	FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
524 525

	/* Logout of the fabric */
526
	fc_fabric_logoff(lport);
527 528

	/* Remove the instance from fcoe's list */
529
	fcoe_hostlist_remove(lport);
530

531
	/* clean up netdev configurations */
532
	fcoe_netdev_cleanup(port);
533 534

	/* tear-down the FCoE controller */
535
	fcoe_ctlr_destroy(&fcoe->ctlr);
536

537
	/* Free queued packets for the per-CPU receive threads */
538
	fcoe_percpu_clean(lport);
539

540
	/* Cleanup the fc_lport */
541 542
	fc_lport_destroy(lport);
	fc_fcp_destroy(lport);
543 544

	/* Detach from the scsi-ml */
545 546
	fc_remove_host(lport->host);
	scsi_remove_host(lport->host);
547 548

	/* There are no more rports or I/O, free the EM */
549
	fc_exch_mgr_free(lport);
550 551

	/* Free existing skbs */
552
	fcoe_clean_pending_queue(lport);
553

V
Vasu Dev 已提交
554
	/* Stop the timer */
555
	del_timer_sync(&port->timer);
V
Vasu Dev 已提交
556

557
	/* Free memory used by statistical counters */
558
	fc_lport_free_stats(lport);
559 560

	/* Release the net_device and Scsi_Host */
561
	dev_put(netdev);
562
	scsi_host_put(lport->host);
563
	kfree(fcoe);		/* TODO, should be refcounted */
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
}

/*
 * 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
611
 * @parent: device pointer to be the parent in sysfs for the SCSI host
612 613 614 615
 *
 * Creates fc_lport struct and scsi_host for lport, configures lport
 * and starts fabric login.
 *
616
 * Returns : The allocated fc_lport or an error pointer
617
 */
618 619
static struct fc_lport *fcoe_if_create(struct net_device *netdev,
				       struct device *parent)
620 621
{
	int rc;
622
	struct fc_lport *lport = NULL;
623 624
	struct fcoe_port *port;
	struct fcoe_interface *fcoe;
625 626
	struct Scsi_Host *shost;

627
	FCOE_NETDEV_DBG(netdev, "Create Interface\n");
628

629 630 631 632 633 634 635
	fcoe = kzalloc(sizeof(*fcoe), GFP_KERNEL);
	if (!fcoe) {
		FCOE_NETDEV_DBG(netdev, "Could not allocate fcoe structure\n");
		rc = -ENOMEM;
		goto out;
	}

636
	shost = libfc_host_alloc(&fcoe_shost_template,
637
				 sizeof(struct fcoe_port));
638
	if (!shost) {
639
		FCOE_NETDEV_DBG(netdev, "Could not allocate host structure\n");
640
		rc = -ENOMEM;
641
		goto out_kfree_port;
642
	}
643
	lport = shost_priv(shost);
644 645 646 647
	port = lport_priv(lport);

	port->fcoe = fcoe;
	fcoe->priv = port;
648 649

	/* configure fc_lport, e.g., em */
650
	rc = fcoe_lport_config(lport);
651
	if (rc) {
652 653
		FCOE_NETDEV_DBG(netdev, "Could not configure lport for the "
				"interface\n");
654 655 656
		goto out_host_put;
	}

657 658 659
	/*
	 * Initialize FIP.
	 */
660 661 662
	fcoe_ctlr_init(&fcoe->ctlr);
	fcoe->ctlr.send = fcoe_fip_send;
	fcoe->ctlr.update_mac = fcoe_update_src_mac;
663

664
	/* configure lport network properties */
665
	rc = fcoe_netdev_config(lport, netdev);
666
	if (rc) {
667 668
		FCOE_NETDEV_DBG(netdev, "Could not configure netdev for the "
				"interface\n");
669 670
		goto out_netdev_cleanup;
	}
671

672
	/* configure lport scsi host properties */
673
	rc = fcoe_shost_config(lport, shost, parent);
674
	if (rc) {
675 676
		FCOE_NETDEV_DBG(netdev, "Could not configure shost for the "
				"interface\n");
677
		goto out_netdev_cleanup;
678 679
	}

680
	/* Initialize the library */
681
	rc = fcoe_libfc_config(lport, &fcoe_libfc_fcn_templ);
682
	if (rc) {
683
		FCOE_NETDEV_DBG(netdev, "Could not configure libfc for the "
684
				"interface\n");
685
		goto out_lp_destroy;
686 687
	}

688 689 690 691 692 693 694
	/*
	 * 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);
695
	/* lport exch manager allocation */
696
	rc = fcoe_em_config(lport);
697
	if (rc) {
698
		FCOE_NETDEV_DBG(netdev, "Could not configure the EM for the "
699
				"interface\n");
700 701 702 703
		goto out_lp_destroy;
	}

	/* add to lports list */
704
	fcoe_hostlist_add(lport);
705
	write_unlock(&fcoe_hostlist_lock);
706

707
	lport->boot_time = jiffies;
708

709
	fc_fabric_login(lport);
710

711
	if (!fcoe_link_ok(lport))
712
		fcoe_ctlr_link_up(&fcoe->ctlr);
713

714 715
	dev_hold(netdev);

716
	return lport;
717 718

out_lp_destroy:
719
	fc_exch_mgr_free(lport);
720
out_netdev_cleanup:
721
	fcoe_netdev_cleanup(port);
722
out_host_put:
723
	scsi_host_put(lport->host);
724 725
out_kfree_port:
	kfree(fcoe);
726 727
out:
	return ERR_PTR(rc);
728 729 730 731 732 733 734 735 736 737 738 739 740 741
}

/**
 * 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) {
742
		printk(KERN_ERR "fcoe: Failed to attach to the FC transport\n");
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
		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;
}

760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
/**
 * 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 */

803
	FCOE_DBG("Destroying receive thread for CPU %d\n", cpu);
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824

	/* 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) {
825 826
			FCOE_DBG("Moving frames from CPU %d to CPU %d\n",
				 cpu, targ_cpu);
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857

			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
	/*
858
	 * This a non-SMP scenario where the singular Rx thread is
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891
	 * 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:
892
		FCOE_DBG("CPU %x online: Create Rx thread\n", cpu);
893 894 895 896
		fcoe_percpu_thread_create(cpu);
		break;
	case CPU_DEAD:
	case CPU_DEAD_FROZEN:
897
		FCOE_DBG("CPU %x offline: Remove Rx thread\n", cpu);
898 899 900 901 902 903 904 905 906 907 908 909
		fcoe_percpu_thread_destroy(cpu);
		break;
	default:
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block fcoe_cpu_notifier = {
	.notifier_call = fcoe_cpu_callback,
};

910
/**
911
 * fcoe_rcv() - this is the fcoe receive function called by NET_RX_SOFTIRQ
912 913 914
 * @skb: the receive skb
 * @dev: associated net device
 * @ptype: context
915
 * @olddev: last device
916 917 918 919
 *
 * this function will receive the packet and build fc frame and pass it up
 *
 * Returns: 0 for success
920
 */
921 922 923 924 925
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;
926
	struct fcoe_interface *fcoe;
927 928
	struct fc_frame_header *fh;
	struct fcoe_percpu_s *fps;
929
	unsigned int cpu;
930

931
	fcoe = container_of(ptype, struct fcoe_interface, fcoe_packet_type);
932
	lp = fcoe->ctlr.lp;
933
	if (unlikely(lp == NULL)) {
934
		FCOE_NETDEV_DBG(dev, "Cannot find hba structure");
935 936
		goto err2;
	}
937 938
	if (!lp->link_up)
		goto err2;
939

940 941 942 943 944
	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>");
945 946 947

	/* check for FCOE packet type */
	if (unlikely(eth_hdr(skb)->h_proto != htons(ETH_P_FCOE))) {
948
		FCOE_NETDEV_DBG(dev, "Wrong FC type frame");
949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
		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;
966

967
	/*
968 969 970 971
	 * 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.
972
	 */
973 974 975 976
	if (ntoh24(fh->fh_f_ctl) & FC_FC_EX_CTX)
		cpu = ntohs(fh->fh_ox_id) & fc_cpu_mask;
	else
		cpu = smp_processor_id();
977

978
	fps = &per_cpu(fcoe_percpu, cpu);
979
	spin_lock_bh(&fps->fcoe_rx_list.lock);
980 981 982 983 984 985
	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.
		 */
986 987 988
		FCOE_NETDEV_DBG(dev, "CPU is online, but no receive thread "
				"ready for incoming skb- using first online "
				"CPU.\n");
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004

		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.
	 */
1005 1006 1007 1008 1009 1010 1011 1012
	__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:
1013
	fc_lport_get_stats(lp)->ErrorFrames++;
1014 1015 1016 1017 1018 1019 1020

err2:
	kfree_skb(skb);
	return -1;
}

/**
1021
 * fcoe_start_io() - pass to netdev to start xmit for fcoe
1022 1023 1024
 * @skb: the skb to be xmitted
 *
 * Returns: 0 for success
1025
 */
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
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;
}

/**
1039
 * fcoe_get_paged_crc_eof() - in case we need to alloc a page for crc_eof
1040 1041 1042 1043
 * @skb: the skb to be xmitted
 * @tlen: total len
 *
 * Returns: 0 for success
1044
 */
1045 1046 1047 1048 1049
static int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen)
{
	struct fcoe_percpu_s *fps;
	struct page *page;

1050
	fps = &get_cpu_var(fcoe_percpu);
1051 1052 1053 1054
	page = fps->crc_eof_page;
	if (!page) {
		page = alloc_page(GFP_ATOMIC);
		if (!page) {
1055
			put_cpu_var(fcoe_percpu);
1056 1057 1058
			return -ENOMEM;
		}
		fps->crc_eof_page = page;
1059
		fps->crc_eof_offset = 0;
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
	}

	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);
	}
1075
	put_cpu_var(fcoe_percpu);
1076 1077 1078 1079
	return 0;
}

/**
1080
 * fcoe_fc_crc() - calculates FC CRC in this fcoe skb
1081
 * @fp: the fc_frame containing data to be checksummed
1082
 *
1083
 * This uses crc32() to calculate the crc for port frame
1084
 * Return   : 32 bit crc
1085
 */
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
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;
}

/**
1115
 * fcoe_xmit() - FCoE frame transmit function
1116
 * @lp:	the associated local fcoe
1117 1118 1119
 * @fp: the fc_frame to be transmitted
 *
 * Return   : 0 for success
1120
 */
1121 1122
int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
{
1123
	int wlen;
1124 1125 1126 1127 1128 1129 1130 1131 1132
	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 */
1133 1134
	struct fcoe_port *port = lport_priv(lp);
	struct fcoe_interface *fcoe = port->fcoe;
1135 1136 1137 1138 1139 1140
	u8 sof, eof;
	struct fcoe_hdr *hp;

	WARN_ON((fr_len(fp) % sizeof(u32)) != 0);

	fh = fc_frame_header_get(fp);
1141 1142 1143 1144
	skb = fp_skb(fp);
	wlen = skb->len / FCOE_WORD_TO_BYTE;

	if (!lp->link_up) {
1145
		kfree_skb(skb);
1146
		return 0;
1147 1148
	}

1149
	if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ) &&
1150
	    fcoe_ctlr_els_send(&fcoe->ctlr, skb))
1151 1152
		return 0;

1153 1154 1155
	sof = fr_sof(fp);
	eof = fr_eof(fp);

1156
	elen = sizeof(struct ethhdr);
1157 1158 1159 1160 1161 1162
	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)) {
1163
		skb->ip_summed = CHECKSUM_PARTIAL;
1164 1165 1166 1167 1168 1169 1170 1171
		skb->csum_start = skb_headroom(skb);
		skb->csum_offset = skb->len;
		crc = 0;
	} else {
		skb->ip_summed = CHECKSUM_NONE;
		crc = fcoe_fc_crc(fp);
	}

1172
	/* copy port crc and eof to the skb buff */
1173 1174 1175
	if (skb_is_nonlinear(skb)) {
		skb_frag_t *frag;
		if (fcoe_get_paged_crc_eof(skb, tlen)) {
R
Roel Kluin 已提交
1176
			kfree_skb(skb);
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
			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;
	}

1195
	/* adjust skb network/transport offsets to match mac/fcoe/port */
1196 1197 1198 1199
	skb_push(skb, elen + hlen);
	skb_reset_mac_header(skb);
	skb_reset_network_header(skb);
	skb->mac_len = elen;
1200
	skb->protocol = htons(ETH_P_FCOE);
1201
	skb->dev = fcoe->netdev;
1202 1203 1204 1205

	/* fill up mac and fcoe headers */
	eh = eth_hdr(skb);
	eh->h_proto = htons(ETH_P_FCOE);
1206
	if (fcoe->ctlr.map_dest)
1207 1208 1209
		fc_fcoe_set_mac(eh->h_dest, fh->fh_d_id);
	else
		/* insert GW address */
1210
		memcpy(eh->h_dest, fcoe->ctlr.dest_addr, ETH_ALEN);
1211

1212 1213
	if (unlikely(fcoe->ctlr.flogi_oxid != FC_XID_UNKNOWN))
		memcpy(eh->h_source, fcoe->ctlr.ctl_src_addr, ETH_ALEN);
1214
	else
1215
		memcpy(eh->h_source, fcoe->ctlr.data_src_addr, ETH_ALEN);
1216 1217 1218 1219 1220 1221 1222

	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;

1223 1224 1225 1226 1227 1228 1229 1230
	/* 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;
	}
1231
	/* update tx stats: regardless if LLD fails */
1232 1233 1234
	stats = fc_lport_get_stats(lp);
	stats->TxFrames++;
	stats->TxWords += wlen;
1235 1236 1237

	/* send down to lld */
	fr_dev(fp) = lp;
1238
	if (port->fcoe_pending_queue.qlen)
1239 1240 1241
		fcoe_check_wait_queue(lp, skb);
	else if (fcoe_start_io(skb))
		fcoe_check_wait_queue(lp, skb);
1242 1243 1244 1245

	return 0;
}

1246 1247
/**
 * fcoe_percpu_receive_thread() - recv thread per cpu
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
 * @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;
1264
	struct fcoe_port *port;
1265 1266
	struct fcoe_hdr *hp;

1267
	set_user_nice(current, -20);
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284

	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)) {
1285
			FCOE_NETDEV_DBG(skb->dev, "Invalid HBA Structure");
1286 1287 1288 1289
			kfree_skb(skb);
			continue;
		}

1290 1291 1292 1293 1294 1295
		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>");
1296 1297 1298 1299

		/*
		 * Save source MAC address before discarding header.
		 */
1300
		port = lport_priv(lp);
1301 1302
		if (skb_is_nonlinear(skb))
			skb_linearize(skb);	/* not ideal */
1303
		mac = eth_hdr(skb)->h_source;
1304 1305 1306 1307 1308 1309 1310 1311

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

1312
		stats = fc_lport_get_stats(lp);
1313
		if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
1314
			if (stats->ErrorFrames < 5)
1315
				printk(KERN_WARNING "fcoe: FCoE version "
1316 1317 1318 1319 1320 1321
				       "mismatch: The frame has "
				       "version %x, but the "
				       "initiator supports version "
				       "%x\n", FC_FCOE_DECAPS_VER(hp),
				       FC_FCOE_VER);
			stats->ErrorFrames++;
1322 1323 1324 1325 1326 1327 1328
			kfree_skb(skb);
			continue;
		}

		skb_pull(skb, sizeof(struct fcoe_hdr));
		fr_len = skb->len - sizeof(struct fcoe_crc_eof);

1329 1330
		stats->RxFrames++;
		stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353

		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.
		 */
1354
		if (lp->crc_offload && skb->ip_summed == CHECKSUM_UNNECESSARY)
1355 1356 1357 1358 1359 1360 1361
			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) {
1362
			fc_exch_recv(lp, fp);
1363 1364 1365 1366 1367
			continue;
		}
		if (fr_flags(fp) & FCPHF_CRC_UNCHECKED) {
			if (le32_to_cpu(fr_crc(fp)) !=
			    ~crc32(~0, skb->data, fr_len)) {
1368
				if (stats->InvalidCRCCount < 5)
1369 1370 1371 1372 1373 1374 1375 1376 1377
					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;
		}
1378 1379
		if (unlikely(port->fcoe->ctlr.flogi_oxid != FC_XID_UNKNOWN) &&
		    fcoe_ctlr_recv_flogi(&port->fcoe->ctlr, fp, mac)) {
1380 1381 1382
			fc_frame_free(fp);
			continue;
		}
1383
		fc_exch_recv(lp, fp);
1384 1385 1386 1387 1388
	}
	return 0;
}

/**
1389 1390
 * fcoe_check_wait_queue() - attempt to clear the transmit backlog
 * @lp: the fc_lport
1391 1392 1393
 *
 * 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
1394
 * transmitted, return qlen or -1 if a error occurs, then restore
1395
 * wait_queue and try again later.
1396 1397
 *
 * The wait_queue is used when the skb transmit fails. skb will go
1398
 * in the wait_queue which will be emptied by the timer function or
1399
 * by the next skb transmit.
1400
 */
1401
static void fcoe_check_wait_queue(struct fc_lport *lp, struct sk_buff *skb)
1402
{
1403
	struct fcoe_port *port = lport_priv(lp);
1404
	int rc;
1405

1406
	spin_lock_bh(&port->fcoe_pending_queue.lock);
1407 1408

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

1411
	if (port->fcoe_pending_queue_active)
1412
		goto out;
1413
	port->fcoe_pending_queue_active = 1;
1414

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

1420
		spin_unlock_bh(&port->fcoe_pending_queue.lock);
1421
		rc = fcoe_start_io(skb);
1422
		spin_lock_bh(&port->fcoe_pending_queue.lock);
1423 1424

		if (rc) {
1425
			__skb_queue_head(&port->fcoe_pending_queue, skb);
1426
			/* undo temporary increment above */
1427
			port->fcoe_pending_queue.qlen--;
1428
			break;
1429
		}
1430
		/* undo temporary increment above */
1431
		port->fcoe_pending_queue.qlen--;
1432
	}
1433

1434
	if (port->fcoe_pending_queue.qlen < FCOE_LOW_QUEUE_DEPTH)
1435
		lp->qfull = 0;
1436 1437 1438
	if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer))
		mod_timer(&port->timer, jiffies + 2);
	port->fcoe_pending_queue_active = 0;
1439
out:
1440
	if (port->fcoe_pending_queue.qlen > FCOE_MAX_QUEUE_DEPTH)
1441
		lp->qfull = 1;
1442
	spin_unlock_bh(&port->fcoe_pending_queue.lock);
1443
	return;
1444 1445 1446
}

/**
1447 1448
 * fcoe_dev_setup() - setup link change notification interface
 */
1449
static void fcoe_dev_setup(void)
1450 1451 1452 1453 1454
{
	register_netdevice_notifier(&fcoe_notifier);
}

/**
1455
 * fcoe_dev_cleanup() - cleanup link change notification interface
1456
 */
1457 1458 1459 1460 1461 1462
static void fcoe_dev_cleanup(void)
{
	unregister_netdevice_notifier(&fcoe_notifier);
}

/**
1463
 * fcoe_device_notification() - netdev event notification callback
1464 1465 1466 1467 1468 1469 1470
 * @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
1471
 */
1472 1473 1474 1475
static int fcoe_device_notification(struct notifier_block *notifier,
				    ulong event, void *ptr)
{
	struct fc_lport *lp = NULL;
1476
	struct net_device *netdev = ptr;
1477
	struct fcoe_interface *fcoe;
1478
	struct fcoe_dev_stats *stats;
1479
	u32 link_possible = 1;
1480 1481 1482 1483
	u32 mfs;
	int rc = NOTIFY_OK;

	read_lock(&fcoe_hostlist_lock);
1484
	list_for_each_entry(fcoe, &fcoe_hostlist, list) {
1485
		if (fcoe->netdev == netdev) {
1486
			lp = fcoe->ctlr.lp;
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
			break;
		}
	}
	read_unlock(&fcoe_hostlist_lock);
	if (lp == NULL) {
		rc = NOTIFY_DONE;
		goto out;
	}

	switch (event) {
	case NETDEV_DOWN:
	case NETDEV_GOING_DOWN:
1499
		link_possible = 0;
1500 1501 1502 1503 1504
		break;
	case NETDEV_UP:
	case NETDEV_CHANGE:
		break;
	case NETDEV_CHANGEMTU:
1505 1506
		mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
				     sizeof(struct fcoe_crc_eof));
1507 1508 1509 1510 1511 1512
		if (mfs >= FC_MIN_MAX_FRAME)
			fc_set_mfs(lp, mfs);
		break;
	case NETDEV_REGISTER:
		break;
	default:
1513
		FCOE_NETDEV_DBG(netdev, "Unknown event %ld "
1514
				"from netdev netlink\n", event);
1515
	}
1516
	if (link_possible && !fcoe_link_ok(lp))
1517 1518
		fcoe_ctlr_link_up(&fcoe->ctlr);
	else if (fcoe_ctlr_link_down(&fcoe->ctlr)) {
1519 1520 1521
		stats = fc_lport_get_stats(lp);
		stats->LinkFailureCount++;
		fcoe_clean_pending_queue(lp);
1522 1523 1524 1525 1526 1527
	}
out:
	return rc;
}

/**
1528
 * fcoe_if_to_netdev() - parse a name buffer to get netdev
1529 1530
 * @buffer: incoming buffer to be copied
 *
1531
 * Returns: NULL or ptr to net_device
1532
 */
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
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;
}

/**
1549
 * fcoe_netdev_to_module_owner() - finds out the driver module of the netdev
1550 1551 1552
 * @netdev: the target netdev
 *
 * Returns: ptr to the struct module, NULL for failure
1553
 */
1554 1555
static struct module *
fcoe_netdev_to_module_owner(const struct net_device *netdev)
1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
{
	struct device *dev;

	if (!netdev)
		return NULL;

	dev = netdev->dev.parent;
	if (!dev)
		return NULL;

	if (!dev->driver)
		return NULL;

	return dev->driver->owner;
}

/**
1573
 * fcoe_ethdrv_get() - Hold the Ethernet driver
1574 1575
 * @netdev: the target netdev
 *
1576 1577 1578
 * Holds the Ethernet driver module by try_module_get() for
 * the corresponding netdev.
 *
1579
 * Returns: 0 for success
1580
 */
1581 1582 1583 1584 1585 1586
static int fcoe_ethdrv_get(const struct net_device *netdev)
{
	struct module *owner;

	owner = fcoe_netdev_to_module_owner(netdev);
	if (owner) {
1587 1588
		FCOE_NETDEV_DBG(netdev, "Hold driver module %s\n",
				module_name(owner));
1589 1590 1591 1592 1593 1594
		return  try_module_get(owner);
	}
	return -ENODEV;
}

/**
1595
 * fcoe_ethdrv_put() - Release the Ethernet driver
1596 1597
 * @netdev: the target netdev
 *
1598 1599 1600
 * Releases the Ethernet driver module by module_put for
 * the corresponding netdev.
 *
1601
 * Returns: 0 for success
1602
 */
1603 1604 1605 1606 1607 1608
static int fcoe_ethdrv_put(const struct net_device *netdev)
{
	struct module *owner;

	owner = fcoe_netdev_to_module_owner(netdev);
	if (owner) {
1609 1610
		FCOE_NETDEV_DBG(netdev, "Release driver module %s\n",
				module_name(owner));
1611 1612 1613 1614 1615 1616 1617
		module_put(owner);
		return 0;
	}
	return -ENODEV;
}

/**
1618
 * fcoe_destroy() - handles the destroy from sysfs
1619
 * @buffer: expected to be an eth if name
1620 1621 1622
 * @kp: associated kernel param
 *
 * Returns: 0 for success
1623
 */
1624 1625 1626
static int fcoe_destroy(const char *buffer, struct kernel_param *kp)
{
	struct net_device *netdev;
1627 1628
	struct fc_lport *lport;
	int rc;
1629 1630 1631 1632 1633 1634 1635

	netdev = fcoe_if_to_netdev(buffer);
	if (!netdev) {
		rc = -ENODEV;
		goto out_nodev;
	}
	/* look for existing lport */
1636 1637
	lport = fcoe_hostlist_lookup(netdev);
	if (!lport) {
1638 1639 1640
		rc = -ENODEV;
		goto out_putdev;
	}
1641
	fcoe_if_destroy(lport);
1642 1643 1644 1645 1646 1647 1648 1649 1650
	fcoe_ethdrv_put(netdev);
	rc = 0;
out_putdev:
	dev_put(netdev);
out_nodev:
	return rc;
}

/**
1651
 * fcoe_create() - Handles the create call from sysfs
1652
 * @buffer: expected to be an eth if name
1653 1654 1655
 * @kp: associated kernel param
 *
 * Returns: 0 for success
1656
 */
1657 1658 1659
static int fcoe_create(const char *buffer, struct kernel_param *kp)
{
	int rc;
1660
	struct fc_lport *lport;
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
	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);

1675 1676
	lport = fcoe_if_create(netdev, &netdev->dev);
	if (IS_ERR(lport)) {
1677
		printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
		       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");
1692
MODULE_PARM_DESC(create, "Create fcoe fcoe using net device passed in.");
1693 1694
module_param_call(destroy, fcoe_destroy, NULL, NULL, S_IWUSR);
__MODULE_PARM_TYPE(destroy, "string");
1695
MODULE_PARM_DESC(destroy, "Destroy fcoe fcoe");
1696

1697 1698
/**
 * fcoe_link_ok() - Check if link is ok for the fc_lport
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
 * @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)
{
1713
	struct fcoe_port *port = lport_priv(lp);
1714
	struct net_device *dev = port->fcoe->netdev;
1715 1716
	struct ethtool_cmd ecmd = { ETHTOOL_GSET };

1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
	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;
1731

1732 1733 1734
		return 0;
	}
	return -1;
1735 1736
}

1737 1738
/**
 * fcoe_percpu_clean() - Clear the pending skbs for an lport
1739 1740 1741 1742 1743 1744 1745 1746 1747
 * @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;
1748
	unsigned int cpu;
1749

1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
	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);
1762 1763
			}
		}
1764
		spin_unlock_bh(&pp->fcoe_rx_list.lock);
1765 1766 1767 1768
	}
}

/**
1769
 * fcoe_clean_pending_queue() - Dequeue a skb and free it
1770 1771 1772
 * @lp: the corresponding fc_lport
 *
 * Returns: none
1773
 */
1774 1775
void fcoe_clean_pending_queue(struct fc_lport *lp)
{
1776
	struct fcoe_port  *port = lport_priv(lp);
1777 1778
	struct sk_buff *skb;

1779 1780 1781
	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);
1782
		kfree_skb(skb);
1783
		spin_lock_bh(&port->fcoe_pending_queue.lock);
1784
	}
1785
	spin_unlock_bh(&port->fcoe_pending_queue.lock);
1786 1787
}

1788 1789
/**
 * fcoe_reset() - Resets the fcoe
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
 * @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;
}

1801
/**
1802
 * fcoe_hostlist_lookup_port() - find the corresponding lport by a given device
1803
 * @dev: this is currently ptr to net_device
1804
 *
1805 1806
 * Called with fcoe_hostlist_lock held.
 *
1807
 * Returns: NULL or the located fcoe_port
1808
 */
1809 1810
static struct fcoe_interface *
fcoe_hostlist_lookup_port(const struct net_device *dev)
1811
{
1812
	struct fcoe_interface *fcoe;
1813

1814
	list_for_each_entry(fcoe, &fcoe_hostlist, list) {
1815
		if (fcoe->netdev == dev)
1816
			return fcoe;
1817 1818 1819 1820
	}
	return NULL;
}

1821 1822
/**
 * fcoe_hostlist_lookup() - Find the corresponding lport by netdev
1823 1824 1825 1826 1827 1828
 * @netdev: ptr to net_device
 *
 * Returns: 0 for success
 */
struct fc_lport *fcoe_hostlist_lookup(const struct net_device *netdev)
{
1829
	struct fcoe_interface *fcoe;
1830

1831
	read_lock(&fcoe_hostlist_lock);
1832
	fcoe = fcoe_hostlist_lookup_port(netdev);
1833
	read_unlock(&fcoe_hostlist_lock);
1834

1835
	return (fcoe) ? fcoe->ctlr.lp : NULL;
1836 1837
}

1838 1839
/**
 * fcoe_hostlist_add() - Add a lport to lports list
1840
 * @lp: ptr to the fc_lport to be added
1841
 *
1842 1843
 * Called with write fcoe_hostlist_lock held.
 *
1844 1845
 * Returns: 0 for success
 */
1846
int fcoe_hostlist_add(const struct fc_lport *lport)
1847
{
1848 1849 1850 1851 1852 1853 1854 1855
	struct fcoe_interface *fcoe;
	struct fcoe_port *port;

	fcoe = fcoe_hostlist_lookup_port(fcoe_netdev(lport));
	if (!fcoe) {
		port = lport_priv(lport);
		fcoe = port->fcoe;
		list_add_tail(&fcoe->list, &fcoe_hostlist);
1856 1857 1858 1859
	}
	return 0;
}

1860 1861
/**
 * fcoe_hostlist_remove() - remove a lport from lports list
1862
 * @lp: ptr to the fc_lport to be removed
1863 1864 1865
 *
 * Returns: 0 for success
 */
1866
int fcoe_hostlist_remove(const struct fc_lport *lport)
1867
{
1868
	struct fcoe_interface *fcoe;
1869

1870
	write_lock_bh(&fcoe_hostlist_lock);
1871 1872 1873
	fcoe = fcoe_hostlist_lookup_port(fcoe_netdev(lport));
	BUG_ON(!fcoe);
	list_del(&fcoe->list);
1874 1875 1876 1877 1878 1879
	write_unlock_bh(&fcoe_hostlist_lock);

	return 0;
}

/**
1880
 * fcoe_init() - fcoe module loading initialization
1881 1882
 *
 * Returns 0 on success, negative on failure
1883
 */
1884 1885
static int __init fcoe_init(void)
{
1886
	unsigned int cpu;
1887
	int rc = 0;
1888 1889
	struct fcoe_percpu_s *p;

1890
	for_each_possible_cpu(cpu) {
1891
		p = &per_cpu(fcoe_percpu, cpu);
1892 1893 1894
		skb_queue_head_init(&p->fcoe_rx_list);
	}

1895 1896
	for_each_online_cpu(cpu)
		fcoe_percpu_thread_create(cpu);
1897

1898 1899 1900 1901
	/* Initialize per CPU interrupt thread */
	rc = register_hotcpu_notifier(&fcoe_cpu_notifier);
	if (rc)
		goto out_free;
1902

1903
	/* Setup link change notification */
1904 1905
	fcoe_dev_setup();

1906 1907 1908
	rc = fcoe_if_init();
	if (rc)
		goto out_free;
1909 1910

	return 0;
1911 1912 1913 1914 1915 1916 1917

out_free:
	for_each_online_cpu(cpu) {
		fcoe_percpu_thread_destroy(cpu);
	}

	return rc;
1918 1919 1920 1921
}
module_init(fcoe_init);

/**
1922
 * fcoe_exit() - fcoe module unloading cleanup
1923 1924
 *
 * Returns 0 on success, negative on failure
1925
 */
1926 1927
static void __exit fcoe_exit(void)
{
1928
	unsigned int cpu;
1929
	struct fcoe_interface *fcoe, *tmp;
1930 1931 1932

	fcoe_dev_cleanup();

1933
	/* releases the associated fcoe hosts */
1934
	list_for_each_entry_safe(fcoe, tmp, &fcoe_hostlist, list)
1935
		fcoe_if_destroy(fcoe->ctlr.lp);
1936

1937 1938
	unregister_hotcpu_notifier(&fcoe_cpu_notifier);

1939
	for_each_online_cpu(cpu)
1940
		fcoe_percpu_thread_destroy(cpu);
1941

1942 1943
	/* detach from scsi transport */
	fcoe_if_exit();
1944 1945
}
module_exit(fcoe_exit);