fcoe.c 75.5 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
 *
 * 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/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>
28
#include <linux/slab.h>
29 30 31 32
#include <linux/cpu.h>
#include <linux/fs.h>
#include <linux/sysfs.h>
#include <linux/ctype.h>
33
#include <linux/workqueue.h>
34 35
#include <net/dcbnl.h>
#include <net/dcbevent.h>
36 37 38 39 40 41 42
#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>
43
#include <scsi/fc/fc_fip.h>
44
#include <scsi/fc/fc_fcoe.h>
45 46 47 48 49

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

50
#include "fcoe.h"
51

52 53
MODULE_AUTHOR("Open-FCoE.org");
MODULE_DESCRIPTION("FCoE");
54
MODULE_LICENSE("GPL v2");
55

56
/* Performance tuning parameters for fcoe */
57
static unsigned int fcoe_ddp_min = 4096;
58 59 60 61
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).");

62 63 64 65 66
unsigned int fcoe_debug_logging;
module_param_named(debug_logging, fcoe_debug_logging, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");

static DEFINE_MUTEX(fcoe_config_mutex);
67

68 69
static struct workqueue_struct *fcoe_wq;

70 71 72
/* fcoe_percpu_clean completion.  Waiter protected by fcoe_create_mutex */
static DECLARE_COMPLETION(fcoe_flush_completion);

73
/* fcoe host list */
74
/* must only by accessed under the RTNL mutex */
75 76
static LIST_HEAD(fcoe_hostlist);
static DEFINE_PER_CPU(struct fcoe_percpu_s, fcoe_percpu);
77

78
/* Function Prototypes */
79
static int fcoe_reset(struct Scsi_Host *);
80 81 82
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 *);
83 84 85
static int fcoe_percpu_receive_thread(void *);
static void fcoe_percpu_clean(struct fc_lport *);
static int fcoe_link_ok(struct fc_lport *);
86 87 88 89

static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *);
static int fcoe_hostlist_add(const struct fc_lport *);

90 91 92
static int fcoe_device_notification(struct notifier_block *, ulong, void *);
static void fcoe_dev_setup(void);
static void fcoe_dev_cleanup(void);
93 94 95 96 97 98 99 100 101 102 103 104 105 106
static struct fcoe_interface
*fcoe_hostlist_lookup_port(const struct net_device *);

static int fcoe_fip_recv(struct sk_buff *, struct net_device *,
			 struct packet_type *, struct net_device *);

static void fcoe_fip_send(struct fcoe_ctlr *, struct sk_buff *);
static void fcoe_update_src_mac(struct fc_lport *, u8 *);
static u8 *fcoe_get_src_mac(struct fc_lport *);
static void fcoe_destroy_work(struct work_struct *);

static int fcoe_ddp_setup(struct fc_lport *, u16, struct scatterlist *,
			  unsigned int);
static int fcoe_ddp_done(struct fc_lport *, u16);
107 108
static int fcoe_ddp_target(struct fc_lport *, u16, struct scatterlist *,
			   unsigned int);
109
static int fcoe_cpu_callback(struct notifier_block *, unsigned long, void *);
110 111
static int fcoe_dcb_app_notification(struct notifier_block *notifier,
				     ulong event, void *ptr);
112

113 114 115 116 117
static bool fcoe_match(struct net_device *netdev);
static int fcoe_create(struct net_device *netdev, enum fip_state fip_mode);
static int fcoe_destroy(struct net_device *netdev);
static int fcoe_enable(struct net_device *netdev);
static int fcoe_disable(struct net_device *netdev);
118

119 120 121 122 123
/* fcoe_syfs control interface handlers */
static int fcoe_ctlr_alloc(struct net_device *netdev);
static int fcoe_ctlr_enabled(struct fcoe_ctlr_device *cdev);


124 125 126 127 128 129 130
static struct fc_seq *fcoe_elsct_send(struct fc_lport *,
				      u32 did, struct fc_frame *,
				      unsigned int op,
				      void (*resp)(struct fc_seq *,
						   struct fc_frame *,
						   void *),
				      void *, u32 timeout);
131
static void fcoe_recv_frame(struct sk_buff *skb);
132 133

/* notification function for packets from net device */
134 135 136 137
static struct notifier_block fcoe_notifier = {
	.notifier_call = fcoe_device_notification,
};

138 139 140 141 142
/* notification function for CPU hotplug events */
static struct notifier_block fcoe_cpu_notifier = {
	.notifier_call = fcoe_cpu_callback,
};

143 144 145 146 147
/* notification function for DCB events */
static struct notifier_block dcb_notifier = {
	.notifier_call = fcoe_dcb_app_notification,
};

148 149
static struct scsi_transport_template *fcoe_nport_scsi_transport;
static struct scsi_transport_template *fcoe_vport_scsi_transport;
150

151 152 153 154
static int fcoe_vport_destroy(struct fc_vport *);
static int fcoe_vport_create(struct fc_vport *, bool disabled);
static int fcoe_vport_disable(struct fc_vport *, bool disable);
static void fcoe_set_vport_symbolic_name(struct fc_vport *);
155
static void fcoe_set_port_id(struct fc_lport *, u32, struct fc_frame *);
156 157 158
static void fcoe_fcf_get_vlan_id(struct fcoe_fcf_device *);

static struct fcoe_sysfs_function_template fcoe_sysfs_templ = {
159 160
	.set_fcoe_ctlr_mode = fcoe_ctlr_set_fip_mode,
	.set_fcoe_ctlr_enabled = fcoe_ctlr_enabled,
161 162 163 164 165 166 167 168 169 170
	.get_fcoe_ctlr_link_fail = fcoe_ctlr_get_lesb,
	.get_fcoe_ctlr_vlink_fail = fcoe_ctlr_get_lesb,
	.get_fcoe_ctlr_miss_fka = fcoe_ctlr_get_lesb,
	.get_fcoe_ctlr_symb_err = fcoe_ctlr_get_lesb,
	.get_fcoe_ctlr_err_block = fcoe_ctlr_get_lesb,
	.get_fcoe_ctlr_fcs_error = fcoe_ctlr_get_lesb,

	.get_fcoe_fcf_selected = fcoe_fcf_get_selected,
	.get_fcoe_fcf_vlan_id = fcoe_fcf_get_vlan_id,
};
171 172 173 174 175

static struct libfc_function_template fcoe_libfc_fcn_templ = {
	.frame_send = fcoe_xmit,
	.ddp_setup = fcoe_ddp_setup,
	.ddp_done = fcoe_ddp_done,
176
	.ddp_target = fcoe_ddp_target,
177
	.elsct_send = fcoe_elsct_send,
178
	.get_lesb = fcoe_get_lesb,
179
	.lport_set_port_id = fcoe_set_port_id,
180
};
181

182
static struct fc_function_template fcoe_nport_fc_functions = {
183 184 185 186 187 188
	.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,
189 190 191 192 193 194 195 196
	.show_host_serial_number = 1,
	.show_host_manufacturer = 1,
	.show_host_model = 1,
	.show_host_model_description = 1,
	.show_host_hardware_version = 1,
	.show_host_driver_version = 1,
	.show_host_firmware_version = 1,
	.show_host_optionrom_version = 1,
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220

	.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,
221 222 223 224

	.vport_create = fcoe_vport_create,
	.vport_delete = fcoe_vport_destroy,
	.vport_disable = fcoe_vport_disable,
225
	.set_vport_symbolic_name = fcoe_set_vport_symbolic_name,
226 227

	.bsg_request = fc_lport_bsg_request,
228 229
};

230
static struct fc_function_template fcoe_vport_fc_functions = {
231 232 233 234 235 236
	.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,
237 238 239 240 241 242 243 244
	.show_host_serial_number = 1,
	.show_host_manufacturer = 1,
	.show_host_model = 1,
	.show_host_model_description = 1,
	.show_host_hardware_version = 1,
	.show_host_driver_version = 1,
	.show_host_firmware_version = 1,
	.show_host_optionrom_version = 1,
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268

	.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,
269 270

	.bsg_request = fc_lport_bsg_request,
271 272
};

273 274 275 276 277 278 279 280 281 282 283 284
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,
285
	.cmd_per_lun = 3,
286 287 288 289 290 291
	.can_queue = FCOE_MAX_OUTSTANDING_COMMANDS,
	.use_clustering = ENABLE_CLUSTERING,
	.sg_tablesize = SG_ALL,
	.max_sectors = 0xffff,
};

292
/**
293 294 295
 * fcoe_interface_setup() - Setup a FCoE interface
 * @fcoe:   The new FCoE interface
 * @netdev: The net device that the fcoe interface is on
296 297
 *
 * Returns : 0 for success
298
 * Locking: must be called with the RTNL mutex held
299 300 301 302
 */
static int fcoe_interface_setup(struct fcoe_interface *fcoe,
				struct net_device *netdev)
{
303
	struct fcoe_ctlr *fip = fcoe_to_ctlr(fcoe);
304
	struct netdev_hw_addr *ha;
305
	struct net_device *real_dev;
306
	u8 flogi_maddr[ETH_ALEN];
307
	const struct net_device_ops *ops;
308 309 310

	fcoe->netdev = netdev;

311 312 313 314 315 316 317 318
	/* Let LLD initialize for FCoE */
	ops = netdev->netdev_ops;
	if (ops->ndo_fcoe_enable) {
		if (ops->ndo_fcoe_enable(netdev))
			FCOE_NETDEV_DBG(netdev, "Failed to enable FCoE"
					" specific feature for LLD.\n");
	}

319
	/* Do not support for bonding device */
J
Jiri Pirko 已提交
320
	if (netdev->priv_flags & IFF_BONDING && netdev->flags & IFF_MASTER) {
321
		FCOE_NETDEV_DBG(netdev, "Bonded interfaces not supported\n");
322 323 324 325 326
		return -EOPNOTSUPP;
	}

	/* look for SAN MAC address, if multiple SAN MACs exist, only
	 * use the first one for SPMA */
327 328
	real_dev = (netdev->priv_flags & IFF_802_1Q_VLAN) ?
		vlan_dev_real_dev(netdev) : netdev;
329
	fcoe->realdev = real_dev;
330
	rcu_read_lock();
331
	for_each_dev_addr(real_dev, ha) {
332
		if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&
Y
Yi Zou 已提交
333
		    (is_valid_ether_addr(ha->addr))) {
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
			memcpy(fip->ctl_src_addr, ha->addr, ETH_ALEN);
			fip->spma = 1;
			break;
		}
	}
	rcu_read_unlock();

	/* setup Source Mac Address */
	if (!fip->spma)
		memcpy(fip->ctl_src_addr, netdev->dev_addr, netdev->addr_len);

	/*
	 * Add FCoE MAC address as second unicast MAC address
	 * or enter promiscuous mode if not capable of listening
	 * for multiple unicast MACs.
	 */
	memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
351
	dev_uc_add(netdev, flogi_maddr);
352
	if (fip->spma)
353
		dev_uc_add(netdev, fip->ctl_src_addr);
354 355 356 357 358
	if (fip->mode == FIP_MODE_VN2VN) {
		dev_mc_add(netdev, FIP_ALL_VN2VN_MACS);
		dev_mc_add(netdev, FIP_ALL_P2P_MACS);
	} else
		dev_mc_add(netdev, FIP_ALL_ENODE_MACS);
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376

	/*
	 * setup the receive function from ethernet driver
	 * on the ethertype for the given device
	 */
	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);

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

	return 0;
}

377
/**
378 379
 * fcoe_interface_create() - Create a FCoE interface on a net device
 * @netdev: The net device to create the FCoE interface on
380
 * @fip_mode: The mode to use for FIP
381 382 383
 *
 * Returns: pointer to a struct fcoe_interface or NULL on error
 */
384 385
static struct fcoe_interface *fcoe_interface_create(struct net_device *netdev,
						    enum fip_state fip_mode)
