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/spinlock.h>
22 #include <linux/netdevice.h>
23 #include <linux/etherdevice.h>
24 #include <linux/ethtool.h>
25 #include <linux/if_ether.h>
26 #include <linux/if_vlan.h>
27 #include <linux/crc32.h>
28 #include <linux/slab.h>
29 #include <linux/cpu.h>
31 #include <linux/sysfs.h>
32 #include <linux/ctype.h>
33 #include <linux/workqueue.h>
34 #include <net/dcbnl.h>
35 #include <net/dcbevent.h>
36 #include <scsi/scsi_tcq.h>
37 #include <scsi/scsicam.h>
38 #include <scsi/scsi_transport.h>
39 #include <scsi/scsi_transport_fc.h>
40 #include <net/rtnetlink.h>
42 #include <scsi/fc/fc_encaps.h>
43 #include <scsi/fc/fc_fip.h>
45 #include <scsi/libfc.h>
46 #include <scsi/fc_frame.h>
47 #include <scsi/libfcoe.h>
51 MODULE_AUTHOR("Open-FCoE.org");
52 MODULE_DESCRIPTION("FCoE");
53 MODULE_LICENSE("GPL v2");
55 /* Performance tuning parameters for fcoe */
56 static unsigned int fcoe_ddp_min
= 4096;
57 module_param_named(ddp_min
, fcoe_ddp_min
, uint
, S_IRUGO
| S_IWUSR
);
58 MODULE_PARM_DESC(ddp_min
, "Minimum I/O size in bytes for " \
59 "Direct Data Placement (DDP).");
61 unsigned int fcoe_debug_logging
;
62 module_param_named(debug_logging
, fcoe_debug_logging
, int, S_IRUGO
|S_IWUSR
);
63 MODULE_PARM_DESC(debug_logging
, "a bit mask of logging levels");
65 static DEFINE_MUTEX(fcoe_config_mutex
);
67 static struct workqueue_struct
*fcoe_wq
;
69 /* fcoe_percpu_clean completion. Waiter protected by fcoe_create_mutex */
70 static DECLARE_COMPLETION(fcoe_flush_completion
);
73 /* must only by accessed under the RTNL mutex */
74 static LIST_HEAD(fcoe_hostlist
);
75 static DEFINE_PER_CPU(struct fcoe_percpu_s
, fcoe_percpu
);
77 /* Function Prototypes */
78 static int fcoe_reset(struct Scsi_Host
*);
79 static int fcoe_xmit(struct fc_lport
*, struct fc_frame
*);
80 static int fcoe_rcv(struct sk_buff
*, struct net_device
*,
81 struct packet_type
*, struct net_device
*);
82 static int fcoe_percpu_receive_thread(void *);
83 static void fcoe_percpu_clean(struct fc_lport
*);
84 static int fcoe_link_speed_update(struct fc_lport
*);
85 static int fcoe_link_ok(struct fc_lport
*);
87 static struct fc_lport
*fcoe_hostlist_lookup(const struct net_device
*);
88 static int fcoe_hostlist_add(const struct fc_lport
*);
90 static int fcoe_device_notification(struct notifier_block
*, ulong
, void *);
91 static void fcoe_dev_setup(void);
92 static void fcoe_dev_cleanup(void);
93 static struct fcoe_interface
94 *fcoe_hostlist_lookup_port(const struct net_device
*);
96 static int fcoe_fip_recv(struct sk_buff
*, struct net_device
*,
97 struct packet_type
*, struct net_device
*);
99 static void fcoe_fip_send(struct fcoe_ctlr
*, struct sk_buff
*);
100 static void fcoe_update_src_mac(struct fc_lport
*, u8
*);
101 static u8
*fcoe_get_src_mac(struct fc_lport
*);
102 static void fcoe_destroy_work(struct work_struct
*);
104 static int fcoe_ddp_setup(struct fc_lport
*, u16
, struct scatterlist
*,
106 static int fcoe_ddp_done(struct fc_lport
*, u16
);
107 static int fcoe_ddp_target(struct fc_lport
*, u16
, struct scatterlist
*,
109 static int fcoe_cpu_callback(struct notifier_block
*, unsigned long, void *);
110 static int fcoe_dcb_app_notification(struct notifier_block
*notifier
,
111 ulong event
, void *ptr
);
113 static bool fcoe_match(struct net_device
*netdev
);
114 static int fcoe_create(struct net_device
*netdev
, enum fip_state fip_mode
);
115 static int fcoe_destroy(struct net_device
*netdev
);
116 static int fcoe_enable(struct net_device
*netdev
);
117 static int fcoe_disable(struct net_device
*netdev
);
119 static struct fc_seq
*fcoe_elsct_send(struct fc_lport
*,
120 u32 did
, struct fc_frame
*,
122 void (*resp
)(struct fc_seq
*,
125 void *, u32 timeout
);
126 static void fcoe_recv_frame(struct sk_buff
*skb
);
128 static void fcoe_get_lesb(struct fc_lport
*, struct fc_els_lesb
*);
130 /* notification function for packets from net device */
131 static struct notifier_block fcoe_notifier
= {
132 .notifier_call
= fcoe_device_notification
,
135 /* notification function for CPU hotplug events */
136 static struct notifier_block fcoe_cpu_notifier
= {
137 .notifier_call
= fcoe_cpu_callback
,
140 /* notification function for DCB events */
141 static struct notifier_block dcb_notifier
= {
142 .notifier_call
= fcoe_dcb_app_notification
,
145 static struct scsi_transport_template
*fcoe_nport_scsi_transport
;
146 static struct scsi_transport_template
*fcoe_vport_scsi_transport
;
148 static int fcoe_vport_destroy(struct fc_vport
*);
149 static int fcoe_vport_create(struct fc_vport
*, bool disabled
);
150 static int fcoe_vport_disable(struct fc_vport
*, bool disable
);
151 static void fcoe_set_vport_symbolic_name(struct fc_vport
*);
152 static void fcoe_set_port_id(struct fc_lport
*, u32
, struct fc_frame
*);
154 static struct libfc_function_template fcoe_libfc_fcn_templ
= {
155 .frame_send
= fcoe_xmit
,
156 .ddp_setup
= fcoe_ddp_setup
,
157 .ddp_done
= fcoe_ddp_done
,
158 .ddp_target
= fcoe_ddp_target
,
159 .elsct_send
= fcoe_elsct_send
,
160 .get_lesb
= fcoe_get_lesb
,
161 .lport_set_port_id
= fcoe_set_port_id
,
164 static struct fc_function_template fcoe_nport_fc_functions
= {
165 .show_host_node_name
= 1,
166 .show_host_port_name
= 1,
167 .show_host_supported_classes
= 1,
168 .show_host_supported_fc4s
= 1,
169 .show_host_active_fc4s
= 1,
170 .show_host_maxframe_size
= 1,
171 .show_host_serial_number
= 1,
172 .show_host_manufacturer
= 1,
173 .show_host_model
= 1,
174 .show_host_model_description
= 1,
175 .show_host_hardware_version
= 1,
176 .show_host_driver_version
= 1,
177 .show_host_firmware_version
= 1,
178 .show_host_optionrom_version
= 1,
180 .show_host_port_id
= 1,
181 .show_host_supported_speeds
= 1,
182 .get_host_speed
= fc_get_host_speed
,
183 .show_host_speed
= 1,
184 .show_host_port_type
= 1,
185 .get_host_port_state
= fc_get_host_port_state
,
186 .show_host_port_state
= 1,
187 .show_host_symbolic_name
= 1,
189 .dd_fcrport_size
= sizeof(struct fc_rport_libfc_priv
),
190 .show_rport_maxframe_size
= 1,
191 .show_rport_supported_classes
= 1,
193 .show_host_fabric_name
= 1,
194 .show_starget_node_name
= 1,
195 .show_starget_port_name
= 1,
196 .show_starget_port_id
= 1,
197 .set_rport_dev_loss_tmo
= fc_set_rport_loss_tmo
,
198 .show_rport_dev_loss_tmo
= 1,
199 .get_fc_host_stats
= fc_get_host_stats
,
200 .issue_fc_host_lip
= fcoe_reset
,
202 .terminate_rport_io
= fc_rport_terminate_io
,
204 .vport_create
= fcoe_vport_create
,
205 .vport_delete
= fcoe_vport_destroy
,
206 .vport_disable
= fcoe_vport_disable
,
207 .set_vport_symbolic_name
= fcoe_set_vport_symbolic_name
,
209 .bsg_request
= fc_lport_bsg_request
,
212 static struct fc_function_template fcoe_vport_fc_functions
= {
213 .show_host_node_name
= 1,
214 .show_host_port_name
= 1,
215 .show_host_supported_classes
= 1,
216 .show_host_supported_fc4s
= 1,
217 .show_host_active_fc4s
= 1,
218 .show_host_maxframe_size
= 1,
219 .show_host_serial_number
= 1,
220 .show_host_manufacturer
= 1,
221 .show_host_model
= 1,
222 .show_host_model_description
= 1,
223 .show_host_hardware_version
= 1,
224 .show_host_driver_version
= 1,
225 .show_host_firmware_version
= 1,
226 .show_host_optionrom_version
= 1,
228 .show_host_port_id
= 1,
229 .show_host_supported_speeds
= 1,
230 .get_host_speed
= fc_get_host_speed
,
231 .show_host_speed
= 1,
232 .show_host_port_type
= 1,
233 .get_host_port_state
= fc_get_host_port_state
,
234 .show_host_port_state
= 1,
235 .show_host_symbolic_name
= 1,
237 .dd_fcrport_size
= sizeof(struct fc_rport_libfc_priv
),
238 .show_rport_maxframe_size
= 1,
239 .show_rport_supported_classes
= 1,
241 .show_host_fabric_name
= 1,
242 .show_starget_node_name
= 1,
243 .show_starget_port_name
= 1,
244 .show_starget_port_id
= 1,
245 .set_rport_dev_loss_tmo
= fc_set_rport_loss_tmo
,
246 .show_rport_dev_loss_tmo
= 1,
247 .get_fc_host_stats
= fc_get_host_stats
,
248 .issue_fc_host_lip
= fcoe_reset
,
250 .terminate_rport_io
= fc_rport_terminate_io
,
252 .bsg_request
= fc_lport_bsg_request
,
255 static struct scsi_host_template fcoe_shost_template
= {
256 .module
= THIS_MODULE
,
257 .name
= "FCoE Driver",
258 .proc_name
= FCOE_NAME
,
259 .queuecommand
= fc_queuecommand
,
260 .eh_abort_handler
= fc_eh_abort
,
261 .eh_device_reset_handler
= fc_eh_device_reset
,
262 .eh_host_reset_handler
= fc_eh_host_reset
,
263 .slave_alloc
= fc_slave_alloc
,
264 .change_queue_depth
= fc_change_queue_depth
,
265 .change_queue_type
= fc_change_queue_type
,
268 .can_queue
= FCOE_MAX_OUTSTANDING_COMMANDS
,
269 .use_clustering
= ENABLE_CLUSTERING
,
270 .sg_tablesize
= SG_ALL
,
271 .max_sectors
= 0xffff,
275 * fcoe_interface_setup() - Setup a FCoE interface
276 * @fcoe: The new FCoE interface
277 * @netdev: The net device that the fcoe interface is on
279 * Returns : 0 for success
280 * Locking: must be called with the RTNL mutex held
282 static int fcoe_interface_setup(struct fcoe_interface
*fcoe
,
283 struct net_device
*netdev
)
285 struct fcoe_ctlr
*fip
= &fcoe
->ctlr
;
286 struct netdev_hw_addr
*ha
;
287 struct net_device
*real_dev
;
288 u8 flogi_maddr
[ETH_ALEN
];
289 const struct net_device_ops
*ops
;
291 fcoe
->netdev
= netdev
;
293 /* Let LLD initialize for FCoE */
294 ops
= netdev
->netdev_ops
;
295 if (ops
->ndo_fcoe_enable
) {
296 if (ops
->ndo_fcoe_enable(netdev
))
297 FCOE_NETDEV_DBG(netdev
, "Failed to enable FCoE"
298 " specific feature for LLD.\n");
301 /* Do not support for bonding device */
302 if (netdev
->priv_flags
& IFF_BONDING
&& netdev
->flags
& IFF_MASTER
) {
303 FCOE_NETDEV_DBG(netdev
, "Bonded interfaces not supported\n");
307 /* look for SAN MAC address, if multiple SAN MACs exist, only
308 * use the first one for SPMA */
309 real_dev
= (netdev
->priv_flags
& IFF_802_1Q_VLAN
) ?
310 vlan_dev_real_dev(netdev
) : netdev
;
311 fcoe
->realdev
= real_dev
;
313 for_each_dev_addr(real_dev
, ha
) {
314 if ((ha
->type
== NETDEV_HW_ADDR_T_SAN
) &&
315 (is_valid_ether_addr(ha
->addr
))) {
316 memcpy(fip
->ctl_src_addr
, ha
->addr
, ETH_ALEN
);
323 /* setup Source Mac Address */
325 memcpy(fip
->ctl_src_addr
, netdev
->dev_addr
, netdev
->addr_len
);
328 * Add FCoE MAC address as second unicast MAC address
329 * or enter promiscuous mode if not capable of listening
330 * for multiple unicast MACs.
332 memcpy(flogi_maddr
, (u8
[6]) FC_FCOE_FLOGI_MAC
, ETH_ALEN
);
333 dev_uc_add(netdev
, flogi_maddr
);
335 dev_uc_add(netdev
, fip
->ctl_src_addr
);
336 if (fip
->mode
== FIP_MODE_VN2VN
) {
337 dev_mc_add(netdev
, FIP_ALL_VN2VN_MACS
);
338 dev_mc_add(netdev
, FIP_ALL_P2P_MACS
);
340 dev_mc_add(netdev
, FIP_ALL_ENODE_MACS
);
343 * setup the receive function from ethernet driver
344 * on the ethertype for the given device
346 fcoe
->fcoe_packet_type
.func
= fcoe_rcv
;
347 fcoe
->fcoe_packet_type
.type
= __constant_htons(ETH_P_FCOE
);
348 fcoe
->fcoe_packet_type
.dev
= netdev
;
349 dev_add_pack(&fcoe
->fcoe_packet_type
);
351 fcoe
->fip_packet_type
.func
= fcoe_fip_recv
;
352 fcoe
->fip_packet_type
.type
= htons(ETH_P_FIP
);
353 fcoe
->fip_packet_type
.dev
= netdev
;
354 dev_add_pack(&fcoe
->fip_packet_type
);
360 * fcoe_interface_create() - Create a FCoE interface on a net device
361 * @netdev: The net device to create the FCoE interface on
362 * @fip_mode: The mode to use for FIP
364 * Returns: pointer to a struct fcoe_interface or NULL on error
366 static struct fcoe_interface
*fcoe_interface_create(struct net_device
*netdev
,
367 enum fip_state fip_mode
)
369 struct fcoe_interface
*fcoe
;
372 if (!try_module_get(THIS_MODULE
)) {
373 FCOE_NETDEV_DBG(netdev
,
374 "Could not get a reference to the module\n");
375 fcoe
= ERR_PTR(-EBUSY
);
379 fcoe
= kzalloc(sizeof(*fcoe
), GFP_KERNEL
);
381 FCOE_NETDEV_DBG(netdev
, "Could not allocate fcoe structure\n");
382 fcoe
= ERR_PTR(-ENOMEM
);
391 fcoe_ctlr_init(&fcoe
->ctlr
, fip_mode
);
392 fcoe
->ctlr
.send
= fcoe_fip_send
;
393 fcoe
->ctlr
.update_mac
= fcoe_update_src_mac
;
394 fcoe
->ctlr
.get_src_addr
= fcoe_get_src_mac
;
396 err
= fcoe_interface_setup(fcoe
, netdev
);
398 fcoe_ctlr_destroy(&fcoe
->ctlr
);
408 module_put(THIS_MODULE
);
414 * fcoe_interface_remove() - remove FCoE interface from netdev
415 * @fcoe: The FCoE interface to be cleaned up
417 * Caller must be holding the RTNL mutex
419 static void fcoe_interface_remove(struct fcoe_interface
*fcoe
)
421 struct net_device
*netdev
= fcoe
->netdev
;
422 struct fcoe_ctlr
*fip
= &fcoe
->ctlr
;
423 u8 flogi_maddr
[ETH_ALEN
];
424 const struct net_device_ops
*ops
;
427 * Don't listen for Ethernet packets anymore.
428 * synchronize_net() ensures that the packet handlers are not running
429 * on another CPU. dev_remove_pack() would do that, this calls the
430 * unsyncronized version __dev_remove_pack() to avoid multiple delays.
432 __dev_remove_pack(&fcoe
->fcoe_packet_type
);
433 __dev_remove_pack(&fcoe
->fip_packet_type
);
436 /* Delete secondary MAC addresses */
437 memcpy(flogi_maddr
, (u8
[6]) FC_FCOE_FLOGI_MAC
, ETH_ALEN
);
438 dev_uc_del(netdev
, flogi_maddr
);
440 dev_uc_del(netdev
, fip
->ctl_src_addr
);
441 if (fip
->mode
== FIP_MODE_VN2VN
) {
442 dev_mc_del(netdev
, FIP_ALL_VN2VN_MACS
);
443 dev_mc_del(netdev
, FIP_ALL_P2P_MACS
);
445 dev_mc_del(netdev
, FIP_ALL_ENODE_MACS
);
447 /* Tell the LLD we are done w/ FCoE */
448 ops
= netdev
->netdev_ops
;
449 if (ops
->ndo_fcoe_disable
) {
450 if (ops
->ndo_fcoe_disable(netdev
))
451 FCOE_NETDEV_DBG(netdev
, "Failed to disable FCoE"
452 " specific feature for LLD.\n");
459 * fcoe_interface_cleanup() - Clean up a FCoE interface
460 * @fcoe: The FCoE interface to be cleaned up
462 static void fcoe_interface_cleanup(struct fcoe_interface
*fcoe
)
464 struct net_device
*netdev
= fcoe
->netdev
;
465 struct fcoe_ctlr
*fip
= &fcoe
->ctlr
;
469 fcoe_interface_remove(fcoe
);
472 /* Release the self-reference taken during fcoe_interface_create() */
473 /* tear-down the FCoE controller */
474 fcoe_ctlr_destroy(fip
);
475 scsi_host_put(fcoe
->ctlr
.lp
->host
);
478 module_put(THIS_MODULE
);
482 * fcoe_fip_recv() - Handler for received FIP frames
483 * @skb: The receive skb
484 * @netdev: The associated net device
485 * @ptype: The packet_type structure which was used to register this handler
486 * @orig_dev: The original net_device the the skb was received on.
487 * (in case dev is a bond)
489 * Returns: 0 for success
491 static int fcoe_fip_recv(struct sk_buff
*skb
, struct net_device
*netdev
,
492 struct packet_type
*ptype
,
493 struct net_device
*orig_dev
)
495 struct fcoe_interface
*fcoe
;
497 fcoe
= container_of(ptype
, struct fcoe_interface
, fip_packet_type
);
498 fcoe_ctlr_recv(&fcoe
->ctlr
, skb
);
503 * fcoe_port_send() - Send an Ethernet-encapsulated FIP/FCoE frame
504 * @port: The FCoE port
505 * @skb: The FIP/FCoE packet to be sent
507 static void fcoe_port_send(struct fcoe_port
*port
, struct sk_buff
*skb
)
509 if (port
->fcoe_pending_queue
.qlen
)
510 fcoe_check_wait_queue(port
->lport
, skb
);
511 else if (fcoe_start_io(skb
))
512 fcoe_check_wait_queue(port
->lport
, skb
);
516 * fcoe_fip_send() - Send an Ethernet-encapsulated FIP frame
517 * @fip: The FCoE controller
518 * @skb: The FIP packet to be sent
520 static void fcoe_fip_send(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
522 skb
->dev
= fcoe_from_ctlr(fip
)->netdev
;
523 fcoe_port_send(lport_priv(fip
->lp
), skb
);
527 * fcoe_update_src_mac() - Update the Ethernet MAC filters
528 * @lport: The local port to update the source MAC on
529 * @addr: Unicast MAC address to add
531 * Remove any previously-set unicast MAC filter.
532 * Add secondary FCoE MAC address filter for our OUI.
534 static void fcoe_update_src_mac(struct fc_lport
*lport
, u8
*addr
)
536 struct fcoe_port
*port
= lport_priv(lport
);
537 struct fcoe_interface
*fcoe
= port
->priv
;
539 if (!is_zero_ether_addr(port
->data_src_addr
))
540 dev_uc_del(fcoe
->netdev
, port
->data_src_addr
);
541 if (!is_zero_ether_addr(addr
))
542 dev_uc_add(fcoe
->netdev
, addr
);
543 memcpy(port
->data_src_addr
, addr
, ETH_ALEN
);
547 * fcoe_get_src_mac() - return the Ethernet source address for an lport
548 * @lport: libfc lport
550 static u8
*fcoe_get_src_mac(struct fc_lport
*lport
)
552 struct fcoe_port
*port
= lport_priv(lport
);
554 return port
->data_src_addr
;
558 * fcoe_lport_config() - Set up a local port
559 * @lport: The local port to be setup
561 * Returns: 0 for success
563 static int fcoe_lport_config(struct fc_lport
*lport
)
567 lport
->max_retry_count
= 3;
568 lport
->max_rport_retry_count
= 3;
569 lport
->e_d_tov
= 2 * 1000; /* FC-FS default */
570 lport
->r_a_tov
= 2 * 2 * 1000;
571 lport
->service_params
= (FCP_SPPF_INIT_FCN
| FCP_SPPF_RD_XRDY_DIS
|
572 FCP_SPPF_RETRY
| FCP_SPPF_CONF_COMPL
);
573 lport
->does_npiv
= 1;
575 fc_lport_init_stats(lport
);
577 /* lport fc_lport related configuration */
578 fc_lport_config(lport
);
580 /* offload related configuration */
581 lport
->crc_offload
= 0;
582 lport
->seq_offload
= 0;
583 lport
->lro_enabled
= 0;
591 * fcoe_netdev_features_change - Updates the lport's offload flags based
592 * on the LLD netdev's FCoE feature flags
594 static void fcoe_netdev_features_change(struct fc_lport
*lport
,
595 struct net_device
*netdev
)
597 mutex_lock(&lport
->lp_mutex
);
599 if (netdev
->features
& NETIF_F_SG
)
604 if (netdev
->features
& NETIF_F_FCOE_CRC
) {
605 lport
->crc_offload
= 1;
606 FCOE_NETDEV_DBG(netdev
, "Supports FCCRC offload\n");
608 lport
->crc_offload
= 0;
611 if (netdev
->features
& NETIF_F_FSO
) {
612 lport
->seq_offload
= 1;
613 lport
->lso_max
= netdev
->gso_max_size
;
614 FCOE_NETDEV_DBG(netdev
, "Supports LSO for max len 0x%x\n",
617 lport
->seq_offload
= 0;
621 if (netdev
->fcoe_ddp_xid
) {
622 lport
->lro_enabled
= 1;
623 lport
->lro_xid
= netdev
->fcoe_ddp_xid
;
624 FCOE_NETDEV_DBG(netdev
, "Supports LRO for max xid 0x%x\n",
627 lport
->lro_enabled
= 0;
631 mutex_unlock(&lport
->lp_mutex
);
635 * fcoe_netdev_config() - Set up net devive for SW FCoE
636 * @lport: The local port that is associated with the net device
637 * @netdev: The associated net device
639 * Must be called after fcoe_lport_config() as it will use local port mutex
641 * Returns: 0 for success
643 static int fcoe_netdev_config(struct fc_lport
*lport
, struct net_device
*netdev
)
647 struct fcoe_interface
*fcoe
;
648 struct fcoe_port
*port
;
650 /* Setup lport private data to point to fcoe softc */
651 port
= lport_priv(lport
);
655 * Determine max frame size based on underlying device and optional
656 * user-configured limit. If the MFS is too low, fcoe_link_ok()
657 * will return 0, so do this first.
660 if (netdev
->features
& NETIF_F_FCOE_MTU
) {
662 FCOE_NETDEV_DBG(netdev
, "Supports FCOE_MTU of %d bytes\n", mfs
);
664 mfs
-= (sizeof(struct fcoe_hdr
) + sizeof(struct fcoe_crc_eof
));
665 if (fc_set_mfs(lport
, mfs
))
668 /* offload features support */
669 fcoe_netdev_features_change(lport
, netdev
);
671 skb_queue_head_init(&port
->fcoe_pending_queue
);
672 port
->fcoe_pending_queue_active
= 0;
673 setup_timer(&port
->timer
, fcoe_queue_timer
, (unsigned long)lport
);
675 fcoe_link_speed_update(lport
);
678 if (fcoe_get_wwn(netdev
, &wwnn
, NETDEV_FCOE_WWNN
))
679 wwnn
= fcoe_wwn_from_mac(fcoe
->ctlr
.ctl_src_addr
, 1, 0);
680 fc_set_wwnn(lport
, wwnn
);
681 if (fcoe_get_wwn(netdev
, &wwpn
, NETDEV_FCOE_WWPN
))
682 wwpn
= fcoe_wwn_from_mac(fcoe
->ctlr
.ctl_src_addr
,
684 fc_set_wwpn(lport
, wwpn
);
691 * fcoe_shost_config() - Set up the SCSI host associated with a local port
692 * @lport: The local port
693 * @dev: The device associated with the SCSI host
695 * Must be called after fcoe_lport_config() and fcoe_netdev_config()
697 * Returns: 0 for success
699 static int fcoe_shost_config(struct fc_lport
*lport
, struct device
*dev
)
703 /* lport scsi host config */
704 lport
->host
->max_lun
= FCOE_MAX_LUN
;
705 lport
->host
->max_id
= FCOE_MAX_FCP_TARGET
;
706 lport
->host
->max_channel
= 0;
707 lport
->host
->max_cmd_len
= FCOE_MAX_CMD_LEN
;
710 lport
->host
->transportt
= fcoe_vport_scsi_transport
;
712 lport
->host
->transportt
= fcoe_nport_scsi_transport
;
714 /* add the new host to the SCSI-ml */
715 rc
= scsi_add_host(lport
->host
, dev
);
717 FCOE_NETDEV_DBG(fcoe_netdev(lport
), "fcoe_shost_config: "
718 "error on scsi_add_host\n");
723 fc_host_max_npiv_vports(lport
->host
) = USHRT_MAX
;
725 snprintf(fc_host_symbolic_name(lport
->host
), FC_SYMBOLIC_NAME_SIZE
,
726 "%s v%s over %s", FCOE_NAME
, FCOE_VERSION
,
727 fcoe_netdev(lport
)->name
);
734 * fcoe_fdmi_info() - Get FDMI related info from net devive for SW FCoE
735 * @lport: The local port that is associated with the net device
736 * @netdev: The associated net device
738 * Must be called after fcoe_shost_config() as it will use local port mutex
741 static void fcoe_fdmi_info(struct fc_lport
*lport
, struct net_device
*netdev
)
743 struct fcoe_interface
*fcoe
;
744 struct fcoe_port
*port
;
745 struct net_device
*realdev
;
747 struct netdev_fcoe_hbainfo fdmi
;
749 port
= lport_priv(lport
);
751 realdev
= fcoe
->realdev
;
756 /* No FDMI state m/c for NPIV ports */
760 if (realdev
->netdev_ops
->ndo_fcoe_get_hbainfo
) {
761 memset(&fdmi
, 0, sizeof(fdmi
));
762 rc
= realdev
->netdev_ops
->ndo_fcoe_get_hbainfo(realdev
,
765 printk(KERN_INFO
"fcoe: Failed to retrieve FDMI "
766 "information from netdev.\n");
770 snprintf(fc_host_serial_number(lport
->host
),
771 FC_SERIAL_NUMBER_SIZE
,
774 snprintf(fc_host_manufacturer(lport
->host
),
775 FC_SERIAL_NUMBER_SIZE
,
778 snprintf(fc_host_model(lport
->host
),
779 FC_SYMBOLIC_NAME_SIZE
,
782 snprintf(fc_host_model_description(lport
->host
),
783 FC_SYMBOLIC_NAME_SIZE
,
785 fdmi
.model_description
);
786 snprintf(fc_host_hardware_version(lport
->host
),
787 FC_VERSION_STRING_SIZE
,
789 fdmi
.hardware_version
);
790 snprintf(fc_host_driver_version(lport
->host
),
791 FC_VERSION_STRING_SIZE
,
793 fdmi
.driver_version
);
794 snprintf(fc_host_optionrom_version(lport
->host
),
795 FC_VERSION_STRING_SIZE
,
797 fdmi
.optionrom_version
);
798 snprintf(fc_host_firmware_version(lport
->host
),
799 FC_VERSION_STRING_SIZE
,
801 fdmi
.firmware_version
);
803 /* Enable FDMI lport states */
804 lport
->fdmi_enabled
= 1;
806 lport
->fdmi_enabled
= 0;
807 printk(KERN_INFO
"fcoe: No FDMI support.\n");
812 * fcoe_oem_match() - The match routine for the offloaded exchange manager
815 * This routine will be associated with an exchange manager (EM). When
816 * the libfc exchange handling code is looking for an EM to use it will
817 * call this routine and pass it the frame that it wishes to send. This
818 * routine will return True if the associated EM is to be used and False
819 * if the echange code should continue looking for an EM.
821 * The offload EM that this routine is associated with will handle any
822 * packets that are for SCSI read requests.
824 * This has been enhanced to work when FCoE stack is operating in target
827 * Returns: True for read types I/O, otherwise returns false.
829 static bool fcoe_oem_match(struct fc_frame
*fp
)
831 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
832 struct fcp_cmnd
*fcp
;
834 if (fc_fcp_is_read(fr_fsp(fp
)) &&
835 (fr_fsp(fp
)->data_len
> fcoe_ddp_min
))
837 else if ((fr_fsp(fp
) == NULL
) &&
838 (fh
->fh_r_ctl
== FC_RCTL_DD_UNSOL_CMD
) &&
839 (ntohs(fh
->fh_rx_id
) == FC_XID_UNKNOWN
)) {
840 fcp
= fc_frame_payload_get(fp
, sizeof(*fcp
));
841 if ((fcp
->fc_flags
& FCP_CFL_WRDATA
) &&
842 (ntohl(fcp
->fc_dl
) > fcoe_ddp_min
))
849 * fcoe_em_config() - Allocate and configure an exchange manager
850 * @lport: The local port that the new EM will be associated with
852 * Returns: 0 on success
854 static inline int fcoe_em_config(struct fc_lport
*lport
)
856 struct fcoe_port
*port
= lport_priv(lport
);
857 struct fcoe_interface
*fcoe
= port
->priv
;
858 struct fcoe_interface
*oldfcoe
= NULL
;
859 struct net_device
*old_real_dev
, *cur_real_dev
;
860 u16 min_xid
= FCOE_MIN_XID
;
861 u16 max_xid
= FCOE_MAX_XID
;
864 * Check if need to allocate an em instance for
865 * offload exchange ids to be shared across all VN_PORTs/lport.
867 if (!lport
->lro_enabled
|| !lport
->lro_xid
||
868 (lport
->lro_xid
>= max_xid
)) {
874 * Reuse existing offload em instance in case
875 * it is already allocated on real eth device
877 if (fcoe
->netdev
->priv_flags
& IFF_802_1Q_VLAN
)
878 cur_real_dev
= vlan_dev_real_dev(fcoe
->netdev
);
880 cur_real_dev
= fcoe
->netdev
;
882 list_for_each_entry(oldfcoe
, &fcoe_hostlist
, list
) {
883 if (oldfcoe
->netdev
->priv_flags
& IFF_802_1Q_VLAN
)
884 old_real_dev
= vlan_dev_real_dev(oldfcoe
->netdev
);
886 old_real_dev
= oldfcoe
->netdev
;
888 if (cur_real_dev
== old_real_dev
) {
889 fcoe
->oem
= oldfcoe
->oem
;
895 if (!fc_exch_mgr_add(lport
, fcoe
->oem
, fcoe_oem_match
)) {
896 printk(KERN_ERR
"fcoe_em_config: failed to add "
897 "offload em:%p on interface:%s\n",
898 fcoe
->oem
, fcoe
->netdev
->name
);
902 fcoe
->oem
= fc_exch_mgr_alloc(lport
, FC_CLASS_3
,
903 FCOE_MIN_XID
, lport
->lro_xid
,
906 printk(KERN_ERR
"fcoe_em_config: failed to allocate "
907 "em for offload exches on interface:%s\n",
914 * Exclude offload EM xid range from next EM xid range.
916 min_xid
+= lport
->lro_xid
+ 1;
919 if (!fc_exch_mgr_alloc(lport
, FC_CLASS_3
, min_xid
, max_xid
, NULL
)) {
920 printk(KERN_ERR
"fcoe_em_config: failed to "
921 "allocate em on interface %s\n", fcoe
->netdev
->name
);
929 * fcoe_if_destroy() - Tear down a SW FCoE instance
930 * @lport: The local port to be destroyed
933 static void fcoe_if_destroy(struct fc_lport
*lport
)
935 struct fcoe_port
*port
= lport_priv(lport
);
936 struct fcoe_interface
*fcoe
= port
->priv
;
937 struct net_device
*netdev
= fcoe
->netdev
;
939 FCOE_NETDEV_DBG(netdev
, "Destroying interface\n");
941 /* Logout of the fabric */
942 fc_fabric_logoff(lport
);
944 /* Cleanup the fc_lport */
945 fc_lport_destroy(lport
);
947 /* Stop the transmit retry timer */
948 del_timer_sync(&port
->timer
);
950 /* Free existing transmit skbs */
951 fcoe_clean_pending_queue(lport
);
954 if (!is_zero_ether_addr(port
->data_src_addr
))
955 dev_uc_del(netdev
, port
->data_src_addr
);
959 fcoe_interface_remove(fcoe
);
962 /* Free queued packets for the per-CPU receive threads */
963 fcoe_percpu_clean(lport
);
965 /* Detach from the scsi-ml */
966 fc_remove_host(lport
->host
);
967 scsi_remove_host(lport
->host
);
969 /* Destroy lport scsi_priv */
970 fc_fcp_destroy(lport
);
972 /* There are no more rports or I/O, free the EM */
973 fc_exch_mgr_free(lport
);
975 /* Free memory used by statistical counters */
976 fc_lport_free_stats(lport
);
979 * Release the Scsi_Host for vport but hold on to
980 * master lport until it fcoe interface fully cleaned-up.
983 scsi_host_put(lport
->host
);
987 * fcoe_ddp_setup() - Call a LLD's ddp_setup through the net device
988 * @lport: The local port to setup DDP for
989 * @xid: The exchange ID for this DDP transfer
990 * @sgl: The scatterlist describing this transfer
991 * @sgc: The number of sg items
993 * Returns: 0 if the DDP context was not configured
995 static int fcoe_ddp_setup(struct fc_lport
*lport
, u16 xid
,
996 struct scatterlist
*sgl
, unsigned int sgc
)
998 struct net_device
*netdev
= fcoe_netdev(lport
);
1000 if (netdev
->netdev_ops
->ndo_fcoe_ddp_setup
)
1001 return netdev
->netdev_ops
->ndo_fcoe_ddp_setup(netdev
,
1009 * fcoe_ddp_target() - Call a LLD's ddp_target through the net device
1010 * @lport: The local port to setup DDP for
1011 * @xid: The exchange ID for this DDP transfer
1012 * @sgl: The scatterlist describing this transfer
1013 * @sgc: The number of sg items
1015 * Returns: 0 if the DDP context was not configured
1017 static int fcoe_ddp_target(struct fc_lport
*lport
, u16 xid
,
1018 struct scatterlist
*sgl
, unsigned int sgc
)
1020 struct net_device
*netdev
= fcoe_netdev(lport
);
1022 if (netdev
->netdev_ops
->ndo_fcoe_ddp_target
)
1023 return netdev
->netdev_ops
->ndo_fcoe_ddp_target(netdev
, xid
,
1031 * fcoe_ddp_done() - Call a LLD's ddp_done through the net device
1032 * @lport: The local port to complete DDP on
1033 * @xid: The exchange ID for this DDP transfer
1035 * Returns: the length of data that have been completed by DDP
1037 static int fcoe_ddp_done(struct fc_lport
*lport
, u16 xid
)
1039 struct net_device
*netdev
= fcoe_netdev(lport
);
1041 if (netdev
->netdev_ops
->ndo_fcoe_ddp_done
)
1042 return netdev
->netdev_ops
->ndo_fcoe_ddp_done(netdev
, xid
);
1047 * fcoe_if_create() - Create a FCoE instance on an interface
1048 * @fcoe: The FCoE interface to create a local port on
1049 * @parent: The device pointer to be the parent in sysfs for the SCSI host
1050 * @npiv: Indicates if the port is a vport or not
1052 * Creates a fc_lport instance and a Scsi_Host instance and configure them.
1054 * Returns: The allocated fc_lport or an error pointer
1056 static struct fc_lport
*fcoe_if_create(struct fcoe_interface
*fcoe
,
1057 struct device
*parent
, int npiv
)
1059 struct net_device
*netdev
= fcoe
->netdev
;
1060 struct fc_lport
*lport
, *n_port
;
1061 struct fcoe_port
*port
;
1062 struct Scsi_Host
*shost
;
1065 * parent is only a vport if npiv is 1,
1066 * but we'll only use vport in that case so go ahead and set it
1068 struct fc_vport
*vport
= dev_to_vport(parent
);
1070 FCOE_NETDEV_DBG(netdev
, "Create Interface\n");
1073 lport
= libfc_host_alloc(&fcoe_shost_template
, sizeof(*port
));
1075 lport
= libfc_vport_create(vport
, sizeof(*port
));
1078 FCOE_NETDEV_DBG(netdev
, "Could not allocate host structure\n");
1082 port
= lport_priv(lport
);
1083 port
->lport
= lport
;
1085 port
->max_queue_depth
= FCOE_MAX_QUEUE_DEPTH
;
1086 port
->min_queue_depth
= FCOE_MIN_QUEUE_DEPTH
;
1087 INIT_WORK(&port
->destroy_work
, fcoe_destroy_work
);
1089 /* configure a fc_lport including the exchange manager */
1090 rc
= fcoe_lport_config(lport
);
1092 FCOE_NETDEV_DBG(netdev
, "Could not configure lport for the "
1098 FCOE_NETDEV_DBG(netdev
, "Setting vport names, "
1099 "%16.16llx %16.16llx\n",
1100 vport
->node_name
, vport
->port_name
);
1101 fc_set_wwnn(lport
, vport
->node_name
);
1102 fc_set_wwpn(lport
, vport
->port_name
);
1105 /* configure lport network properties */
1106 rc
= fcoe_netdev_config(lport
, netdev
);
1108 FCOE_NETDEV_DBG(netdev
, "Could not configure netdev for the "
1110 goto out_lp_destroy
;
1113 /* configure lport scsi host properties */
1114 rc
= fcoe_shost_config(lport
, parent
);
1116 FCOE_NETDEV_DBG(netdev
, "Could not configure shost for the "
1118 goto out_lp_destroy
;
1121 /* Initialize the library */
1122 rc
= fcoe_libfc_config(lport
, &fcoe
->ctlr
, &fcoe_libfc_fcn_templ
, 1);
1124 FCOE_NETDEV_DBG(netdev
, "Could not configure libfc for the "
1126 goto out_lp_destroy
;
1129 /* Initialized FDMI information */
1130 fcoe_fdmi_info(lport
, netdev
);
1133 * fcoe_em_alloc() and fcoe_hostlist_add() both
1134 * need to be atomic with respect to other changes to the
1135 * hostlist since fcoe_em_alloc() looks for an existing EM
1136 * instance on host list updated by fcoe_hostlist_add().
1138 * This is currently handled through the fcoe_config_mutex
1142 /* lport exch manager allocation */
1143 rc
= fcoe_em_config(lport
);
1145 shost
= vport_to_shost(vport
);
1146 n_port
= shost_priv(shost
);
1147 rc
= fc_exch_mgr_list_clone(n_port
, lport
);
1151 FCOE_NETDEV_DBG(netdev
, "Could not configure the EM\n");
1152 goto out_lp_destroy
;
1158 fc_exch_mgr_free(lport
);
1160 scsi_host_put(lport
->host
);
1166 * fcoe_if_init() - Initialization routine for fcoe.ko
1168 * Attaches the SW FCoE transport to the FC transport
1170 * Returns: 0 on success
1172 static int __init
fcoe_if_init(void)
1174 /* attach to scsi transport */
1175 fcoe_nport_scsi_transport
=
1176 fc_attach_transport(&fcoe_nport_fc_functions
);
1177 fcoe_vport_scsi_transport
=
1178 fc_attach_transport(&fcoe_vport_fc_functions
);
1180 if (!fcoe_nport_scsi_transport
) {
1181 printk(KERN_ERR
"fcoe: Failed to attach to the FC transport\n");
1189 * fcoe_if_exit() - Tear down fcoe.ko
1191 * Detaches the SW FCoE transport from the FC transport
1193 * Returns: 0 on success
1195 static int __exit
fcoe_if_exit(void)
1197 fc_release_transport(fcoe_nport_scsi_transport
);
1198 fc_release_transport(fcoe_vport_scsi_transport
);
1199 fcoe_nport_scsi_transport
= NULL
;
1200 fcoe_vport_scsi_transport
= NULL
;
1205 * fcoe_percpu_thread_create() - Create a receive thread for an online CPU
1206 * @cpu: The CPU index of the CPU to create a receive thread for
1208 static void fcoe_percpu_thread_create(unsigned int cpu
)
1210 struct fcoe_percpu_s
*p
;
1211 struct task_struct
*thread
;
1213 p
= &per_cpu(fcoe_percpu
, cpu
);
1215 thread
= kthread_create_on_node(fcoe_percpu_receive_thread
,
1216 (void *)p
, cpu_to_node(cpu
),
1217 "fcoethread/%d", cpu
);
1219 if (likely(!IS_ERR(thread
))) {
1220 kthread_bind(thread
, cpu
);
1221 wake_up_process(thread
);
1223 spin_lock_bh(&p
->fcoe_rx_list
.lock
);
1225 spin_unlock_bh(&p
->fcoe_rx_list
.lock
);
1230 * fcoe_percpu_thread_destroy() - Remove the receive thread of a CPU
1231 * @cpu: The CPU index of the CPU whose receive thread is to be destroyed
1233 * Destroys a per-CPU Rx thread. Any pending skbs are moved to the
1234 * current CPU's Rx thread. If the thread being destroyed is bound to
1235 * the CPU processing this context the skbs will be freed.
1237 static void fcoe_percpu_thread_destroy(unsigned int cpu
)
1239 struct fcoe_percpu_s
*p
;
1240 struct task_struct
*thread
;
1241 struct page
*crc_eof
;
1242 struct sk_buff
*skb
;
1244 struct fcoe_percpu_s
*p0
;
1245 unsigned targ_cpu
= get_cpu();
1246 #endif /* CONFIG_SMP */
1248 FCOE_DBG("Destroying receive thread for CPU %d\n", cpu
);
1250 /* Prevent any new skbs from being queued for this CPU. */
1251 p
= &per_cpu(fcoe_percpu
, cpu
);
1252 spin_lock_bh(&p
->fcoe_rx_list
.lock
);
1255 crc_eof
= p
->crc_eof_page
;
1256 p
->crc_eof_page
= NULL
;
1257 p
->crc_eof_offset
= 0;
1258 spin_unlock_bh(&p
->fcoe_rx_list
.lock
);
1262 * Don't bother moving the skb's if this context is running
1263 * on the same CPU that is having its thread destroyed. This
1264 * can easily happen when the module is removed.
1266 if (cpu
!= targ_cpu
) {
1267 p0
= &per_cpu(fcoe_percpu
, targ_cpu
);
1268 spin_lock_bh(&p0
->fcoe_rx_list
.lock
);
1270 FCOE_DBG("Moving frames from CPU %d to CPU %d\n",
1273 while ((skb
= __skb_dequeue(&p
->fcoe_rx_list
)) != NULL
)
1274 __skb_queue_tail(&p0
->fcoe_rx_list
, skb
);
1275 spin_unlock_bh(&p0
->fcoe_rx_list
.lock
);
1278 * The targeted CPU is not initialized and cannot accept
1279 * new skbs. Unlock the targeted CPU and drop the skbs
1280 * on the CPU that is going offline.
1282 while ((skb
= __skb_dequeue(&p
->fcoe_rx_list
)) != NULL
)
1284 spin_unlock_bh(&p0
->fcoe_rx_list
.lock
);
1288 * This scenario occurs when the module is being removed
1289 * and all threads are being destroyed. skbs will continue
1290 * to be shifted from the CPU thread that is being removed
1291 * to the CPU thread associated with the CPU that is processing
1292 * the module removal. Once there is only one CPU Rx thread it
1293 * will reach this case and we will drop all skbs and later
1296 spin_lock_bh(&p
->fcoe_rx_list
.lock
);
1297 while ((skb
= __skb_dequeue(&p
->fcoe_rx_list
)) != NULL
)
1299 spin_unlock_bh(&p
->fcoe_rx_list
.lock
);
1304 * This a non-SMP scenario where the singular Rx thread is
1305 * being removed. Free all skbs and stop the thread.
1307 spin_lock_bh(&p
->fcoe_rx_list
.lock
);
1308 while ((skb
= __skb_dequeue(&p
->fcoe_rx_list
)) != NULL
)
1310 spin_unlock_bh(&p
->fcoe_rx_list
.lock
);
1314 kthread_stop(thread
);
1321 * fcoe_cpu_callback() - Handler for CPU hotplug events
1322 * @nfb: The callback data block
1323 * @action: The event triggering the callback
1324 * @hcpu: The index of the CPU that the event is for
1326 * This creates or destroys per-CPU data for fcoe
1328 * Returns NOTIFY_OK always.
1330 static int fcoe_cpu_callback(struct notifier_block
*nfb
,
1331 unsigned long action
, void *hcpu
)
1333 unsigned cpu
= (unsigned long)hcpu
;
1337 case CPU_ONLINE_FROZEN
:
1338 FCOE_DBG("CPU %x online: Create Rx thread\n", cpu
);
1339 fcoe_percpu_thread_create(cpu
);
1342 case CPU_DEAD_FROZEN
:
1343 FCOE_DBG("CPU %x offline: Remove Rx thread\n", cpu
);
1344 fcoe_percpu_thread_destroy(cpu
);
1353 * fcoe_select_cpu() - Selects CPU to handle post-processing of incoming
1356 * This routine selects next CPU based on cpumask to distribute
1357 * incoming requests in round robin.
1359 * Returns: int CPU number
1361 static inline unsigned int fcoe_select_cpu(void)
1363 static unsigned int selected_cpu
;
1365 selected_cpu
= cpumask_next(selected_cpu
, cpu_online_mask
);
1366 if (selected_cpu
>= nr_cpu_ids
)
1367 selected_cpu
= cpumask_first(cpu_online_mask
);
1369 return selected_cpu
;
1373 * fcoe_rcv() - Receive packets from a net device
1374 * @skb: The received packet
1375 * @netdev: The net device that the packet was received on
1376 * @ptype: The packet type context
1377 * @olddev: The last device net device
1379 * This routine is called by NET_RX_SOFTIRQ. It receives a packet, builds a
1380 * FC frame and passes the frame to libfc.
1382 * Returns: 0 for success
1384 static int fcoe_rcv(struct sk_buff
*skb
, struct net_device
*netdev
,
1385 struct packet_type
*ptype
, struct net_device
*olddev
)
1387 struct fc_lport
*lport
;
1388 struct fcoe_rcv_info
*fr
;
1389 struct fcoe_interface
*fcoe
;
1390 struct fc_frame_header
*fh
;
1391 struct fcoe_percpu_s
*fps
;
1395 fcoe
= container_of(ptype
, struct fcoe_interface
, fcoe_packet_type
);
1396 lport
= fcoe
->ctlr
.lp
;
1397 if (unlikely(!lport
)) {
1398 FCOE_NETDEV_DBG(netdev
, "Cannot find hba structure");
1401 if (!lport
->link_up
)
1404 FCOE_NETDEV_DBG(netdev
, "skb_info: len:%d data_len:%d head:%p "
1405 "data:%p tail:%p end:%p sum:%d dev:%s",
1406 skb
->len
, skb
->data_len
, skb
->head
, skb
->data
,
1407 skb_tail_pointer(skb
), skb_end_pointer(skb
),
1408 skb
->csum
, skb
->dev
? skb
->dev
->name
: "<NULL>");
1412 if (is_fip_mode(&fcoe
->ctlr
) &&
1413 compare_ether_addr(eh
->h_source
, fcoe
->ctlr
.dest_addr
)) {
1414 FCOE_NETDEV_DBG(netdev
, "wrong source mac address:%pM\n",
1420 * Check for minimum frame length, and make sure required FCoE
1421 * and FC headers are pulled into the linear data area.
1423 if (unlikely((skb
->len
< FCOE_MIN_FRAME
) ||
1424 !pskb_may_pull(skb
, FCOE_HEADER_LEN
)))
1427 skb_set_transport_header(skb
, sizeof(struct fcoe_hdr
));
1428 fh
= (struct fc_frame_header
*) skb_transport_header(skb
);
1430 if (ntoh24(&eh
->h_dest
[3]) != ntoh24(fh
->fh_d_id
)) {
1431 FCOE_NETDEV_DBG(netdev
, "FC frame d_id mismatch with MAC:%pM\n",
1436 fr
= fcoe_dev_from_skb(skb
);
1440 * In case the incoming frame's exchange is originated from
1441 * the initiator, then received frame's exchange id is ANDed
1442 * with fc_cpu_mask bits to get the same cpu on which exchange
1443 * was originated, otherwise select cpu using rx exchange id
1444 * or fcoe_select_cpu().
1446 if (ntoh24(fh
->fh_f_ctl
) & FC_FC_EX_CTX
)
1447 cpu
= ntohs(fh
->fh_ox_id
) & fc_cpu_mask
;
1449 if (ntohs(fh
->fh_rx_id
) == FC_XID_UNKNOWN
)
1450 cpu
= fcoe_select_cpu();
1452 cpu
= ntohs(fh
->fh_rx_id
) & fc_cpu_mask
;
1455 if (cpu
>= nr_cpu_ids
)
1458 fps
= &per_cpu(fcoe_percpu
, cpu
);
1459 spin_lock(&fps
->fcoe_rx_list
.lock
);
1460 if (unlikely(!fps
->thread
)) {
1462 * The targeted CPU is not ready, let's target
1463 * the first CPU now. For non-SMP systems this
1464 * will check the same CPU twice.
1466 FCOE_NETDEV_DBG(netdev
, "CPU is online, but no receive thread "
1467 "ready for incoming skb- using first online "
1470 spin_unlock(&fps
->fcoe_rx_list
.lock
);
1471 cpu
= cpumask_first(cpu_online_mask
);
1472 fps
= &per_cpu(fcoe_percpu
, cpu
);
1473 spin_lock(&fps
->fcoe_rx_list
.lock
);
1475 spin_unlock(&fps
->fcoe_rx_list
.lock
);
1481 * We now have a valid CPU that we're targeting for
1482 * this skb. We also have this receive thread locked,
1483 * so we're free to queue skbs into it's queue.
1487 * Note: We used to have a set of conditions under which we would
1488 * call fcoe_recv_frame directly, rather than queuing to the rx list
1489 * as it could save a few cycles, but doing so is prohibited, as
1490 * fcoe_recv_frame has several paths that may sleep, which is forbidden
1491 * in softirq context.
1493 __skb_queue_tail(&fps
->fcoe_rx_list
, skb
);
1494 if (fps
->thread
->state
== TASK_INTERRUPTIBLE
)
1495 wake_up_process(fps
->thread
);
1496 spin_unlock(&fps
->fcoe_rx_list
.lock
);
1500 per_cpu_ptr(lport
->dev_stats
, get_cpu())->ErrorFrames
++;
1508 * fcoe_alloc_paged_crc_eof() - Allocate a page to be used for the trailer CRC
1509 * @skb: The packet to be transmitted
1510 * @tlen: The total length of the trailer
1512 * Returns: 0 for success
1514 static int fcoe_alloc_paged_crc_eof(struct sk_buff
*skb
, int tlen
)
1516 struct fcoe_percpu_s
*fps
;
1519 fps
= &get_cpu_var(fcoe_percpu
);
1520 rc
= fcoe_get_paged_crc_eof(skb
, tlen
, fps
);
1521 put_cpu_var(fcoe_percpu
);
1527 * fcoe_xmit() - Transmit a FCoE frame
1528 * @lport: The local port that the frame is to be transmitted for
1529 * @fp: The frame to be transmitted
1531 * Return: 0 for success
1533 static int fcoe_xmit(struct fc_lport
*lport
, struct fc_frame
*fp
)
1538 struct fcoe_crc_eof
*cp
;
1539 struct sk_buff
*skb
;
1540 struct fcoe_dev_stats
*stats
;
1541 struct fc_frame_header
*fh
;
1542 unsigned int hlen
; /* header length implies the version */
1543 unsigned int tlen
; /* trailer length */
1544 unsigned int elen
; /* eth header, may include vlan */
1545 struct fcoe_port
*port
= lport_priv(lport
);
1546 struct fcoe_interface
*fcoe
= port
->priv
;
1548 struct fcoe_hdr
*hp
;
1550 WARN_ON((fr_len(fp
) % sizeof(u32
)) != 0);
1552 fh
= fc_frame_header_get(fp
);
1554 wlen
= skb
->len
/ FCOE_WORD_TO_BYTE
;
1556 if (!lport
->link_up
) {
1561 if (unlikely(fh
->fh_type
== FC_TYPE_ELS
) &&
1562 fcoe_ctlr_els_send(&fcoe
->ctlr
, lport
, skb
))
1568 elen
= sizeof(struct ethhdr
);
1569 hlen
= sizeof(struct fcoe_hdr
);
1570 tlen
= sizeof(struct fcoe_crc_eof
);
1571 wlen
= (skb
->len
- tlen
+ sizeof(crc
)) / FCOE_WORD_TO_BYTE
;
1574 if (likely(lport
->crc_offload
)) {
1575 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1576 skb
->csum_start
= skb_headroom(skb
);
1577 skb
->csum_offset
= skb
->len
;
1580 skb
->ip_summed
= CHECKSUM_NONE
;
1581 crc
= fcoe_fc_crc(fp
);
1584 /* copy port crc and eof to the skb buff */
1585 if (skb_is_nonlinear(skb
)) {
1587 if (fcoe_alloc_paged_crc_eof(skb
, tlen
)) {
1591 frag
= &skb_shinfo(skb
)->frags
[skb_shinfo(skb
)->nr_frags
- 1];
1592 cp
= kmap_atomic(skb_frag_page(frag
))
1593 + frag
->page_offset
;
1595 cp
= (struct fcoe_crc_eof
*)skb_put(skb
, tlen
);
1598 memset(cp
, 0, sizeof(*cp
));
1600 cp
->fcoe_crc32
= cpu_to_le32(~crc
);
1602 if (skb_is_nonlinear(skb
)) {
1607 /* adjust skb network/transport offsets to match mac/fcoe/port */
1608 skb_push(skb
, elen
+ hlen
);
1609 skb_reset_mac_header(skb
);
1610 skb_reset_network_header(skb
);
1611 skb
->mac_len
= elen
;
1612 skb
->protocol
= htons(ETH_P_FCOE
);
1613 skb
->priority
= port
->priority
;
1615 if (fcoe
->netdev
->priv_flags
& IFF_802_1Q_VLAN
&&
1616 fcoe
->realdev
->features
& NETIF_F_HW_VLAN_TX
) {
1617 skb
->vlan_tci
= VLAN_TAG_PRESENT
|
1618 vlan_dev_vlan_id(fcoe
->netdev
);
1619 skb
->dev
= fcoe
->realdev
;
1621 skb
->dev
= fcoe
->netdev
;
1623 /* fill up mac and fcoe headers */
1625 eh
->h_proto
= htons(ETH_P_FCOE
);
1626 memcpy(eh
->h_dest
, fcoe
->ctlr
.dest_addr
, ETH_ALEN
);
1627 if (fcoe
->ctlr
.map_dest
)
1628 memcpy(eh
->h_dest
+ 3, fh
->fh_d_id
, 3);
1630 if (unlikely(fcoe
->ctlr
.flogi_oxid
!= FC_XID_UNKNOWN
))
1631 memcpy(eh
->h_source
, fcoe
->ctlr
.ctl_src_addr
, ETH_ALEN
);
1633 memcpy(eh
->h_source
, port
->data_src_addr
, ETH_ALEN
);
1635 hp
= (struct fcoe_hdr
*)(eh
+ 1);
1636 memset(hp
, 0, sizeof(*hp
));
1638 FC_FCOE_ENCAPS_VER(hp
, FC_FCOE_VER
);
1641 /* fcoe lso, mss is in max_payload which is non-zero for FCP data */
1642 if (lport
->seq_offload
&& fr_max_payload(fp
)) {
1643 skb_shinfo(skb
)->gso_type
= SKB_GSO_FCOE
;
1644 skb_shinfo(skb
)->gso_size
= fr_max_payload(fp
);
1646 skb_shinfo(skb
)->gso_type
= 0;
1647 skb_shinfo(skb
)->gso_size
= 0;
1649 /* update tx stats: regardless if LLD fails */
1650 stats
= per_cpu_ptr(lport
->dev_stats
, get_cpu());
1652 stats
->TxWords
+= wlen
;
1655 /* send down to lld */
1657 fcoe_port_send(port
, skb
);
1662 * fcoe_percpu_flush_done() - Indicate per-CPU queue flush completion
1663 * @skb: The completed skb (argument required by destructor)
1665 static void fcoe_percpu_flush_done(struct sk_buff
*skb
)
1667 complete(&fcoe_flush_completion
);
1671 * fcoe_filter_frames() - filter out bad fcoe frames, i.e. bad CRC
1672 * @lport: The local port the frame was received on
1673 * @fp: The received frame
1675 * Return: 0 on passing filtering checks
1677 static inline int fcoe_filter_frames(struct fc_lport
*lport
,
1678 struct fc_frame
*fp
)
1680 struct fcoe_interface
*fcoe
;
1681 struct fc_frame_header
*fh
;
1682 struct sk_buff
*skb
= (struct sk_buff
*)fp
;
1683 struct fcoe_dev_stats
*stats
;
1686 * We only check CRC if no offload is available and if it is
1687 * it's solicited data, in which case, the FCP layer would
1688 * check it during the copy.
1690 if (lport
->crc_offload
&& skb
->ip_summed
== CHECKSUM_UNNECESSARY
)
1691 fr_flags(fp
) &= ~FCPHF_CRC_UNCHECKED
;
1693 fr_flags(fp
) |= FCPHF_CRC_UNCHECKED
;
1695 fh
= (struct fc_frame_header
*) skb_transport_header(skb
);
1696 fh
= fc_frame_header_get(fp
);
1697 if (fh
->fh_r_ctl
== FC_RCTL_DD_SOL_DATA
&& fh
->fh_type
== FC_TYPE_FCP
)
1700 fcoe
= ((struct fcoe_port
*)lport_priv(lport
))->priv
;
1701 if (is_fip_mode(&fcoe
->ctlr
) && fc_frame_payload_op(fp
) == ELS_LOGO
&&
1702 ntoh24(fh
->fh_s_id
) == FC_FID_FLOGI
) {
1703 FCOE_DBG("fcoe: dropping FCoE lport LOGO in fip mode\n");
1707 if (!(fr_flags(fp
) & FCPHF_CRC_UNCHECKED
) ||
1708 le32_to_cpu(fr_crc(fp
)) == ~crc32(~0, skb
->data
, skb
->len
)) {
1709 fr_flags(fp
) &= ~FCPHF_CRC_UNCHECKED
;
1713 stats
= per_cpu_ptr(lport
->dev_stats
, get_cpu());
1714 stats
->InvalidCRCCount
++;
1715 if (stats
->InvalidCRCCount
< 5)
1716 printk(KERN_WARNING
"fcoe: dropping frame with CRC error\n");
1722 * fcoe_recv_frame() - process a single received frame
1723 * @skb: frame to process
1725 static void fcoe_recv_frame(struct sk_buff
*skb
)
1728 struct fc_lport
*lport
;
1729 struct fcoe_rcv_info
*fr
;
1730 struct fcoe_dev_stats
*stats
;
1731 struct fcoe_crc_eof crc_eof
;
1732 struct fc_frame
*fp
;
1733 struct fcoe_port
*port
;
1734 struct fcoe_hdr
*hp
;
1736 fr
= fcoe_dev_from_skb(skb
);
1738 if (unlikely(!lport
)) {
1739 if (skb
->destructor
!= fcoe_percpu_flush_done
)
1740 FCOE_NETDEV_DBG(skb
->dev
, "NULL lport in skb");
1745 FCOE_NETDEV_DBG(skb
->dev
, "skb_info: len:%d data_len:%d "
1746 "head:%p data:%p tail:%p end:%p sum:%d dev:%s",
1747 skb
->len
, skb
->data_len
,
1748 skb
->head
, skb
->data
, skb_tail_pointer(skb
),
1749 skb_end_pointer(skb
), skb
->csum
,
1750 skb
->dev
? skb
->dev
->name
: "<NULL>");
1752 port
= lport_priv(lport
);
1753 skb_linearize(skb
); /* check for skb_is_nonlinear is within skb_linearize */
1756 * Frame length checks and setting up the header pointers
1757 * was done in fcoe_rcv already.
1759 hp
= (struct fcoe_hdr
*) skb_network_header(skb
);
1761 stats
= per_cpu_ptr(lport
->dev_stats
, get_cpu());
1762 if (unlikely(FC_FCOE_DECAPS_VER(hp
) != FC_FCOE_VER
)) {
1763 if (stats
->ErrorFrames
< 5)
1764 printk(KERN_WARNING
"fcoe: FCoE version "
1765 "mismatch: The frame has "
1766 "version %x, but the "
1767 "initiator supports version "
1768 "%x\n", FC_FCOE_DECAPS_VER(hp
),
1773 skb_pull(skb
, sizeof(struct fcoe_hdr
));
1774 fr_len
= skb
->len
- sizeof(struct fcoe_crc_eof
);
1777 stats
->RxWords
+= fr_len
/ FCOE_WORD_TO_BYTE
;
1779 fp
= (struct fc_frame
*)skb
;
1782 fr_sof(fp
) = hp
->fcoe_sof
;
1784 /* Copy out the CRC and EOF trailer for access */
1785 if (skb_copy_bits(skb
, fr_len
, &crc_eof
, sizeof(crc_eof
)))
1787 fr_eof(fp
) = crc_eof
.fcoe_eof
;
1788 fr_crc(fp
) = crc_eof
.fcoe_crc32
;
1789 if (pskb_trim(skb
, fr_len
))
1792 if (!fcoe_filter_frames(lport
, fp
)) {
1794 fc_exch_recv(lport
, fp
);
1798 stats
->ErrorFrames
++;
1804 * fcoe_percpu_receive_thread() - The per-CPU packet receive thread
1805 * @arg: The per-CPU context
1807 * Return: 0 for success
1809 static int fcoe_percpu_receive_thread(void *arg
)
1811 struct fcoe_percpu_s
*p
= arg
;
1812 struct sk_buff
*skb
;
1813 struct sk_buff_head tmp
;
1815 skb_queue_head_init(&tmp
);
1817 set_user_nice(current
, -20);
1819 while (!kthread_should_stop()) {
1821 spin_lock_bh(&p
->fcoe_rx_list
.lock
);
1822 skb_queue_splice_init(&p
->fcoe_rx_list
, &tmp
);
1823 spin_unlock_bh(&p
->fcoe_rx_list
.lock
);
1825 while ((skb
= __skb_dequeue(&tmp
)) != NULL
)
1826 fcoe_recv_frame(skb
);
1828 spin_lock_bh(&p
->fcoe_rx_list
.lock
);
1829 if (!skb_queue_len(&p
->fcoe_rx_list
)) {
1830 set_current_state(TASK_INTERRUPTIBLE
);
1831 spin_unlock_bh(&p
->fcoe_rx_list
.lock
);
1833 set_current_state(TASK_RUNNING
);
1835 spin_unlock_bh(&p
->fcoe_rx_list
.lock
);
1841 * fcoe_dev_setup() - Setup the link change notification interface
1843 static void fcoe_dev_setup(void)
1845 register_dcbevent_notifier(&dcb_notifier
);
1846 register_netdevice_notifier(&fcoe_notifier
);
1850 * fcoe_dev_cleanup() - Cleanup the link change notification interface
1852 static void fcoe_dev_cleanup(void)
1854 unregister_dcbevent_notifier(&dcb_notifier
);
1855 unregister_netdevice_notifier(&fcoe_notifier
);
1858 static struct fcoe_interface
*
1859 fcoe_hostlist_lookup_realdev_port(struct net_device
*netdev
)
1861 struct fcoe_interface
*fcoe
;
1862 struct net_device
*real_dev
;
1864 list_for_each_entry(fcoe
, &fcoe_hostlist
, list
) {
1865 if (fcoe
->netdev
->priv_flags
& IFF_802_1Q_VLAN
)
1866 real_dev
= vlan_dev_real_dev(fcoe
->netdev
);
1868 real_dev
= fcoe
->netdev
;
1870 if (netdev
== real_dev
)
1876 static int fcoe_dcb_app_notification(struct notifier_block
*notifier
,
1877 ulong event
, void *ptr
)
1879 struct dcb_app_type
*entry
= ptr
;
1880 struct fcoe_interface
*fcoe
;
1881 struct net_device
*netdev
;
1882 struct fcoe_port
*port
;
1885 if (entry
->app
.selector
!= DCB_APP_IDTYPE_ETHTYPE
)
1888 netdev
= dev_get_by_index(&init_net
, entry
->ifindex
);
1892 fcoe
= fcoe_hostlist_lookup_realdev_port(netdev
);
1897 if (entry
->dcbx
& DCB_CAP_DCBX_VER_CEE
)
1898 prio
= ffs(entry
->app
.priority
) - 1;
1900 prio
= entry
->app
.priority
;
1905 if (entry
->app
.protocol
== ETH_P_FIP
||
1906 entry
->app
.protocol
== ETH_P_FCOE
)
1907 fcoe
->ctlr
.priority
= prio
;
1909 if (entry
->app
.protocol
== ETH_P_FCOE
) {
1910 port
= lport_priv(fcoe
->ctlr
.lp
);
1911 port
->priority
= prio
;
1918 * fcoe_device_notification() - Handler for net device events
1919 * @notifier: The context of the notification
1920 * @event: The type of event
1921 * @ptr: The net device that the event was on
1923 * This function is called by the Ethernet driver in case of link change event.
1925 * Returns: 0 for success
1927 static int fcoe_device_notification(struct notifier_block
*notifier
,
1928 ulong event
, void *ptr
)
1930 struct fc_lport
*lport
= NULL
;
1931 struct net_device
*netdev
= ptr
;
1932 struct fcoe_interface
*fcoe
;
1933 struct fcoe_port
*port
;
1934 struct fcoe_dev_stats
*stats
;
1935 u32 link_possible
= 1;
1939 list_for_each_entry(fcoe
, &fcoe_hostlist
, list
) {
1940 if (fcoe
->netdev
== netdev
) {
1941 lport
= fcoe
->ctlr
.lp
;
1952 case NETDEV_GOING_DOWN
:
1958 case NETDEV_CHANGEMTU
:
1959 if (netdev
->features
& NETIF_F_FCOE_MTU
)
1961 mfs
= netdev
->mtu
- (sizeof(struct fcoe_hdr
) +
1962 sizeof(struct fcoe_crc_eof
));
1963 if (mfs
>= FC_MIN_MAX_FRAME
)
1964 fc_set_mfs(lport
, mfs
);
1966 case NETDEV_REGISTER
:
1968 case NETDEV_UNREGISTER
:
1969 list_del(&fcoe
->list
);
1970 port
= lport_priv(fcoe
->ctlr
.lp
);
1971 queue_work(fcoe_wq
, &port
->destroy_work
);
1974 case NETDEV_FEAT_CHANGE
:
1975 fcoe_netdev_features_change(lport
, netdev
);
1978 FCOE_NETDEV_DBG(netdev
, "Unknown event %ld "
1979 "from netdev netlink\n", event
);
1982 fcoe_link_speed_update(lport
);
1984 if (link_possible
&& !fcoe_link_ok(lport
))
1985 fcoe_ctlr_link_up(&fcoe
->ctlr
);
1986 else if (fcoe_ctlr_link_down(&fcoe
->ctlr
)) {
1987 stats
= per_cpu_ptr(lport
->dev_stats
, get_cpu());
1988 stats
->LinkFailureCount
++;
1990 fcoe_clean_pending_queue(lport
);
1997 * fcoe_disable() - Disables a FCoE interface
1998 * @netdev : The net_device object the Ethernet interface to create on
2000 * Called from fcoe transport.
2002 * Returns: 0 for success
2004 static int fcoe_disable(struct net_device
*netdev
)
2006 struct fcoe_interface
*fcoe
;
2009 mutex_lock(&fcoe_config_mutex
);
2012 fcoe
= fcoe_hostlist_lookup_port(netdev
);
2016 fcoe_ctlr_link_down(&fcoe
->ctlr
);
2017 fcoe_clean_pending_queue(fcoe
->ctlr
.lp
);
2021 mutex_unlock(&fcoe_config_mutex
);
2026 * fcoe_enable() - Enables a FCoE interface
2027 * @netdev : The net_device object the Ethernet interface to create on
2029 * Called from fcoe transport.
2031 * Returns: 0 for success
2033 static int fcoe_enable(struct net_device
*netdev
)
2035 struct fcoe_interface
*fcoe
;
2038 mutex_lock(&fcoe_config_mutex
);
2040 fcoe
= fcoe_hostlist_lookup_port(netdev
);
2045 else if (!fcoe_link_ok(fcoe
->ctlr
.lp
))
2046 fcoe_ctlr_link_up(&fcoe
->ctlr
);
2048 mutex_unlock(&fcoe_config_mutex
);
2053 * fcoe_destroy() - Destroy a FCoE interface
2054 * @netdev : The net_device object the Ethernet interface to create on
2056 * Called from fcoe transport
2058 * Returns: 0 for success
2060 static int fcoe_destroy(struct net_device
*netdev
)
2062 struct fcoe_interface
*fcoe
;
2063 struct fc_lport
*lport
;
2064 struct fcoe_port
*port
;
2067 mutex_lock(&fcoe_config_mutex
);
2069 fcoe
= fcoe_hostlist_lookup_port(netdev
);
2074 lport
= fcoe
->ctlr
.lp
;
2075 port
= lport_priv(lport
);
2076 list_del(&fcoe
->list
);
2077 queue_work(fcoe_wq
, &port
->destroy_work
);
2080 mutex_unlock(&fcoe_config_mutex
);
2085 * fcoe_destroy_work() - Destroy a FCoE port in a deferred work context
2086 * @work: Handle to the FCoE port to be destroyed
2088 static void fcoe_destroy_work(struct work_struct
*work
)
2090 struct fcoe_port
*port
;
2091 struct fcoe_interface
*fcoe
;
2093 port
= container_of(work
, struct fcoe_port
, destroy_work
);
2094 mutex_lock(&fcoe_config_mutex
);
2097 fcoe_if_destroy(port
->lport
);
2098 fcoe_interface_cleanup(fcoe
);
2100 mutex_unlock(&fcoe_config_mutex
);
2104 * fcoe_match() - Check if the FCoE is supported on the given netdevice
2105 * @netdev : The net_device object the Ethernet interface to create on
2107 * Called from fcoe transport.
2109 * Returns: always returns true as this is the default FCoE transport,
2110 * i.e., support all netdevs.
2112 static bool fcoe_match(struct net_device
*netdev
)
2118 * fcoe_dcb_create() - Initialize DCB attributes and hooks
2119 * @netdev: The net_device object of the L2 link that should be queried
2120 * @port: The fcoe_port to bind FCoE APP priority with
2123 static void fcoe_dcb_create(struct fcoe_interface
*fcoe
)
2128 struct net_device
*netdev
= fcoe
->realdev
;
2129 struct fcoe_port
*port
= lport_priv(fcoe
->ctlr
.lp
);
2130 struct dcb_app app
= {
2132 .protocol
= ETH_P_FCOE
2135 /* setup DCB priority attributes. */
2136 if (netdev
&& netdev
->dcbnl_ops
&& netdev
->dcbnl_ops
->getdcbx
) {
2137 dcbx
= netdev
->dcbnl_ops
->getdcbx(netdev
);
2139 if (dcbx
& DCB_CAP_DCBX_VER_IEEE
) {
2140 app
.selector
= IEEE_8021QAZ_APP_SEL_ETHERTYPE
;
2141 up
= dcb_ieee_getapp_mask(netdev
, &app
);
2142 app
.protocol
= ETH_P_FIP
;
2143 fup
= dcb_ieee_getapp_mask(netdev
, &app
);
2145 app
.selector
= DCB_APP_IDTYPE_ETHTYPE
;
2146 up
= dcb_getapp(netdev
, &app
);
2147 app
.protocol
= ETH_P_FIP
;
2148 fup
= dcb_getapp(netdev
, &app
);
2151 port
->priority
= ffs(up
) ? ffs(up
) - 1 : 0;
2152 fcoe
->ctlr
.priority
= ffs(fup
) ? ffs(fup
) - 1 : port
->priority
;
2158 * fcoe_create() - Create a fcoe interface
2159 * @netdev : The net_device object the Ethernet interface to create on
2160 * @fip_mode: The FIP mode for this creation
2162 * Called from fcoe transport
2164 * Returns: 0 for success
2166 static int fcoe_create(struct net_device
*netdev
, enum fip_state fip_mode
)
2169 struct fcoe_interface
*fcoe
;
2170 struct fc_lport
*lport
;
2172 mutex_lock(&fcoe_config_mutex
);
2175 /* look for existing lport */
2176 if (fcoe_hostlist_lookup(netdev
)) {
2181 fcoe
= fcoe_interface_create(netdev
, fip_mode
);
2187 lport
= fcoe_if_create(fcoe
, &netdev
->dev
, 0);
2188 if (IS_ERR(lport
)) {
2189 printk(KERN_ERR
"fcoe: Failed to create interface (%s)\n",
2193 fcoe_interface_cleanup(fcoe
);
2197 /* Make this the "master" N_Port */
2198 fcoe
->ctlr
.lp
= lport
;
2200 /* setup DCB priority attributes. */
2201 fcoe_dcb_create(fcoe
);
2203 /* add to lports list */
2204 fcoe_hostlist_add(lport
);
2206 /* start FIP Discovery and FLOGI */
2207 lport
->boot_time
= jiffies
;
2208 fc_fabric_login(lport
);
2209 if (!fcoe_link_ok(lport
)) {
2211 fcoe_ctlr_link_up(&fcoe
->ctlr
);
2212 mutex_unlock(&fcoe_config_mutex
);
2219 mutex_unlock(&fcoe_config_mutex
);
2224 * fcoe_link_speed_update() - Update the supported and actual link speeds
2225 * @lport: The local port to update speeds for
2227 * Returns: 0 if the ethtool query was successful
2228 * -1 if the ethtool query failed
2230 static int fcoe_link_speed_update(struct fc_lport
*lport
)
2232 struct net_device
*netdev
= fcoe_netdev(lport
);
2233 struct ethtool_cmd ecmd
;
2235 if (!__ethtool_get_settings(netdev
, &ecmd
)) {
2236 lport
->link_supported_speeds
&=
2237 ~(FC_PORTSPEED_1GBIT
| FC_PORTSPEED_10GBIT
);
2238 if (ecmd
.supported
& (SUPPORTED_1000baseT_Half
|
2239 SUPPORTED_1000baseT_Full
))
2240 lport
->link_supported_speeds
|= FC_PORTSPEED_1GBIT
;
2241 if (ecmd
.supported
& SUPPORTED_10000baseT_Full
)
2242 lport
->link_supported_speeds
|=
2243 FC_PORTSPEED_10GBIT
;
2244 switch (ethtool_cmd_speed(&ecmd
)) {
2246 lport
->link_speed
= FC_PORTSPEED_1GBIT
;
2249 lport
->link_speed
= FC_PORTSPEED_10GBIT
;
2258 * fcoe_link_ok() - Check if the link is OK for a local port
2259 * @lport: The local port to check link on
2261 * Returns: 0 if link is UP and OK, -1 if not
2264 static int fcoe_link_ok(struct fc_lport
*lport
)
2266 struct net_device
*netdev
= fcoe_netdev(lport
);
2268 if (netif_oper_up(netdev
))
2274 * fcoe_percpu_clean() - Clear all pending skbs for an local port
2275 * @lport: The local port whose skbs are to be cleared
2277 * Must be called with fcoe_create_mutex held to single-thread completion.
2279 * This flushes the pending skbs by adding a new skb to each queue and
2280 * waiting until they are all freed. This assures us that not only are
2281 * there no packets that will be handled by the lport, but also that any
2282 * threads already handling packet have returned.
2284 static void fcoe_percpu_clean(struct fc_lport
*lport
)
2286 struct fcoe_percpu_s
*pp
;
2287 struct sk_buff
*skb
;
2290 for_each_possible_cpu(cpu
) {
2291 pp
= &per_cpu(fcoe_percpu
, cpu
);
2293 if (!pp
->thread
|| !cpu_online(cpu
))
2296 skb
= dev_alloc_skb(0);
2298 spin_unlock_bh(&pp
->fcoe_rx_list
.lock
);
2301 skb
->destructor
= fcoe_percpu_flush_done
;
2303 spin_lock_bh(&pp
->fcoe_rx_list
.lock
);
2304 __skb_queue_tail(&pp
->fcoe_rx_list
, skb
);
2305 if (pp
->fcoe_rx_list
.qlen
== 1)
2306 wake_up_process(pp
->thread
);
2307 spin_unlock_bh(&pp
->fcoe_rx_list
.lock
);
2309 wait_for_completion(&fcoe_flush_completion
);
2314 * fcoe_reset() - Reset a local port
2315 * @shost: The SCSI host associated with the local port to be reset
2317 * Returns: Always 0 (return value required by FC transport template)
2319 static int fcoe_reset(struct Scsi_Host
*shost
)
2321 struct fc_lport
*lport
= shost_priv(shost
);
2322 struct fcoe_port
*port
= lport_priv(lport
);
2323 struct fcoe_interface
*fcoe
= port
->priv
;
2325 fcoe_ctlr_link_down(&fcoe
->ctlr
);
2326 fcoe_clean_pending_queue(fcoe
->ctlr
.lp
);
2327 if (!fcoe_link_ok(fcoe
->ctlr
.lp
))
2328 fcoe_ctlr_link_up(&fcoe
->ctlr
);
2333 * fcoe_hostlist_lookup_port() - Find the FCoE interface associated with a net device
2334 * @netdev: The net device used as a key
2336 * Locking: Must be called with the RNL mutex held.
2338 * Returns: NULL or the FCoE interface
2340 static struct fcoe_interface
*
2341 fcoe_hostlist_lookup_port(const struct net_device
*netdev
)
2343 struct fcoe_interface
*fcoe
;
2345 list_for_each_entry(fcoe
, &fcoe_hostlist
, list
) {
2346 if (fcoe
->netdev
== netdev
)
2353 * fcoe_hostlist_lookup() - Find the local port associated with a
2355 * @netdev: The netdevice used as a key
2357 * Locking: Must be called with the RTNL mutex held
2359 * Returns: NULL or the local port
2361 static struct fc_lport
*fcoe_hostlist_lookup(const struct net_device
*netdev
)
2363 struct fcoe_interface
*fcoe
;
2365 fcoe
= fcoe_hostlist_lookup_port(netdev
);
2366 return (fcoe
) ? fcoe
->ctlr
.lp
: NULL
;
2370 * fcoe_hostlist_add() - Add the FCoE interface identified by a local
2371 * port to the hostlist
2372 * @lport: The local port that identifies the FCoE interface to be added
2374 * Locking: must be called with the RTNL mutex held
2376 * Returns: 0 for success
2378 static int fcoe_hostlist_add(const struct fc_lport
*lport
)
2380 struct fcoe_interface
*fcoe
;
2381 struct fcoe_port
*port
;
2383 fcoe
= fcoe_hostlist_lookup_port(fcoe_netdev(lport
));
2385 port
= lport_priv(lport
);
2387 list_add_tail(&fcoe
->list
, &fcoe_hostlist
);
2393 static struct fcoe_transport fcoe_sw_transport
= {
2394 .name
= {FCOE_TRANSPORT_DEFAULT
},
2396 .list
= LIST_HEAD_INIT(fcoe_sw_transport
.list
),
2397 .match
= fcoe_match
,
2398 .create
= fcoe_create
,
2399 .destroy
= fcoe_destroy
,
2400 .enable
= fcoe_enable
,
2401 .disable
= fcoe_disable
,
2405 * fcoe_init() - Initialize fcoe.ko
2407 * Returns: 0 on success, or a negative value on failure
2409 static int __init
fcoe_init(void)
2411 struct fcoe_percpu_s
*p
;
2415 fcoe_wq
= alloc_workqueue("fcoe", 0, 0);
2419 /* register as a fcoe transport */
2420 rc
= fcoe_transport_attach(&fcoe_sw_transport
);
2422 printk(KERN_ERR
"failed to register an fcoe transport, check "
2423 "if libfcoe is loaded\n");
2427 mutex_lock(&fcoe_config_mutex
);
2429 for_each_possible_cpu(cpu
) {
2430 p
= &per_cpu(fcoe_percpu
, cpu
);
2431 skb_queue_head_init(&p
->fcoe_rx_list
);
2434 for_each_online_cpu(cpu
)
2435 fcoe_percpu_thread_create(cpu
);
2437 /* Initialize per CPU interrupt thread */
2438 rc
= register_hotcpu_notifier(&fcoe_cpu_notifier
);
2442 /* Setup link change notification */
2445 rc
= fcoe_if_init();
2449 mutex_unlock(&fcoe_config_mutex
);
2453 for_each_online_cpu(cpu
) {
2454 fcoe_percpu_thread_destroy(cpu
);
2456 mutex_unlock(&fcoe_config_mutex
);
2457 destroy_workqueue(fcoe_wq
);
2460 module_init(fcoe_init
);
2463 * fcoe_exit() - Clean up fcoe.ko
2465 * Returns: 0 on success or a negative value on failure
2467 static void __exit
fcoe_exit(void)
2469 struct fcoe_interface
*fcoe
, *tmp
;
2470 struct fcoe_port
*port
;
2473 mutex_lock(&fcoe_config_mutex
);
2477 /* releases the associated fcoe hosts */
2479 list_for_each_entry_safe(fcoe
, tmp
, &fcoe_hostlist
, list
) {
2480 list_del(&fcoe
->list
);
2481 port
= lport_priv(fcoe
->ctlr
.lp
);
2482 queue_work(fcoe_wq
, &port
->destroy_work
);
2486 unregister_hotcpu_notifier(&fcoe_cpu_notifier
);
2488 for_each_online_cpu(cpu
)
2489 fcoe_percpu_thread_destroy(cpu
);
2491 mutex_unlock(&fcoe_config_mutex
);
2494 * destroy_work's may be chained but destroy_workqueue()
2495 * can take care of them. Just kill the fcoe_wq.
2497 destroy_workqueue(fcoe_wq
);
2500 * Detaching from the scsi transport must happen after all
2501 * destroys are done on the fcoe_wq. destroy_workqueue will
2502 * enusre the fcoe_wq is flushed.
2506 /* detach from fcoe transport */
2507 fcoe_transport_detach(&fcoe_sw_transport
);
2509 module_exit(fcoe_exit
);
2512 * fcoe_flogi_resp() - FCoE specific FLOGI and FDISC response handler
2513 * @seq: active sequence in the FLOGI or FDISC exchange
2514 * @fp: response frame, or error encoded in a pointer (timeout)
2515 * @arg: pointer the the fcoe_ctlr structure
2517 * This handles MAC address management for FCoE, then passes control on to
2518 * the libfc FLOGI response handler.
2520 static void fcoe_flogi_resp(struct fc_seq
*seq
, struct fc_frame
*fp
, void *arg
)
2522 struct fcoe_ctlr
*fip
= arg
;
2523 struct fc_exch
*exch
= fc_seq_exch(seq
);
2524 struct fc_lport
*lport
= exch
->lp
;
2530 mac
= fr_cb(fp
)->granted_mac
;
2532 if (is_zero_ether_addr(mac
))
2533 fcoe_ctlr_recv_flogi(fip
, lport
, fp
);
2534 if (!is_zero_ether_addr(mac
))
2535 fcoe_update_src_mac(lport
, mac
);
2537 fc_lport_flogi_resp(seq
, fp
, lport
);
2541 * fcoe_logo_resp() - FCoE specific LOGO response handler
2542 * @seq: active sequence in the LOGO exchange
2543 * @fp: response frame, or error encoded in a pointer (timeout)
2544 * @arg: pointer the the fcoe_ctlr structure
2546 * This handles MAC address management for FCoE, then passes control on to
2547 * the libfc LOGO response handler.
2549 static void fcoe_logo_resp(struct fc_seq
*seq
, struct fc_frame
*fp
, void *arg
)
2551 struct fc_lport
*lport
= arg
;
2552 static u8 zero_mac
[ETH_ALEN
] = { 0 };
2555 fcoe_update_src_mac(lport
, zero_mac
);
2556 fc_lport_logo_resp(seq
, fp
, lport
);
2560 * fcoe_elsct_send - FCoE specific ELS handler
2562 * This does special case handling of FIP encapsualted ELS exchanges for FCoE,
2563 * using FCoE specific response handlers and passing the FIP controller as
2564 * the argument (the lport is still available from the exchange).
2566 * Most of the work here is just handed off to the libfc routine.
2568 static struct fc_seq
*fcoe_elsct_send(struct fc_lport
*lport
, u32 did
,
2569 struct fc_frame
*fp
, unsigned int op
,
2570 void (*resp
)(struct fc_seq
*,
2573 void *arg
, u32 timeout
)
2575 struct fcoe_port
*port
= lport_priv(lport
);
2576 struct fcoe_interface
*fcoe
= port
->priv
;
2577 struct fcoe_ctlr
*fip
= &fcoe
->ctlr
;
2578 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
2583 if (lport
->point_to_multipoint
)
2585 return fc_elsct_send(lport
, did
, fp
, op
, fcoe_flogi_resp
,
2588 /* only hook onto fabric logouts, not port logouts */
2589 if (ntoh24(fh
->fh_d_id
) != FC_FID_FLOGI
)
2591 return fc_elsct_send(lport
, did
, fp
, op
, fcoe_logo_resp
,
2594 return fc_elsct_send(lport
, did
, fp
, op
, resp
, arg
, timeout
);
2598 * fcoe_vport_create() - create an fc_host/scsi_host for a vport
2599 * @vport: fc_vport object to create a new fc_host for
2600 * @disabled: start the new fc_host in a disabled state by default?
2602 * Returns: 0 for success
2604 static int fcoe_vport_create(struct fc_vport
*vport
, bool disabled
)
2606 struct Scsi_Host
*shost
= vport_to_shost(vport
);
2607 struct fc_lport
*n_port
= shost_priv(shost
);
2608 struct fcoe_port
*port
= lport_priv(n_port
);
2609 struct fcoe_interface
*fcoe
= port
->priv
;
2610 struct net_device
*netdev
= fcoe
->netdev
;
2611 struct fc_lport
*vn_port
;
2615 rc
= fcoe_validate_vport_create(vport
);
2617 fcoe_wwn_to_str(vport
->port_name
, buf
, sizeof(buf
));
2618 printk(KERN_ERR
"fcoe: Failed to create vport, "
2619 "WWPN (0x%s) already exists\n",
2624 mutex_lock(&fcoe_config_mutex
);
2626 vn_port
= fcoe_if_create(fcoe
, &vport
->dev
, 1);
2628 mutex_unlock(&fcoe_config_mutex
);
2630 if (IS_ERR(vn_port
)) {
2631 printk(KERN_ERR
"fcoe: fcoe_vport_create(%s) failed\n",
2637 fc_vport_set_state(vport
, FC_VPORT_DISABLED
);
2639 vn_port
->boot_time
= jiffies
;
2640 fc_fabric_login(vn_port
);
2641 fc_vport_setlink(vn_port
);
2647 * fcoe_vport_destroy() - destroy the fc_host/scsi_host for a vport
2648 * @vport: fc_vport object that is being destroyed
2650 * Returns: 0 for success
2652 static int fcoe_vport_destroy(struct fc_vport
*vport
)
2654 struct Scsi_Host
*shost
= vport_to_shost(vport
);
2655 struct fc_lport
*n_port
= shost_priv(shost
);
2656 struct fc_lport
*vn_port
= vport
->dd_data
;
2658 mutex_lock(&n_port
->lp_mutex
);
2659 list_del(&vn_port
->list
);
2660 mutex_unlock(&n_port
->lp_mutex
);
2662 mutex_lock(&fcoe_config_mutex
);
2663 fcoe_if_destroy(vn_port
);
2664 mutex_unlock(&fcoe_config_mutex
);
2670 * fcoe_vport_disable() - change vport state
2671 * @vport: vport to bring online/offline
2672 * @disable: should the vport be disabled?
2674 static int fcoe_vport_disable(struct fc_vport
*vport
, bool disable
)
2676 struct fc_lport
*lport
= vport
->dd_data
;
2679 fc_vport_set_state(vport
, FC_VPORT_DISABLED
);
2680 fc_fabric_logoff(lport
);
2682 lport
->boot_time
= jiffies
;
2683 fc_fabric_login(lport
);
2684 fc_vport_setlink(lport
);
2691 * fcoe_vport_set_symbolic_name() - append vport string to symbolic name
2692 * @vport: fc_vport with a new symbolic name string
2694 * After generating a new symbolic name string, a new RSPN_ID request is
2695 * sent to the name server. There is no response handler, so if it fails
2696 * for some reason it will not be retried.
2698 static void fcoe_set_vport_symbolic_name(struct fc_vport
*vport
)
2700 struct fc_lport
*lport
= vport
->dd_data
;
2701 struct fc_frame
*fp
;
2704 snprintf(fc_host_symbolic_name(lport
->host
), FC_SYMBOLIC_NAME_SIZE
,
2705 "%s v%s over %s : %s", FCOE_NAME
, FCOE_VERSION
,
2706 fcoe_netdev(lport
)->name
, vport
->symbolic_name
);
2708 if (lport
->state
!= LPORT_ST_READY
)
2711 len
= strnlen(fc_host_symbolic_name(lport
->host
), 255);
2712 fp
= fc_frame_alloc(lport
,
2713 sizeof(struct fc_ct_hdr
) +
2714 sizeof(struct fc_ns_rspn
) + len
);
2717 lport
->tt
.elsct_send(lport
, FC_FID_DIR_SERV
, fp
, FC_NS_RSPN_ID
,
2718 NULL
, NULL
, 3 * lport
->r_a_tov
);
2722 * fcoe_get_lesb() - Fill the FCoE Link Error Status Block
2723 * @lport: the local port
2724 * @fc_lesb: the link error status block
2726 static void fcoe_get_lesb(struct fc_lport
*lport
,
2727 struct fc_els_lesb
*fc_lesb
)
2729 struct net_device
*netdev
= fcoe_netdev(lport
);
2731 __fcoe_get_lesb(lport
, fc_lesb
, netdev
);
2735 * fcoe_set_port_id() - Callback from libfc when Port_ID is set.
2736 * @lport: the local port
2737 * @port_id: the port ID
2738 * @fp: the received frame, if any, that caused the port_id to be set.
2740 * This routine handles the case where we received a FLOGI and are
2741 * entering point-to-point mode. We need to call fcoe_ctlr_recv_flogi()
2742 * so it can set the non-mapped mode and gateway address.
2744 * The FLOGI LS_ACC is handled by fcoe_flogi_resp().
2746 static void fcoe_set_port_id(struct fc_lport
*lport
,
2747 u32 port_id
, struct fc_frame
*fp
)
2749 struct fcoe_port
*port
= lport_priv(lport
);
2750 struct fcoe_interface
*fcoe
= port
->priv
;
2752 if (fp
&& fc_frame_payload_op(fp
) == ELS_FLOGI
)
2753 fcoe_ctlr_recv_flogi(&fcoe
->ctlr
, lport
, fp
);