2 * Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
17 * Maintained at www.Open-FCoE.org
20 #include <linux/module.h>
21 #include <linux/version.h>
22 #include <linux/spinlock.h>
23 #include <linux/netdevice.h>
24 #include <linux/etherdevice.h>
25 #include <linux/ethtool.h>
26 #include <linux/if_ether.h>
27 #include <linux/if_vlan.h>
28 #include <linux/crc32.h>
29 #include <linux/slab.h>
30 #include <linux/cpu.h>
32 #include <linux/sysfs.h>
33 #include <linux/ctype.h>
34 #include <scsi/scsi_tcq.h>
35 #include <scsi/scsicam.h>
36 #include <scsi/scsi_transport.h>
37 #include <scsi/scsi_transport_fc.h>
38 #include <net/rtnetlink.h>
40 #include <scsi/fc/fc_encaps.h>
41 #include <scsi/fc/fc_fip.h>
43 #include <scsi/libfc.h>
44 #include <scsi/fc_frame.h>
45 #include <scsi/libfcoe.h>
49 MODULE_AUTHOR("Open-FCoE.org");
50 MODULE_DESCRIPTION("FCoE");
51 MODULE_LICENSE("GPL v2");
53 /* Performance tuning parameters for fcoe */
54 static unsigned int fcoe_ddp_min;
55 module_param_named(ddp_min, fcoe_ddp_min, uint, S_IRUGO | S_IWUSR);
56 MODULE_PARM_DESC(ddp_min, "Minimum I/O size in bytes for " \
57 "Direct Data Placement (DDP).");
59 DEFINE_MUTEX(fcoe_config_mutex);
61 /* fcoe_percpu_clean completion. Waiter protected by fcoe_create_mutex */
62 static DECLARE_COMPLETION(fcoe_flush_completion);
65 /* must only by accessed under the RTNL mutex */
66 LIST_HEAD(fcoe_hostlist);
67 DEFINE_PER_CPU(struct fcoe_percpu_s, fcoe_percpu);
69 /* Function Prototypes */
70 static int fcoe_reset(struct Scsi_Host *);
71 static int fcoe_xmit(struct fc_lport *, struct fc_frame *);
72 static int fcoe_rcv(struct sk_buff *, struct net_device *,
73 struct packet_type *, struct net_device *);
74 static int fcoe_percpu_receive_thread(void *);
75 static void fcoe_clean_pending_queue(struct fc_lport *);
76 static void fcoe_percpu_clean(struct fc_lport *);
77 static int fcoe_link_speed_update(struct fc_lport *);
78 static int fcoe_link_ok(struct fc_lport *);
80 static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *);
81 static int fcoe_hostlist_add(const struct fc_lport *);
83 static void fcoe_check_wait_queue(struct fc_lport *, struct sk_buff *);
84 static int fcoe_device_notification(struct notifier_block *, ulong, void *);
85 static void fcoe_dev_setup(void);
86 static void fcoe_dev_cleanup(void);
87 static struct fcoe_interface
88 *fcoe_hostlist_lookup_port(const struct net_device *);
90 static int fcoe_fip_recv(struct sk_buff *, struct net_device *,
91 struct packet_type *, struct net_device *);
93 static void fcoe_fip_send(struct fcoe_ctlr *, struct sk_buff *);
94 static void fcoe_update_src_mac(struct fc_lport *, u8 *);
95 static u8 *fcoe_get_src_mac(struct fc_lport *);
96 static void fcoe_destroy_work(struct work_struct *);
98 static int fcoe_ddp_setup(struct fc_lport *, u16, struct scatterlist *,
100 static int fcoe_ddp_done(struct fc_lport *, u16);
102 static int fcoe_cpu_callback(struct notifier_block *, unsigned long, void *);
104 static int fcoe_create(const char *, struct kernel_param *);
105 static int fcoe_destroy(const char *, struct kernel_param *);
106 static int fcoe_enable(const char *, struct kernel_param *);
107 static int fcoe_disable(const char *, struct kernel_param *);
109 static struct fc_seq *fcoe_elsct_send(struct fc_lport *,
110 u32 did, struct fc_frame *,
112 void (*resp)(struct fc_seq *,
115 void *, u32 timeout);
116 static void fcoe_recv_frame(struct sk_buff *skb);
118 static void fcoe_get_lesb(struct fc_lport *, struct fc_els_lesb *);
120 module_param_call(create, fcoe_create, NULL, (void *)FIP_MODE_AUTO, S_IWUSR);
121 __MODULE_PARM_TYPE(create, "string");
122 MODULE_PARM_DESC(create, " Creates fcoe instance on a ethernet interface");
123 module_param_call(create_vn2vn, fcoe_create, NULL,
124 (void *)FIP_MODE_VN2VN, S_IWUSR);
125 __MODULE_PARM_TYPE(create_vn2vn, "string");
126 MODULE_PARM_DESC(create_vn2vn, " Creates a VN_node to VN_node FCoE instance "
127 "on an Ethernet interface");
128 module_param_call(destroy, fcoe_destroy, NULL, NULL, S_IWUSR);
129 __MODULE_PARM_TYPE(destroy, "string");
130 MODULE_PARM_DESC(destroy, " Destroys fcoe instance on a ethernet interface");
131 module_param_call(enable, fcoe_enable, NULL, NULL, S_IWUSR);
132 __MODULE_PARM_TYPE(enable, "string");
133 MODULE_PARM_DESC(enable, " Enables fcoe on a ethernet interface.");
134 module_param_call(disable, fcoe_disable, NULL, NULL, S_IWUSR);
135 __MODULE_PARM_TYPE(disable, "string");
136 MODULE_PARM_DESC(disable, " Disables fcoe on a ethernet interface.");
138 /* notification function for packets from net device */
139 static struct notifier_block fcoe_notifier = {
140 .notifier_call = fcoe_device_notification,
143 /* notification function for CPU hotplug events */
144 static struct notifier_block fcoe_cpu_notifier = {
145 .notifier_call = fcoe_cpu_callback,
148 static struct scsi_transport_template *fcoe_transport_template;
149 static struct scsi_transport_template *fcoe_vport_transport_template;
151 static int fcoe_vport_destroy(struct fc_vport *);
152 static int fcoe_vport_create(struct fc_vport *, bool disabled);
153 static int fcoe_vport_disable(struct fc_vport *, bool disable);
154 static void fcoe_set_vport_symbolic_name(struct fc_vport *);
155 static void fcoe_set_port_id(struct fc_lport *, u32, struct fc_frame *);
157 static struct libfc_function_template fcoe_libfc_fcn_templ = {
158 .frame_send = fcoe_xmit,
159 .ddp_setup = fcoe_ddp_setup,
160 .ddp_done = fcoe_ddp_done,
161 .elsct_send = fcoe_elsct_send,
162 .get_lesb = fcoe_get_lesb,
163 .lport_set_port_id = fcoe_set_port_id,
166 struct fc_function_template fcoe_transport_function = {
167 .show_host_node_name = 1,
168 .show_host_port_name = 1,
169 .show_host_supported_classes = 1,
170 .show_host_supported_fc4s = 1,
171 .show_host_active_fc4s = 1,
172 .show_host_maxframe_size = 1,
174 .show_host_port_id = 1,
175 .show_host_supported_speeds = 1,
176 .get_host_speed = fc_get_host_speed,
177 .show_host_speed = 1,
178 .show_host_port_type = 1,
179 .get_host_port_state = fc_get_host_port_state,
180 .show_host_port_state = 1,
181 .show_host_symbolic_name = 1,
183 .dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
184 .show_rport_maxframe_size = 1,
185 .show_rport_supported_classes = 1,
187 .show_host_fabric_name = 1,
188 .show_starget_node_name = 1,
189 .show_starget_port_name = 1,
190 .show_starget_port_id = 1,
191 .set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
192 .show_rport_dev_loss_tmo = 1,
193 .get_fc_host_stats = fc_get_host_stats,
194 .issue_fc_host_lip = fcoe_reset,
196 .terminate_rport_io = fc_rport_terminate_io,
198 .vport_create = fcoe_vport_create,
199 .vport_delete = fcoe_vport_destroy,
200 .vport_disable = fcoe_vport_disable,
201 .set_vport_symbolic_name = fcoe_set_vport_symbolic_name,
203 .bsg_request = fc_lport_bsg_request,
206 struct fc_function_template fcoe_vport_transport_function = {
207 .show_host_node_name = 1,
208 .show_host_port_name = 1,
209 .show_host_supported_classes = 1,
210 .show_host_supported_fc4s = 1,
211 .show_host_active_fc4s = 1,
212 .show_host_maxframe_size = 1,
214 .show_host_port_id = 1,
215 .show_host_supported_speeds = 1,
216 .get_host_speed = fc_get_host_speed,
217 .show_host_speed = 1,
218 .show_host_port_type = 1,
219 .get_host_port_state = fc_get_host_port_state,
220 .show_host_port_state = 1,
221 .show_host_symbolic_name = 1,
223 .dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
224 .show_rport_maxframe_size = 1,
225 .show_rport_supported_classes = 1,
227 .show_host_fabric_name = 1,
228 .show_starget_node_name = 1,
229 .show_starget_port_name = 1,
230 .show_starget_port_id = 1,
231 .set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
232 .show_rport_dev_loss_tmo = 1,
233 .get_fc_host_stats = fc_get_host_stats,
234 .issue_fc_host_lip = fcoe_reset,
236 .terminate_rport_io = fc_rport_terminate_io,
238 .bsg_request = fc_lport_bsg_request,
241 static struct scsi_host_template fcoe_shost_template = {
242 .module = THIS_MODULE,
243 .name = "FCoE Driver",
244 .proc_name = FCOE_NAME,
245 .queuecommand = fc_queuecommand,
246 .eh_abort_handler = fc_eh_abort,
247 .eh_device_reset_handler = fc_eh_device_reset,
248 .eh_host_reset_handler = fc_eh_host_reset,
249 .slave_alloc = fc_slave_alloc,
250 .change_queue_depth = fc_change_queue_depth,
251 .change_queue_type = fc_change_queue_type,
254 .can_queue = FCOE_MAX_OUTSTANDING_COMMANDS,
255 .use_clustering = ENABLE_CLUSTERING,
256 .sg_tablesize = SG_ALL,
257 .max_sectors = 0xffff,
261 * fcoe_interface_setup() - Setup a FCoE interface
262 * @fcoe: The new FCoE interface
263 * @netdev: The net device that the fcoe interface is on
265 * Returns : 0 for success
266 * Locking: must be called with the RTNL mutex held
268 static int fcoe_interface_setup(struct fcoe_interface *fcoe,
269 struct net_device *netdev)
271 struct fcoe_ctlr *fip = &fcoe->ctlr;
272 struct netdev_hw_addr *ha;
273 struct net_device *real_dev;
274 u8 flogi_maddr[ETH_ALEN];
275 const struct net_device_ops *ops;
277 fcoe->netdev = netdev;
279 /* Let LLD initialize for FCoE */
280 ops = netdev->netdev_ops;
281 if (ops->ndo_fcoe_enable) {
282 if (ops->ndo_fcoe_enable(netdev))
283 FCOE_NETDEV_DBG(netdev, "Failed to enable FCoE"
284 " specific feature for LLD.\n");
287 /* Do not support for bonding device */
288 if ((netdev->priv_flags & IFF_MASTER_ALB) ||
289 (netdev->priv_flags & IFF_SLAVE_INACTIVE) ||
290 (netdev->priv_flags & IFF_MASTER_8023AD)) {
291 FCOE_NETDEV_DBG(netdev, "Bonded interfaces not supported\n");
295 /* look for SAN MAC address, if multiple SAN MACs exist, only
296 * use the first one for SPMA */
297 real_dev = (netdev->priv_flags & IFF_802_1Q_VLAN) ?
298 vlan_dev_real_dev(netdev) : netdev;
300 for_each_dev_addr(real_dev, ha) {
301 if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&
302 (is_valid_ether_addr(ha->addr))) {
303 memcpy(fip->ctl_src_addr, ha->addr, ETH_ALEN);
310 /* setup Source Mac Address */
312 memcpy(fip->ctl_src_addr, netdev->dev_addr, netdev->addr_len);
315 * Add FCoE MAC address as second unicast MAC address
316 * or enter promiscuous mode if not capable of listening
317 * for multiple unicast MACs.
319 memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
320 dev_uc_add(netdev, flogi_maddr);
322 dev_uc_add(netdev, fip->ctl_src_addr);
323 if (fip->mode == FIP_MODE_VN2VN) {
324 dev_mc_add(netdev, FIP_ALL_VN2VN_MACS);
325 dev_mc_add(netdev, FIP_ALL_P2P_MACS);
327 dev_mc_add(netdev, FIP_ALL_ENODE_MACS);
330 * setup the receive function from ethernet driver
331 * on the ethertype for the given device
333 fcoe->fcoe_packet_type.func = fcoe_rcv;
334 fcoe->fcoe_packet_type.type = __constant_htons(ETH_P_FCOE);
335 fcoe->fcoe_packet_type.dev = netdev;
336 dev_add_pack(&fcoe->fcoe_packet_type);
338 fcoe->fip_packet_type.func = fcoe_fip_recv;
339 fcoe->fip_packet_type.type = htons(ETH_P_FIP);
340 fcoe->fip_packet_type.dev = netdev;
341 dev_add_pack(&fcoe->fip_packet_type);
347 * fcoe_interface_create() - Create a FCoE interface on a net device
348 * @netdev: The net device to create the FCoE interface on
349 * @fip_mode: The mode to use for FIP
351 * Returns: pointer to a struct fcoe_interface or NULL on error
353 static struct fcoe_interface *fcoe_interface_create(struct net_device *netdev,
354 enum fip_state fip_mode)
356 struct fcoe_interface *fcoe;
359 fcoe = kzalloc(sizeof(*fcoe), GFP_KERNEL);
361 FCOE_NETDEV_DBG(netdev, "Could not allocate fcoe structure\n");
366 kref_init(&fcoe->kref);
371 fcoe_ctlr_init(&fcoe->ctlr, fip_mode);
372 fcoe->ctlr.send = fcoe_fip_send;
373 fcoe->ctlr.update_mac = fcoe_update_src_mac;
374 fcoe->ctlr.get_src_addr = fcoe_get_src_mac;
376 err = fcoe_interface_setup(fcoe, netdev);
378 fcoe_ctlr_destroy(&fcoe->ctlr);
388 * fcoe_interface_cleanup() - Clean up a FCoE interface
389 * @fcoe: The FCoE interface to be cleaned up
391 * Caller must be holding the RTNL mutex
393 void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
395 struct net_device *netdev = fcoe->netdev;
396 struct fcoe_ctlr *fip = &fcoe->ctlr;
397 u8 flogi_maddr[ETH_ALEN];
398 const struct net_device_ops *ops;
401 * Don't listen for Ethernet packets anymore.
402 * synchronize_net() ensures that the packet handlers are not running
403 * on another CPU. dev_remove_pack() would do that, this calls the
404 * unsyncronized version __dev_remove_pack() to avoid multiple delays.
406 __dev_remove_pack(&fcoe->fcoe_packet_type);
407 __dev_remove_pack(&fcoe->fip_packet_type);
410 /* Delete secondary MAC addresses */
411 memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
412 dev_uc_del(netdev, flogi_maddr);
414 dev_uc_del(netdev, fip->ctl_src_addr);
415 if (fip->mode == FIP_MODE_VN2VN) {
416 dev_mc_del(netdev, FIP_ALL_VN2VN_MACS);
417 dev_mc_del(netdev, FIP_ALL_P2P_MACS);
419 dev_mc_del(netdev, FIP_ALL_ENODE_MACS);
421 /* Tell the LLD we are done w/ FCoE */
422 ops = netdev->netdev_ops;
423 if (ops->ndo_fcoe_disable) {
424 if (ops->ndo_fcoe_disable(netdev))
425 FCOE_NETDEV_DBG(netdev, "Failed to disable FCoE"
426 " specific feature for LLD.\n");
431 * fcoe_interface_release() - fcoe_port kref release function
432 * @kref: Embedded reference count in an fcoe_interface struct
434 static void fcoe_interface_release(struct kref *kref)
436 struct fcoe_interface *fcoe;
437 struct net_device *netdev;
439 fcoe = container_of(kref, struct fcoe_interface, kref);
440 netdev = fcoe->netdev;
441 /* tear-down the FCoE controller */
442 fcoe_ctlr_destroy(&fcoe->ctlr);
448 * fcoe_interface_get() - Get a reference to a FCoE interface
449 * @fcoe: The FCoE interface to be held
451 static inline void fcoe_interface_get(struct fcoe_interface *fcoe)
453 kref_get(&fcoe->kref);
457 * fcoe_interface_put() - Put a reference to a FCoE interface
458 * @fcoe: The FCoE interface to be released
460 static inline void fcoe_interface_put(struct fcoe_interface *fcoe)
462 kref_put(&fcoe->kref, fcoe_interface_release);
466 * fcoe_fip_recv() - Handler for received FIP frames
467 * @skb: The receive skb
468 * @netdev: The associated net device
469 * @ptype: The packet_type structure which was used to register this handler
470 * @orig_dev: The original net_device the the skb was received on.
471 * (in case dev is a bond)
473 * Returns: 0 for success
475 static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *netdev,
476 struct packet_type *ptype,
477 struct net_device *orig_dev)
479 struct fcoe_interface *fcoe;
481 fcoe = container_of(ptype, struct fcoe_interface, fip_packet_type);
482 fcoe_ctlr_recv(&fcoe->ctlr, skb);
487 * fcoe_fip_send() - Send an Ethernet-encapsulated FIP frame
488 * @fip: The FCoE controller
489 * @skb: The FIP packet to be sent
491 static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
493 skb->dev = fcoe_from_ctlr(fip)->netdev;
498 * fcoe_update_src_mac() - Update the Ethernet MAC filters
499 * @lport: The local port to update the source MAC on
500 * @addr: Unicast MAC address to add
502 * Remove any previously-set unicast MAC filter.
503 * Add secondary FCoE MAC address filter for our OUI.
505 static void fcoe_update_src_mac(struct fc_lport *lport, u8 *addr)
507 struct fcoe_port *port = lport_priv(lport);
508 struct fcoe_interface *fcoe = port->fcoe;
511 if (!is_zero_ether_addr(port->data_src_addr))
512 dev_uc_del(fcoe->netdev, port->data_src_addr);
513 if (!is_zero_ether_addr(addr))
514 dev_uc_add(fcoe->netdev, addr);
515 memcpy(port->data_src_addr, addr, ETH_ALEN);
520 * fcoe_get_src_mac() - return the Ethernet source address for an lport
521 * @lport: libfc lport
523 static u8 *fcoe_get_src_mac(struct fc_lport *lport)
525 struct fcoe_port *port = lport_priv(lport);
527 return port->data_src_addr;
531 * fcoe_lport_config() - Set up a local port
532 * @lport: The local port to be setup
534 * Returns: 0 for success
536 static int fcoe_lport_config(struct fc_lport *lport)
540 lport->max_retry_count = 3;
541 lport->max_rport_retry_count = 3;
542 lport->e_d_tov = 2 * 1000; /* FC-FS default */
543 lport->r_a_tov = 2 * 2 * 1000;
544 lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
545 FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
546 lport->does_npiv = 1;
548 fc_lport_init_stats(lport);
550 /* lport fc_lport related configuration */
551 fc_lport_config(lport);
553 /* offload related configuration */
554 lport->crc_offload = 0;
555 lport->seq_offload = 0;
556 lport->lro_enabled = 0;
564 * fcoe_queue_timer() - The fcoe queue timer
565 * @lport: The local port
567 * Calls fcoe_check_wait_queue on timeout
569 static void fcoe_queue_timer(ulong lport)
571 fcoe_check_wait_queue((struct fc_lport *)lport, NULL);
575 * fcoe_get_wwn() - Get the world wide name from LLD if it supports it
576 * @netdev: the associated net device
577 * @wwn: the output WWN
578 * @type: the type of WWN (WWPN or WWNN)
580 * Returns: 0 for success
582 static int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
584 const struct net_device_ops *ops = netdev->netdev_ops;
586 if (ops->ndo_fcoe_get_wwn)
587 return ops->ndo_fcoe_get_wwn(netdev, wwn, type);
592 * fcoe_netdev_features_change - Updates the lport's offload flags based
593 * on the LLD netdev's FCoE feature flags
595 static void fcoe_netdev_features_change(struct fc_lport *lport,
596 struct net_device *netdev)
598 mutex_lock(&lport->lp_mutex);
600 if (netdev->features & NETIF_F_SG)
605 if (netdev->features & NETIF_F_FCOE_CRC) {
606 lport->crc_offload = 1;
607 FCOE_NETDEV_DBG(netdev, "Supports FCCRC offload\n");
609 lport->crc_offload = 0;
612 if (netdev->features & NETIF_F_FSO) {
613 lport->seq_offload = 1;
614 lport->lso_max = netdev->gso_max_size;
615 FCOE_NETDEV_DBG(netdev, "Supports LSO for max len 0x%x\n",
618 lport->seq_offload = 0;
622 if (netdev->fcoe_ddp_xid) {
623 lport->lro_enabled = 1;
624 lport->lro_xid = netdev->fcoe_ddp_xid;
625 FCOE_NETDEV_DBG(netdev, "Supports LRO for max xid 0x%x\n",
628 lport->lro_enabled = 0;
632 mutex_unlock(&lport->lp_mutex);
636 * fcoe_netdev_config() - Set up net devive for SW FCoE
637 * @lport: The local port that is associated with the net device
638 * @netdev: The associated net device
640 * Must be called after fcoe_lport_config() as it will use local port mutex
642 * Returns: 0 for success
644 static int fcoe_netdev_config(struct fc_lport *lport, struct net_device *netdev)
648 struct fcoe_interface *fcoe;
649 struct fcoe_port *port;
652 /* Setup lport private data to point to fcoe softc */
653 port = lport_priv(lport);
657 * Determine max frame size based on underlying device and optional
658 * user-configured limit. If the MFS is too low, fcoe_link_ok()
659 * will return 0, so do this first.
662 if (netdev->features & NETIF_F_FCOE_MTU) {
664 FCOE_NETDEV_DBG(netdev, "Supports FCOE_MTU of %d bytes\n", mfs);
666 mfs -= (sizeof(struct fcoe_hdr) + sizeof(struct fcoe_crc_eof));
667 if (fc_set_mfs(lport, mfs))
670 /* offload features support */
671 fcoe_netdev_features_change(lport, netdev);
673 skb_queue_head_init(&port->fcoe_pending_queue);
674 port->fcoe_pending_queue_active = 0;
675 setup_timer(&port->timer, fcoe_queue_timer, (unsigned long)lport);
677 fcoe_link_speed_update(lport);
681 * Use NAA 1&2 (FC-FS Rev. 2.0, Sec. 15) to generate WWNN/WWPN:
682 * For WWNN, we use NAA 1 w/ bit 27-16 of word 0 as 0.
683 * For WWPN, we use NAA 2 w/ bit 27-16 of word 0 from VLAN ID
685 if (netdev->priv_flags & IFF_802_1Q_VLAN)
686 vid = vlan_dev_vlan_id(netdev);
688 if (fcoe_get_wwn(netdev, &wwnn, NETDEV_FCOE_WWNN))
689 wwnn = fcoe_wwn_from_mac(fcoe->ctlr.ctl_src_addr, 1, 0);
690 fc_set_wwnn(lport, wwnn);
691 if (fcoe_get_wwn(netdev, &wwpn, NETDEV_FCOE_WWPN))
692 wwpn = fcoe_wwn_from_mac(fcoe->ctlr.ctl_src_addr,
694 fc_set_wwpn(lport, wwpn);
701 * fcoe_shost_config() - Set up the SCSI host associated with a local port
702 * @lport: The local port
703 * @dev: The device associated with the SCSI host
705 * Must be called after fcoe_lport_config() and fcoe_netdev_config()
707 * Returns: 0 for success
709 static int fcoe_shost_config(struct fc_lport *lport, struct device *dev)
713 /* lport scsi host config */
714 lport->host->max_lun = FCOE_MAX_LUN;
715 lport->host->max_id = FCOE_MAX_FCP_TARGET;
716 lport->host->max_channel = 0;
717 lport->host->max_cmd_len = FCOE_MAX_CMD_LEN;
720 lport->host->transportt = fcoe_vport_transport_template;
722 lport->host->transportt = fcoe_transport_template;
724 /* add the new host to the SCSI-ml */
725 rc = scsi_add_host(lport->host, dev);
727 FCOE_NETDEV_DBG(fcoe_netdev(lport), "fcoe_shost_config: "
728 "error on scsi_add_host\n");
733 fc_host_max_npiv_vports(lport->host) = USHRT_MAX;
735 snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
736 "%s v%s over %s", FCOE_NAME, FCOE_VERSION,
737 fcoe_netdev(lport)->name);
743 * fcoe_oem_match() - The match routine for the offloaded exchange manager
746 * This routine will be associated with an exchange manager (EM). When
747 * the libfc exchange handling code is looking for an EM to use it will
748 * call this routine and pass it the frame that it wishes to send. This
749 * routine will return True if the associated EM is to be used and False
750 * if the echange code should continue looking for an EM.
752 * The offload EM that this routine is associated with will handle any
753 * packets that are for SCSI read requests.
755 * Returns: True for read types I/O, otherwise returns false.
757 bool fcoe_oem_match(struct fc_frame *fp)
759 return fc_fcp_is_read(fr_fsp(fp)) &&
760 (fr_fsp(fp)->data_len > fcoe_ddp_min);
764 * fcoe_em_config() - Allocate and configure an exchange manager
765 * @lport: The local port that the new EM will be associated with
767 * Returns: 0 on success
769 static inline int fcoe_em_config(struct fc_lport *lport)
771 struct fcoe_port *port = lport_priv(lport);
772 struct fcoe_interface *fcoe = port->fcoe;
773 struct fcoe_interface *oldfcoe = NULL;
774 struct net_device *old_real_dev, *cur_real_dev;
775 u16 min_xid = FCOE_MIN_XID;
776 u16 max_xid = FCOE_MAX_XID;
779 * Check if need to allocate an em instance for
780 * offload exchange ids to be shared across all VN_PORTs/lport.
782 if (!lport->lro_enabled || !lport->lro_xid ||
783 (lport->lro_xid >= max_xid)) {
789 * Reuse existing offload em instance in case
790 * it is already allocated on real eth device
792 if (fcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
793 cur_real_dev = vlan_dev_real_dev(fcoe->netdev);
795 cur_real_dev = fcoe->netdev;
797 list_for_each_entry(oldfcoe, &fcoe_hostlist, list) {
798 if (oldfcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
799 old_real_dev = vlan_dev_real_dev(oldfcoe->netdev);
801 old_real_dev = oldfcoe->netdev;
803 if (cur_real_dev == old_real_dev) {
804 fcoe->oem = oldfcoe->oem;
810 if (!fc_exch_mgr_add(lport, fcoe->oem, fcoe_oem_match)) {
811 printk(KERN_ERR "fcoe_em_config: failed to add "
812 "offload em:%p on interface:%s\n",
813 fcoe->oem, fcoe->netdev->name);
817 fcoe->oem = fc_exch_mgr_alloc(lport, FC_CLASS_3,
818 FCOE_MIN_XID, lport->lro_xid,
821 printk(KERN_ERR "fcoe_em_config: failed to allocate "
822 "em for offload exches on interface:%s\n",
829 * Exclude offload EM xid range from next EM xid range.
831 min_xid += lport->lro_xid + 1;
834 if (!fc_exch_mgr_alloc(lport, FC_CLASS_3, min_xid, max_xid, NULL)) {
835 printk(KERN_ERR "fcoe_em_config: failed to "
836 "allocate em on interface %s\n", fcoe->netdev->name);
844 * fcoe_if_destroy() - Tear down a SW FCoE instance
845 * @lport: The local port to be destroyed
847 * Locking: must be called with the RTNL mutex held and RTNL mutex
848 * needed to be dropped by this function since not dropping RTNL
849 * would cause circular locking warning on synchronous fip worker
850 * cancelling thru fcoe_interface_put invoked by this function.
853 static void fcoe_if_destroy(struct fc_lport *lport)
855 struct fcoe_port *port = lport_priv(lport);
856 struct fcoe_interface *fcoe = port->fcoe;
857 struct net_device *netdev = fcoe->netdev;
859 FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
861 /* Logout of the fabric */
862 fc_fabric_logoff(lport);
864 /* Cleanup the fc_lport */
865 fc_lport_destroy(lport);
866 fc_fcp_destroy(lport);
868 /* Stop the transmit retry timer */
869 del_timer_sync(&port->timer);
871 /* Free existing transmit skbs */
872 fcoe_clean_pending_queue(lport);
874 if (!is_zero_ether_addr(port->data_src_addr))
875 dev_uc_del(netdev, port->data_src_addr);
878 /* receives may not be stopped until after this */
879 fcoe_interface_put(fcoe);
881 /* Free queued packets for the per-CPU receive threads */
882 fcoe_percpu_clean(lport);
884 /* Detach from the scsi-ml */
885 fc_remove_host(lport->host);
886 scsi_remove_host(lport->host);
888 /* There are no more rports or I/O, free the EM */
889 fc_exch_mgr_free(lport);
891 /* Free memory used by statistical counters */
892 fc_lport_free_stats(lport);
894 /* Release the Scsi_Host */
895 scsi_host_put(lport->host);
896 module_put(THIS_MODULE);
900 * fcoe_ddp_setup() - Call a LLD's ddp_setup through the net device
901 * @lport: The local port to setup DDP for
902 * @xid: The exchange ID for this DDP transfer
903 * @sgl: The scatterlist describing this transfer
904 * @sgc: The number of sg items
906 * Returns: 0 if the DDP context was not configured
908 static int fcoe_ddp_setup(struct fc_lport *lport, u16 xid,
909 struct scatterlist *sgl, unsigned int sgc)
911 struct net_device *netdev = fcoe_netdev(lport);
913 if (netdev->netdev_ops->ndo_fcoe_ddp_setup)
914 return netdev->netdev_ops->ndo_fcoe_ddp_setup(netdev,
922 * fcoe_ddp_done() - Call a LLD's ddp_done through the net device
923 * @lport: The local port to complete DDP on
924 * @xid: The exchange ID for this DDP transfer
926 * Returns: the length of data that have been completed by DDP
928 static int fcoe_ddp_done(struct fc_lport *lport, u16 xid)
930 struct net_device *netdev = fcoe_netdev(lport);
932 if (netdev->netdev_ops->ndo_fcoe_ddp_done)
933 return netdev->netdev_ops->ndo_fcoe_ddp_done(netdev, xid);
938 * fcoe_if_create() - Create a FCoE instance on an interface
939 * @fcoe: The FCoE interface to create a local port on
940 * @parent: The device pointer to be the parent in sysfs for the SCSI host
941 * @npiv: Indicates if the port is a vport or not
943 * Creates a fc_lport instance and a Scsi_Host instance and configure them.
945 * Returns: The allocated fc_lport or an error pointer
947 static struct fc_lport *fcoe_if_create(struct fcoe_interface *fcoe,
948 struct device *parent, int npiv)
950 struct net_device *netdev = fcoe->netdev;
951 struct fc_lport *lport = NULL;
952 struct fcoe_port *port;
955 * parent is only a vport if npiv is 1,
956 * but we'll only use vport in that case so go ahead and set it
958 struct fc_vport *vport = dev_to_vport(parent);
960 FCOE_NETDEV_DBG(netdev, "Create Interface\n");
963 lport = libfc_host_alloc(&fcoe_shost_template,
964 sizeof(struct fcoe_port));
966 lport = libfc_vport_create(vport,
967 sizeof(struct fcoe_port));
970 FCOE_NETDEV_DBG(netdev, "Could not allocate host structure\n");
974 port = lport_priv(lport);
977 INIT_WORK(&port->destroy_work, fcoe_destroy_work);
979 /* configure a fc_lport including the exchange manager */
980 rc = fcoe_lport_config(lport);
982 FCOE_NETDEV_DBG(netdev, "Could not configure lport for the "
988 FCOE_NETDEV_DBG(netdev, "Setting vport names, "
989 "%16.16llx %16.16llx\n",
990 vport->node_name, vport->port_name);
991 fc_set_wwnn(lport, vport->node_name);
992 fc_set_wwpn(lport, vport->port_name);
995 /* configure lport network properties */
996 rc = fcoe_netdev_config(lport, netdev);
998 FCOE_NETDEV_DBG(netdev, "Could not configure netdev for the "
1000 goto out_lp_destroy;
1003 /* configure lport scsi host properties */
1004 rc = fcoe_shost_config(lport, parent);
1006 FCOE_NETDEV_DBG(netdev, "Could not configure shost for the "
1008 goto out_lp_destroy;
1011 /* Initialize the library */
1012 rc = fcoe_libfc_config(lport, &fcoe->ctlr, &fcoe_libfc_fcn_templ, 1);
1014 FCOE_NETDEV_DBG(netdev, "Could not configure libfc for the "
1016 goto out_lp_destroy;
1021 * fcoe_em_alloc() and fcoe_hostlist_add() both
1022 * need to be atomic with respect to other changes to the
1023 * hostlist since fcoe_em_alloc() looks for an existing EM
1024 * instance on host list updated by fcoe_hostlist_add().
1026 * This is currently handled through the fcoe_config_mutex
1030 /* lport exch manager allocation */
1031 rc = fcoe_em_config(lport);
1033 FCOE_NETDEV_DBG(netdev, "Could not configure the EM "
1034 "for the interface\n");
1035 goto out_lp_destroy;
1039 fcoe_interface_get(fcoe);
1043 fc_exch_mgr_free(lport);
1045 scsi_host_put(lport->host);
1051 * fcoe_if_init() - Initialization routine for fcoe.ko
1053 * Attaches the SW FCoE transport to the FC transport
1055 * Returns: 0 on success
1057 static int __init fcoe_if_init(void)
1059 /* attach to scsi transport */
1060 fcoe_transport_template = fc_attach_transport(&fcoe_transport_function);
1061 fcoe_vport_transport_template =
1062 fc_attach_transport(&fcoe_vport_transport_function);
1064 if (!fcoe_transport_template) {
1065 printk(KERN_ERR "fcoe: Failed to attach to the FC transport\n");
1073 * fcoe_if_exit() - Tear down fcoe.ko
1075 * Detaches the SW FCoE transport from the FC transport
1077 * Returns: 0 on success
1079 int __exit fcoe_if_exit(void)
1081 fc_release_transport(fcoe_transport_template);
1082 fc_release_transport(fcoe_vport_transport_template);
1083 fcoe_transport_template = NULL;
1084 fcoe_vport_transport_template = NULL;
1089 * fcoe_percpu_thread_create() - Create a receive thread for an online CPU
1090 * @cpu: The CPU index of the CPU to create a receive thread for
1092 static void fcoe_percpu_thread_create(unsigned int cpu)
1094 struct fcoe_percpu_s *p;
1095 struct task_struct *thread;
1097 p = &per_cpu(fcoe_percpu, cpu);
1099 thread = kthread_create(fcoe_percpu_receive_thread,
1100 (void *)p, "fcoethread/%d", cpu);
1102 if (likely(!IS_ERR(thread))) {
1103 kthread_bind(thread, cpu);
1104 wake_up_process(thread);
1106 spin_lock_bh(&p->fcoe_rx_list.lock);
1108 spin_unlock_bh(&p->fcoe_rx_list.lock);
1113 * fcoe_percpu_thread_destroy() - Remove the receive thread of a CPU
1114 * @cpu: The CPU index of the CPU whose receive thread is to be destroyed
1116 * Destroys a per-CPU Rx thread. Any pending skbs are moved to the
1117 * current CPU's Rx thread. If the thread being destroyed is bound to
1118 * the CPU processing this context the skbs will be freed.
1120 static void fcoe_percpu_thread_destroy(unsigned int cpu)
1122 struct fcoe_percpu_s *p;
1123 struct task_struct *thread;
1124 struct page *crc_eof;
1125 struct sk_buff *skb;
1127 struct fcoe_percpu_s *p0;
1128 unsigned targ_cpu = get_cpu();
1129 #endif /* CONFIG_SMP */
1131 FCOE_DBG("Destroying receive thread for CPU %d\n", cpu);
1133 /* Prevent any new skbs from being queued for this CPU. */
1134 p = &per_cpu(fcoe_percpu, cpu);
1135 spin_lock_bh(&p->fcoe_rx_list.lock);
1138 crc_eof = p->crc_eof_page;
1139 p->crc_eof_page = NULL;
1140 p->crc_eof_offset = 0;
1141 spin_unlock_bh(&p->fcoe_rx_list.lock);
1145 * Don't bother moving the skb's if this context is running
1146 * on the same CPU that is having its thread destroyed. This
1147 * can easily happen when the module is removed.
1149 if (cpu != targ_cpu) {
1150 p0 = &per_cpu(fcoe_percpu, targ_cpu);
1151 spin_lock_bh(&p0->fcoe_rx_list.lock);
1153 FCOE_DBG("Moving frames from CPU %d to CPU %d\n",
1156 while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
1157 __skb_queue_tail(&p0->fcoe_rx_list, skb);
1158 spin_unlock_bh(&p0->fcoe_rx_list.lock);
1161 * The targeted CPU is not initialized and cannot accept
1162 * new skbs. Unlock the targeted CPU and drop the skbs
1163 * on the CPU that is going offline.
1165 while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
1167 spin_unlock_bh(&p0->fcoe_rx_list.lock);
1171 * This scenario occurs when the module is being removed
1172 * and all threads are being destroyed. skbs will continue
1173 * to be shifted from the CPU thread that is being removed
1174 * to the CPU thread associated with the CPU that is processing
1175 * the module removal. Once there is only one CPU Rx thread it
1176 * will reach this case and we will drop all skbs and later
1179 spin_lock_bh(&p->fcoe_rx_list.lock);
1180 while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
1182 spin_unlock_bh(&p->fcoe_rx_list.lock);
1187 * This a non-SMP scenario where the singular Rx thread is
1188 * being removed. Free all skbs and stop the thread.
1190 spin_lock_bh(&p->fcoe_rx_list.lock);
1191 while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
1193 spin_unlock_bh(&p->fcoe_rx_list.lock);
1197 kthread_stop(thread);
1204 * fcoe_cpu_callback() - Handler for CPU hotplug events
1205 * @nfb: The callback data block
1206 * @action: The event triggering the callback
1207 * @hcpu: The index of the CPU that the event is for
1209 * This creates or destroys per-CPU data for fcoe
1211 * Returns NOTIFY_OK always.
1213 static int fcoe_cpu_callback(struct notifier_block *nfb,
1214 unsigned long action, void *hcpu)
1216 unsigned cpu = (unsigned long)hcpu;
1220 case CPU_ONLINE_FROZEN:
1221 FCOE_DBG("CPU %x online: Create Rx thread\n", cpu);
1222 fcoe_percpu_thread_create(cpu);
1225 case CPU_DEAD_FROZEN:
1226 FCOE_DBG("CPU %x offline: Remove Rx thread\n", cpu);
1227 fcoe_percpu_thread_destroy(cpu);
1236 * fcoe_rcv() - Receive packets from a net device
1237 * @skb: The received packet
1238 * @netdev: The net device that the packet was received on
1239 * @ptype: The packet type context
1240 * @olddev: The last device net device
1242 * This routine is called by NET_RX_SOFTIRQ. It receives a packet, builds a
1243 * FC frame and passes the frame to libfc.
1245 * Returns: 0 for success
1247 int fcoe_rcv(struct sk_buff *skb, struct net_device *netdev,
1248 struct packet_type *ptype, struct net_device *olddev)
1250 struct fc_lport *lport;
1251 struct fcoe_rcv_info *fr;
1252 struct fcoe_interface *fcoe;
1253 struct fc_frame_header *fh;
1254 struct fcoe_percpu_s *fps;
1255 struct fcoe_port *port;
1259 fcoe = container_of(ptype, struct fcoe_interface, fcoe_packet_type);
1260 lport = fcoe->ctlr.lp;
1261 if (unlikely(!lport)) {
1262 FCOE_NETDEV_DBG(netdev, "Cannot find hba structure");
1265 if (!lport->link_up)
1268 FCOE_NETDEV_DBG(netdev, "skb_info: len:%d data_len:%d head:%p "
1269 "data:%p tail:%p end:%p sum:%d dev:%s",
1270 skb->len, skb->data_len, skb->head, skb->data,
1271 skb_tail_pointer(skb), skb_end_pointer(skb),
1272 skb->csum, skb->dev ? skb->dev->name : "<NULL>");
1274 /* check for mac addresses */
1276 port = lport_priv(lport);
1277 if (compare_ether_addr(eh->h_dest, port->data_src_addr) &&
1278 compare_ether_addr(eh->h_dest, fcoe->ctlr.ctl_src_addr) &&
1279 compare_ether_addr(eh->h_dest, (u8[6])FC_FCOE_FLOGI_MAC)) {
1280 FCOE_NETDEV_DBG(netdev, "wrong destination mac address:%pM\n",
1285 if (is_fip_mode(&fcoe->ctlr) &&
1286 compare_ether_addr(eh->h_source, fcoe->ctlr.dest_addr)) {
1287 FCOE_NETDEV_DBG(netdev, "wrong source mac address:%pM\n",
1293 * Check for minimum frame length, and make sure required FCoE
1294 * and FC headers are pulled into the linear data area.
1296 if (unlikely((skb->len < FCOE_MIN_FRAME) ||
1297 !pskb_may_pull(skb, FCOE_HEADER_LEN)))
1300 skb_set_transport_header(skb, sizeof(struct fcoe_hdr));
1301 fh = (struct fc_frame_header *) skb_transport_header(skb);
1303 fr = fcoe_dev_from_skb(skb);
1308 * In case the incoming frame's exchange is originated from
1309 * the initiator, then received frame's exchange id is ANDed
1310 * with fc_cpu_mask bits to get the same cpu on which exchange
1311 * was originated, otherwise just use the current cpu.
1313 if (ntoh24(fh->fh_f_ctl) & FC_FC_EX_CTX)
1314 cpu = ntohs(fh->fh_ox_id) & fc_cpu_mask;
1316 cpu = smp_processor_id();
1318 fps = &per_cpu(fcoe_percpu, cpu);
1319 spin_lock_bh(&fps->fcoe_rx_list.lock);
1320 if (unlikely(!fps->thread)) {
1322 * The targeted CPU is not ready, let's target
1323 * the first CPU now. For non-SMP systems this
1324 * will check the same CPU twice.
1326 FCOE_NETDEV_DBG(netdev, "CPU is online, but no receive thread "
1327 "ready for incoming skb- using first online "
1330 spin_unlock_bh(&fps->fcoe_rx_list.lock);
1331 cpu = cpumask_first(cpu_online_mask);
1332 fps = &per_cpu(fcoe_percpu, cpu);
1333 spin_lock_bh(&fps->fcoe_rx_list.lock);
1335 spin_unlock_bh(&fps->fcoe_rx_list.lock);
1341 * We now have a valid CPU that we're targeting for
1342 * this skb. We also have this receive thread locked,
1343 * so we're free to queue skbs into it's queue.
1346 /* If this is a SCSI-FCP frame, and this is already executing on the
1347 * correct CPU, and the queue for this CPU is empty, then go ahead
1348 * and process the frame directly in the softirq context.
1349 * This lets us process completions without context switching from the
1350 * NET_RX softirq, to our receive processing thread, and then back to
1351 * BLOCK softirq context.
1353 if (fh->fh_type == FC_TYPE_FCP &&
1354 cpu == smp_processor_id() &&
1355 skb_queue_empty(&fps->fcoe_rx_list)) {
1356 spin_unlock_bh(&fps->fcoe_rx_list.lock);
1357 fcoe_recv_frame(skb);
1359 __skb_queue_tail(&fps->fcoe_rx_list, skb);
1360 if (fps->fcoe_rx_list.qlen == 1)
1361 wake_up_process(fps->thread);
1362 spin_unlock_bh(&fps->fcoe_rx_list.lock);
1367 per_cpu_ptr(lport->dev_stats, get_cpu())->ErrorFrames++;
1375 * fcoe_start_io() - Start FCoE I/O
1376 * @skb: The packet to be transmitted
1378 * This routine is called from the net device to start transmitting
1381 * Returns: 0 for success
1383 static inline int fcoe_start_io(struct sk_buff *skb)
1385 struct sk_buff *nskb;
1388 nskb = skb_clone(skb, GFP_ATOMIC);
1389 rc = dev_queue_xmit(nskb);
1397 * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC
1398 * @skb: The packet to be transmitted
1399 * @tlen: The total length of the trailer
1401 * This routine allocates a page for frame trailers. The page is re-used if
1402 * there is enough room left on it for the current trailer. If there isn't
1403 * enough buffer left a new page is allocated for the trailer. Reference to
1404 * the page from this function as well as the skbs using the page fragments
1405 * ensure that the page is freed at the appropriate time.
1407 * Returns: 0 for success
1409 static int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen)
1411 struct fcoe_percpu_s *fps;
1414 fps = &get_cpu_var(fcoe_percpu);
1415 page = fps->crc_eof_page;
1417 page = alloc_page(GFP_ATOMIC);
1419 put_cpu_var(fcoe_percpu);
1422 fps->crc_eof_page = page;
1423 fps->crc_eof_offset = 0;
1427 skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page,
1428 fps->crc_eof_offset, tlen);
1430 skb->data_len += tlen;
1431 skb->truesize += tlen;
1432 fps->crc_eof_offset += sizeof(struct fcoe_crc_eof);
1434 if (fps->crc_eof_offset >= PAGE_SIZE) {
1435 fps->crc_eof_page = NULL;
1436 fps->crc_eof_offset = 0;
1439 put_cpu_var(fcoe_percpu);
1444 * fcoe_fc_crc() - Calculates the CRC for a given frame
1445 * @fp: The frame to be checksumed
1447 * This uses crc32() routine to calculate the CRC for a frame
1449 * Return: The 32 bit CRC value
1451 u32 fcoe_fc_crc(struct fc_frame *fp)
1453 struct sk_buff *skb = fp_skb(fp);
1454 struct skb_frag_struct *frag;
1455 unsigned char *data;
1456 unsigned long off, len, clen;
1460 crc = crc32(~0, skb->data, skb_headlen(skb));
1462 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1463 frag = &skb_shinfo(skb)->frags[i];
1464 off = frag->page_offset;
1467 clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
1468 data = kmap_atomic(frag->page + (off >> PAGE_SHIFT),
1469 KM_SKB_DATA_SOFTIRQ);
1470 crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
1471 kunmap_atomic(data, KM_SKB_DATA_SOFTIRQ);
1480 * fcoe_xmit() - Transmit a FCoE frame
1481 * @lport: The local port that the frame is to be transmitted for
1482 * @fp: The frame to be transmitted
1484 * Return: 0 for success
1486 int fcoe_xmit(struct fc_lport *lport, struct fc_frame *fp)
1491 struct fcoe_crc_eof *cp;
1492 struct sk_buff *skb;
1493 struct fcoe_dev_stats *stats;
1494 struct fc_frame_header *fh;
1495 unsigned int hlen; /* header length implies the version */
1496 unsigned int tlen; /* trailer length */
1497 unsigned int elen; /* eth header, may include vlan */
1498 struct fcoe_port *port = lport_priv(lport);
1499 struct fcoe_interface *fcoe = port->fcoe;
1501 struct fcoe_hdr *hp;
1503 WARN_ON((fr_len(fp) % sizeof(u32)) != 0);
1505 fh = fc_frame_header_get(fp);
1507 wlen = skb->len / FCOE_WORD_TO_BYTE;
1509 if (!lport->link_up) {
1514 if (unlikely(fh->fh_type == FC_TYPE_ELS) &&
1515 fcoe_ctlr_els_send(&fcoe->ctlr, lport, skb))
1521 elen = sizeof(struct ethhdr);
1522 hlen = sizeof(struct fcoe_hdr);
1523 tlen = sizeof(struct fcoe_crc_eof);
1524 wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;
1527 if (likely(lport->crc_offload)) {
1528 skb->ip_summed = CHECKSUM_PARTIAL;
1529 skb->csum_start = skb_headroom(skb);
1530 skb->csum_offset = skb->len;
1533 skb->ip_summed = CHECKSUM_NONE;
1534 crc = fcoe_fc_crc(fp);
1537 /* copy port crc and eof to the skb buff */
1538 if (skb_is_nonlinear(skb)) {
1540 if (fcoe_get_paged_crc_eof(skb, tlen)) {
1544 frag = &skb_shinfo(skb)->frags[skb_shinfo(skb)->nr_frags - 1];
1545 cp = kmap_atomic(frag->page, KM_SKB_DATA_SOFTIRQ)
1546 + frag->page_offset;
1548 cp = (struct fcoe_crc_eof *)skb_put(skb, tlen);
1551 memset(cp, 0, sizeof(*cp));
1553 cp->fcoe_crc32 = cpu_to_le32(~crc);
1555 if (skb_is_nonlinear(skb)) {
1556 kunmap_atomic(cp, KM_SKB_DATA_SOFTIRQ);
1560 /* adjust skb network/transport offsets to match mac/fcoe/port */
1561 skb_push(skb, elen + hlen);
1562 skb_reset_mac_header(skb);
1563 skb_reset_network_header(skb);
1564 skb->mac_len = elen;
1565 skb->protocol = htons(ETH_P_FCOE);
1566 skb->dev = fcoe->netdev;
1568 /* fill up mac and fcoe headers */
1570 eh->h_proto = htons(ETH_P_FCOE);
1571 memcpy(eh->h_dest, fcoe->ctlr.dest_addr, ETH_ALEN);
1572 if (fcoe->ctlr.map_dest)
1573 memcpy(eh->h_dest + 3, fh->fh_d_id, 3);
1575 if (unlikely(fcoe->ctlr.flogi_oxid != FC_XID_UNKNOWN))
1576 memcpy(eh->h_source, fcoe->ctlr.ctl_src_addr, ETH_ALEN);
1578 memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);
1580 hp = (struct fcoe_hdr *)(eh + 1);
1581 memset(hp, 0, sizeof(*hp));
1583 FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
1586 /* fcoe lso, mss is in max_payload which is non-zero for FCP data */
1587 if (lport->seq_offload && fr_max_payload(fp)) {
1588 skb_shinfo(skb)->gso_type = SKB_GSO_FCOE;
1589 skb_shinfo(skb)->gso_size = fr_max_payload(fp);
1591 skb_shinfo(skb)->gso_type = 0;
1592 skb_shinfo(skb)->gso_size = 0;
1594 /* update tx stats: regardless if LLD fails */
1595 stats = per_cpu_ptr(lport->dev_stats, get_cpu());
1597 stats->TxWords += wlen;
1600 /* send down to lld */
1602 if (port->fcoe_pending_queue.qlen)
1603 fcoe_check_wait_queue(lport, skb);
1604 else if (fcoe_start_io(skb))
1605 fcoe_check_wait_queue(lport, skb);
1611 * fcoe_percpu_flush_done() - Indicate per-CPU queue flush completion
1612 * @skb: The completed skb (argument required by destructor)
1614 static void fcoe_percpu_flush_done(struct sk_buff *skb)
1616 complete(&fcoe_flush_completion);
1620 * fcoe_recv_frame() - process a single received frame
1621 * @skb: frame to process
1623 static void fcoe_recv_frame(struct sk_buff *skb)
1626 struct fc_lport *lport;
1627 struct fcoe_rcv_info *fr;
1628 struct fcoe_dev_stats *stats;
1629 struct fc_frame_header *fh;
1630 struct fcoe_crc_eof crc_eof;
1631 struct fc_frame *fp;
1632 struct fcoe_port *port;
1633 struct fcoe_hdr *hp;
1635 fr = fcoe_dev_from_skb(skb);
1637 if (unlikely(!lport)) {
1638 if (skb->destructor != fcoe_percpu_flush_done)
1639 FCOE_NETDEV_DBG(skb->dev, "NULL lport in skb");
1644 FCOE_NETDEV_DBG(skb->dev, "skb_info: len:%d data_len:%d "
1645 "head:%p data:%p tail:%p end:%p sum:%d dev:%s",
1646 skb->len, skb->data_len,
1647 skb->head, skb->data, skb_tail_pointer(skb),
1648 skb_end_pointer(skb), skb->csum,
1649 skb->dev ? skb->dev->name : "<NULL>");
1651 port = lport_priv(lport);
1652 if (skb_is_nonlinear(skb))
1653 skb_linearize(skb); /* not ideal */
1656 * Frame length checks and setting up the header pointers
1657 * was done in fcoe_rcv already.
1659 hp = (struct fcoe_hdr *) skb_network_header(skb);
1660 fh = (struct fc_frame_header *) skb_transport_header(skb);
1662 stats = per_cpu_ptr(lport->dev_stats, get_cpu());
1663 if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
1664 if (stats->ErrorFrames < 5)
1665 printk(KERN_WARNING "fcoe: FCoE version "
1666 "mismatch: The frame has "
1667 "version %x, but the "
1668 "initiator supports version "
1669 "%x\n", FC_FCOE_DECAPS_VER(hp),
1674 skb_pull(skb, sizeof(struct fcoe_hdr));
1675 fr_len = skb->len - sizeof(struct fcoe_crc_eof);
1678 stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;
1680 fp = (struct fc_frame *)skb;
1683 fr_sof(fp) = hp->fcoe_sof;
1685 /* Copy out the CRC and EOF trailer for access */
1686 if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof)))
1688 fr_eof(fp) = crc_eof.fcoe_eof;
1689 fr_crc(fp) = crc_eof.fcoe_crc32;
1690 if (pskb_trim(skb, fr_len))
1694 * We only check CRC if no offload is available and if it is
1695 * it's solicited data, in which case, the FCP layer would
1696 * check it during the copy.
1698 if (lport->crc_offload &&
1699 skb->ip_summed == CHECKSUM_UNNECESSARY)
1700 fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
1702 fr_flags(fp) |= FCPHF_CRC_UNCHECKED;
1704 fh = fc_frame_header_get(fp);
1705 if ((fh->fh_r_ctl != FC_RCTL_DD_SOL_DATA ||
1706 fh->fh_type != FC_TYPE_FCP) &&
1707 (fr_flags(fp) & FCPHF_CRC_UNCHECKED)) {
1708 if (le32_to_cpu(fr_crc(fp)) !=
1709 ~crc32(~0, skb->data, fr_len)) {
1710 if (stats->InvalidCRCCount < 5)
1711 printk(KERN_WARNING "fcoe: dropping "
1712 "frame with CRC error\n");
1713 stats->InvalidCRCCount++;
1716 fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
1719 fc_exch_recv(lport, fp);
1723 stats->ErrorFrames++;
1729 * fcoe_percpu_receive_thread() - The per-CPU packet receive thread
1730 * @arg: The per-CPU context
1732 * Return: 0 for success
1734 int fcoe_percpu_receive_thread(void *arg)
1736 struct fcoe_percpu_s *p = arg;
1737 struct sk_buff *skb;
1739 set_user_nice(current, -20);
1741 while (!kthread_should_stop()) {
1743 spin_lock_bh(&p->fcoe_rx_list.lock);
1744 while ((skb = __skb_dequeue(&p->fcoe_rx_list)) == NULL) {
1745 set_current_state(TASK_INTERRUPTIBLE);
1746 spin_unlock_bh(&p->fcoe_rx_list.lock);
1748 set_current_state(TASK_RUNNING);
1749 if (kthread_should_stop())
1751 spin_lock_bh(&p->fcoe_rx_list.lock);
1753 spin_unlock_bh(&p->fcoe_rx_list.lock);
1754 fcoe_recv_frame(skb);
1760 * fcoe_check_wait_queue() - Attempt to clear the transmit backlog
1761 * @lport: The local port whose backlog is to be cleared
1763 * This empties the wait_queue, dequeues the head of the wait_queue queue
1764 * and calls fcoe_start_io() for each packet. If all skb have been
1765 * transmitted it returns the qlen. If an error occurs it restores
1766 * wait_queue (to try again later) and returns -1.
1768 * The wait_queue is used when the skb transmit fails. The failed skb
1769 * will go in the wait_queue which will be emptied by the timer function or
1770 * by the next skb transmit.
1772 static void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb)
1774 struct fcoe_port *port = lport_priv(lport);
1777 spin_lock_bh(&port->fcoe_pending_queue.lock);
1780 __skb_queue_tail(&port->fcoe_pending_queue, skb);
1782 if (port->fcoe_pending_queue_active)
1784 port->fcoe_pending_queue_active = 1;
1786 while (port->fcoe_pending_queue.qlen) {
1787 /* keep qlen > 0 until fcoe_start_io succeeds */
1788 port->fcoe_pending_queue.qlen++;
1789 skb = __skb_dequeue(&port->fcoe_pending_queue);
1791 spin_unlock_bh(&port->fcoe_pending_queue.lock);
1792 rc = fcoe_start_io(skb);
1793 spin_lock_bh(&port->fcoe_pending_queue.lock);
1796 __skb_queue_head(&port->fcoe_pending_queue, skb);
1797 /* undo temporary increment above */
1798 port->fcoe_pending_queue.qlen--;
1801 /* undo temporary increment above */
1802 port->fcoe_pending_queue.qlen--;
1805 if (port->fcoe_pending_queue.qlen < FCOE_LOW_QUEUE_DEPTH)
1807 if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer))
1808 mod_timer(&port->timer, jiffies + 2);
1809 port->fcoe_pending_queue_active = 0;
1811 if (port->fcoe_pending_queue.qlen > FCOE_MAX_QUEUE_DEPTH)
1813 spin_unlock_bh(&port->fcoe_pending_queue.lock);
1818 * fcoe_dev_setup() - Setup the link change notification interface
1820 static void fcoe_dev_setup(void)
1822 register_netdevice_notifier(&fcoe_notifier);
1826 * fcoe_dev_cleanup() - Cleanup the link change notification interface
1828 static void fcoe_dev_cleanup(void)
1830 unregister_netdevice_notifier(&fcoe_notifier);
1834 * fcoe_device_notification() - Handler for net device events
1835 * @notifier: The context of the notification
1836 * @event: The type of event
1837 * @ptr: The net device that the event was on
1839 * This function is called by the Ethernet driver in case of link change event.
1841 * Returns: 0 for success
1843 static int fcoe_device_notification(struct notifier_block *notifier,
1844 ulong event, void *ptr)
1846 struct fc_lport *lport = NULL;
1847 struct net_device *netdev = ptr;
1848 struct fcoe_interface *fcoe;
1849 struct fcoe_port *port;
1850 struct fcoe_dev_stats *stats;
1851 u32 link_possible = 1;
1855 list_for_each_entry(fcoe, &fcoe_hostlist, list) {
1856 if (fcoe->netdev == netdev) {
1857 lport = fcoe->ctlr.lp;
1868 case NETDEV_GOING_DOWN:
1874 case NETDEV_CHANGEMTU:
1875 if (netdev->features & NETIF_F_FCOE_MTU)
1877 mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
1878 sizeof(struct fcoe_crc_eof));
1879 if (mfs >= FC_MIN_MAX_FRAME)
1880 fc_set_mfs(lport, mfs);
1882 case NETDEV_REGISTER:
1884 case NETDEV_UNREGISTER:
1885 list_del(&fcoe->list);
1886 port = lport_priv(fcoe->ctlr.lp);
1887 fcoe_interface_cleanup(fcoe);
1888 schedule_work(&port->destroy_work);
1891 case NETDEV_FEAT_CHANGE:
1892 fcoe_netdev_features_change(lport, netdev);
1895 FCOE_NETDEV_DBG(netdev, "Unknown event %ld "
1896 "from netdev netlink\n", event);
1899 fcoe_link_speed_update(lport);
1901 if (link_possible && !fcoe_link_ok(lport))
1902 fcoe_ctlr_link_up(&fcoe->ctlr);
1903 else if (fcoe_ctlr_link_down(&fcoe->ctlr)) {
1904 stats = per_cpu_ptr(lport->dev_stats, get_cpu());
1905 stats->LinkFailureCount++;
1907 fcoe_clean_pending_queue(lport);
1914 * fcoe_if_to_netdev() - Parse a name buffer to get a net device
1915 * @buffer: The name of the net device
1917 * Returns: NULL or a ptr to net_device
1919 static struct net_device *fcoe_if_to_netdev(const char *buffer)
1922 char ifname[IFNAMSIZ + 2];
1925 strlcpy(ifname, buffer, IFNAMSIZ);
1926 cp = ifname + strlen(ifname);
1927 while (--cp >= ifname && *cp == '\n')
1929 return dev_get_by_name(&init_net, ifname);
1935 * fcoe_disable() - Disables a FCoE interface
1936 * @buffer: The name of the Ethernet interface to be disabled
1937 * @kp: The associated kernel parameter
1939 * Called from sysfs.
1941 * Returns: 0 for success
1943 static int fcoe_disable(const char *buffer, struct kernel_param *kp)
1945 struct fcoe_interface *fcoe;
1946 struct net_device *netdev;
1949 mutex_lock(&fcoe_config_mutex);
1950 #ifdef CONFIG_FCOE_MODULE
1952 * Make sure the module has been initialized, and is not about to be
1953 * removed. Module paramter sysfs files are writable before the
1954 * module_init function is called and after module_exit.
1956 if (THIS_MODULE->state != MODULE_STATE_LIVE) {
1962 netdev = fcoe_if_to_netdev(buffer);
1968 if (!rtnl_trylock()) {
1970 mutex_unlock(&fcoe_config_mutex);
1971 return restart_syscall();
1974 fcoe = fcoe_hostlist_lookup_port(netdev);
1978 fcoe_ctlr_link_down(&fcoe->ctlr);
1979 fcoe_clean_pending_queue(fcoe->ctlr.lp);
1985 mutex_unlock(&fcoe_config_mutex);
1990 * fcoe_enable() - Enables a FCoE interface
1991 * @buffer: The name of the Ethernet interface to be enabled
1992 * @kp: The associated kernel parameter
1994 * Called from sysfs.
1996 * Returns: 0 for success
1998 static int fcoe_enable(const char *buffer, struct kernel_param *kp)
2000 struct fcoe_interface *fcoe;
2001 struct net_device *netdev;
2004 mutex_lock(&fcoe_config_mutex);
2005 #ifdef CONFIG_FCOE_MODULE
2007 * Make sure the module has been initialized, and is not about to be
2008 * removed. Module paramter sysfs files are writable before the
2009 * module_init function is called and after module_exit.
2011 if (THIS_MODULE->state != MODULE_STATE_LIVE) {
2017 netdev = fcoe_if_to_netdev(buffer);
2023 if (!rtnl_trylock()) {
2025 mutex_unlock(&fcoe_config_mutex);
2026 return restart_syscall();
2029 fcoe = fcoe_hostlist_lookup_port(netdev);
2034 else if (!fcoe_link_ok(fcoe->ctlr.lp))
2035 fcoe_ctlr_link_up(&fcoe->ctlr);
2039 mutex_unlock(&fcoe_config_mutex);
2044 * fcoe_destroy() - Destroy a FCoE interface
2045 * @buffer: The name of the Ethernet interface to be destroyed
2046 * @kp: The associated kernel parameter
2048 * Called from sysfs.
2050 * Returns: 0 for success
2052 static int fcoe_destroy(const char *buffer, struct kernel_param *kp)
2054 struct fcoe_interface *fcoe;
2055 struct net_device *netdev;
2058 mutex_lock(&fcoe_config_mutex);
2059 #ifdef CONFIG_FCOE_MODULE
2061 * Make sure the module has been initialized, and is not about to be
2062 * removed. Module paramter sysfs files are writable before the
2063 * module_init function is called and after module_exit.
2065 if (THIS_MODULE->state != MODULE_STATE_LIVE) {
2071 netdev = fcoe_if_to_netdev(buffer);
2077 if (!rtnl_trylock()) {
2079 mutex_unlock(&fcoe_config_mutex);
2080 return restart_syscall();
2083 fcoe = fcoe_hostlist_lookup_port(netdev);
2089 fcoe_interface_cleanup(fcoe);
2090 list_del(&fcoe->list);
2091 /* RTNL mutex is dropped by fcoe_if_destroy */
2092 fcoe_if_destroy(fcoe->ctlr.lp);
2097 mutex_unlock(&fcoe_config_mutex);
2102 * fcoe_destroy_work() - Destroy a FCoE port in a deferred work context
2103 * @work: Handle to the FCoE port to be destroyed
2105 static void fcoe_destroy_work(struct work_struct *work)
2107 struct fcoe_port *port;
2109 port = container_of(work, struct fcoe_port, destroy_work);
2110 mutex_lock(&fcoe_config_mutex);
2112 /* RTNL mutex is dropped by fcoe_if_destroy */
2113 fcoe_if_destroy(port->lport);
2114 mutex_unlock(&fcoe_config_mutex);
2118 * fcoe_create() - Create a fcoe interface
2119 * @buffer: The name of the Ethernet interface to create on
2120 * @kp: The associated kernel param
2122 * Called from sysfs.
2124 * Returns: 0 for success
2126 static int fcoe_create(const char *buffer, struct kernel_param *kp)
2128 enum fip_state fip_mode = (enum fip_state)(long)kp->arg;
2130 struct fcoe_interface *fcoe;
2131 struct fc_lport *lport;
2132 struct net_device *netdev;
2134 mutex_lock(&fcoe_config_mutex);
2136 if (!rtnl_trylock()) {
2137 mutex_unlock(&fcoe_config_mutex);
2138 return restart_syscall();
2141 #ifdef CONFIG_FCOE_MODULE
2143 * Make sure the module has been initialized, and is not about to be
2144 * removed. Module paramter sysfs files are writable before the
2145 * module_init function is called and after module_exit.
2147 if (THIS_MODULE->state != MODULE_STATE_LIVE) {
2153 if (!try_module_get(THIS_MODULE)) {
2158 netdev = fcoe_if_to_netdev(buffer);
2164 /* look for existing lport */
2165 if (fcoe_hostlist_lookup(netdev)) {
2170 fcoe = fcoe_interface_create(netdev, fip_mode);
2176 lport = fcoe_if_create(fcoe, &netdev->dev, 0);
2177 if (IS_ERR(lport)) {
2178 printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
2181 fcoe_interface_cleanup(fcoe);
2185 /* Make this the "master" N_Port */
2186 fcoe->ctlr.lp = lport;
2188 /* add to lports list */
2189 fcoe_hostlist_add(lport);
2191 /* start FIP Discovery and FLOGI */
2192 lport->boot_time = jiffies;
2193 fc_fabric_login(lport);
2194 if (!fcoe_link_ok(lport))
2195 fcoe_ctlr_link_up(&fcoe->ctlr);
2198 * Release from init in fcoe_interface_create(), on success lport
2199 * should be holding a reference taken in fcoe_if_create().
2201 fcoe_interface_put(fcoe);
2204 mutex_unlock(&fcoe_config_mutex);
2208 fcoe_interface_put(fcoe);
2212 module_put(THIS_MODULE);
2215 mutex_unlock(&fcoe_config_mutex);
2220 * fcoe_link_speed_update() - Update the supported and actual link speeds
2221 * @lport: The local port to update speeds for
2223 * Returns: 0 if the ethtool query was successful
2224 * -1 if the ethtool query failed
2226 int fcoe_link_speed_update(struct fc_lport *lport)
2228 struct fcoe_port *port = lport_priv(lport);
2229 struct net_device *netdev = port->fcoe->netdev;
2230 struct ethtool_cmd ecmd = { ETHTOOL_GSET };
2232 if (!dev_ethtool_get_settings(netdev, &ecmd)) {
2233 lport->link_supported_speeds &=
2234 ~(FC_PORTSPEED_1GBIT | FC_PORTSPEED_10GBIT);
2235 if (ecmd.supported & (SUPPORTED_1000baseT_Half |
2236 SUPPORTED_1000baseT_Full))
2237 lport->link_supported_speeds |= FC_PORTSPEED_1GBIT;
2238 if (ecmd.supported & SUPPORTED_10000baseT_Full)
2239 lport->link_supported_speeds |=
2240 FC_PORTSPEED_10GBIT;
2241 if (ecmd.speed == SPEED_1000)
2242 lport->link_speed = FC_PORTSPEED_1GBIT;
2243 if (ecmd.speed == SPEED_10000)
2244 lport->link_speed = FC_PORTSPEED_10GBIT;
2252 * fcoe_link_ok() - Check if the link is OK for a local port
2253 * @lport: The local port to check link on
2255 * Returns: 0 if link is UP and OK, -1 if not
2258 int fcoe_link_ok(struct fc_lport *lport)
2260 struct fcoe_port *port = lport_priv(lport);
2261 struct net_device *netdev = port->fcoe->netdev;
2263 if (netif_oper_up(netdev))
2269 * fcoe_percpu_clean() - Clear all pending skbs for an local port
2270 * @lport: The local port whose skbs are to be cleared
2272 * Must be called with fcoe_create_mutex held to single-thread completion.
2274 * This flushes the pending skbs by adding a new skb to each queue and
2275 * waiting until they are all freed. This assures us that not only are
2276 * there no packets that will be handled by the lport, but also that any
2277 * threads already handling packet have returned.
2279 void fcoe_percpu_clean(struct fc_lport *lport)
2281 struct fcoe_percpu_s *pp;
2282 struct fcoe_rcv_info *fr;
2283 struct sk_buff_head *list;
2284 struct sk_buff *skb, *next;
2285 struct sk_buff *head;
2288 for_each_possible_cpu(cpu) {
2289 pp = &per_cpu(fcoe_percpu, cpu);
2290 spin_lock_bh(&pp->fcoe_rx_list.lock);
2291 list = &pp->fcoe_rx_list;
2293 for (skb = head; skb != (struct sk_buff *)list;
2296 fr = fcoe_dev_from_skb(skb);
2297 if (fr->fr_dev == lport) {
2298 __skb_unlink(skb, list);
2303 if (!pp->thread || !cpu_online(cpu)) {
2304 spin_unlock_bh(&pp->fcoe_rx_list.lock);
2308 skb = dev_alloc_skb(0);
2310 spin_unlock_bh(&pp->fcoe_rx_list.lock);
2313 skb->destructor = fcoe_percpu_flush_done;
2315 __skb_queue_tail(&pp->fcoe_rx_list, skb);
2316 if (pp->fcoe_rx_list.qlen == 1)
2317 wake_up_process(pp->thread);
2318 spin_unlock_bh(&pp->fcoe_rx_list.lock);
2320 wait_for_completion(&fcoe_flush_completion);
2325 * fcoe_clean_pending_queue() - Dequeue a skb and free it
2326 * @lport: The local port to dequeue a skb on
2328 void fcoe_clean_pending_queue(struct fc_lport *lport)
2330 struct fcoe_port *port = lport_priv(lport);
2331 struct sk_buff *skb;
2333 spin_lock_bh(&port->fcoe_pending_queue.lock);
2334 while ((skb = __skb_dequeue(&port->fcoe_pending_queue)) != NULL) {
2335 spin_unlock_bh(&port->fcoe_pending_queue.lock);
2337 spin_lock_bh(&port->fcoe_pending_queue.lock);
2339 spin_unlock_bh(&port->fcoe_pending_queue.lock);
2343 * fcoe_reset() - Reset a local port
2344 * @shost: The SCSI host associated with the local port to be reset
2346 * Returns: Always 0 (return value required by FC transport template)
2348 int fcoe_reset(struct Scsi_Host *shost)
2350 struct fc_lport *lport = shost_priv(shost);
2351 fc_lport_reset(lport);
2356 * fcoe_hostlist_lookup_port() - Find the FCoE interface associated with a net device
2357 * @netdev: The net device used as a key
2359 * Locking: Must be called with the RNL mutex held.
2361 * Returns: NULL or the FCoE interface
2363 static struct fcoe_interface *
2364 fcoe_hostlist_lookup_port(const struct net_device *netdev)
2366 struct fcoe_interface *fcoe;
2368 list_for_each_entry(fcoe, &fcoe_hostlist, list) {
2369 if (fcoe->netdev == netdev)
2376 * fcoe_hostlist_lookup() - Find the local port associated with a
2378 * @netdev: The netdevice used as a key
2380 * Locking: Must be called with the RTNL mutex held
2382 * Returns: NULL or the local port
2384 static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *netdev)
2386 struct fcoe_interface *fcoe;
2388 fcoe = fcoe_hostlist_lookup_port(netdev);
2389 return (fcoe) ? fcoe->ctlr.lp : NULL;
2393 * fcoe_hostlist_add() - Add the FCoE interface identified by a local
2394 * port to the hostlist
2395 * @lport: The local port that identifies the FCoE interface to be added
2397 * Locking: must be called with the RTNL mutex held
2399 * Returns: 0 for success
2401 static int fcoe_hostlist_add(const struct fc_lport *lport)
2403 struct fcoe_interface *fcoe;
2404 struct fcoe_port *port;
2406 fcoe = fcoe_hostlist_lookup_port(fcoe_netdev(lport));
2408 port = lport_priv(lport);
2410 list_add_tail(&fcoe->list, &fcoe_hostlist);
2416 * fcoe_init() - Initialize fcoe.ko
2418 * Returns: 0 on success, or a negative value on failure
2420 static int __init fcoe_init(void)
2422 struct fcoe_percpu_s *p;
2426 mutex_lock(&fcoe_config_mutex);
2428 for_each_possible_cpu(cpu) {
2429 p = &per_cpu(fcoe_percpu, cpu);
2430 skb_queue_head_init(&p->fcoe_rx_list);
2433 for_each_online_cpu(cpu)
2434 fcoe_percpu_thread_create(cpu);
2436 /* Initialize per CPU interrupt thread */
2437 rc = register_hotcpu_notifier(&fcoe_cpu_notifier);
2441 /* Setup link change notification */
2444 rc = fcoe_if_init();
2448 mutex_unlock(&fcoe_config_mutex);
2452 for_each_online_cpu(cpu) {
2453 fcoe_percpu_thread_destroy(cpu);
2455 mutex_unlock(&fcoe_config_mutex);
2458 module_init(fcoe_init);
2461 * fcoe_exit() - Clean up fcoe.ko
2463 * Returns: 0 on success or a negative value on failure
2465 static void __exit fcoe_exit(void)
2467 struct fcoe_interface *fcoe, *tmp;
2468 struct fcoe_port *port;
2471 mutex_lock(&fcoe_config_mutex);
2475 /* releases the associated fcoe hosts */
2477 list_for_each_entry_safe(fcoe, tmp, &fcoe_hostlist, list) {
2478 list_del(&fcoe->list);
2479 port = lport_priv(fcoe->ctlr.lp);
2480 fcoe_interface_cleanup(fcoe);
2481 schedule_work(&port->destroy_work);
2485 unregister_hotcpu_notifier(&fcoe_cpu_notifier);
2487 for_each_online_cpu(cpu)
2488 fcoe_percpu_thread_destroy(cpu);
2490 mutex_unlock(&fcoe_config_mutex);
2492 /* flush any asyncronous interface destroys,
2493 * this should happen after the netdev notifier is unregistered */
2494 flush_scheduled_work();
2495 /* That will flush out all the N_Ports on the hostlist, but now we
2496 * may have NPIV VN_Ports scheduled for destruction */
2497 flush_scheduled_work();
2499 /* detach from scsi transport
2500 * must happen after all destroys are done, therefor after the flush */
2503 module_exit(fcoe_exit);
2506 * fcoe_flogi_resp() - FCoE specific FLOGI and FDISC response handler
2507 * @seq: active sequence in the FLOGI or FDISC exchange
2508 * @fp: response frame, or error encoded in a pointer (timeout)
2509 * @arg: pointer the the fcoe_ctlr structure
2511 * This handles MAC address managment for FCoE, then passes control on to
2512 * the libfc FLOGI response handler.
2514 static void fcoe_flogi_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
2516 struct fcoe_ctlr *fip = arg;
2517 struct fc_exch *exch = fc_seq_exch(seq);
2518 struct fc_lport *lport = exch->lp;
2524 mac = fr_cb(fp)->granted_mac;
2525 if (is_zero_ether_addr(mac)) {
2527 if (fcoe_ctlr_recv_flogi(fip, lport, fp)) {
2532 fcoe_update_src_mac(lport, mac);
2534 fc_lport_flogi_resp(seq, fp, lport);
2538 * fcoe_logo_resp() - FCoE specific LOGO response handler
2539 * @seq: active sequence in the LOGO exchange
2540 * @fp: response frame, or error encoded in a pointer (timeout)
2541 * @arg: pointer the the fcoe_ctlr structure
2543 * This handles MAC address managment for FCoE, then passes control on to
2544 * the libfc LOGO response handler.
2546 static void fcoe_logo_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
2548 struct fc_lport *lport = arg;
2549 static u8 zero_mac[ETH_ALEN] = { 0 };
2552 fcoe_update_src_mac(lport, zero_mac);
2553 fc_lport_logo_resp(seq, fp, lport);
2557 * fcoe_elsct_send - FCoE specific ELS handler
2559 * This does special case handling of FIP encapsualted ELS exchanges for FCoE,
2560 * using FCoE specific response handlers and passing the FIP controller as
2561 * the argument (the lport is still available from the exchange).
2563 * Most of the work here is just handed off to the libfc routine.
2565 static struct fc_seq *fcoe_elsct_send(struct fc_lport *lport, u32 did,
2566 struct fc_frame *fp, unsigned int op,
2567 void (*resp)(struct fc_seq *,
2570 void *arg, u32 timeout)
2572 struct fcoe_port *port = lport_priv(lport);
2573 struct fcoe_interface *fcoe = port->fcoe;
2574 struct fcoe_ctlr *fip = &fcoe->ctlr;
2575 struct fc_frame_header *fh = fc_frame_header_get(fp);
2580 if (lport->point_to_multipoint)
2582 return fc_elsct_send(lport, did, fp, op, fcoe_flogi_resp,
2585 /* only hook onto fabric logouts, not port logouts */
2586 if (ntoh24(fh->fh_d_id) != FC_FID_FLOGI)
2588 return fc_elsct_send(lport, did, fp, op, fcoe_logo_resp,
2591 return fc_elsct_send(lport, did, fp, op, resp, arg, timeout);
2595 * fcoe_vport_create() - create an fc_host/scsi_host for a vport
2596 * @vport: fc_vport object to create a new fc_host for
2597 * @disabled: start the new fc_host in a disabled state by default?
2599 * Returns: 0 for success
2601 static int fcoe_vport_create(struct fc_vport *vport, bool disabled)
2603 struct Scsi_Host *shost = vport_to_shost(vport);
2604 struct fc_lport *n_port = shost_priv(shost);
2605 struct fcoe_port *port = lport_priv(n_port);
2606 struct fcoe_interface *fcoe = port->fcoe;
2607 struct net_device *netdev = fcoe->netdev;
2608 struct fc_lport *vn_port;
2610 mutex_lock(&fcoe_config_mutex);
2611 vn_port = fcoe_if_create(fcoe, &vport->dev, 1);
2612 mutex_unlock(&fcoe_config_mutex);
2614 if (IS_ERR(vn_port)) {
2615 printk(KERN_ERR "fcoe: fcoe_vport_create(%s) failed\n",
2621 fc_vport_set_state(vport, FC_VPORT_DISABLED);
2623 vn_port->boot_time = jiffies;
2624 fc_fabric_login(vn_port);
2625 fc_vport_setlink(vn_port);
2631 * fcoe_vport_destroy() - destroy the fc_host/scsi_host for a vport
2632 * @vport: fc_vport object that is being destroyed
2634 * Returns: 0 for success
2636 static int fcoe_vport_destroy(struct fc_vport *vport)
2638 struct Scsi_Host *shost = vport_to_shost(vport);
2639 struct fc_lport *n_port = shost_priv(shost);
2640 struct fc_lport *vn_port = vport->dd_data;
2641 struct fcoe_port *port = lport_priv(vn_port);
2643 mutex_lock(&n_port->lp_mutex);
2644 list_del(&vn_port->list);
2645 mutex_unlock(&n_port->lp_mutex);
2646 schedule_work(&port->destroy_work);
2651 * fcoe_vport_disable() - change vport state
2652 * @vport: vport to bring online/offline
2653 * @disable: should the vport be disabled?
2655 static int fcoe_vport_disable(struct fc_vport *vport, bool disable)
2657 struct fc_lport *lport = vport->dd_data;
2660 fc_vport_set_state(vport, FC_VPORT_DISABLED);
2661 fc_fabric_logoff(lport);
2663 lport->boot_time = jiffies;
2664 fc_fabric_login(lport);
2665 fc_vport_setlink(lport);
2672 * fcoe_vport_set_symbolic_name() - append vport string to symbolic name
2673 * @vport: fc_vport with a new symbolic name string
2675 * After generating a new symbolic name string, a new RSPN_ID request is
2676 * sent to the name server. There is no response handler, so if it fails
2677 * for some reason it will not be retried.
2679 static void fcoe_set_vport_symbolic_name(struct fc_vport *vport)
2681 struct fc_lport *lport = vport->dd_data;
2682 struct fc_frame *fp;
2685 snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
2686 "%s v%s over %s : %s", FCOE_NAME, FCOE_VERSION,
2687 fcoe_netdev(lport)->name, vport->symbolic_name);
2689 if (lport->state != LPORT_ST_READY)
2692 len = strnlen(fc_host_symbolic_name(lport->host), 255);
2693 fp = fc_frame_alloc(lport,
2694 sizeof(struct fc_ct_hdr) +
2695 sizeof(struct fc_ns_rspn) + len);
2698 lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RSPN_ID,
2699 NULL, NULL, 3 * lport->r_a_tov);
2703 * fcoe_get_lesb() - Fill the FCoE Link Error Status Block
2704 * @lport: the local port
2705 * @fc_lesb: the link error status block
2707 static void fcoe_get_lesb(struct fc_lport *lport,
2708 struct fc_els_lesb *fc_lesb)
2711 u32 lfc, vlfc, mdac;
2712 struct fcoe_dev_stats *devst;
2713 struct fcoe_fc_els_lesb *lesb;
2714 struct net_device *netdev = fcoe_netdev(lport);
2719 lesb = (struct fcoe_fc_els_lesb *)fc_lesb;
2720 memset(lesb, 0, sizeof(*lesb));
2721 for_each_possible_cpu(cpu) {
2722 devst = per_cpu_ptr(lport->dev_stats, cpu);
2723 lfc += devst->LinkFailureCount;
2724 vlfc += devst->VLinkFailureCount;
2725 mdac += devst->MissDiscAdvCount;
2727 lesb->lesb_link_fail = htonl(lfc);
2728 lesb->lesb_vlink_fail = htonl(vlfc);
2729 lesb->lesb_miss_fka = htonl(mdac);
2730 lesb->lesb_fcs_error = htonl(dev_get_stats(netdev)->rx_crc_errors);
2734 * fcoe_set_port_id() - Callback from libfc when Port_ID is set.
2735 * @lport: the local port
2736 * @port_id: the port ID
2737 * @fp: the received frame, if any, that caused the port_id to be set.
2739 * This routine handles the case where we received a FLOGI and are
2740 * entering point-to-point mode. We need to call fcoe_ctlr_recv_flogi()
2741 * so it can set the non-mapped mode and gateway address.
2743 * The FLOGI LS_ACC is handled by fcoe_flogi_resp().
2745 static void fcoe_set_port_id(struct fc_lport *lport,
2746 u32 port_id, struct fc_frame *fp)
2748 struct fcoe_port *port = lport_priv(lport);
2749 struct fcoe_interface *fcoe = port->fcoe;
2751 if (fp && fc_frame_payload_op(fp) == ELS_FLOGI)
2752 fcoe_ctlr_recv_flogi(&fcoe->ctlr, lport, fp);