386
{
387
	struct fcoe_ctlr_device *ctlr_dev;
388
	struct fcoe_ctlr *ctlr;
389
	struct fcoe_interface *fcoe;
390
	int size;
391
	int err;
392

393 394 395 396 397 398 399
	if (!try_module_get(THIS_MODULE)) {
		FCOE_NETDEV_DBG(netdev,
				"Could not get a reference to the module\n");
		fcoe = ERR_PTR(-EBUSY);
		goto out;
	}

400
	size = sizeof(struct fcoe_ctlr) + sizeof(struct fcoe_interface);
401 402 403 404
	ctlr_dev = fcoe_ctlr_device_add(&netdev->dev, &fcoe_sysfs_templ,
					size);
	if (!ctlr_dev) {
		FCOE_DBG("Failed to add fcoe_ctlr_device\n");
405
		fcoe = ERR_PTR(-ENOMEM);
406
		goto out_putmod;
407 408
	}

409 410 411
	ctlr = fcoe_ctlr_device_priv(ctlr_dev);
	fcoe = fcoe_ctlr_priv(ctlr);

412
	dev_hold(netdev);
413 414 415 416

	/*
	 * Initialize FIP.
	 */
417 418 419 420
	fcoe_ctlr_init(ctlr, fip_mode);
	ctlr->send = fcoe_fip_send;
	ctlr->update_mac = fcoe_update_src_mac;
	ctlr->get_src_addr = fcoe_get_src_mac;
421

422 423
	err = fcoe_interface_setup(fcoe, netdev);
	if (err) {
424
		fcoe_ctlr_destroy(ctlr);
425
		fcoe_ctlr_device_delete(ctlr_dev);
426
		dev_put(netdev);
427
		fcoe = ERR_PTR(err);
428
		goto out_putmod;
429
	}
430

431 432
	goto out;

433
out_putmod:
434 435
	module_put(THIS_MODULE);
out:
436 437 438
	return fcoe;
}

439
/**
440
 * fcoe_interface_remove() - remove FCoE interface from netdev
441
 * @fcoe: The FCoE interface to be cleaned up
442 443
 *
 * Caller must be holding the RTNL mutex
444
 */
445
static void fcoe_interface_remove(struct fcoe_interface *fcoe)
446 447
{
	struct net_device *netdev = fcoe->netdev;
448
	struct fcoe_ctlr *fip = fcoe_to_ctlr(fcoe);
449
	u8 flogi_maddr[ETH_ALEN];
450
	const struct net_device_ops *ops;
451 452 453 454 455 456 457 458 459 460 461 462 463

	/*
	 * Don't listen for Ethernet packets anymore.
	 * synchronize_net() ensures that the packet handlers are not running
	 * on another CPU. dev_remove_pack() would do that, this calls the
	 * unsyncronized version __dev_remove_pack() to avoid multiple delays.
	 */
	__dev_remove_pack(&fcoe->fcoe_packet_type);
	__dev_remove_pack(&fcoe->fip_packet_type);
	synchronize_net();

	/* Delete secondary MAC addresses */
	memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
464
	dev_uc_del(netdev, flogi_maddr);
465
	if (fip->spma)
466
		dev_uc_del(netdev, fip->ctl_src_addr);
467 468 469 470 471
	if (fip->mode == FIP_MODE_VN2VN) {
		dev_mc_del(netdev, FIP_ALL_VN2VN_MACS);
		dev_mc_del(netdev, FIP_ALL_P2P_MACS);
	} else
		dev_mc_del(netdev, FIP_ALL_ENODE_MACS);
472 473 474 475 476 477 478 479

	/* Tell the LLD we are done w/ FCoE */
	ops = netdev->netdev_ops;
	if (ops->ndo_fcoe_disable) {
		if (ops->ndo_fcoe_disable(netdev))
			FCOE_NETDEV_DBG(netdev, "Failed to disable FCoE"
					" specific feature for LLD.\n");
	}
480 481 482 483 484 485 486 487 488 489 490
	fcoe->removed = 1;
}


/**
 * fcoe_interface_cleanup() - Clean up a FCoE interface
 * @fcoe: The FCoE interface to be cleaned up
 */
static void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
{
	struct net_device *netdev = fcoe->netdev;
491
	struct fcoe_ctlr *fip = fcoe_to_ctlr(fcoe);
492
	struct fcoe_ctlr_device *ctlr_dev = fcoe_ctlr_to_ctlr_dev(fip);
493

494 495 496
	rtnl_lock();
	if (!fcoe->removed)
		fcoe_interface_remove(fcoe);
497 498
	rtnl_unlock();

499
	/* Release the self-reference taken during fcoe_interface_create() */
500 501
	/* tear-down the FCoE controller */
	fcoe_ctlr_destroy(fip);
502
	scsi_host_put(fip->lp->host);
503
	fcoe_ctlr_device_delete(ctlr_dev);
504 505
	dev_put(netdev);
	module_put(THIS_MODULE);
506 507
}

508
/**
509 510 511 512 513 514
 * fcoe_fip_recv() - Handler for received FIP frames
 * @skb:      The receive skb
 * @netdev:   The associated net device
 * @ptype:    The packet_type structure which was used to register this handler
 * @orig_dev: The original net_device the the skb was received on.
 *	      (in case dev is a bond)
515 516 517
 *
 * Returns: 0 for success
 */
518
static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *netdev,
519 520 521
			 struct packet_type *ptype,
			 struct net_device *orig_dev)
{
522
	struct fcoe_interface *fcoe;
523
	struct fcoe_ctlr *ctlr;
524

525
	fcoe = container_of(ptype, struct fcoe_interface, fip_packet_type);
526 527
	ctlr = fcoe_to_ctlr(fcoe);
	fcoe_ctlr_recv(ctlr, skb);
528 529 530
	return 0;
}

531 532 533 534 535 536 537 538 539 540 541 542 543
/**
 * fcoe_port_send() - Send an Ethernet-encapsulated FIP/FCoE frame
 * @port: The FCoE port
 * @skb: The FIP/FCoE packet to be sent
 */
static void fcoe_port_send(struct fcoe_port *port, struct sk_buff *skb)
{
	if (port->fcoe_pending_queue.qlen)
		fcoe_check_wait_queue(port->lport, skb);
	else if (fcoe_start_io(skb))
		fcoe_check_wait_queue(port->lport, skb);
}

544
/**
545 546 547
 * fcoe_fip_send() - Send an Ethernet-encapsulated FIP frame
 * @fip: The FCoE controller
 * @skb: The FIP packet to be sent
548 549 550
 */
static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
{
551
	skb->dev = fcoe_from_ctlr(fip)->netdev;
552
	fcoe_port_send(lport_priv(fip->lp), skb);
553 554 555
}

/**
556 557 558
 * fcoe_update_src_mac() - Update the Ethernet MAC filters
 * @lport: The local port to update the source MAC on
 * @addr:  Unicast MAC address to add
559 560 561 562
 *
 * Remove any previously-set unicast MAC filter.
 * Add secondary FCoE MAC address filter for our OUI.
 */
563
static void fcoe_update_src_mac(struct fc_lport *lport, u8 *addr)
564
{
565
	struct fcoe_port *port = lport_priv(lport);
566
	struct fcoe_interface *fcoe = port->priv;
567

568
	if (!is_zero_ether_addr(port->data_src_addr))
569
		dev_uc_del(fcoe->netdev, port->data_src_addr);
570
	if (!is_zero_ether_addr(addr))
571
		dev_uc_add(fcoe->netdev, addr);
572
	memcpy(port->data_src_addr, addr, ETH_ALEN);
573 574
}

575 576 577 578 579 580 581 582 583 584 585
/**
 * fcoe_get_src_mac() - return the Ethernet source address for an lport
 * @lport: libfc lport
 */
static u8 *fcoe_get_src_mac(struct fc_lport *lport)
{
	struct fcoe_port *port = lport_priv(lport);

	return port->data_src_addr;
}

586
/**
587 588
 * fcoe_lport_config() - Set up a local port
 * @lport: The local port to be setup
589 590 591
 *
 * Returns: 0 for success
 */
592
static int fcoe_lport_config(struct fc_lport *lport)
593
{
594 595 596 597 598 599 600 601 602 603 604
	lport->link_up = 0;
	lport->qfull = 0;
	lport->max_retry_count = 3;
	lport->max_rport_retry_count = 3;
	lport->e_d_tov = 2 * 1000;	/* FC-FS default */
	lport->r_a_tov = 2 * 2 * 1000;
	lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
				 FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
	lport->does_npiv = 1;

	fc_lport_init_stats(lport);
605 606

	/* lport fc_lport related configuration */
607
	fc_lport_config(lport);
608 609

	/* offload related configuration */
610 611 612 613 614
	lport->crc_offload = 0;
	lport->seq_offload = 0;
	lport->lro_enabled = 0;
	lport->lro_xid = 0;
	lport->lso_max = 0;
615 616 617 618

	return 0;
}

619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
/**
 * fcoe_netdev_features_change - Updates the lport's offload flags based
 * on the LLD netdev's FCoE feature flags
 */
static void fcoe_netdev_features_change(struct fc_lport *lport,
					struct net_device *netdev)
{
	mutex_lock(&lport->lp_mutex);

	if (netdev->features & NETIF_F_SG)
		lport->sg_supp = 1;
	else
		lport->sg_supp = 0;

	if (netdev->features & NETIF_F_FCOE_CRC) {
		lport->crc_offload = 1;
		FCOE_NETDEV_DBG(netdev, "Supports FCCRC offload\n");
	} else {
		lport->crc_offload = 0;
	}

	if (netdev->features & NETIF_F_FSO) {
		lport->seq_offload = 1;
		lport->lso_max = netdev->gso_max_size;
		FCOE_NETDEV_DBG(netdev, "Supports LSO for max len 0x%x\n",
				lport->lso_max);
	} else {
		lport->seq_offload = 0;
		lport->lso_max = 0;
	}

	if (netdev->fcoe_ddp_xid) {
		lport->lro_enabled = 1;
		lport->lro_xid = netdev->fcoe_ddp_xid;
		FCOE_NETDEV_DBG(netdev, "Supports LRO for max xid 0x%x\n",
				lport->lro_xid);
	} else {
		lport->lro_enabled = 0;
		lport->lro_xid = 0;
	}

	mutex_unlock(&lport->lp_mutex);
}

663
/**
664 665 666
 * fcoe_netdev_config() - Set up net devive for SW FCoE
 * @lport:  The local port that is associated with the net device
 * @netdev: The associated net device
667
 *
668
 * Must be called after fcoe_lport_config() as it will use local port mutex
669
 *
670
 * Returns: 0 for success
671
 */
672
static int fcoe_netdev_config(struct fc_lport *lport, struct net_device *netdev)
673 674 675
{
	u32 mfs;
	u64 wwnn, wwpn;
676
	struct fcoe_interface *fcoe;
677
	struct fcoe_ctlr *ctlr;
678
	struct fcoe_port *port;
679 680

	/* Setup lport private data to point to fcoe softc */
681
	port = lport_priv(lport);
682
	fcoe = port->priv;
683
	ctlr = fcoe_to_ctlr(fcoe);
684 685 686 687 688 689

	/*
	 * 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.
	 */
690 691 692 693 694 695
	mfs = netdev->mtu;
	if (netdev->features & NETIF_F_FCOE_MTU) {
		mfs = FCOE_MTU;
		FCOE_NETDEV_DBG(netdev, "Supports FCOE_MTU of %d bytes\n", mfs);
	}
	mfs -= (sizeof(struct fcoe_hdr) + sizeof(struct fcoe_crc_eof));
696
	if (fc_set_mfs(lport, mfs))
697 698 699
		return -EINVAL;

	/* offload features support */
700
	fcoe_netdev_features_change(lport, netdev);
701

702 703
	skb_queue_head_init(&port->fcoe_pending_queue);
	port->fcoe_pending_queue_active = 0;
704
	setup_timer(&port->timer, fcoe_queue_timer, (unsigned long)lport);
705

706 707
	fcoe_link_speed_update(lport);

708
	if (!lport->vport) {
709
		if (fcoe_get_wwn(netdev, &wwnn, NETDEV_FCOE_WWNN))
710
			wwnn = fcoe_wwn_from_mac(ctlr->ctl_src_addr, 1, 0);
711
		fc_set_wwnn(lport, wwnn);
712
		if (fcoe_get_wwn(netdev, &wwpn, NETDEV_FCOE_WWPN))
713
			wwpn = fcoe_wwn_from_mac(ctlr->ctl_src_addr,
714
						 2, 0);
715
		fc_set_wwpn(lport, wwpn);
716
	}
717 718 719 720 721

	return 0;
}

/**
722 723 724
 * fcoe_shost_config() - Set up the SCSI host associated with a local port
 * @lport: The local port
 * @dev:   The device associated with the SCSI host
725 726 727
 *
 * Must be called after fcoe_lport_config() and fcoe_netdev_config()
 *
728
 * Returns: 0 for success
729
 */
730
static int fcoe_shost_config(struct fc_lport *lport, struct device *dev)
731 732 733 734
{
	int rc = 0;

	/* lport scsi host config */
735 736 737
	lport->host->max_lun = FCOE_MAX_LUN;
	lport->host->max_id = FCOE_MAX_FCP_TARGET;
	lport->host->max_channel = 0;
738 739
	lport->host->max_cmd_len = FCOE_MAX_CMD_LEN;

740
	if (lport->vport)
741
		lport->host->transportt = fcoe_vport_scsi_transport;
742
	else
743
		lport->host->transportt = fcoe_nport_scsi_transport;
744 745

	/* add the new host to the SCSI-ml */
746
	rc = scsi_add_host(lport->host, dev);
747
	if (rc) {
748
		FCOE_NETDEV_DBG(fcoe_netdev(lport), "fcoe_shost_config: "
749
				"error on scsi_add_host\n");
750 751
		return rc;
	}
752

753
	if (!lport->vport)
754
		fc_host_max_npiv_vports(lport->host) = USHRT_MAX;
755

756
	snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
757
		 "%s v%s over %s", FCOE_NAME, FCOE_VERSION,
758
		 fcoe_netdev(lport)->name);
759 760 761 762

	return 0;
}

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 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841

/**
 * fcoe_fdmi_info() - Get FDMI related info from net devive for SW FCoE
 * @lport:  The local port that is associated with the net device
 * @netdev: The associated net device
 *
 * Must be called after fcoe_shost_config() as it will use local port mutex
 *
 */
static void fcoe_fdmi_info(struct fc_lport *lport, struct net_device *netdev)
{
	struct fcoe_interface *fcoe;
	struct fcoe_port *port;
	struct net_device *realdev;
	int rc;
	struct netdev_fcoe_hbainfo fdmi;

	port = lport_priv(lport);
	fcoe = port->priv;
	realdev = fcoe->realdev;

	if (!realdev)
		return;

	/* No FDMI state m/c for NPIV ports */
	if (lport->vport)
		return;

	if (realdev->netdev_ops->ndo_fcoe_get_hbainfo) {
		memset(&fdmi, 0, sizeof(fdmi));
		rc = realdev->netdev_ops->ndo_fcoe_get_hbainfo(realdev,
							       &fdmi);
		if (rc) {
			printk(KERN_INFO "fcoe: Failed to retrieve FDMI "
					"information from netdev.\n");
			return;
		}

		snprintf(fc_host_serial_number(lport->host),
			 FC_SERIAL_NUMBER_SIZE,
			 "%s",
			 fdmi.serial_number);
		snprintf(fc_host_manufacturer(lport->host),
			 FC_SERIAL_NUMBER_SIZE,
			 "%s",
			 fdmi.manufacturer);
		snprintf(fc_host_model(lport->host),
			 FC_SYMBOLIC_NAME_SIZE,
			 "%s",
			 fdmi.model);
		snprintf(fc_host_model_description(lport->host),
			 FC_SYMBOLIC_NAME_SIZE,
			 "%s",
			 fdmi.model_description);
		snprintf(fc_host_hardware_version(lport->host),
			 FC_VERSION_STRING_SIZE,
			 "%s",
			 fdmi.hardware_version);
		snprintf(fc_host_driver_version(lport->host),
			 FC_VERSION_STRING_SIZE,
			 "%s",
			 fdmi.driver_version);
		snprintf(fc_host_optionrom_version(lport->host),
			 FC_VERSION_STRING_SIZE,
			 "%s",
			 fdmi.optionrom_version);
		snprintf(fc_host_firmware_version(lport->host),
			 FC_VERSION_STRING_SIZE,
			 "%s",
			 fdmi.firmware_version);

		/* Enable FDMI lport states */
		lport->fdmi_enabled = 1;
	} else {
		lport->fdmi_enabled = 0;
		printk(KERN_INFO "fcoe: No FDMI support.\n");
	}
}

842 843 844
/**
 * fcoe_oem_match() - The match routine for the offloaded exchange manager
 * @fp: The I/O frame
845
 *
846 847 848 849 850 851 852 853 854
 * This routine will be associated with an exchange manager (EM). When
 * the libfc exchange handling code is looking for an EM to use it will
 * call this routine and pass it the frame that it wishes to send. This
 * routine will return True if the associated EM is to be used and False
 * if the echange code should continue looking for an EM.
 *
 * The offload EM that this routine is associated with will handle any
 * packets that are for SCSI read requests.
 *
855 856 857
 * This has been enhanced to work when FCoE stack is operating in target
 * mode.
 *
858
 * Returns: True for read types I/O, otherwise returns false.
859
 */
860
static bool fcoe_oem_match(struct fc_frame *fp)
861
{
862 863 864 865 866 867
	struct fc_frame_header *fh = fc_frame_header_get(fp);
	struct fcp_cmnd *fcp;

	if (fc_fcp_is_read(fr_fsp(fp)) &&
	    (fr_fsp(fp)->data_len > fcoe_ddp_min))
		return true;
868 869 870
	else if ((fr_fsp(fp) == NULL) &&
		 (fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD) &&
		 (ntohs(fh->fh_rx_id) == FC_XID_UNKNOWN)) {
871
		fcp = fc_frame_payload_get(fp, sizeof(*fcp));
872 873
		if ((fcp->fc_flags & FCP_CFL_WRDATA) &&
		    (ntohl(fcp->fc_dl) > fcoe_ddp_min))
874 875 876
			return true;
	}
	return false;
877 878
}

879
/**
880 881
 * fcoe_em_config() - Allocate and configure an exchange manager
 * @lport: The local port that the new EM will be associated with
882
 *
883
 * Returns: 0 on success
884
 */
885
static inline int fcoe_em_config(struct fc_lport *lport)
886
{
887
	struct fcoe_port *port = lport_priv(lport);
888
	struct fcoe_interface *fcoe = port->priv;
889
	struct fcoe_interface *oldfcoe = NULL;
890
	struct net_device *old_real_dev, *cur_real_dev;
891 892 893 894 895 896 897
	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.
	 */
898 899 900
	if (!lport->lro_enabled || !lport->lro_xid ||
	    (lport->lro_xid >= max_xid)) {
		lport->lro_xid = 0;
901 902 903 904 905
		goto skip_oem;
	}

	/*
	 * Reuse existing offload em instance in case
906
	 * it is already allocated on real eth device
907
	 */
908 909
	if (fcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
		cur_real_dev = vlan_dev_real_dev(fcoe->netdev);
910
	else
911
		cur_real_dev = fcoe->netdev;
912

913 914 915
	list_for_each_entry(oldfcoe, &fcoe_hostlist, list) {
		if (oldfcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
			old_real_dev = vlan_dev_real_dev(oldfcoe->netdev);
916
		else
917
			old_real_dev = oldfcoe->netdev;
918 919

		if (cur_real_dev == old_real_dev) {
920
			fcoe->oem = oldfcoe->oem;
921 922 923 924
			break;
		}
	}

925
	if (fcoe->oem) {
926
		if (!fc_exch_mgr_add(lport, fcoe->oem, fcoe_oem_match)) {
927 928
			printk(KERN_ERR "fcoe_em_config: failed to add "
			       "offload em:%p on interface:%s\n",
929
			       fcoe->oem, fcoe->netdev->name);
930 931 932
			return -ENOMEM;
		}
	} else {
933 934 935
		fcoe->oem = fc_exch_mgr_alloc(lport, FC_CLASS_3,
					      FCOE_MIN_XID, lport->lro_xid,
					      fcoe_oem_match);
936
		if (!fcoe->oem) {
937 938
			printk(KERN_ERR "fcoe_em_config: failed to allocate "
			       "em for offload exches on interface:%s\n",
939
			       fcoe->netdev->name);
940 941 942 943 944 945 946
			return -ENOMEM;
		}
	}

	/*
	 * Exclude offload EM xid range from next EM xid range.
	 */
947
	min_xid += lport->lro_xid + 1;
948 949

skip_oem:
950
	if (!fc_exch_mgr_alloc(lport, FC_CLASS_3, min_xid, max_xid, NULL)) {
951
		printk(KERN_ERR "fcoe_em_config: failed to "
952
		       "allocate em on interface %s\n", fcoe->netdev->name);
953
		return -ENOMEM;
954
	}
955 956 957 958 959

	return 0;
}

/**
960 961
 * fcoe_if_destroy() - Tear down a SW FCoE instance
 * @lport: The local port to be destroyed
962
 *
963
 */
964
static void fcoe_if_destroy(struct fc_lport *lport)
965
{
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986
	struct fcoe_port *port = lport_priv(lport);
	struct fcoe_interface *fcoe = port->priv;
	struct net_device *netdev = fcoe->netdev;

	FCOE_NETDEV_DBG(netdev, "Destroying interface\n");

	/* Logout of the fabric */
	fc_fabric_logoff(lport);

	/* Cleanup the fc_lport */
	fc_lport_destroy(lport);

	/* Stop the transmit retry timer */
	del_timer_sync(&port->timer);

	/* Free existing transmit skbs */
	fcoe_clean_pending_queue(lport);

	rtnl_lock();
	if (!is_zero_ether_addr(port->data_src_addr))
		dev_uc_del(netdev, port->data_src_addr);
987 988 989 990
	if (lport->vport)
		synchronize_net();
	else
		fcoe_interface_remove(fcoe);
991 992
	rtnl_unlock();

993
	/* Free queued packets for the per-CPU receive threads */
994
	fcoe_percpu_clean(lport);
995

996
	/* Detach from the scsi-ml */
997 998
	fc_remove_host(lport->host);
	scsi_remove_host(lport->host);
999

1000 1001 1002
	/* Destroy lport scsi_priv */
	fc_fcp_destroy(lport);

1003
	/* There are no more rports or I/O, free the EM */
1004
	fc_exch_mgr_free(lport);
1005 1006

	/* Free memory used by statistical counters */
1007
	fc_lport_free_stats(lport);
1008

1009 1010 1011 1012 1013 1014
	/*
	 * Release the Scsi_Host for vport but hold on to
	 * master lport until it fcoe interface fully cleaned-up.
	 */
	if (lport->vport)
		scsi_host_put(lport->host);
1015 1016
}

1017 1018 1019 1020 1021 1022
/**
 * fcoe_ddp_setup() - Call a LLD's ddp_setup through the net device
 * @lport: The local port to setup DDP for
 * @xid:   The exchange ID for this DDP transfer
 * @sgl:   The scatterlist describing this transfer
 * @sgc:   The number of sg items
1023
 *
1024
 * Returns: 0 if the DDP context was not configured
1025
 */
1026 1027
static int fcoe_ddp_setup(struct fc_lport *lport, u16 xid,
			  struct scatterlist *sgl, unsigned int sgc)
1028
{
1029
	struct net_device *netdev = fcoe_netdev(lport);
1030

1031 1032 1033 1034
	if (netdev->netdev_ops->ndo_fcoe_ddp_setup)
		return netdev->netdev_ops->ndo_fcoe_ddp_setup(netdev,
							      xid, sgl,
							      sgc);
1035 1036 1037 1038

	return 0;
}

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
/**
 * fcoe_ddp_target() - Call a LLD's ddp_target through the net device
 * @lport: The local port to setup DDP for
 * @xid:   The exchange ID for this DDP transfer
 * @sgl:   The scatterlist describing this transfer
 * @sgc:   The number of sg items
 *
 * Returns: 0 if the DDP context was not configured
 */
static int fcoe_ddp_target(struct fc_lport *lport, u16 xid,
			   struct scatterlist *sgl, unsigned int sgc)
{
	struct net_device *netdev = fcoe_netdev(lport);

	if (netdev->netdev_ops->ndo_fcoe_ddp_target)
		return netdev->netdev_ops->ndo_fcoe_ddp_target(netdev, xid,
							       sgl, sgc);

	return 0;
}


1061 1062 1063 1064
/**
 * fcoe_ddp_done() - Call a LLD's ddp_done through the net device
 * @lport: The local port to complete DDP on
 * @xid:   The exchange ID for this DDP transfer
1065
 *
1066
 * Returns: the length of data that have been completed by DDP
1067
 */
1068
static int fcoe_ddp_done(struct fc_lport *lport, u16 xid)
1069
{
1070
	struct net_device *netdev = fcoe_netdev(lport);
1071

1072 1073
	if (netdev->netdev_ops->ndo_fcoe_ddp_done)
		return netdev->netdev_ops->ndo_fcoe_ddp_done(netdev, xid);
1074 1075 1076 1077
	return 0;
}

/**
1078 1079 1080 1081
 * fcoe_if_create() - Create a FCoE instance on an interface
 * @fcoe:   The FCoE interface to create a local port on
 * @parent: The device pointer to be the parent in sysfs for the SCSI host
 * @npiv:   Indicates if the port is a vport or not
1082
 *
1083
 * Creates a fc_lport instance and a Scsi_Host instance and configure them.
1084
 *
1085
 * Returns: The allocated fc_lport or an error pointer
1086
 */
1087
static struct fc_lport *fcoe_if_create(struct fcoe_interface *fcoe,
1088
				       struct device *parent, int npiv)
1089
{
1090
	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
1091
	struct net_device *netdev = fcoe->netdev;
1092
	struct fc_lport *lport, *n_port;
1093
	struct fcoe_port *port;
1094
	struct Scsi_Host *shost;
1095
	int rc;
1096 1097 1098 1099 1100
	/*
	 * parent is only a vport if npiv is 1,
	 * but we'll only use vport in that case so go ahead and set it
	 */
	struct fc_vport *vport = dev_to_vport(parent);
1101

1102
	FCOE_NETDEV_DBG(netdev, "Create Interface\n");
1103

1104 1105 1106 1107 1108
	if (!npiv)
		lport = libfc_host_alloc(&fcoe_shost_template, sizeof(*port));
	else
		lport = libfc_vport_create(vport, sizeof(*port));

1109
	if (!lport) {
1110
		FCOE_NETDEV_DBG(netdev, "Could not allocate host structure\n");
1111
		rc = -ENOMEM;
1112
		goto out;
1113
	}
1114
	port = lport_priv(lport);
1115
	port->lport = lport;
1116
	port->priv = fcoe;
1117
	port->get_netdev = fcoe_netdev;
1118 1119
	port->max_queue_depth = FCOE_MAX_QUEUE_DEPTH;
	port->min_queue_depth = FCOE_MIN_QUEUE_DEPTH;
1120
	INIT_WORK(&port->destroy_work, fcoe_destroy_work);
1121

1122
	/* configure a fc_lport including the exchange manager */
1123
	rc = fcoe_lport_config(lport);
1124
	if (rc) {
1125 1126
		FCOE_NETDEV_DBG(netdev, "Could not configure lport for the "
				"interface\n");
1127 1128 1129
		goto out_host_put;
	}

1130
	if (npiv) {
1131 1132
		FCOE_NETDEV_DBG(netdev, "Setting vport names, "
				"%16.16llx %16.16llx\n",
1133
				vport->node_name, vport->port_name);
1134 1135 1136 1137
		fc_set_wwnn(lport, vport->node_name);
		fc_set_wwpn(lport, vport->port_name);
	}

1138
	/* configure lport network properties */
1139
	rc = fcoe_netdev_config(lport, netdev);
1140
	if (rc) {
1141 1142
		FCOE_NETDEV_DBG(netdev, "Could not configure netdev for the "
				"interface\n");
1143
		goto out_lp_destroy;
1144
	}
1145

1146
	/* configure lport scsi host properties */
1147
	rc = fcoe_shost_config(lport, parent);
1148
	if (rc) {
1149 1150
		FCOE_NETDEV_DBG(netdev, "Could not configure shost for the "
				"interface\n");
1151
		goto out_lp_destroy;
1152 1153
	}

1154
	/* Initialize the library */
1155
	rc = fcoe_libfc_config(lport, ctlr, &fcoe_libfc_fcn_templ, 1);
1156
	if (rc) {
1157
		FCOE_NETDEV_DBG(netdev, "Could not configure libfc for the "
1158
				"interface\n");
1159
		goto out_lp_destroy;
1160 1161
	}

1162 1163 1164
	/* Initialized FDMI information */
	fcoe_fdmi_info(lport, netdev);

1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
	/*
	 * fcoe_em_alloc() and fcoe_hostlist_add() both
	 * need to be atomic with respect to other changes to the
	 * hostlist since fcoe_em_alloc() looks for an existing EM
	 * instance on host list updated by fcoe_hostlist_add().
	 *
	 * This is currently handled through the fcoe_config_mutex
	 * begin held.
	 */
	if (!npiv)
1175 1176
		/* lport exch manager allocation */
		rc = fcoe_em_config(lport);
1177 1178 1179 1180 1181 1182 1183 1184 1185
	else {
		shost = vport_to_shost(vport);
		n_port = shost_priv(shost);
		rc = fc_exch_mgr_list_clone(n_port, lport);
	}

	if (rc) {
		FCOE_NETDEV_DBG(netdev, "Could not configure the EM\n");
		goto out_lp_destroy;
1186 1187
	}

1188
	return lport;
1189 1190

out_lp_destroy:
1191
	fc_exch_mgr_free(lport);
1192
out_host_put:
1193 1194 1195
	scsi_host_put(lport->host);
out:
	return ERR_PTR(rc);
1196 1197 1198
}

/**
1199
 * fcoe_if_init() - Initialization routine for fcoe.ko
1200
 *
1201 1202 1203
 * Attaches the SW FCoE transport to the FC transport
 *
 * Returns: 0 on success
1204 1205 1206 1207
 */
static int __init fcoe_if_init(void)
{
	/* attach to scsi transport */
1208 1209 1210 1211
	fcoe_nport_scsi_transport =
		fc_attach_transport(&fcoe_nport_fc_functions);
	fcoe_vport_scsi_transport =
		fc_attach_transport(&fcoe_vport_fc_functions);
1212

1213
	if (!fcoe_nport_scsi_transport) {
1214
		printk(KERN_ERR "fcoe: Failed to attach to the FC transport\n");
1215 1216 1217 1218 1219 1220 1221
		return -ENODEV;
	}

	return 0;
}

/**
1222 1223 1224
 * fcoe_if_exit() - Tear down fcoe.ko
 *
 * Detaches the SW FCoE transport from the FC transport
1225
 *
1226
 * Returns: 0 on success
1227
 */
1228
static int __exit fcoe_if_exit(void)
1229
{
1230 1231 1232 1233
	fc_release_transport(fcoe_nport_scsi_transport);
	fc_release_transport(fcoe_vport_scsi_transport);
	fcoe_nport_scsi_transport = NULL;
	fcoe_vport_scsi_transport = NULL;
1234 1235 1236
	return 0;
}

1237
/**
1238 1239
 * fcoe_percpu_thread_create() - Create a receive thread for an online CPU
 * @cpu: The CPU index of the CPU to create a receive thread for
1240 1241 1242 1243 1244 1245 1246 1247
 */
static void fcoe_percpu_thread_create(unsigned int cpu)
{
	struct fcoe_percpu_s *p;
	struct task_struct *thread;

	p = &per_cpu(fcoe_percpu, cpu);

1248 1249 1250
	thread = kthread_create_on_node(fcoe_percpu_receive_thread,
					(void *)p, cpu_to_node(cpu),
					"fcoethread/%d", cpu);
1251

1252
	if (likely(!IS_ERR(thread))) {
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
		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);
	}
}

/**
1263 1264
 * fcoe_percpu_thread_destroy() - Remove the receive thread of a CPU
 * @cpu: The CPU index of the CPU whose receive thread is to be destroyed
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
 *
 * 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;
1278
	unsigned targ_cpu = get_cpu();
1279 1280
#endif /* CONFIG_SMP */

1281
	FCOE_DBG("Destroying receive thread for CPU %d\n", cpu);
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302

	/* 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) {
1303 1304
			FCOE_DBG("Moving frames from CPU %d to CPU %d\n",
				 cpu, targ_cpu);
1305 1306 1307 1308 1309 1310 1311

			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
1312
			 * new	skbs. Unlock the targeted CPU and drop the skbs
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
			 * 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);
	}
1334
	put_cpu();
1335 1336
#else
	/*
1337
	 * This a non-SMP scenario where the singular Rx thread is
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
	 * 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);
}

/**
1354 1355 1356 1357
 * fcoe_cpu_callback() - Handler for CPU hotplug events
 * @nfb:    The callback data block
 * @action: The event triggering the callback
 * @hcpu:   The index of the CPU that the event is for
1358
 *
1359
 * This creates or destroys per-CPU data for fcoe
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
 *
 * 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:
1371
		FCOE_DBG("CPU %x online: Create Rx thread\n", cpu);
1372 1373 1374 1375
		fcoe_percpu_thread_create(cpu);
		break;
	case CPU_DEAD:
	case CPU_DEAD_FROZEN:
1376
		FCOE_DBG("CPU %x offline: Remove Rx thread\n", cpu);
1377 1378 1379 1380 1381 1382 1383 1384
		fcoe_percpu_thread_destroy(cpu);
		break;
	default:
		break;
	}
	return NOTIFY_OK;
}

1385 1386 1387 1388
/**
 * fcoe_select_cpu() - Selects CPU to handle post-processing of incoming
 *			command.
 *
1389 1390
 * This routine selects next CPU based on cpumask to distribute
 * incoming requests in round robin.
1391
 *
1392
 * Returns: int CPU number
1393
 */
1394
static inline unsigned int fcoe_select_cpu(void)
1395 1396 1397
{
	static unsigned int selected_cpu;

1398 1399 1400 1401
	selected_cpu = cpumask_next(selected_cpu, cpu_online_mask);
	if (selected_cpu >= nr_cpu_ids)
		selected_cpu = cpumask_first(cpu_online_mask);

1402 1403 1404
	return selected_cpu;
}

1405
/**
1406 1407 1408 1409 1410
 * fcoe_rcv() - Receive packets from a net device
 * @skb:    The received packet
 * @netdev: The net device that the packet was received on
 * @ptype:  The packet type context
 * @olddev: The last device net device
1411
 *
1412 1413
 * This routine is called by NET_RX_SOFTIRQ. It receives a packet, builds a
 * FC frame and passes the frame to libfc.
1414 1415
 *
 * Returns: 0 for success
1416
 */
1417
static int fcoe_rcv(struct sk_buff *skb, struct net_device *netdev,
1418 1419
	     struct packet_type *ptype, struct net_device *olddev)
{
1420
	struct fc_lport *lport;
1421
	struct fcoe_rcv_info *fr;
1422
	struct fcoe_ctlr *ctlr;
1423
	struct fcoe_interface *fcoe;
1424 1425
	struct fc_frame_header *fh;
	struct fcoe_percpu_s *fps;
1426
	struct ethhdr *eh;
1427
	unsigned int cpu;
1428

1429
	fcoe = container_of(ptype, struct fcoe_interface, fcoe_packet_type);
1430 1431
	ctlr = fcoe_to_ctlr(fcoe);
	lport = ctlr->lp;
1432 1433
	if (unlikely(!lport)) {
		FCOE_NETDEV_DBG(netdev, "Cannot find hba structure");
1434 1435
		goto err2;
	}
1436
	if (!lport->link_up)
1437
		goto err2;
1438

1439
	FCOE_NETDEV_DBG(netdev, "skb_info: len:%d data_len:%d head:%p "
1440 1441 1442 1443
			"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>");
1444

1445 1446
	eh = eth_hdr(skb);

1447 1448
	if (is_fip_mode(ctlr) &&
	    compare_ether_addr(eh->h_source, ctlr->dest_addr)) {
1449 1450
		FCOE_NETDEV_DBG(netdev, "wrong source mac address:%pM\n",
				eh->h_source);
1451 1452 1453 1454 1455 1456 1457 1458
		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) ||
1459
		     !pskb_may_pull(skb, FCOE_HEADER_LEN)))
1460 1461 1462 1463 1464
		goto err;

	skb_set_transport_header(skb, sizeof(struct fcoe_hdr));
	fh = (struct fc_frame_header *) skb_transport_header(skb);

1465 1466 1467 1468 1469 1470
	if (ntoh24(&eh->h_dest[3]) != ntoh24(fh->fh_d_id)) {
		FCOE_NETDEV_DBG(netdev, "FC frame d_id mismatch with MAC:%pM\n",
				eh->h_dest);
		goto err;
	}

1471
	fr = fcoe_dev_from_skb(skb);
1472
	fr->fr_dev = lport;
1473

1474
	/*
1475 1476 1477
	 * 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
1478 1479
	 * was originated, otherwise select cpu using rx exchange id
	 * or fcoe_select_cpu().
1480
	 */
1481 1482
	if (ntoh24(fh->fh_f_ctl) & FC_FC_EX_CTX)
		cpu = ntohs(fh->fh_ox_id) & fc_cpu_mask;
1483
	else {
1484 1485 1486
		if (ntohs(fh->fh_rx_id) == FC_XID_UNKNOWN)
			cpu = fcoe_select_cpu();
		else
1487
			cpu = ntohs(fh->fh_rx_id) & fc_cpu_mask;
1488
	}
1489 1490 1491 1492

	if (cpu >= nr_cpu_ids)
		goto err;

1493
	fps = &per_cpu(fcoe_percpu, cpu);
1494
	spin_lock(&fps->fcoe_rx_list.lock);
1495 1496 1497 1498 1499 1500
	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.
		 */
1501
		FCOE_NETDEV_DBG(netdev, "CPU is online, but no receive thread "
1502 1503
				"ready for incoming skb- using first online "
				"CPU.\n");
1504

1505
		spin_unlock(&fps->fcoe_rx_list.lock);
1506
		cpu = cpumask_first(cpu_online_mask);
1507
		fps = &per_cpu(fcoe_percpu, cpu);
1508
		spin_lock(&fps->fcoe_rx_list.lock);
1509
		if (!fps->thread) {
1510
			spin_unlock(&fps->fcoe_rx_list.lock);
1511 1512 1513 1514 1515 1516 1517 1518 1519
			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.
	 */
1520

1521 1522 1523 1524 1525 1526
	/*
	 * Note: We used to have a set of conditions under which we would
	 * call fcoe_recv_frame directly, rather than queuing to the rx list
	 * as it could save a few cycles, but doing so is prohibited, as
	 * fcoe_recv_frame has several paths that may sleep, which is forbidden
	 * in softirq context.
1527
	 */
1528
	__skb_queue_tail(&fps->fcoe_rx_list, skb);
1529
	if (fps->thread->state == TASK_INTERRUPTIBLE)
1530
		wake_up_process(fps->thread);
1531
	spin_unlock(&fps->fcoe_rx_list.lock);
1532 1533 1534

	return 0;
err:
1535
	per_cpu_ptr(lport->stats, get_cpu())->ErrorFrames++;
1536
	put_cpu();
1537 1538 1539 1540 1541 1542
err2:
	kfree_skb(skb);
	return -1;
}

/**
1543
 * fcoe_alloc_paged_crc_eof() - Allocate a page to be used for the trailer CRC
1544 1545 1546
 * @skb:  The packet to be transmitted
 * @tlen: The total length of the trailer
 *
1547
 * Returns: 0 for success
1548
 */
1549
static int fcoe_alloc_paged_crc_eof(struct sk_buff *skb, int tlen)
1550 1551
{
	struct fcoe_percpu_s *fps;
1552
	int rc;
1553

1554
	fps = &get_cpu_var(fcoe_percpu);
1555
	rc = fcoe_get_paged_crc_eof(skb, tlen, fps);
1556
	put_cpu_var(fcoe_percpu);
1557

1558
	return rc;
1559 1560 1561
}

/**
1562 1563 1564
 * fcoe_xmit() - Transmit a FCoE frame
 * @lport: The local port that the frame is to be transmitted for
 * @fp:	   The frame to be transmitted
1565
 *
1566
 * Return: 0 for success
1567
 */
1568
static int fcoe_xmit(struct fc_lport *lport, struct fc_frame *fp)
1569
{
1570
	int wlen;
1571 1572 1573 1574
	u32 crc;
	struct ethhdr *eh;
	struct fcoe_crc_eof *cp;
	struct sk_buff *skb;
1575
	struct fc_stats *stats;
1576 1577 1578 1579
	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 */
1580
	struct fcoe_port *port = lport_priv(lport);
1581
	struct fcoe_interface *fcoe = port->priv;
1582
	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
1583 1584 1585 1586 1587 1588
	u8 sof, eof;
	struct fcoe_hdr *hp;

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

	fh = fc_frame_header_get(fp);
1589 1590 1591
	skb = fp_skb(fp);
	wlen = skb->len / FCOE_WORD_TO_BYTE;

1592
	if (!lport->link_up) {
1593
		kfree_skb(skb);
1594
		return 0;
1595 1596
	}

1597
	if (unlikely(fh->fh_type == FC_TYPE_ELS) &&
1598
	    fcoe_ctlr_els_send(ctlr, lport, skb))
1599 1600
		return 0;

1601 1602 1603
	sof = fr_sof(fp);
	eof = fr_eof(fp);

1604
	elen = sizeof(struct ethhdr);
1605 1606 1607 1608 1609
	hlen = sizeof(struct fcoe_hdr);
	tlen = sizeof(struct fcoe_crc_eof);
	wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;

	/* crc offload */
1610
	if (likely(lport->crc_offload)) {
1611
		skb->ip_summed = CHECKSUM_UNNECESSARY;
1612 1613 1614 1615 1616 1617 1618 1619
		skb->csum_start = skb_headroom(skb);
		skb->csum_offset = skb->len;
		crc = 0;
	} else {
		skb->ip_summed = CHECKSUM_NONE;
		crc = fcoe_fc_crc(fp);
	}

1620
	/* copy port crc and eof to the skb buff */
1621 1622
	if (skb_is_nonlinear(skb)) {
		skb_frag_t *frag;
1623
		if (fcoe_alloc_paged_crc_eof(skb, tlen)) {
R
Roel Kluin 已提交
1624
			kfree_skb(skb);
1625 1626 1627
			return -ENOMEM;
		}
		frag = &skb_shinfo(skb)->frags[skb_shinfo(skb)->nr_frags - 1];
1628
		cp = kmap_atomic(skb_frag_page(frag))
1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
			+ 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)) {
1639
		kunmap_atomic(cp);
1640 1641 1642
		cp = NULL;
	}

1643
	/* adjust skb network/transport offsets to match mac/fcoe/port */
1644 1645 1646 1647
	skb_push(skb, elen + hlen);
	skb_reset_mac_header(skb);
	skb_reset_network_header(skb);
	skb->mac_len = elen;
1648
	skb->protocol = htons(ETH_P_FCOE);
1649
	skb->priority = fcoe->priority;
1650

1651 1652 1653 1654 1655 1656 1657
	if (fcoe->netdev->priv_flags & IFF_802_1Q_VLAN &&
	    fcoe->realdev->features & NETIF_F_HW_VLAN_TX) {
		skb->vlan_tci = VLAN_TAG_PRESENT |
				vlan_dev_vlan_id(fcoe->netdev);
		skb->dev = fcoe->realdev;
	} else
		skb->dev = fcoe->netdev;
1658 1659 1660 1661

	/* fill up mac and fcoe headers */
	eh = eth_hdr(skb);
	eh->h_proto = htons(ETH_P_FCOE);
1662 1663
	memcpy(eh->h_dest, ctlr->dest_addr, ETH_ALEN);
	if (ctlr->map_dest)
1664
		memcpy(eh->h_dest + 3, fh->fh_d_id, 3);
1665

1666 1667
	if (unlikely(ctlr->flogi_oxid != FC_XID_UNKNOWN))
		memcpy(eh->h_source, ctlr->ctl_src_addr, ETH_ALEN);
1668
	else
1669
		memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);
1670 1671 1672 1673 1674 1675 1676

	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;

1677
	/* fcoe lso, mss is in max_payload which is non-zero for FCP data */
1678
	if (lport->seq_offload && fr_max_payload(fp)) {
1679 1680 1681 1682 1683 1684
		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;
	}
1685
	/* update tx stats: regardless if LLD fails */
1686
	stats = per_cpu_ptr(lport->stats, get_cpu());
1687 1688
	stats->TxFrames++;
	stats->TxWords += wlen;
1689
	put_cpu();
1690 1691

	/* send down to lld */
1692
	fr_dev(fp) = lport;
1693
	fcoe_port_send(port, skb);
1694 1695 1696
	return 0;
}

1697
/**
1698 1699
 * fcoe_percpu_flush_done() - Indicate per-CPU queue flush completion
 * @skb: The completed skb (argument required by destructor)
1700 1701 1702 1703 1704 1705
 */
static void fcoe_percpu_flush_done(struct sk_buff *skb)
{
	complete(&fcoe_flush_completion);
}

1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
/**
 * fcoe_filter_frames() - filter out bad fcoe frames, i.e. bad CRC
 * @lport: The local port the frame was received on
 * @fp:	   The received frame
 *
 * Return: 0 on passing filtering checks
 */
static inline int fcoe_filter_frames(struct fc_lport *lport,
				     struct fc_frame *fp)
{
1716
	struct fcoe_ctlr *ctlr;
1717 1718 1719
	struct fcoe_interface *fcoe;
	struct fc_frame_header *fh;
	struct sk_buff *skb = (struct sk_buff *)fp;
1720
	struct fc_stats *stats;
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736

	/*
	 * 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.
	 */
	if (lport->crc_offload && skb->ip_summed == CHECKSUM_UNNECESSARY)
		fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
	else
		fr_flags(fp) |= FCPHF_CRC_UNCHECKED;

	fh = (struct fc_frame_header *) skb_transport_header(skb);
	fh = fc_frame_header_get(fp);
	if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA && fh->fh_type == FC_TYPE_FCP)
		return 0;

1737
	fcoe = ((struct fcoe_port *)lport_priv(lport))->priv;
1738 1739
	ctlr = fcoe_to_ctlr(fcoe);
	if (is_fip_mode(ctlr) && fc_frame_payload_op(fp) == ELS_LOGO &&
1740 1741 1742 1743 1744
	    ntoh24(fh->fh_s_id) == FC_FID_FLOGI) {
		FCOE_DBG("fcoe: dropping FCoE lport LOGO in fip mode\n");
		return -EINVAL;
	}

1745
	if (!(fr_flags(fp) & FCPHF_CRC_UNCHECKED) ||
1746 1747 1748 1749 1750
	    le32_to_cpu(fr_crc(fp)) == ~crc32(~0, skb->data, skb->len)) {
		fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
		return 0;
	}

1751
	stats = per_cpu_ptr(lport->stats, get_cpu());
1752 1753 1754
	stats->InvalidCRCCount++;
	if (stats->InvalidCRCCount < 5)
		printk(KERN_WARNING "fcoe: dropping frame with CRC error\n");
1755
	put_cpu();
1756 1757 1758
	return -EINVAL;
}

1759
/**
1760 1761
 * fcoe_recv_frame() - process a single received frame
 * @skb: frame to process
1762
 */
1763
static void fcoe_recv_frame(struct sk_buff *skb)
1764 1765
{
	u32 fr_len;
1766
	struct fc_lport *lport;
1767
	struct fcoe_rcv_info *fr;
1768
	struct fc_stats *stats;
1769 1770
	struct fcoe_crc_eof crc_eof;
	struct fc_frame *fp;
1771
	struct fcoe_port *port;
1772 1773
	struct fcoe_hdr *hp;

1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
	fr = fcoe_dev_from_skb(skb);
	lport = fr->fr_dev;
	if (unlikely(!lport)) {
		if (skb->destructor != fcoe_percpu_flush_done)
			FCOE_NETDEV_DBG(skb->dev, "NULL lport in skb");
		kfree_skb(skb);
		return;
	}

	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>");

	port = lport_priv(lport);
1791
	skb_linearize(skb); /* check for skb_is_nonlinear is within skb_linearize */
1792 1793 1794 1795 1796 1797 1798

	/*
	 * Frame length checks and setting up the header pointers
	 * was done in fcoe_rcv already.
	 */
	hp = (struct fcoe_hdr *) skb_network_header(skb);

1799
	stats = per_cpu_ptr(lport->stats, get_cpu());
1800 1801 1802 1803 1804 1805 1806 1807
	if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
		if (stats->ErrorFrames < 5)
			printk(KERN_WARNING "fcoe: FCoE version "
			       "mismatch: The frame has "
			       "version %x, but the "
			       "initiator supports version "
			       "%x\n", FC_FCOE_DECAPS_VER(hp),
			       FC_FCOE_VER);
1808
		goto drop;
1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
	}

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

	stats->RxFrames++;
	stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;

	fp = (struct fc_frame *)skb;
	fc_frame_init(fp);
	fr_dev(fp) = lport;
	fr_sof(fp) = hp->fcoe_sof;

	/* Copy out the CRC and EOF trailer for access */
1823 1824
	if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof)))
		goto drop;
1825 1826
	fr_eof(fp) = crc_eof.fcoe_eof;
	fr_crc(fp) = crc_eof.fcoe_crc32;
1827 1828
	if (pskb_trim(skb, fr_len))
		goto drop;
1829

1830 1831 1832 1833
	if (!fcoe_filter_frames(lport, fp)) {
		put_cpu();
		fc_exch_recv(lport, fp);
		return;
1834
	}
1835 1836 1837 1838
drop:
	stats->ErrorFrames++;
	put_cpu();
	kfree_skb(skb);
1839 1840 1841 1842 1843 1844 1845 1846
}

/**
 * fcoe_percpu_receive_thread() - The per-CPU packet receive thread
 * @arg: The per-CPU context
 *
 * Return: 0 for success
 */
1847
static int fcoe_percpu_receive_thread(void *arg)
1848 1849 1850
{
	struct fcoe_percpu_s *p = arg;
	struct sk_buff *skb;
1851 1852 1853
	struct sk_buff_head tmp;

	skb_queue_head_init(&tmp);
1854

1855
	set_user_nice(current, -20);
1856

1857
retry:
1858 1859 1860
	while (!kthread_should_stop()) {

		spin_lock_bh(&p->fcoe_rx_list.lock);
1861 1862
		skb_queue_splice_init(&p->fcoe_rx_list, &tmp);

1863
		if (!skb_queue_len(&tmp)) {
1864 1865 1866 1867
			set_current_state(TASK_INTERRUPTIBLE);
			spin_unlock_bh(&p->fcoe_rx_list.lock);
			schedule();
			set_current_state(TASK_RUNNING);
1868 1869 1870 1871 1872 1873 1874 1875
			goto retry;
		}

		spin_unlock_bh(&p->fcoe_rx_list.lock);

		while ((skb = __skb_dequeue(&tmp)) != NULL)
			fcoe_recv_frame(skb);

1876 1877 1878 1879 1880
	}
	return 0;
}

/**
1881
 * fcoe_dev_setup() - Setup the link change notification interface
1882
 */
1883
static void fcoe_dev_setup(void)
1884
{
1885
	register_dcbevent_notifier(&dcb_notifier);
1886 1887 1888 1889
	register_netdevice_notifier(&fcoe_notifier);
}

/**
1890
 * fcoe_dev_cleanup() - Cleanup the link change notification interface
1891
 */
1892 1893
static void fcoe_dev_cleanup(void)
{
1894
	unregister_dcbevent_notifier(&dcb_notifier);
1895 1896 1897
	unregister_netdevice_notifier(&fcoe_notifier);
}

1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
static struct fcoe_interface *
fcoe_hostlist_lookup_realdev_port(struct net_device *netdev)
{
	struct fcoe_interface *fcoe;
	struct net_device *real_dev;

	list_for_each_entry(fcoe, &fcoe_hostlist, list) {
		if (fcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
			real_dev = vlan_dev_real_dev(fcoe->netdev);
		else
			real_dev = fcoe->netdev;

		if (netdev == real_dev)
			return fcoe;
	}
	return NULL;
}

static int fcoe_dcb_app_notification(struct notifier_block *notifier,
				     ulong event, void *ptr)
{
	struct dcb_app_type *entry = ptr;
1920
	struct fcoe_ctlr *ctlr;
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
	struct fcoe_interface *fcoe;
	struct net_device *netdev;
	int prio;

	if (entry->app.selector != DCB_APP_IDTYPE_ETHTYPE)
		return NOTIFY_OK;

	netdev = dev_get_by_index(&init_net, entry->ifindex);
	if (!netdev)
		return NOTIFY_OK;

	fcoe = fcoe_hostlist_lookup_realdev_port(netdev);
	dev_put(netdev);
	if (!fcoe)
		return NOTIFY_OK;

1937 1938
	ctlr = fcoe_to_ctlr(fcoe);

1939 1940 1941 1942 1943 1944 1945 1946 1947 1948
	if (entry->dcbx & DCB_CAP_DCBX_VER_CEE)
		prio = ffs(entry->app.priority) - 1;
	else
		prio = entry->app.priority;

	if (prio < 0)
		return NOTIFY_OK;

	if (entry->app.protocol == ETH_P_FIP ||
	    entry->app.protocol == ETH_P_FCOE)
1949
		ctlr->priority = prio;
1950

1951 1952
	if (entry->app.protocol == ETH_P_FCOE)
		fcoe->priority = prio;
1953 1954 1955 1956

	return NOTIFY_OK;
}

1957
/**
1958 1959 1960 1961
 * fcoe_device_notification() - Handler for net device events
 * @notifier: The context of the notification
 * @event:    The type of event
 * @ptr:      The net device that the event was on
1962
 *
1963
 * This function is called by the Ethernet driver in case of link change event.
1964 1965
 *
 * Returns: 0 for success
1966
 */
1967 1968 1969
static int fcoe_device_notification(struct notifier_block *notifier,
				    ulong event, void *ptr)
{
1970
	struct fcoe_ctlr_device *cdev;
1971
	struct fc_lport *lport = NULL;
1972
	struct net_device *netdev = ptr;
1973
	struct fcoe_ctlr *ctlr;
1974
	struct fcoe_interface *fcoe;
1975
	struct fcoe_port *port;
1976
	struct fc_stats *stats;
1977
	u32 link_possible = 1;
1978 1979 1980
	u32 mfs;
	int rc = NOTIFY_OK;

1981
	list_for_each_entry(fcoe, &fcoe_hostlist, list) {
1982
		if (fcoe->netdev == netdev) {
1983 1984
			ctlr = fcoe_to_ctlr(fcoe);
			lport = ctlr->lp;
1985 1986 1987
			break;
		}
	}
1988
	if (!lport) {
1989 1990 1991 1992 1993 1994 1995
		rc = NOTIFY_DONE;
		goto out;
	}

	switch (event) {
	case NETDEV_DOWN:
	case NETDEV_GOING_DOWN:
1996
		link_possible = 0;
1997 1998 1999 2000 2001
		break;
	case NETDEV_UP:
	case NETDEV_CHANGE:
		break;
	case NETDEV_CHANGEMTU:
2002 2003
		if (netdev->features & NETIF_F_FCOE_MTU)
			break;
2004 2005
		mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
				     sizeof(struct fcoe_crc_eof));
2006
		if (mfs >= FC_MIN_MAX_FRAME)
2007
			fc_set_mfs(lport, mfs);
2008 2009 2010
		break;
	case NETDEV_REGISTER:
		break;
2011 2012
	case NETDEV_UNREGISTER:
		list_del(&fcoe->list);
2013
		port = lport_priv(ctlr->lp);
2014
		queue_work(fcoe_wq, &port->destroy_work);
2015 2016
		goto out;
		break;
2017 2018 2019
	case NETDEV_FEAT_CHANGE:
		fcoe_netdev_features_change(lport, netdev);
		break;
2020
	default:
2021
		FCOE_NETDEV_DBG(netdev, "Unknown event %ld "
2022
				"from netdev netlink\n", event);
2023
	}
2024 2025 2026

	fcoe_link_speed_update(lport);

2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
	cdev = fcoe_ctlr_to_ctlr_dev(ctlr);

	if (link_possible && !fcoe_link_ok(lport)) {
		switch (cdev->enabled) {
		case FCOE_CTLR_DISABLED:
			pr_info("Link up while interface is disabled.\n");
			break;
		case FCOE_CTLR_ENABLED:
		case FCOE_CTLR_UNUSED:
			fcoe_ctlr_link_up(ctlr);
		};
	} else if (fcoe_ctlr_link_down(ctlr)) {
		switch (cdev->enabled) {
		case FCOE_CTLR_DISABLED:
			pr_info("Link down while interface is disabled.\n");
			break;
		case FCOE_CTLR_ENABLED:
		case FCOE_CTLR_UNUSED:
			stats = per_cpu_ptr(lport->stats, get_cpu());
			stats->LinkFailureCount++;
			put_cpu();
			fcoe_clean_pending_queue(lport);
		};
2050 2051 2052 2053 2054
	}
out:
	return rc;
}

2055 2056
/**
 * fcoe_disable() - Disables a FCoE interface
2057
 * @netdev  : The net_device object the Ethernet interface to create on
2058
 *
2059
 * Called from fcoe transport.
2060 2061
 *
 * Returns: 0 for success
2062 2063
 *
 * Deprecated: use fcoe_ctlr_enabled()
2064
 */
2065
static int fcoe_disable(struct net_device *netdev)
2066
{
2067
	struct fcoe_ctlr *ctlr;
2068 2069 2070 2071 2072
	struct fcoe_interface *fcoe;
	int rc = 0;

	mutex_lock(&fcoe_config_mutex);

2073
	rtnl_lock();
2074 2075 2076
	fcoe = fcoe_hostlist_lookup_port(netdev);
	rtnl_unlock();

2077
	if (fcoe) {
2078 2079 2080
		ctlr = fcoe_to_ctlr(fcoe);
		fcoe_ctlr_link_down(ctlr);
		fcoe_clean_pending_queue(ctlr->lp);
2081
	} else
2082 2083 2084 2085 2086 2087 2088 2089
		rc = -ENODEV;

	mutex_unlock(&fcoe_config_mutex);
	return rc;
}

/**
 * fcoe_enable() - Enables a FCoE interface
2090
 * @netdev  : The net_device object the Ethernet interface to create on
2091
 *
2092
 * Called from fcoe transport.
2093 2094 2095
 *
 * Returns: 0 for success
 */
2096
static int fcoe_enable(struct net_device *netdev)
2097
{
2098
	struct fcoe_ctlr *ctlr;
2099 2100 2101 2102
	struct fcoe_interface *fcoe;
	int rc = 0;

	mutex_lock(&fcoe_config_mutex);
2103
	rtnl_lock();
2104 2105 2106
	fcoe = fcoe_hostlist_lookup_port(netdev);
	rtnl_unlock();

2107
	if (!fcoe) {
2108
		rc = -ENODEV;
2109 2110
		goto out;
	}
2111

2112 2113 2114 2115 2116 2117
	ctlr = fcoe_to_ctlr(fcoe);

	if (!fcoe_link_ok(ctlr->lp))
		fcoe_ctlr_link_up(ctlr);

out:
2118 2119 2120 2121
	mutex_unlock(&fcoe_config_mutex);
	return rc;
}

2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
/**
 * fcoe_ctlr_enabled() - Enable or disable an FCoE Controller
 * @cdev: The FCoE Controller that is being enabled or disabled
 *
 * fcoe_sysfs will ensure that the state of 'enabled' has
 * changed, so no checking is necessary here. This routine simply
 * calls fcoe_enable or fcoe_disable, both of which are deprecated.
 * When those routines are removed the functionality can be merged
 * here.
 */
static int fcoe_ctlr_enabled(struct fcoe_ctlr_device *cdev)
{
	struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(cdev);
	struct fc_lport *lport = ctlr->lp;
	struct net_device *netdev = fcoe_netdev(lport);

	switch (cdev->enabled) {
	case FCOE_CTLR_ENABLED:
		return fcoe_enable(netdev);
	case FCOE_CTLR_DISABLED:
		return fcoe_disable(netdev);
	case FCOE_CTLR_UNUSED:
	default:
		return -ENOTSUPP;
	};
}

2149
/**
2150
 * fcoe_destroy() - Destroy a FCoE interface
2151
 * @netdev  : The net_device object the Ethernet interface to create on
2152
 *
2153
 * Called from fcoe transport
2154 2155
 *
 * Returns: 0 for success
2156
 */
2157
static int fcoe_destroy(struct net_device *netdev)
2158
{
2159
	struct fcoe_ctlr *ctlr;
2160
	struct fcoe_interface *fcoe;
2161
	struct fc_lport *lport;
2162
	struct fcoe_port *port;
2163
	int rc = 0;
2164

2165
	mutex_lock(&fcoe_config_mutex);
2166
	rtnl_lock();
2167 2168
	fcoe = fcoe_hostlist_lookup_port(netdev);
	if (!fcoe) {
2169
		rc = -ENODEV;
2170
		goto out_nodev;
2171
	}
2172 2173
	ctlr = fcoe_to_ctlr(fcoe);
	lport = ctlr->lp;
2174
	port = lport_priv(lport);
2175
	list_del(&fcoe->list);
2176
	queue_work(fcoe_wq, &port->destroy_work);
2177
out_nodev:
2178
	rtnl_unlock();
2179
	mutex_unlock(&fcoe_config_mutex);
2180 2181 2182
	return rc;
}

2183 2184 2185 2186
/**
 * fcoe_destroy_work() - Destroy a FCoE port in a deferred work context
 * @work: Handle to the FCoE port to be destroyed
 */
2187 2188 2189
static void fcoe_destroy_work(struct work_struct *work)
{
	struct fcoe_port *port;
2190
	struct fcoe_interface *fcoe;
2191 2192 2193

	port = container_of(work, struct fcoe_port, destroy_work);
	mutex_lock(&fcoe_config_mutex);
2194 2195

	fcoe = port->priv;
2196
	fcoe_if_destroy(port->lport);
2197
	fcoe_interface_cleanup(fcoe);
2198

2199 2200 2201
	mutex_unlock(&fcoe_config_mutex);
}

2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
/**
 * fcoe_match() - Check if the FCoE is supported on the given netdevice
 * @netdev  : The net_device object the Ethernet interface to create on
 *
 * Called from fcoe transport.
 *
 * Returns: always returns true as this is the default FCoE transport,
 * i.e., support all netdevs.
 */
static bool fcoe_match(struct net_device *netdev)
{
	return true;
}

2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227
/**
 * fcoe_dcb_create() - Initialize DCB attributes and hooks
 * @netdev: The net_device object of the L2 link that should be queried
 * @port: The fcoe_port to bind FCoE APP priority with
 * @
 */
static void fcoe_dcb_create(struct fcoe_interface *fcoe)
{
#ifdef CONFIG_DCB
	int dcbx;
	u8 fup, up;
	struct net_device *netdev = fcoe->realdev;
2228
	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249
	struct dcb_app app = {
				.priority = 0,
				.protocol = ETH_P_FCOE
			     };

	/* setup DCB priority attributes. */
	if (netdev && netdev->dcbnl_ops && netdev->dcbnl_ops->getdcbx) {
		dcbx = netdev->dcbnl_ops->getdcbx(netdev);

		if (dcbx & DCB_CAP_DCBX_VER_IEEE) {
			app.selector = IEEE_8021QAZ_APP_SEL_ETHERTYPE;
			up = dcb_ieee_getapp_mask(netdev, &app);
			app.protocol = ETH_P_FIP;
			fup = dcb_ieee_getapp_mask(netdev, &app);
		} else {
			app.selector = DCB_APP_IDTYPE_ETHTYPE;
			up = dcb_getapp(netdev, &app);
			app.protocol = ETH_P_FIP;
			fup = dcb_getapp(netdev, &app);
		}

2250 2251
		fcoe->priority = ffs(up) ? ffs(up) - 1 : 0;
		ctlr->priority = ffs(fup) ? ffs(fup) - 1 : fcoe->priority;
2252 2253 2254 2255
	}
#endif
}

2256 2257 2258 2259 2260
enum fcoe_create_link_state {
	FCOE_CREATE_LINK_DOWN,
	FCOE_CREATE_LINK_UP,
};

2261
/**
2262 2263 2264 2265
 * _fcoe_create() - (internal) Create a fcoe interface
 * @netdev  :   The net_device object the Ethernet interface to create on
 * @fip_mode:   The FIP mode for this creation
 * @link_state: The ctlr link state on creation
2266
 *
2267 2268
 * Called from either the libfcoe 'create' module parameter
 * via fcoe_create or from fcoe_syfs's ctlr_create file.
2269
 *
2270 2271 2272
 * libfcoe's 'create' module parameter is deprecated so some
 * consolidation of code can be done when that interface is
 * removed.
2273
 */
2274 2275
static int _fcoe_create(struct net_device *netdev, enum fip_state fip_mode,
			enum fcoe_create_link_state link_state)
2276
{
2277
	int rc = 0;
2278
	struct fcoe_ctlr_device *ctlr_dev;
2279
	struct fcoe_ctlr *ctlr;
2280
	struct fcoe_interface *fcoe;
2281
	struct fc_lport *lport;
2282

2283
	mutex_lock(&fcoe_config_mutex);
2284
	rtnl_lock();
2285

2286 2287 2288
	/* look for existing lport */
	if (fcoe_hostlist_lookup(netdev)) {
		rc = -EEXIST;
2289
		goto out_nodev;
2290 2291
	}

2292
	fcoe = fcoe_interface_create(netdev, fip_mode);
2293 2294
	if (IS_ERR(fcoe)) {
		rc = PTR_ERR(fcoe);
2295
		goto out_nodev;
2296 2297
	}

2298
	ctlr = fcoe_to_ctlr(fcoe);
2299 2300
	ctlr_dev = fcoe_ctlr_to_ctlr_dev(ctlr);
	lport = fcoe_if_create(fcoe, &ctlr_dev->dev, 0);
2301
	if (IS_ERR(lport)) {
2302
		printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
2303 2304
		       netdev->name);
		rc = -EIO;
2305
		rtnl_unlock();
2306
		fcoe_interface_cleanup(fcoe);
2307
		goto out_nortnl;
2308
	}
2309

2310
	/* Make this the "master" N_Port */
2311
	ctlr->lp = lport;
2312

2313 2314 2315
	/* setup DCB priority attributes. */
	fcoe_dcb_create(fcoe);

2316 2317 2318
	/* add to lports list */
	fcoe_hostlist_add(lport);

2319 2320 2321
	/* start FIP Discovery and FLOGI */
	lport->boot_time = jiffies;
	fc_fabric_login(lport);
2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341

	/*
	 * If the fcoe_ctlr_device is to be set to DISABLED
	 * it must be done after the lport is added to the
	 * hostlist, but before the rtnl_lock is released.
	 * This is because the rtnl_lock protects the
	 * hostlist that fcoe_device_notification uses. If
	 * the FCoE Controller is intended to be created
	 * DISABLED then 'enabled' needs to be considered
	 * handling link events. 'enabled' must be set
	 * before the lport can be found in the hostlist
	 * when a link up event is received.
	 */
	if (link_state == FCOE_CREATE_LINK_UP)
		ctlr_dev->enabled = FCOE_CTLR_ENABLED;
	else
		ctlr_dev->enabled = FCOE_CTLR_DISABLED;

	if (link_state == FCOE_CREATE_LINK_UP &&
	    !fcoe_link_ok(lport)) {
2342
		rtnl_unlock();
2343
		fcoe_ctlr_link_up(ctlr);
2344 2345 2346
		mutex_unlock(&fcoe_config_mutex);
		return rc;
	}
2347

2348
out_nodev:
2349
	rtnl_unlock();
2350
out_nortnl:
2351
	mutex_unlock(&fcoe_config_mutex);
2352 2353 2354
	return rc;
}

2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
/**
 * fcoe_create() - Create a fcoe interface
 * @netdev  : The net_device object the Ethernet interface to create on
 * @fip_mode: The FIP mode for this creation
 *
 * Called from fcoe transport
 *
 * Returns: 0 for success
 */
static int fcoe_create(struct net_device *netdev, enum fip_state fip_mode)
{
	return _fcoe_create(netdev, fip_mode, FCOE_CREATE_LINK_UP);
}

/**
 * fcoe_ctlr_alloc() - Allocate a fcoe interface from fcoe_sysfs
 * @netdev: The net_device to be used by the allocated FCoE Controller
 *
 * This routine is called from fcoe_sysfs. It will start the fcoe_ctlr
 * in a link_down state. The allows the user an opportunity to configure
 * the FCoE Controller from sysfs before enabling the FCoE Controller.
 *
 * Creating in with this routine starts the FCoE Controller in Fabric
 * mode. The user can change to VN2VN or another mode before enabling.
 */
static int fcoe_ctlr_alloc(struct net_device *netdev)
{
	return _fcoe_create(netdev, FIP_MODE_FABRIC,
			    FCOE_CREATE_LINK_DOWN);
}

2386 2387 2388 2389 2390 2391 2392
/**
 * fcoe_link_ok() - Check if the link is OK for a local port
 * @lport: The local port to check link on
 *
 * Returns: 0 if link is UP and OK, -1 if not
 *
 */
2393
static int fcoe_link_ok(struct fc_lport *lport)
2394
{
2395
	struct net_device *netdev = fcoe_netdev(lport);
2396 2397 2398 2399 2400 2401

	if (netif_oper_up(netdev))
		return 0;
	return -1;
}

2402
/**
2403 2404
 * fcoe_percpu_clean() - Clear all pending skbs for an local port
 * @lport: The local port whose skbs are to be cleared
2405 2406 2407 2408 2409 2410 2411
 *
 * Must be called with fcoe_create_mutex held to single-thread completion.
 *
 * This flushes the pending skbs by adding a new skb to each queue and
 * waiting until they are all freed.  This assures us that not only are
 * there no packets that will be handled by the lport, but also that any
 * threads already handling packet have returned.
2412
 */
2413
static void fcoe_percpu_clean(struct fc_lport *lport)
2414 2415
{
	struct fcoe_percpu_s *pp;
2416
	struct sk_buff *skb;
2417
	unsigned int cpu;
2418

2419 2420
	for_each_possible_cpu(cpu) {
		pp = &per_cpu(fcoe_percpu, cpu);
2421

2422
		if (!pp->thread || !cpu_online(cpu))
2423 2424 2425
			continue;

		skb = dev_alloc_skb(0);
2426
		if (!skb)
2427
			continue;
2428

2429 2430
		skb->destructor = fcoe_percpu_flush_done;

2431
		spin_lock_bh(&pp->fcoe_rx_list.lock);
2432 2433 2434
		__skb_queue_tail(&pp->fcoe_rx_list, skb);
		if (pp->fcoe_rx_list.qlen == 1)
			wake_up_process(pp->thread);
2435
		spin_unlock_bh(&pp->fcoe_rx_list.lock);
2436 2437

		wait_for_completion(&fcoe_flush_completion);
2438 2439 2440
	}
}

2441
/**
2442 2443
 * fcoe_reset() - Reset a local port
 * @shost: The SCSI host associated with the local port to be reset
2444
 *
2445
 * Returns: Always 0 (return value required by FC transport template)
2446
 */
2447
static int fcoe_reset(struct Scsi_Host *shost)
2448 2449
{
	struct fc_lport *lport = shost_priv(shost);
2450 2451
	struct fcoe_port *port = lport_priv(lport);
	struct fcoe_interface *fcoe = port->priv;
2452
	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
2453
	struct fcoe_ctlr_device *cdev = fcoe_ctlr_to_ctlr_dev(ctlr);
2454

2455 2456
	fcoe_ctlr_link_down(ctlr);
	fcoe_clean_pending_queue(ctlr->lp);
2457 2458 2459

	if (cdev->enabled != FCOE_CTLR_DISABLED &&
	    !fcoe_link_ok(ctlr->lp))
2460
		fcoe_ctlr_link_up(ctlr);
2461 2462 2463
	return 0;
}

2464
/**
2465 2466
 * fcoe_hostlist_lookup_port() - Find the FCoE interface associated with a net device
 * @netdev: The net device used as a key
2467
 *
2468 2469 2470
 * Locking: Must be called with the RNL mutex held.
 *
 * Returns: NULL or the FCoE interface
2471
 */
2472
static struct fcoe_interface *
2473
fcoe_hostlist_lookup_port(const struct net_device *netdev)
2474
{
2475
	struct fcoe_interface *fcoe;
2476

2477
	list_for_each_entry(fcoe, &fcoe_hostlist, list) {
2478
		if (fcoe->netdev == netdev)
2479
			return fcoe;
2480 2481 2482 2483
	}
	return NULL;
}

2484
/**
2485 2486 2487
 * fcoe_hostlist_lookup() - Find the local port associated with a
 *			    given net device
 * @netdev: The netdevice used as a key
2488
 *
2489 2490 2491
 * Locking: Must be called with the RTNL mutex held
 *
 * Returns: NULL or the local port
2492
 */
2493
static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *netdev)
2494
{
2495
	struct fcoe_ctlr *ctlr;
2496
	struct fcoe_interface *fcoe;
2497

2498
	fcoe = fcoe_hostlist_lookup_port(netdev);
2499 2500
	ctlr = fcoe_to_ctlr(fcoe);
	return (fcoe) ? ctlr->lp : NULL;
2501 2502
}

2503
/**
2504 2505 2506
 * fcoe_hostlist_add() - Add the FCoE interface identified by a local
 *			 port to the hostlist
 * @lport: The local port that identifies the FCoE interface to be added
2507
 *
2508
 * Locking: must be called with the RTNL mutex held
2509 2510
 *
 * Returns: 0 for success
2511
 */
2512
static int fcoe_hostlist_add(const struct fc_lport *lport)
2513
{
2514 2515 2516 2517 2518 2519
	struct fcoe_interface *fcoe;
	struct fcoe_port *port;

	fcoe = fcoe_hostlist_lookup_port(fcoe_netdev(lport));
	if (!fcoe) {
		port = lport_priv(lport);
2520
		fcoe = port->priv;
2521
		list_add_tail(&fcoe->list, &fcoe_hostlist);
2522 2523 2524 2525
	}
	return 0;
}

2526 2527 2528 2529 2530 2531

static struct fcoe_transport fcoe_sw_transport = {
	.name = {FCOE_TRANSPORT_DEFAULT},
	.attached = false,
	.list = LIST_HEAD_INIT(fcoe_sw_transport.list),
	.match = fcoe_match,
2532
	.alloc = fcoe_ctlr_alloc,
2533 2534 2535 2536 2537 2538
	.create = fcoe_create,
	.destroy = fcoe_destroy,
	.enable = fcoe_enable,
	.disable = fcoe_disable,
};

2539
/**
2540
 * fcoe_init() - Initialize fcoe.ko
2541
 *
2542
 * Returns: 0 on success, or a negative value on failure
2543
 */
2544 2545
static int __init fcoe_init(void)
{
2546
	struct fcoe_percpu_s *p;
2547
	unsigned int cpu;
2548
	int rc = 0;
2549

2550 2551 2552 2553
	fcoe_wq = alloc_workqueue("fcoe", 0, 0);
	if (!fcoe_wq)
		return -ENOMEM;

2554 2555 2556 2557 2558 2559 2560 2561
	/* register as a fcoe transport */
	rc = fcoe_transport_attach(&fcoe_sw_transport);
	if (rc) {
		printk(KERN_ERR "failed to register an fcoe transport, check "
			"if libfcoe is loaded\n");
		return rc;
	}

2562 2563
	mutex_lock(&fcoe_config_mutex);

2564
	for_each_possible_cpu(cpu) {
2565
		p = &per_cpu(fcoe_percpu, cpu);
2566 2567 2568
		skb_queue_head_init(&p->fcoe_rx_list);
	}

2569 2570
	for_each_online_cpu(cpu)
		fcoe_percpu_thread_create(cpu);
2571

2572 2573 2574 2575
	/* Initialize per CPU interrupt thread */
	rc = register_hotcpu_notifier(&fcoe_cpu_notifier);
	if (rc)
		goto out_free;
2576

2577
	/* Setup link change notification */
2578 2579
	fcoe_dev_setup();

2580 2581 2582
	rc = fcoe_if_init();
	if (rc)
		goto out_free;
2583

2584
	mutex_unlock(&fcoe_config_mutex);
2585
	return 0;
2586 2587 2588 2589 2590

out_free:
	for_each_online_cpu(cpu) {
		fcoe_percpu_thread_destroy(cpu);
	}
2591
	mutex_unlock(&fcoe_config_mutex);
2592
	destroy_workqueue(fcoe_wq);
2593
	return rc;
2594 2595 2596 2597
}
module_init(fcoe_init);

/**
2598
 * fcoe_exit() - Clean up fcoe.ko
2599
 *
2600
 * Returns: 0 on success or a  negative value on failure
2601
 */
2602 2603
static void __exit fcoe_exit(void)
{
2604
	struct fcoe_interface *fcoe, *tmp;
2605
	struct fcoe_ctlr *ctlr;
2606
	struct fcoe_port *port;
2607
	unsigned int cpu;
2608

2609 2610
	mutex_lock(&fcoe_config_mutex);

2611 2612
	fcoe_dev_cleanup();

2613
	/* releases the associated fcoe hosts */
2614 2615
	rtnl_lock();
	list_for_each_entry_safe(fcoe, tmp, &fcoe_hostlist, list) {
2616
		list_del(&fcoe->list);
2617 2618
		ctlr = fcoe_to_ctlr(fcoe);
		port = lport_priv(ctlr->lp);
2619
		queue_work(fcoe_wq, &port->destroy_work);
2620
	}
2621
	rtnl_unlock();
2622

2623 2624
	unregister_hotcpu_notifier(&fcoe_cpu_notifier);

2625
	for_each_online_cpu(cpu)
2626
		fcoe_percpu_thread_destroy(cpu);
2627

2628
	mutex_unlock(&fcoe_config_mutex);
2629

2630 2631 2632 2633 2634
	/*
	 * destroy_work's may be chained but destroy_workqueue()
	 * can take care of them. Just kill the fcoe_wq.
	 */
	destroy_workqueue(fcoe_wq);
2635

2636 2637 2638 2639 2640
	/*
	 * Detaching from the scsi transport must happen after all
	 * destroys are done on the fcoe_wq. destroy_workqueue will
	 * enusre the fcoe_wq is flushed.
	 */
2641
	fcoe_if_exit();
2642 2643 2644

	/* detach from fcoe transport */
	fcoe_transport_detach(&fcoe_sw_transport);
2645 2646
}
module_exit(fcoe_exit);
2647 2648 2649 2650 2651 2652 2653

/**
 * fcoe_flogi_resp() - FCoE specific FLOGI and FDISC response handler
 * @seq: active sequence in the FLOGI or FDISC exchange
 * @fp: response frame, or error encoded in a pointer (timeout)
 * @arg: pointer the the fcoe_ctlr structure
 *
2654
 * This handles MAC address management for FCoE, then passes control on to
2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667
 * the libfc FLOGI response handler.
 */
static void fcoe_flogi_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
{
	struct fcoe_ctlr *fip = arg;
	struct fc_exch *exch = fc_seq_exch(seq);
	struct fc_lport *lport = exch->lp;
	u8 *mac;

	if (IS_ERR(fp))
		goto done;

	mac = fr_cb(fp)->granted_mac;
2668 2669 2670 2671 2672
	/* pre-FIP */
	if (is_zero_ether_addr(mac))
		fcoe_ctlr_recv_flogi(fip, lport, fp);
	if (!is_zero_ether_addr(mac))
		fcoe_update_src_mac(lport, mac);
2673 2674 2675 2676 2677 2678 2679 2680 2681 2682
done:
	fc_lport_flogi_resp(seq, fp, lport);
}

/**
 * fcoe_logo_resp() - FCoE specific LOGO response handler
 * @seq: active sequence in the LOGO exchange
 * @fp: response frame, or error encoded in a pointer (timeout)
 * @arg: pointer the the fcoe_ctlr structure
 *
2683
 * This handles MAC address management for FCoE, then passes control on to
2684 2685 2686 2687
 * the libfc LOGO response handler.
 */
static void fcoe_logo_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
{
2688
	struct fc_lport *lport = arg;
2689 2690 2691
	static u8 zero_mac[ETH_ALEN] = { 0 };

	if (!IS_ERR(fp))
2692
		fcoe_update_src_mac(lport, zero_mac);
2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704
	fc_lport_logo_resp(seq, fp, lport);
}

/**
 * fcoe_elsct_send - FCoE specific ELS handler
 *
 * This does special case handling of FIP encapsualted ELS exchanges for FCoE,
 * using FCoE specific response handlers and passing the FIP controller as
 * the argument (the lport is still available from the exchange).
 *
 * Most of the work here is just handed off to the libfc routine.
 */
2705 2706 2707 2708 2709 2710
static struct fc_seq *fcoe_elsct_send(struct fc_lport *lport, u32 did,
				      struct fc_frame *fp, unsigned int op,
				      void (*resp)(struct fc_seq *,
						   struct fc_frame *,
						   void *),
				      void *arg, u32 timeout)
2711 2712
{
	struct fcoe_port *port = lport_priv(lport);
2713
	struct fcoe_interface *fcoe = port->priv;
2714
	struct fcoe_ctlr *fip = fcoe_to_ctlr(fcoe);
2715 2716 2717 2718 2719
	struct fc_frame_header *fh = fc_frame_header_get(fp);

	switch (op) {
	case ELS_FLOGI:
	case ELS_FDISC:
2720 2721
		if (lport->point_to_multipoint)
			break;
2722 2723 2724 2725 2726 2727 2728
		return fc_elsct_send(lport, did, fp, op, fcoe_flogi_resp,
				     fip, timeout);
	case ELS_LOGO:
		/* only hook onto fabric logouts, not port logouts */
		if (ntoh24(fh->fh_d_id) != FC_FID_FLOGI)
			break;
		return fc_elsct_send(lport, did, fp, op, fcoe_logo_resp,
2729
				     lport, timeout);
2730 2731 2732 2733
	}
	return fc_elsct_send(lport, did, fp, op, resp, arg, timeout);
}

2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745
/**
 * fcoe_vport_create() - create an fc_host/scsi_host for a vport
 * @vport: fc_vport object to create a new fc_host for
 * @disabled: start the new fc_host in a disabled state by default?
 *
 * Returns: 0 for success
 */
static int fcoe_vport_create(struct fc_vport *vport, bool disabled)
{
	struct Scsi_Host *shost = vport_to_shost(vport);
	struct fc_lport *n_port = shost_priv(shost);
	struct fcoe_port *port = lport_priv(n_port);
2746
	struct fcoe_interface *fcoe = port->priv;
2747 2748
	struct net_device *netdev = fcoe->netdev;
	struct fc_lport *vn_port;
2749 2750 2751 2752 2753
	int rc;
	char buf[32];

	rc = fcoe_validate_vport_create(vport);
	if (rc) {
2754
		fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
2755 2756 2757 2758 2759
		printk(KERN_ERR "fcoe: Failed to create vport, "
			"WWPN (0x%s) already exists\n",
			buf);
		return rc;
	}
2760 2761

	mutex_lock(&fcoe_config_mutex);
2762
	rtnl_lock();
2763
	vn_port = fcoe_if_create(fcoe, &vport->dev, 1);
2764
	rtnl_unlock();
2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797
	mutex_unlock(&fcoe_config_mutex);

	if (IS_ERR(vn_port)) {
		printk(KERN_ERR "fcoe: fcoe_vport_create(%s) failed\n",
		       netdev->name);
		return -EIO;
	}

	if (disabled) {
		fc_vport_set_state(vport, FC_VPORT_DISABLED);
	} else {
		vn_port->boot_time = jiffies;
		fc_fabric_login(vn_port);
		fc_vport_setlink(vn_port);
	}
	return 0;
}

/**
 * fcoe_vport_destroy() - destroy the fc_host/scsi_host for a vport
 * @vport: fc_vport object that is being destroyed
 *
 * Returns: 0 for success
 */
static int fcoe_vport_destroy(struct fc_vport *vport)
{
	struct Scsi_Host *shost = vport_to_shost(vport);
	struct fc_lport *n_port = shost_priv(shost);
	struct fc_lport *vn_port = vport->dd_data;

	mutex_lock(&n_port->lp_mutex);
	list_del(&vn_port->list);
	mutex_unlock(&n_port->lp_mutex);
2798 2799 2800 2801 2802

	mutex_lock(&fcoe_config_mutex);
	fcoe_if_destroy(vn_port);
	mutex_unlock(&fcoe_config_mutex);

2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826
	return 0;
}

/**
 * fcoe_vport_disable() - change vport state
 * @vport: vport to bring online/offline
 * @disable: should the vport be disabled?
 */
static int fcoe_vport_disable(struct fc_vport *vport, bool disable)
{
	struct fc_lport *lport = vport->dd_data;

	if (disable) {
		fc_vport_set_state(vport, FC_VPORT_DISABLED);
		fc_fabric_logoff(lport);
	} else {
		lport->boot_time = jiffies;
		fc_fabric_login(lport);
		fc_vport_setlink(lport);
	}

	return 0;
}

2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854
/**
 * fcoe_vport_set_symbolic_name() - append vport string to symbolic name
 * @vport: fc_vport with a new symbolic name string
 *
 * After generating a new symbolic name string, a new RSPN_ID request is
 * sent to the name server.  There is no response handler, so if it fails
 * for some reason it will not be retried.
 */
static void fcoe_set_vport_symbolic_name(struct fc_vport *vport)
{
	struct fc_lport *lport = vport->dd_data;
	struct fc_frame *fp;
	size_t len;

	snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
		 "%s v%s over %s : %s", FCOE_NAME, FCOE_VERSION,
		 fcoe_netdev(lport)->name, vport->symbolic_name);

	if (lport->state != LPORT_ST_READY)
		return;

	len = strnlen(fc_host_symbolic_name(lport->host), 255);
	fp = fc_frame_alloc(lport,
			    sizeof(struct fc_ct_hdr) +
			    sizeof(struct fc_ns_rspn) + len);
	if (!fp)
		return;
	lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RSPN_ID,
2855
			     NULL, NULL, 3 * lport->r_a_tov);
2856
}
2857

2858 2859 2860 2861 2862 2863 2864 2865 2866 2867
static void fcoe_fcf_get_vlan_id(struct fcoe_fcf_device *fcf_dev)
{
	struct fcoe_ctlr_device *ctlr_dev =
		fcoe_fcf_dev_to_ctlr_dev(fcf_dev);
	struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr_dev);
	struct fcoe_interface *fcoe = fcoe_ctlr_priv(ctlr);

	fcf_dev->vlan_id = vlan_dev_vlan_id(fcoe->netdev);
}

2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883
/**
 * fcoe_set_port_id() - Callback from libfc when Port_ID is set.
 * @lport: the local port
 * @port_id: the port ID
 * @fp: the received frame, if any, that caused the port_id to be set.
 *
 * This routine handles the case where we received a FLOGI and are
 * entering point-to-point mode.  We need to call fcoe_ctlr_recv_flogi()
 * so it can set the non-mapped mode and gateway address.
 *
 * The FLOGI LS_ACC is handled by fcoe_flogi_resp().
 */
static void fcoe_set_port_id(struct fc_lport *lport,
			     u32 port_id, struct fc_frame *fp)
{
	struct fcoe_port *port = lport_priv(lport);
2884
	struct fcoe_interface *fcoe = port->priv;
2885
	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
2886 2887

	if (fp && fc_frame_payload_op(fp) == ELS_FLOGI)
2888
		fcoe_ctlr_recv_flogi(ctlr, lport, fp);
2889
}