449d31ea07bd45346ff51114a4df2bc96ba4f441
[linux-2.6.git] / drivers / scsi / fcoe / fcoe.c
1 /*
2  * Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved.
3  *
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.
7  *
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
11  * more details.
12  *
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.
16  *
17  * Maintained at www.Open-FCoE.org
18  */
19
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>
30 #include <linux/fs.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>
41
42 #include <scsi/fc/fc_encaps.h>
43 #include <scsi/fc/fc_fip.h>
44
45 #include <scsi/libfc.h>
46 #include <scsi/fc_frame.h>
47 #include <scsi/libfcoe.h>
48
49 #include "fcoe.h"
50
51 MODULE_AUTHOR("Open-FCoE.org");
52 MODULE_DESCRIPTION("FCoE");
53 MODULE_LICENSE("GPL v2");
54
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).");
60
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");
64
65 static DEFINE_MUTEX(fcoe_config_mutex);
66
67 static struct workqueue_struct *fcoe_wq;
68
69 /* fcoe_percpu_clean completion.  Waiter protected by fcoe_create_mutex */
70 static DECLARE_COMPLETION(fcoe_flush_completion);
71
72 /* fcoe host list */
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);
76
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 *);
86
87 static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *);
88 static int fcoe_hostlist_add(const struct fc_lport *);
89
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 *);
95
96 static int fcoe_fip_recv(struct sk_buff *, struct net_device *,
97                          struct packet_type *, struct net_device *);
98
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 *);
103
104 static int fcoe_ddp_setup(struct fc_lport *, u16, struct scatterlist *,
105                           unsigned int);
106 static int fcoe_ddp_done(struct fc_lport *, u16);
107 static int fcoe_ddp_target(struct fc_lport *, u16, struct scatterlist *,
108                            unsigned int);
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);
112
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);
118
119 static struct fc_seq *fcoe_elsct_send(struct fc_lport *,
120                                       u32 did, struct fc_frame *,
121                                       unsigned int op,
122                                       void (*resp)(struct fc_seq *,
123                                                    struct fc_frame *,
124                                                    void *),
125                                       void *, u32 timeout);
126 static void fcoe_recv_frame(struct sk_buff *skb);
127
128 static void fcoe_get_lesb(struct fc_lport *, struct fc_els_lesb *);
129
130 /* notification function for packets from net device */
131 static struct notifier_block fcoe_notifier = {
132         .notifier_call = fcoe_device_notification,
133 };
134
135 /* notification function for CPU hotplug events */
136 static struct notifier_block fcoe_cpu_notifier = {
137         .notifier_call = fcoe_cpu_callback,
138 };
139
140 /* notification function for DCB events */
141 static struct notifier_block dcb_notifier = {
142         .notifier_call = fcoe_dcb_app_notification,
143 };
144
145 static struct scsi_transport_template *fcoe_nport_scsi_transport;
146 static struct scsi_transport_template *fcoe_vport_scsi_transport;
147
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 *);
153
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,
162 };
163
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,
179
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,
188
189         .dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
190         .show_rport_maxframe_size = 1,
191         .show_rport_supported_classes = 1,
192
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,
201
202         .terminate_rport_io = fc_rport_terminate_io,
203
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,
208
209         .bsg_request = fc_lport_bsg_request,
210 };
211
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,
227
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,
236
237         .dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
238         .show_rport_maxframe_size = 1,
239         .show_rport_supported_classes = 1,
240
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,
249
250         .terminate_rport_io = fc_rport_terminate_io,
251
252         .bsg_request = fc_lport_bsg_request,
253 };
254
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,
266         .this_id = -1,
267         .cmd_per_lun = 3,
268         .can_queue = FCOE_MAX_OUTSTANDING_COMMANDS,
269         .use_clustering = ENABLE_CLUSTERING,
270         .sg_tablesize = SG_ALL,
271         .max_sectors = 0xffff,
272 };
273
274 /**
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
278  *
279  * Returns : 0 for success
280  * Locking: must be called with the RTNL mutex held
281  */
282 static int fcoe_interface_setup(struct fcoe_interface *fcoe,
283                                 struct net_device *netdev)
284 {
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;
290
291         fcoe->netdev = netdev;
292
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");
299         }
300
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");
304                 return -EOPNOTSUPP;
305         }
306
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;
312         rcu_read_lock();
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);
317                         fip->spma = 1;
318                         break;
319                 }
320         }
321         rcu_read_unlock();
322
323         /* setup Source Mac Address */
324         if (!fip->spma)
325                 memcpy(fip->ctl_src_addr, netdev->dev_addr, netdev->addr_len);
326
327         /*
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.
331          */
332         memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
333         dev_uc_add(netdev, flogi_maddr);
334         if (fip->spma)
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);
339         } else
340                 dev_mc_add(netdev, FIP_ALL_ENODE_MACS);
341
342         /*
343          * setup the receive function from ethernet driver
344          * on the ethertype for the given device
345          */
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);
350
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);
355
356         return 0;
357 }
358
359 /**
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
363  *
364  * Returns: pointer to a struct fcoe_interface or NULL on error
365  */
366 static struct fcoe_interface *fcoe_interface_create(struct net_device *netdev,
367                                                     enum fip_state fip_mode)
368 {
369         struct fcoe_interface *fcoe;
370         int err;
371
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);
376                 goto out;
377         }
378
379         fcoe = kzalloc(sizeof(*fcoe), GFP_KERNEL);
380         if (!fcoe) {
381                 FCOE_NETDEV_DBG(netdev, "Could not allocate fcoe structure\n");
382                 fcoe = ERR_PTR(-ENOMEM);
383                 goto out_putmod;
384         }
385
386         dev_hold(netdev);
387         kref_init(&fcoe->kref);
388
389         /*
390          * Initialize FIP.
391          */
392         fcoe_ctlr_init(&fcoe->ctlr, fip_mode);
393         fcoe->ctlr.send = fcoe_fip_send;
394         fcoe->ctlr.update_mac = fcoe_update_src_mac;
395         fcoe->ctlr.get_src_addr = fcoe_get_src_mac;
396
397         err = fcoe_interface_setup(fcoe, netdev);
398         if (err) {
399                 fcoe_ctlr_destroy(&fcoe->ctlr);
400                 kfree(fcoe);
401                 dev_put(netdev);
402                 fcoe = ERR_PTR(err);
403                 goto out_putmod;
404         }
405
406         goto out;
407
408 out_putmod:
409         module_put(THIS_MODULE);
410 out:
411         return fcoe;
412 }
413
414 /**
415  * fcoe_interface_release() - fcoe_port kref release function
416  * @kref: Embedded reference count in an fcoe_interface struct
417  */
418 static void fcoe_interface_release(struct kref *kref)
419 {
420         struct fcoe_interface *fcoe;
421         struct net_device *netdev;
422
423         fcoe = container_of(kref, struct fcoe_interface, kref);
424         netdev = fcoe->netdev;
425         /* tear-down the FCoE controller */
426         fcoe_ctlr_destroy(&fcoe->ctlr);
427         kfree(fcoe);
428         dev_put(netdev);
429         module_put(THIS_MODULE);
430 }
431
432 /**
433  * fcoe_interface_get() - Get a reference to a FCoE interface
434  * @fcoe: The FCoE interface to be held
435  */
436 static inline void fcoe_interface_get(struct fcoe_interface *fcoe)
437 {
438         kref_get(&fcoe->kref);
439 }
440
441 /**
442  * fcoe_interface_put() - Put a reference to a FCoE interface
443  * @fcoe: The FCoE interface to be released
444  */
445 static inline void fcoe_interface_put(struct fcoe_interface *fcoe)
446 {
447         kref_put(&fcoe->kref, fcoe_interface_release);
448 }
449
450 /**
451  * fcoe_interface_cleanup() - Clean up a FCoE interface
452  * @fcoe: The FCoE interface to be cleaned up
453  *
454  * Caller must be holding the RTNL mutex
455  */
456 static void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
457 {
458         struct net_device *netdev = fcoe->netdev;
459         struct fcoe_ctlr *fip = &fcoe->ctlr;
460         u8 flogi_maddr[ETH_ALEN];
461         const struct net_device_ops *ops;
462
463         rtnl_lock();
464
465         /*
466          * Don't listen for Ethernet packets anymore.
467          * synchronize_net() ensures that the packet handlers are not running
468          * on another CPU. dev_remove_pack() would do that, this calls the
469          * unsyncronized version __dev_remove_pack() to avoid multiple delays.
470          */
471         __dev_remove_pack(&fcoe->fcoe_packet_type);
472         __dev_remove_pack(&fcoe->fip_packet_type);
473         synchronize_net();
474
475         /* Delete secondary MAC addresses */
476         memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
477         dev_uc_del(netdev, flogi_maddr);
478         if (fip->spma)
479                 dev_uc_del(netdev, fip->ctl_src_addr);
480         if (fip->mode == FIP_MODE_VN2VN) {
481                 dev_mc_del(netdev, FIP_ALL_VN2VN_MACS);
482                 dev_mc_del(netdev, FIP_ALL_P2P_MACS);
483         } else
484                 dev_mc_del(netdev, FIP_ALL_ENODE_MACS);
485
486         /* Tell the LLD we are done w/ FCoE */
487         ops = netdev->netdev_ops;
488         if (ops->ndo_fcoe_disable) {
489                 if (ops->ndo_fcoe_disable(netdev))
490                         FCOE_NETDEV_DBG(netdev, "Failed to disable FCoE"
491                                         " specific feature for LLD.\n");
492         }
493
494         rtnl_unlock();
495
496         /* Release the self-reference taken during fcoe_interface_create() */
497         fcoe_interface_put(fcoe);
498 }
499
500 /**
501  * fcoe_fip_recv() - Handler for received FIP frames
502  * @skb:      The receive skb
503  * @netdev:   The associated net device
504  * @ptype:    The packet_type structure which was used to register this handler
505  * @orig_dev: The original net_device the the skb was received on.
506  *            (in case dev is a bond)
507  *
508  * Returns: 0 for success
509  */
510 static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *netdev,
511                          struct packet_type *ptype,
512                          struct net_device *orig_dev)
513 {
514         struct fcoe_interface *fcoe;
515
516         fcoe = container_of(ptype, struct fcoe_interface, fip_packet_type);
517         fcoe_ctlr_recv(&fcoe->ctlr, skb);
518         return 0;
519 }
520
521 /**
522  * fcoe_port_send() - Send an Ethernet-encapsulated FIP/FCoE frame
523  * @port: The FCoE port
524  * @skb: The FIP/FCoE packet to be sent
525  */
526 static void fcoe_port_send(struct fcoe_port *port, struct sk_buff *skb)
527 {
528         if (port->fcoe_pending_queue.qlen)
529                 fcoe_check_wait_queue(port->lport, skb);
530         else if (fcoe_start_io(skb))
531                 fcoe_check_wait_queue(port->lport, skb);
532 }
533
534 /**
535  * fcoe_fip_send() - Send an Ethernet-encapsulated FIP frame
536  * @fip: The FCoE controller
537  * @skb: The FIP packet to be sent
538  */
539 static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
540 {
541         skb->dev = fcoe_from_ctlr(fip)->netdev;
542         fcoe_port_send(lport_priv(fip->lp), skb);
543 }
544
545 /**
546  * fcoe_update_src_mac() - Update the Ethernet MAC filters
547  * @lport: The local port to update the source MAC on
548  * @addr:  Unicast MAC address to add
549  *
550  * Remove any previously-set unicast MAC filter.
551  * Add secondary FCoE MAC address filter for our OUI.
552  */
553 static void fcoe_update_src_mac(struct fc_lport *lport, u8 *addr)
554 {
555         struct fcoe_port *port = lport_priv(lport);
556         struct fcoe_interface *fcoe = port->priv;
557
558         rtnl_lock();
559         if (!is_zero_ether_addr(port->data_src_addr))
560                 dev_uc_del(fcoe->netdev, port->data_src_addr);
561         if (!is_zero_ether_addr(addr))
562                 dev_uc_add(fcoe->netdev, addr);
563         memcpy(port->data_src_addr, addr, ETH_ALEN);
564         rtnl_unlock();
565 }
566
567 /**
568  * fcoe_get_src_mac() - return the Ethernet source address for an lport
569  * @lport: libfc lport
570  */
571 static u8 *fcoe_get_src_mac(struct fc_lport *lport)
572 {
573         struct fcoe_port *port = lport_priv(lport);
574
575         return port->data_src_addr;
576 }
577
578 /**
579  * fcoe_lport_config() - Set up a local port
580  * @lport: The local port to be setup
581  *
582  * Returns: 0 for success
583  */
584 static int fcoe_lport_config(struct fc_lport *lport)
585 {
586         lport->link_up = 0;
587         lport->qfull = 0;
588         lport->max_retry_count = 3;
589         lport->max_rport_retry_count = 3;
590         lport->e_d_tov = 2 * 1000;      /* FC-FS default */
591         lport->r_a_tov = 2 * 2 * 1000;
592         lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
593                                  FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
594         lport->does_npiv = 1;
595
596         fc_lport_init_stats(lport);
597
598         /* lport fc_lport related configuration */
599         fc_lport_config(lport);
600
601         /* offload related configuration */
602         lport->crc_offload = 0;
603         lport->seq_offload = 0;
604         lport->lro_enabled = 0;
605         lport->lro_xid = 0;
606         lport->lso_max = 0;
607
608         return 0;
609 }
610
611 /**
612  * fcoe_netdev_features_change - Updates the lport's offload flags based
613  * on the LLD netdev's FCoE feature flags
614  */
615 static void fcoe_netdev_features_change(struct fc_lport *lport,
616                                         struct net_device *netdev)
617 {
618         mutex_lock(&lport->lp_mutex);
619
620         if (netdev->features & NETIF_F_SG)
621                 lport->sg_supp = 1;
622         else
623                 lport->sg_supp = 0;
624
625         if (netdev->features & NETIF_F_FCOE_CRC) {
626                 lport->crc_offload = 1;
627                 FCOE_NETDEV_DBG(netdev, "Supports FCCRC offload\n");
628         } else {
629                 lport->crc_offload = 0;
630         }
631
632         if (netdev->features & NETIF_F_FSO) {
633                 lport->seq_offload = 1;
634                 lport->lso_max = netdev->gso_max_size;
635                 FCOE_NETDEV_DBG(netdev, "Supports LSO for max len 0x%x\n",
636                                 lport->lso_max);
637         } else {
638                 lport->seq_offload = 0;
639                 lport->lso_max = 0;
640         }
641
642         if (netdev->fcoe_ddp_xid) {
643                 lport->lro_enabled = 1;
644                 lport->lro_xid = netdev->fcoe_ddp_xid;
645                 FCOE_NETDEV_DBG(netdev, "Supports LRO for max xid 0x%x\n",
646                                 lport->lro_xid);
647         } else {
648                 lport->lro_enabled = 0;
649                 lport->lro_xid = 0;
650         }
651
652         mutex_unlock(&lport->lp_mutex);
653 }
654
655 /**
656  * fcoe_netdev_config() - Set up net devive for SW FCoE
657  * @lport:  The local port that is associated with the net device
658  * @netdev: The associated net device
659  *
660  * Must be called after fcoe_lport_config() as it will use local port mutex
661  *
662  * Returns: 0 for success
663  */
664 static int fcoe_netdev_config(struct fc_lport *lport, struct net_device *netdev)
665 {
666         u32 mfs;
667         u64 wwnn, wwpn;
668         struct fcoe_interface *fcoe;
669         struct fcoe_port *port;
670
671         /* Setup lport private data to point to fcoe softc */
672         port = lport_priv(lport);
673         fcoe = port->priv;
674
675         /*
676          * Determine max frame size based on underlying device and optional
677          * user-configured limit.  If the MFS is too low, fcoe_link_ok()
678          * will return 0, so do this first.
679          */
680         mfs = netdev->mtu;
681         if (netdev->features & NETIF_F_FCOE_MTU) {
682                 mfs = FCOE_MTU;
683                 FCOE_NETDEV_DBG(netdev, "Supports FCOE_MTU of %d bytes\n", mfs);
684         }
685         mfs -= (sizeof(struct fcoe_hdr) + sizeof(struct fcoe_crc_eof));
686         if (fc_set_mfs(lport, mfs))
687                 return -EINVAL;
688
689         /* offload features support */
690         fcoe_netdev_features_change(lport, netdev);
691
692         skb_queue_head_init(&port->fcoe_pending_queue);
693         port->fcoe_pending_queue_active = 0;
694         setup_timer(&port->timer, fcoe_queue_timer, (unsigned long)lport);
695
696         fcoe_link_speed_update(lport);
697
698         if (!lport->vport) {
699                 if (fcoe_get_wwn(netdev, &wwnn, NETDEV_FCOE_WWNN))
700                         wwnn = fcoe_wwn_from_mac(fcoe->ctlr.ctl_src_addr, 1, 0);
701                 fc_set_wwnn(lport, wwnn);
702                 if (fcoe_get_wwn(netdev, &wwpn, NETDEV_FCOE_WWPN))
703                         wwpn = fcoe_wwn_from_mac(fcoe->ctlr.ctl_src_addr,
704                                                  2, 0);
705                 fc_set_wwpn(lport, wwpn);
706         }
707
708         return 0;
709 }
710
711 /**
712  * fcoe_shost_config() - Set up the SCSI host associated with a local port
713  * @lport: The local port
714  * @dev:   The device associated with the SCSI host
715  *
716  * Must be called after fcoe_lport_config() and fcoe_netdev_config()
717  *
718  * Returns: 0 for success
719  */
720 static int fcoe_shost_config(struct fc_lport *lport, struct device *dev)
721 {
722         int rc = 0;
723
724         /* lport scsi host config */
725         lport->host->max_lun = FCOE_MAX_LUN;
726         lport->host->max_id = FCOE_MAX_FCP_TARGET;
727         lport->host->max_channel = 0;
728         lport->host->max_cmd_len = FCOE_MAX_CMD_LEN;
729
730         if (lport->vport)
731                 lport->host->transportt = fcoe_vport_scsi_transport;
732         else
733                 lport->host->transportt = fcoe_nport_scsi_transport;
734
735         /* add the new host to the SCSI-ml */
736         rc = scsi_add_host(lport->host, dev);
737         if (rc) {
738                 FCOE_NETDEV_DBG(fcoe_netdev(lport), "fcoe_shost_config: "
739                                 "error on scsi_add_host\n");
740                 return rc;
741         }
742
743         if (!lport->vport)
744                 fc_host_max_npiv_vports(lport->host) = USHRT_MAX;
745
746         snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
747                  "%s v%s over %s", FCOE_NAME, FCOE_VERSION,
748                  fcoe_netdev(lport)->name);
749
750         return 0;
751 }
752
753
754 /**
755  * fcoe_fdmi_info() - Get FDMI related info from net devive for SW FCoE
756  * @lport:  The local port that is associated with the net device
757  * @netdev: The associated net device
758  *
759  * Must be called after fcoe_shost_config() as it will use local port mutex
760  *
761  */
762 static void fcoe_fdmi_info(struct fc_lport *lport, struct net_device *netdev)
763 {
764         struct fcoe_interface *fcoe;
765         struct fcoe_port *port;
766         struct net_device *realdev;
767         int rc;
768         struct netdev_fcoe_hbainfo fdmi;
769
770         port = lport_priv(lport);
771         fcoe = port->priv;
772         realdev = fcoe->realdev;
773
774         if (!realdev)
775                 return;
776
777         /* No FDMI state m/c for NPIV ports */
778         if (lport->vport)
779                 return;
780
781         if (realdev->netdev_ops->ndo_fcoe_get_hbainfo) {
782                 memset(&fdmi, 0, sizeof(fdmi));
783                 rc = realdev->netdev_ops->ndo_fcoe_get_hbainfo(realdev,
784                                                                &fdmi);
785                 if (rc) {
786                         printk(KERN_INFO "fcoe: Failed to retrieve FDMI "
787                                         "information from netdev.\n");
788                         return;
789                 }
790
791                 snprintf(fc_host_serial_number(lport->host),
792                          FC_SERIAL_NUMBER_SIZE,
793                          "%s",
794                          fdmi.serial_number);
795                 snprintf(fc_host_manufacturer(lport->host),
796                          FC_SERIAL_NUMBER_SIZE,
797                          "%s",
798                          fdmi.manufacturer);
799                 snprintf(fc_host_model(lport->host),
800                          FC_SYMBOLIC_NAME_SIZE,
801                          "%s",
802                          fdmi.model);
803                 snprintf(fc_host_model_description(lport->host),
804                          FC_SYMBOLIC_NAME_SIZE,
805                          "%s",
806                          fdmi.model_description);
807                 snprintf(fc_host_hardware_version(lport->host),
808                          FC_VERSION_STRING_SIZE,
809                          "%s",
810                          fdmi.hardware_version);
811                 snprintf(fc_host_driver_version(lport->host),
812                          FC_VERSION_STRING_SIZE,
813                          "%s",
814                          fdmi.driver_version);
815                 snprintf(fc_host_optionrom_version(lport->host),
816                          FC_VERSION_STRING_SIZE,
817                          "%s",
818                          fdmi.optionrom_version);
819                 snprintf(fc_host_firmware_version(lport->host),
820                          FC_VERSION_STRING_SIZE,
821                          "%s",
822                          fdmi.firmware_version);
823
824                 /* Enable FDMI lport states */
825                 lport->fdmi_enabled = 1;
826         } else {
827                 lport->fdmi_enabled = 0;
828                 printk(KERN_INFO "fcoe: No FDMI support.\n");
829         }
830 }
831
832 /**
833  * fcoe_oem_match() - The match routine for the offloaded exchange manager
834  * @fp: The I/O frame
835  *
836  * This routine will be associated with an exchange manager (EM). When
837  * the libfc exchange handling code is looking for an EM to use it will
838  * call this routine and pass it the frame that it wishes to send. This
839  * routine will return True if the associated EM is to be used and False
840  * if the echange code should continue looking for an EM.
841  *
842  * The offload EM that this routine is associated with will handle any
843  * packets that are for SCSI read requests.
844  *
845  * This has been enhanced to work when FCoE stack is operating in target
846  * mode.
847  *
848  * Returns: True for read types I/O, otherwise returns false.
849  */
850 static bool fcoe_oem_match(struct fc_frame *fp)
851 {
852         struct fc_frame_header *fh = fc_frame_header_get(fp);
853         struct fcp_cmnd *fcp;
854
855         if (fc_fcp_is_read(fr_fsp(fp)) &&
856             (fr_fsp(fp)->data_len > fcoe_ddp_min))
857                 return true;
858         else if ((fr_fsp(fp) == NULL) &&
859                  (fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD) &&
860                  (ntohs(fh->fh_rx_id) == FC_XID_UNKNOWN)) {
861                 fcp = fc_frame_payload_get(fp, sizeof(*fcp));
862                 if ((fcp->fc_flags & FCP_CFL_WRDATA) &&
863                     (ntohl(fcp->fc_dl) > fcoe_ddp_min))
864                         return true;
865         }
866         return false;
867 }
868
869 /**
870  * fcoe_em_config() - Allocate and configure an exchange manager
871  * @lport: The local port that the new EM will be associated with
872  *
873  * Returns: 0 on success
874  */
875 static inline int fcoe_em_config(struct fc_lport *lport)
876 {
877         struct fcoe_port *port = lport_priv(lport);
878         struct fcoe_interface *fcoe = port->priv;
879         struct fcoe_interface *oldfcoe = NULL;
880         struct net_device *old_real_dev, *cur_real_dev;
881         u16 min_xid = FCOE_MIN_XID;
882         u16 max_xid = FCOE_MAX_XID;
883
884         /*
885          * Check if need to allocate an em instance for
886          * offload exchange ids to be shared across all VN_PORTs/lport.
887          */
888         if (!lport->lro_enabled || !lport->lro_xid ||
889             (lport->lro_xid >= max_xid)) {
890                 lport->lro_xid = 0;
891                 goto skip_oem;
892         }
893
894         /*
895          * Reuse existing offload em instance in case
896          * it is already allocated on real eth device
897          */
898         if (fcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
899                 cur_real_dev = vlan_dev_real_dev(fcoe->netdev);
900         else
901                 cur_real_dev = fcoe->netdev;
902
903         list_for_each_entry(oldfcoe, &fcoe_hostlist, list) {
904                 if (oldfcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
905                         old_real_dev = vlan_dev_real_dev(oldfcoe->netdev);
906                 else
907                         old_real_dev = oldfcoe->netdev;
908
909                 if (cur_real_dev == old_real_dev) {
910                         fcoe->oem = oldfcoe->oem;
911                         break;
912                 }
913         }
914
915         if (fcoe->oem) {
916                 if (!fc_exch_mgr_add(lport, fcoe->oem, fcoe_oem_match)) {
917                         printk(KERN_ERR "fcoe_em_config: failed to add "
918                                "offload em:%p on interface:%s\n",
919                                fcoe->oem, fcoe->netdev->name);
920                         return -ENOMEM;
921                 }
922         } else {
923                 fcoe->oem = fc_exch_mgr_alloc(lport, FC_CLASS_3,
924                                               FCOE_MIN_XID, lport->lro_xid,
925                                               fcoe_oem_match);
926                 if (!fcoe->oem) {
927                         printk(KERN_ERR "fcoe_em_config: failed to allocate "
928                                "em for offload exches on interface:%s\n",
929                                fcoe->netdev->name);
930                         return -ENOMEM;
931                 }
932         }
933
934         /*
935          * Exclude offload EM xid range from next EM xid range.
936          */
937         min_xid += lport->lro_xid + 1;
938
939 skip_oem:
940         if (!fc_exch_mgr_alloc(lport, FC_CLASS_3, min_xid, max_xid, NULL)) {
941                 printk(KERN_ERR "fcoe_em_config: failed to "
942                        "allocate em on interface %s\n", fcoe->netdev->name);
943                 return -ENOMEM;
944         }
945
946         return 0;
947 }
948
949 /**
950  * fcoe_if_destroy() - Tear down a SW FCoE instance
951  * @lport: The local port to be destroyed
952  *
953  */
954 static void fcoe_if_destroy(struct fc_lport *lport)
955 {
956         struct fcoe_port *port = lport_priv(lport);
957         struct fcoe_interface *fcoe = port->priv;
958         struct net_device *netdev = fcoe->netdev;
959
960         FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
961
962         /* Logout of the fabric */
963         fc_fabric_logoff(lport);
964
965         /* Cleanup the fc_lport */
966         fc_lport_destroy(lport);
967
968         /* Stop the transmit retry timer */
969         del_timer_sync(&port->timer);
970
971         /* Free existing transmit skbs */
972         fcoe_clean_pending_queue(lport);
973
974         rtnl_lock();
975         if (!is_zero_ether_addr(port->data_src_addr))
976                 dev_uc_del(netdev, port->data_src_addr);
977         rtnl_unlock();
978
979         /* Release reference held in fcoe_if_create() */
980         fcoe_interface_put(fcoe);
981
982         /* Free queued packets for the per-CPU receive threads */
983         fcoe_percpu_clean(lport);
984
985         /* Detach from the scsi-ml */
986         fc_remove_host(lport->host);
987         scsi_remove_host(lport->host);
988
989         /* Destroy lport scsi_priv */
990         fc_fcp_destroy(lport);
991
992         /* There are no more rports or I/O, free the EM */
993         fc_exch_mgr_free(lport);
994
995         /* Free memory used by statistical counters */
996         fc_lport_free_stats(lport);
997
998         /* Release the Scsi_Host */
999         scsi_host_put(lport->host);
1000 }
1001
1002 /**
1003  * fcoe_ddp_setup() - Call a LLD's ddp_setup through the net device
1004  * @lport: The local port to setup DDP for
1005  * @xid:   The exchange ID for this DDP transfer
1006  * @sgl:   The scatterlist describing this transfer
1007  * @sgc:   The number of sg items
1008  *
1009  * Returns: 0 if the DDP context was not configured
1010  */
1011 static int fcoe_ddp_setup(struct fc_lport *lport, u16 xid,
1012                           struct scatterlist *sgl, unsigned int sgc)
1013 {
1014         struct net_device *netdev = fcoe_netdev(lport);
1015
1016         if (netdev->netdev_ops->ndo_fcoe_ddp_setup)
1017                 return netdev->netdev_ops->ndo_fcoe_ddp_setup(netdev,
1018                                                               xid, sgl,
1019                                                               sgc);
1020
1021         return 0;
1022 }
1023
1024 /**
1025  * fcoe_ddp_target() - Call a LLD's ddp_target through the net device
1026  * @lport: The local port to setup DDP for
1027  * @xid:   The exchange ID for this DDP transfer
1028  * @sgl:   The scatterlist describing this transfer
1029  * @sgc:   The number of sg items
1030  *
1031  * Returns: 0 if the DDP context was not configured
1032  */
1033 static int fcoe_ddp_target(struct fc_lport *lport, u16 xid,
1034                            struct scatterlist *sgl, unsigned int sgc)
1035 {
1036         struct net_device *netdev = fcoe_netdev(lport);
1037
1038         if (netdev->netdev_ops->ndo_fcoe_ddp_target)
1039                 return netdev->netdev_ops->ndo_fcoe_ddp_target(netdev, xid,
1040                                                                sgl, sgc);
1041
1042         return 0;
1043 }
1044
1045
1046 /**
1047  * fcoe_ddp_done() - Call a LLD's ddp_done through the net device
1048  * @lport: The local port to complete DDP on
1049  * @xid:   The exchange ID for this DDP transfer
1050  *
1051  * Returns: the length of data that have been completed by DDP
1052  */
1053 static int fcoe_ddp_done(struct fc_lport *lport, u16 xid)
1054 {
1055         struct net_device *netdev = fcoe_netdev(lport);
1056
1057         if (netdev->netdev_ops->ndo_fcoe_ddp_done)
1058                 return netdev->netdev_ops->ndo_fcoe_ddp_done(netdev, xid);
1059         return 0;
1060 }
1061
1062 /**
1063  * fcoe_if_create() - Create a FCoE instance on an interface
1064  * @fcoe:   The FCoE interface to create a local port on
1065  * @parent: The device pointer to be the parent in sysfs for the SCSI host
1066  * @npiv:   Indicates if the port is a vport or not
1067  *
1068  * Creates a fc_lport instance and a Scsi_Host instance and configure them.
1069  *
1070  * Returns: The allocated fc_lport or an error pointer
1071  */
1072 static struct fc_lport *fcoe_if_create(struct fcoe_interface *fcoe,
1073                                        struct device *parent, int npiv)
1074 {
1075         struct net_device *netdev = fcoe->netdev;
1076         struct fc_lport *lport, *n_port;
1077         struct fcoe_port *port;
1078         struct Scsi_Host *shost;
1079         int rc;
1080         /*
1081          * parent is only a vport if npiv is 1,
1082          * but we'll only use vport in that case so go ahead and set it
1083          */
1084         struct fc_vport *vport = dev_to_vport(parent);
1085
1086         FCOE_NETDEV_DBG(netdev, "Create Interface\n");
1087
1088         if (!npiv)
1089                 lport = libfc_host_alloc(&fcoe_shost_template, sizeof(*port));
1090         else
1091                 lport = libfc_vport_create(vport, sizeof(*port));
1092
1093         if (!lport) {
1094                 FCOE_NETDEV_DBG(netdev, "Could not allocate host structure\n");
1095                 rc = -ENOMEM;
1096                 goto out;
1097         }
1098         port = lport_priv(lport);
1099         port->lport = lport;
1100         port->priv = fcoe;
1101         port->max_queue_depth = FCOE_MAX_QUEUE_DEPTH;
1102         port->min_queue_depth = FCOE_MIN_QUEUE_DEPTH;
1103         INIT_WORK(&port->destroy_work, fcoe_destroy_work);
1104
1105         /* configure a fc_lport including the exchange manager */
1106         rc = fcoe_lport_config(lport);
1107         if (rc) {
1108                 FCOE_NETDEV_DBG(netdev, "Could not configure lport for the "
1109                                 "interface\n");
1110                 goto out_host_put;
1111         }
1112
1113         if (npiv) {
1114                 FCOE_NETDEV_DBG(netdev, "Setting vport names, "
1115                                 "%16.16llx %16.16llx\n",
1116                                 vport->node_name, vport->port_name);
1117                 fc_set_wwnn(lport, vport->node_name);
1118                 fc_set_wwpn(lport, vport->port_name);
1119         }
1120
1121         /* configure lport network properties */
1122         rc = fcoe_netdev_config(lport, netdev);
1123         if (rc) {
1124                 FCOE_NETDEV_DBG(netdev, "Could not configure netdev for the "
1125                                 "interface\n");
1126                 goto out_lp_destroy;
1127         }
1128
1129         /* configure lport scsi host properties */
1130         rc = fcoe_shost_config(lport, parent);
1131         if (rc) {
1132                 FCOE_NETDEV_DBG(netdev, "Could not configure shost for the "
1133                                 "interface\n");
1134                 goto out_lp_destroy;
1135         }
1136
1137         /* Initialize the library */
1138         rc = fcoe_libfc_config(lport, &fcoe->ctlr, &fcoe_libfc_fcn_templ, 1);
1139         if (rc) {
1140                 FCOE_NETDEV_DBG(netdev, "Could not configure libfc for the "
1141                                 "interface\n");
1142                 goto out_lp_destroy;
1143         }
1144
1145         /* Initialized FDMI information */
1146         fcoe_fdmi_info(lport, netdev);
1147
1148         /*
1149          * fcoe_em_alloc() and fcoe_hostlist_add() both
1150          * need to be atomic with respect to other changes to the
1151          * hostlist since fcoe_em_alloc() looks for an existing EM
1152          * instance on host list updated by fcoe_hostlist_add().
1153          *
1154          * This is currently handled through the fcoe_config_mutex
1155          * begin held.
1156          */
1157         if (!npiv)
1158                 /* lport exch manager allocation */
1159                 rc = fcoe_em_config(lport);
1160         else {
1161                 shost = vport_to_shost(vport);
1162                 n_port = shost_priv(shost);
1163                 rc = fc_exch_mgr_list_clone(n_port, lport);
1164         }
1165
1166         if (rc) {
1167                 FCOE_NETDEV_DBG(netdev, "Could not configure the EM\n");
1168                 goto out_lp_destroy;
1169         }
1170
1171         fcoe_interface_get(fcoe);
1172         return lport;
1173
1174 out_lp_destroy:
1175         fc_exch_mgr_free(lport);
1176 out_host_put:
1177         scsi_host_put(lport->host);
1178 out:
1179         return ERR_PTR(rc);
1180 }
1181
1182 /**
1183  * fcoe_if_init() - Initialization routine for fcoe.ko
1184  *
1185  * Attaches the SW FCoE transport to the FC transport
1186  *
1187  * Returns: 0 on success
1188  */
1189 static int __init fcoe_if_init(void)
1190 {
1191         /* attach to scsi transport */
1192         fcoe_nport_scsi_transport =
1193                 fc_attach_transport(&fcoe_nport_fc_functions);
1194         fcoe_vport_scsi_transport =
1195                 fc_attach_transport(&fcoe_vport_fc_functions);
1196
1197         if (!fcoe_nport_scsi_transport) {
1198                 printk(KERN_ERR "fcoe: Failed to attach to the FC transport\n");
1199                 return -ENODEV;
1200         }
1201
1202         return 0;
1203 }
1204
1205 /**
1206  * fcoe_if_exit() - Tear down fcoe.ko
1207  *
1208  * Detaches the SW FCoE transport from the FC transport
1209  *
1210  * Returns: 0 on success
1211  */
1212 static int __exit fcoe_if_exit(void)
1213 {
1214         fc_release_transport(fcoe_nport_scsi_transport);
1215         fc_release_transport(fcoe_vport_scsi_transport);
1216         fcoe_nport_scsi_transport = NULL;
1217         fcoe_vport_scsi_transport = NULL;
1218         return 0;
1219 }
1220
1221 /**
1222  * fcoe_percpu_thread_create() - Create a receive thread for an online CPU
1223  * @cpu: The CPU index of the CPU to create a receive thread for
1224  */
1225 static void fcoe_percpu_thread_create(unsigned int cpu)
1226 {
1227         struct fcoe_percpu_s *p;
1228         struct task_struct *thread;
1229
1230         p = &per_cpu(fcoe_percpu, cpu);
1231
1232         thread = kthread_create_on_node(fcoe_percpu_receive_thread,
1233                                         (void *)p, cpu_to_node(cpu),
1234                                         "fcoethread/%d", cpu);
1235
1236         if (likely(!IS_ERR(thread))) {
1237                 kthread_bind(thread, cpu);
1238                 wake_up_process(thread);
1239
1240                 spin_lock_bh(&p->fcoe_rx_list.lock);
1241                 p->thread = thread;
1242                 spin_unlock_bh(&p->fcoe_rx_list.lock);
1243         }
1244 }
1245
1246 /**
1247  * fcoe_percpu_thread_destroy() - Remove the receive thread of a CPU
1248  * @cpu: The CPU index of the CPU whose receive thread is to be destroyed
1249  *
1250  * Destroys a per-CPU Rx thread. Any pending skbs are moved to the
1251  * current CPU's Rx thread. If the thread being destroyed is bound to
1252  * the CPU processing this context the skbs will be freed.
1253  */
1254 static void fcoe_percpu_thread_destroy(unsigned int cpu)
1255 {
1256         struct fcoe_percpu_s *p;
1257         struct task_struct *thread;
1258         struct page *crc_eof;
1259         struct sk_buff *skb;
1260 #ifdef CONFIG_SMP
1261         struct fcoe_percpu_s *p0;
1262         unsigned targ_cpu = get_cpu();
1263 #endif /* CONFIG_SMP */
1264
1265         FCOE_DBG("Destroying receive thread for CPU %d\n", cpu);
1266
1267         /* Prevent any new skbs from being queued for this CPU. */
1268         p = &per_cpu(fcoe_percpu, cpu);
1269         spin_lock_bh(&p->fcoe_rx_list.lock);
1270         thread = p->thread;
1271         p->thread = NULL;
1272         crc_eof = p->crc_eof_page;
1273         p->crc_eof_page = NULL;
1274         p->crc_eof_offset = 0;
1275         spin_unlock_bh(&p->fcoe_rx_list.lock);
1276
1277 #ifdef CONFIG_SMP
1278         /*
1279          * Don't bother moving the skb's if this context is running
1280          * on the same CPU that is having its thread destroyed. This
1281          * can easily happen when the module is removed.
1282          */
1283         if (cpu != targ_cpu) {
1284                 p0 = &per_cpu(fcoe_percpu, targ_cpu);
1285                 spin_lock_bh(&p0->fcoe_rx_list.lock);
1286                 if (p0->thread) {
1287                         FCOE_DBG("Moving frames from CPU %d to CPU %d\n",
1288                                  cpu, targ_cpu);
1289
1290                         while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
1291                                 __skb_queue_tail(&p0->fcoe_rx_list, skb);
1292                         spin_unlock_bh(&p0->fcoe_rx_list.lock);
1293                 } else {
1294                         /*
1295                          * The targeted CPU is not initialized and cannot accept
1296                          * new  skbs. Unlock the targeted CPU and drop the skbs
1297                          * on the CPU that is going offline.
1298                          */
1299                         while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
1300                                 kfree_skb(skb);
1301                         spin_unlock_bh(&p0->fcoe_rx_list.lock);
1302                 }
1303         } else {
1304                 /*
1305                  * This scenario occurs when the module is being removed
1306                  * and all threads are being destroyed. skbs will continue
1307                  * to be shifted from the CPU thread that is being removed
1308                  * to the CPU thread associated with the CPU that is processing
1309                  * the module removal. Once there is only one CPU Rx thread it
1310                  * will reach this case and we will drop all skbs and later
1311                  * stop the thread.
1312                  */
1313                 spin_lock_bh(&p->fcoe_rx_list.lock);
1314                 while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
1315                         kfree_skb(skb);
1316                 spin_unlock_bh(&p->fcoe_rx_list.lock);
1317         }
1318         put_cpu();
1319 #else
1320         /*
1321          * This a non-SMP scenario where the singular Rx thread is
1322          * being removed. Free all skbs and stop the thread.
1323          */
1324         spin_lock_bh(&p->fcoe_rx_list.lock);
1325         while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
1326                 kfree_skb(skb);
1327         spin_unlock_bh(&p->fcoe_rx_list.lock);
1328 #endif
1329
1330         if (thread)
1331                 kthread_stop(thread);
1332
1333         if (crc_eof)
1334                 put_page(crc_eof);
1335 }
1336
1337 /**
1338  * fcoe_cpu_callback() - Handler for CPU hotplug events
1339  * @nfb:    The callback data block
1340  * @action: The event triggering the callback
1341  * @hcpu:   The index of the CPU that the event is for
1342  *
1343  * This creates or destroys per-CPU data for fcoe
1344  *
1345  * Returns NOTIFY_OK always.
1346  */
1347 static int fcoe_cpu_callback(struct notifier_block *nfb,
1348                              unsigned long action, void *hcpu)
1349 {
1350         unsigned cpu = (unsigned long)hcpu;
1351
1352         switch (action) {
1353         case CPU_ONLINE:
1354         case CPU_ONLINE_FROZEN:
1355                 FCOE_DBG("CPU %x online: Create Rx thread\n", cpu);
1356                 fcoe_percpu_thread_create(cpu);
1357                 break;
1358         case CPU_DEAD:
1359         case CPU_DEAD_FROZEN:
1360                 FCOE_DBG("CPU %x offline: Remove Rx thread\n", cpu);
1361                 fcoe_percpu_thread_destroy(cpu);
1362                 break;
1363         default:
1364                 break;
1365         }
1366         return NOTIFY_OK;
1367 }
1368
1369 /**
1370  * fcoe_select_cpu() - Selects CPU to handle post-processing of incoming
1371  *                      command.
1372  *
1373  * This routine selects next CPU based on cpumask to distribute
1374  * incoming requests in round robin.
1375  *
1376  * Returns: int CPU number
1377  */
1378 static inline unsigned int fcoe_select_cpu(void)
1379 {
1380         static unsigned int selected_cpu;
1381
1382         selected_cpu = cpumask_next(selected_cpu, cpu_online_mask);
1383         if (selected_cpu >= nr_cpu_ids)
1384                 selected_cpu = cpumask_first(cpu_online_mask);
1385
1386         return selected_cpu;
1387 }
1388
1389 /**
1390  * fcoe_rcv() - Receive packets from a net device
1391  * @skb:    The received packet
1392  * @netdev: The net device that the packet was received on
1393  * @ptype:  The packet type context
1394  * @olddev: The last device net device
1395  *
1396  * This routine is called by NET_RX_SOFTIRQ. It receives a packet, builds a
1397  * FC frame and passes the frame to libfc.
1398  *
1399  * Returns: 0 for success
1400  */
1401 static int fcoe_rcv(struct sk_buff *skb, struct net_device *netdev,
1402              struct packet_type *ptype, struct net_device *olddev)
1403 {
1404         struct fc_lport *lport;
1405         struct fcoe_rcv_info *fr;
1406         struct fcoe_interface *fcoe;
1407         struct fc_frame_header *fh;
1408         struct fcoe_percpu_s *fps;
1409         struct ethhdr *eh;
1410         unsigned int cpu;
1411
1412         fcoe = container_of(ptype, struct fcoe_interface, fcoe_packet_type);
1413         lport = fcoe->ctlr.lp;
1414         if (unlikely(!lport)) {
1415                 FCOE_NETDEV_DBG(netdev, "Cannot find hba structure");
1416                 goto err2;
1417         }
1418         if (!lport->link_up)
1419                 goto err2;
1420
1421         FCOE_NETDEV_DBG(netdev, "skb_info: len:%d data_len:%d head:%p "
1422                         "data:%p tail:%p end:%p sum:%d dev:%s",
1423                         skb->len, skb->data_len, skb->head, skb->data,
1424                         skb_tail_pointer(skb), skb_end_pointer(skb),
1425                         skb->csum, skb->dev ? skb->dev->name : "<NULL>");
1426
1427         eh = eth_hdr(skb);
1428
1429         if (is_fip_mode(&fcoe->ctlr) &&
1430             compare_ether_addr(eh->h_source, fcoe->ctlr.dest_addr)) {
1431                 FCOE_NETDEV_DBG(netdev, "wrong source mac address:%pM\n",
1432                                 eh->h_source);
1433                 goto err;
1434         }
1435
1436         /*
1437          * Check for minimum frame length, and make sure required FCoE
1438          * and FC headers are pulled into the linear data area.
1439          */
1440         if (unlikely((skb->len < FCOE_MIN_FRAME) ||
1441                      !pskb_may_pull(skb, FCOE_HEADER_LEN)))
1442                 goto err;
1443
1444         skb_set_transport_header(skb, sizeof(struct fcoe_hdr));
1445         fh = (struct fc_frame_header *) skb_transport_header(skb);
1446
1447         if (ntoh24(&eh->h_dest[3]) != ntoh24(fh->fh_d_id)) {
1448                 FCOE_NETDEV_DBG(netdev, "FC frame d_id mismatch with MAC:%pM\n",
1449                                 eh->h_dest);
1450                 goto err;
1451         }
1452
1453         fr = fcoe_dev_from_skb(skb);
1454         fr->fr_dev = lport;
1455
1456         /*
1457          * In case the incoming frame's exchange is originated from
1458          * the initiator, then received frame's exchange id is ANDed
1459          * with fc_cpu_mask bits to get the same cpu on which exchange
1460          * was originated, otherwise select cpu using rx exchange id
1461          * or fcoe_select_cpu().
1462          */
1463         if (ntoh24(fh->fh_f_ctl) & FC_FC_EX_CTX)
1464                 cpu = ntohs(fh->fh_ox_id) & fc_cpu_mask;
1465         else {
1466                 if (ntohs(fh->fh_rx_id) == FC_XID_UNKNOWN)
1467                         cpu = fcoe_select_cpu();
1468                 else
1469                         cpu = ntohs(fh->fh_rx_id) & fc_cpu_mask;
1470         }
1471
1472         if (cpu >= nr_cpu_ids)
1473                 goto err;
1474
1475         fps = &per_cpu(fcoe_percpu, cpu);
1476         spin_lock_bh(&fps->fcoe_rx_list.lock);
1477         if (unlikely(!fps->thread)) {
1478                 /*
1479                  * The targeted CPU is not ready, let's target
1480                  * the first CPU now. For non-SMP systems this
1481                  * will check the same CPU twice.
1482                  */
1483                 FCOE_NETDEV_DBG(netdev, "CPU is online, but no receive thread "
1484                                 "ready for incoming skb- using first online "
1485                                 "CPU.\n");
1486
1487                 spin_unlock_bh(&fps->fcoe_rx_list.lock);
1488                 cpu = cpumask_first(cpu_online_mask);
1489                 fps = &per_cpu(fcoe_percpu, cpu);
1490                 spin_lock_bh(&fps->fcoe_rx_list.lock);
1491                 if (!fps->thread) {
1492                         spin_unlock_bh(&fps->fcoe_rx_list.lock);
1493                         goto err;
1494                 }
1495         }
1496
1497         /*
1498          * We now have a valid CPU that we're targeting for
1499          * this skb. We also have this receive thread locked,
1500          * so we're free to queue skbs into it's queue.
1501          */
1502
1503         /* If this is a SCSI-FCP frame, and this is already executing on the
1504          * correct CPU, and the queue for this CPU is empty, then go ahead
1505          * and process the frame directly in the softirq context.
1506          * This lets us process completions without context switching from the
1507          * NET_RX softirq, to our receive processing thread, and then back to
1508          * BLOCK softirq context.
1509          */
1510         if (fh->fh_type == FC_TYPE_FCP &&
1511             cpu == smp_processor_id() &&
1512             skb_queue_empty(&fps->fcoe_rx_list)) {
1513                 spin_unlock_bh(&fps->fcoe_rx_list.lock);
1514                 fcoe_recv_frame(skb);
1515         } else {
1516                 __skb_queue_tail(&fps->fcoe_rx_list, skb);
1517                 if (fps->fcoe_rx_list.qlen == 1)
1518                         wake_up_process(fps->thread);
1519                 spin_unlock_bh(&fps->fcoe_rx_list.lock);
1520         }
1521
1522         return 0;
1523 err:
1524         per_cpu_ptr(lport->dev_stats, get_cpu())->ErrorFrames++;
1525         put_cpu();
1526 err2:
1527         kfree_skb(skb);
1528         return -1;
1529 }
1530
1531 /**
1532  * fcoe_alloc_paged_crc_eof() - Allocate a page to be used for the trailer CRC
1533  * @skb:  The packet to be transmitted
1534  * @tlen: The total length of the trailer
1535  *
1536  * Returns: 0 for success
1537  */
1538 static int fcoe_alloc_paged_crc_eof(struct sk_buff *skb, int tlen)
1539 {
1540         struct fcoe_percpu_s *fps;
1541         int rc;
1542
1543         fps = &get_cpu_var(fcoe_percpu);
1544         rc = fcoe_get_paged_crc_eof(skb, tlen, fps);
1545         put_cpu_var(fcoe_percpu);
1546
1547         return rc;
1548 }
1549
1550 /**
1551  * fcoe_xmit() - Transmit a FCoE frame
1552  * @lport: The local port that the frame is to be transmitted for
1553  * @fp:    The frame to be transmitted
1554  *
1555  * Return: 0 for success
1556  */
1557 static int fcoe_xmit(struct fc_lport *lport, struct fc_frame *fp)
1558 {
1559         int wlen;
1560         u32 crc;
1561         struct ethhdr *eh;
1562         struct fcoe_crc_eof *cp;
1563         struct sk_buff *skb;
1564         struct fcoe_dev_stats *stats;
1565         struct fc_frame_header *fh;
1566         unsigned int hlen;              /* header length implies the version */
1567         unsigned int tlen;              /* trailer length */
1568         unsigned int elen;              /* eth header, may include vlan */
1569         struct fcoe_port *port = lport_priv(lport);
1570         struct fcoe_interface *fcoe = port->priv;
1571         u8 sof, eof;
1572         struct fcoe_hdr *hp;
1573
1574         WARN_ON((fr_len(fp) % sizeof(u32)) != 0);
1575
1576         fh = fc_frame_header_get(fp);
1577         skb = fp_skb(fp);
1578         wlen = skb->len / FCOE_WORD_TO_BYTE;
1579
1580         if (!lport->link_up) {
1581                 kfree_skb(skb);
1582                 return 0;
1583         }
1584
1585         if (unlikely(fh->fh_type == FC_TYPE_ELS) &&
1586             fcoe_ctlr_els_send(&fcoe->ctlr, lport, skb))
1587                 return 0;
1588
1589         sof = fr_sof(fp);
1590         eof = fr_eof(fp);
1591
1592         elen = sizeof(struct ethhdr);
1593         hlen = sizeof(struct fcoe_hdr);
1594         tlen = sizeof(struct fcoe_crc_eof);
1595         wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;
1596
1597         /* crc offload */
1598         if (likely(lport->crc_offload)) {
1599                 skb->ip_summed = CHECKSUM_PARTIAL;
1600                 skb->csum_start = skb_headroom(skb);
1601                 skb->csum_offset = skb->len;
1602                 crc = 0;
1603         } else {
1604                 skb->ip_summed = CHECKSUM_NONE;
1605                 crc = fcoe_fc_crc(fp);
1606         }
1607
1608         /* copy port crc and eof to the skb buff */
1609         if (skb_is_nonlinear(skb)) {
1610                 skb_frag_t *frag;
1611                 if (fcoe_alloc_paged_crc_eof(skb, tlen)) {
1612                         kfree_skb(skb);
1613                         return -ENOMEM;
1614                 }
1615                 frag = &skb_shinfo(skb)->frags[skb_shinfo(skb)->nr_frags - 1];
1616                 cp = kmap_atomic(skb_frag_page(frag), KM_SKB_DATA_SOFTIRQ)
1617                         + frag->page_offset;
1618         } else {
1619                 cp = (struct fcoe_crc_eof *)skb_put(skb, tlen);
1620         }
1621
1622         memset(cp, 0, sizeof(*cp));
1623         cp->fcoe_eof = eof;
1624         cp->fcoe_crc32 = cpu_to_le32(~crc);
1625
1626         if (skb_is_nonlinear(skb)) {
1627                 kunmap_atomic(cp, KM_SKB_DATA_SOFTIRQ);
1628                 cp = NULL;
1629         }
1630
1631         /* adjust skb network/transport offsets to match mac/fcoe/port */
1632         skb_push(skb, elen + hlen);
1633         skb_reset_mac_header(skb);
1634         skb_reset_network_header(skb);
1635         skb->mac_len = elen;
1636         skb->protocol = htons(ETH_P_FCOE);
1637         skb->priority = port->priority;
1638
1639         if (fcoe->netdev->priv_flags & IFF_802_1Q_VLAN &&
1640             fcoe->realdev->features & NETIF_F_HW_VLAN_TX) {
1641                 skb->vlan_tci = VLAN_TAG_PRESENT |
1642                                 vlan_dev_vlan_id(fcoe->netdev);
1643                 skb->dev = fcoe->realdev;
1644         } else
1645                 skb->dev = fcoe->netdev;
1646
1647         /* fill up mac and fcoe headers */
1648         eh = eth_hdr(skb);
1649         eh->h_proto = htons(ETH_P_FCOE);
1650         memcpy(eh->h_dest, fcoe->ctlr.dest_addr, ETH_ALEN);
1651         if (fcoe->ctlr.map_dest)
1652                 memcpy(eh->h_dest + 3, fh->fh_d_id, 3);
1653
1654         if (unlikely(fcoe->ctlr.flogi_oxid != FC_XID_UNKNOWN))
1655                 memcpy(eh->h_source, fcoe->ctlr.ctl_src_addr, ETH_ALEN);
1656         else
1657                 memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);
1658
1659         hp = (struct fcoe_hdr *)(eh + 1);
1660         memset(hp, 0, sizeof(*hp));
1661         if (FC_FCOE_VER)
1662                 FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
1663         hp->fcoe_sof = sof;
1664
1665         /* fcoe lso, mss is in max_payload which is non-zero for FCP data */
1666         if (lport->seq_offload && fr_max_payload(fp)) {
1667                 skb_shinfo(skb)->gso_type = SKB_GSO_FCOE;
1668                 skb_shinfo(skb)->gso_size = fr_max_payload(fp);
1669         } else {
1670                 skb_shinfo(skb)->gso_type = 0;
1671                 skb_shinfo(skb)->gso_size = 0;
1672         }
1673         /* update tx stats: regardless if LLD fails */
1674         stats = per_cpu_ptr(lport->dev_stats, get_cpu());
1675         stats->TxFrames++;
1676         stats->TxWords += wlen;
1677         put_cpu();
1678
1679         /* send down to lld */
1680         fr_dev(fp) = lport;
1681         fcoe_port_send(port, skb);
1682         return 0;
1683 }
1684
1685 /**
1686  * fcoe_percpu_flush_done() - Indicate per-CPU queue flush completion
1687  * @skb: The completed skb (argument required by destructor)
1688  */
1689 static void fcoe_percpu_flush_done(struct sk_buff *skb)
1690 {
1691         complete(&fcoe_flush_completion);
1692 }
1693
1694 /**
1695  * fcoe_filter_frames() - filter out bad fcoe frames, i.e. bad CRC
1696  * @lport: The local port the frame was received on
1697  * @fp:    The received frame
1698  *
1699  * Return: 0 on passing filtering checks
1700  */
1701 static inline int fcoe_filter_frames(struct fc_lport *lport,
1702                                      struct fc_frame *fp)
1703 {
1704         struct fcoe_interface *fcoe;
1705         struct fc_frame_header *fh;
1706         struct sk_buff *skb = (struct sk_buff *)fp;
1707         struct fcoe_dev_stats *stats;
1708
1709         /*
1710          * We only check CRC if no offload is available and if it is
1711          * it's solicited data, in which case, the FCP layer would
1712          * check it during the copy.
1713          */
1714         if (lport->crc_offload && skb->ip_summed == CHECKSUM_UNNECESSARY)
1715                 fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
1716         else
1717                 fr_flags(fp) |= FCPHF_CRC_UNCHECKED;
1718
1719         fh = (struct fc_frame_header *) skb_transport_header(skb);
1720         fh = fc_frame_header_get(fp);
1721         if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA && fh->fh_type == FC_TYPE_FCP)
1722                 return 0;
1723
1724         fcoe = ((struct fcoe_port *)lport_priv(lport))->priv;
1725         if (is_fip_mode(&fcoe->ctlr) && fc_frame_payload_op(fp) == ELS_LOGO &&
1726             ntoh24(fh->fh_s_id) == FC_FID_FLOGI) {
1727                 FCOE_DBG("fcoe: dropping FCoE lport LOGO in fip mode\n");
1728                 return -EINVAL;
1729         }
1730
1731         if (!(fr_flags(fp) & FCPHF_CRC_UNCHECKED) ||
1732             le32_to_cpu(fr_crc(fp)) == ~crc32(~0, skb->data, skb->len)) {
1733                 fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
1734                 return 0;
1735         }
1736
1737         stats = per_cpu_ptr(lport->dev_stats, get_cpu());
1738         stats->InvalidCRCCount++;
1739         if (stats->InvalidCRCCount < 5)
1740                 printk(KERN_WARNING "fcoe: dropping frame with CRC error\n");
1741         put_cpu();
1742         return -EINVAL;
1743 }
1744
1745 /**
1746  * fcoe_recv_frame() - process a single received frame
1747  * @skb: frame to process
1748  */
1749 static void fcoe_recv_frame(struct sk_buff *skb)
1750 {
1751         u32 fr_len;
1752         struct fc_lport *lport;
1753         struct fcoe_rcv_info *fr;
1754         struct fcoe_dev_stats *stats;
1755         struct fcoe_crc_eof crc_eof;
1756         struct fc_frame *fp;
1757         struct fcoe_port *port;
1758         struct fcoe_hdr *hp;
1759
1760         fr = fcoe_dev_from_skb(skb);
1761         lport = fr->fr_dev;
1762         if (unlikely(!lport)) {
1763                 if (skb->destructor != fcoe_percpu_flush_done)
1764                         FCOE_NETDEV_DBG(skb->dev, "NULL lport in skb");
1765                 kfree_skb(skb);
1766                 return;
1767         }
1768
1769         FCOE_NETDEV_DBG(skb->dev, "skb_info: len:%d data_len:%d "
1770                         "head:%p data:%p tail:%p end:%p sum:%d dev:%s",
1771                         skb->len, skb->data_len,
1772                         skb->head, skb->data, skb_tail_pointer(skb),
1773                         skb_end_pointer(skb), skb->csum,
1774                         skb->dev ? skb->dev->name : "<NULL>");
1775
1776         port = lport_priv(lport);
1777         skb_linearize(skb); /* check for skb_is_nonlinear is within skb_linearize */
1778
1779         /*
1780          * Frame length checks and setting up the header pointers
1781          * was done in fcoe_rcv already.
1782          */
1783         hp = (struct fcoe_hdr *) skb_network_header(skb);
1784
1785         stats = per_cpu_ptr(lport->dev_stats, get_cpu());
1786         if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
1787                 if (stats->ErrorFrames < 5)
1788                         printk(KERN_WARNING "fcoe: FCoE version "
1789                                "mismatch: The frame has "
1790                                "version %x, but the "
1791                                "initiator supports version "
1792                                "%x\n", FC_FCOE_DECAPS_VER(hp),
1793                                FC_FCOE_VER);
1794                 goto drop;
1795         }
1796
1797         skb_pull(skb, sizeof(struct fcoe_hdr));
1798         fr_len = skb->len - sizeof(struct fcoe_crc_eof);
1799
1800         stats->RxFrames++;
1801         stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;
1802
1803         fp = (struct fc_frame *)skb;
1804         fc_frame_init(fp);
1805         fr_dev(fp) = lport;
1806         fr_sof(fp) = hp->fcoe_sof;
1807
1808         /* Copy out the CRC and EOF trailer for access */
1809         if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof)))
1810                 goto drop;
1811         fr_eof(fp) = crc_eof.fcoe_eof;
1812         fr_crc(fp) = crc_eof.fcoe_crc32;
1813         if (pskb_trim(skb, fr_len))
1814                 goto drop;
1815
1816         if (!fcoe_filter_frames(lport, fp)) {
1817                 put_cpu();
1818                 fc_exch_recv(lport, fp);
1819                 return;
1820         }
1821 drop:
1822         stats->ErrorFrames++;
1823         put_cpu();
1824         kfree_skb(skb);
1825 }
1826
1827 /**
1828  * fcoe_percpu_receive_thread() - The per-CPU packet receive thread
1829  * @arg: The per-CPU context
1830  *
1831  * Return: 0 for success
1832  */
1833 static int fcoe_percpu_receive_thread(void *arg)
1834 {
1835         struct fcoe_percpu_s *p = arg;
1836         struct sk_buff *skb;
1837
1838         set_user_nice(current, -20);
1839
1840         while (!kthread_should_stop()) {
1841
1842                 spin_lock_bh(&p->fcoe_rx_list.lock);
1843                 while ((skb = __skb_dequeue(&p->fcoe_rx_list)) == NULL) {
1844                         set_current_state(TASK_INTERRUPTIBLE);
1845                         spin_unlock_bh(&p->fcoe_rx_list.lock);
1846                         schedule();
1847                         set_current_state(TASK_RUNNING);
1848                         if (kthread_should_stop())
1849                                 return 0;
1850                         spin_lock_bh(&p->fcoe_rx_list.lock);
1851                 }
1852                 spin_unlock_bh(&p->fcoe_rx_list.lock);
1853                 fcoe_recv_frame(skb);
1854         }
1855         return 0;
1856 }
1857
1858 /**
1859  * fcoe_dev_setup() - Setup the link change notification interface
1860  */
1861 static void fcoe_dev_setup(void)
1862 {
1863         register_dcbevent_notifier(&dcb_notifier);
1864         register_netdevice_notifier(&fcoe_notifier);
1865 }
1866
1867 /**
1868  * fcoe_dev_cleanup() - Cleanup the link change notification interface
1869  */
1870 static void fcoe_dev_cleanup(void)
1871 {
1872         unregister_dcbevent_notifier(&dcb_notifier);
1873         unregister_netdevice_notifier(&fcoe_notifier);
1874 }
1875
1876 static struct fcoe_interface *
1877 fcoe_hostlist_lookup_realdev_port(struct net_device *netdev)
1878 {
1879         struct fcoe_interface *fcoe;
1880         struct net_device *real_dev;
1881
1882         list_for_each_entry(fcoe, &fcoe_hostlist, list) {
1883                 if (fcoe->netdev->priv_flags & IFF_802_1Q_VLAN)
1884                         real_dev = vlan_dev_real_dev(fcoe->netdev);
1885                 else
1886                         real_dev = fcoe->netdev;
1887
1888                 if (netdev == real_dev)
1889                         return fcoe;
1890         }
1891         return NULL;
1892 }
1893
1894 static int fcoe_dcb_app_notification(struct notifier_block *notifier,
1895                                      ulong event, void *ptr)
1896 {
1897         struct dcb_app_type *entry = ptr;
1898         struct fcoe_interface *fcoe;
1899         struct net_device *netdev;
1900         struct fcoe_port *port;
1901         int prio;
1902
1903         if (entry->app.selector != DCB_APP_IDTYPE_ETHTYPE)
1904                 return NOTIFY_OK;
1905
1906         netdev = dev_get_by_index(&init_net, entry->ifindex);
1907         if (!netdev)
1908                 return NOTIFY_OK;
1909
1910         fcoe = fcoe_hostlist_lookup_realdev_port(netdev);
1911         dev_put(netdev);
1912         if (!fcoe)
1913                 return NOTIFY_OK;
1914
1915         if (entry->dcbx & DCB_CAP_DCBX_VER_CEE)
1916                 prio = ffs(entry->app.priority) - 1;
1917         else
1918                 prio = entry->app.priority;
1919
1920         if (prio < 0)
1921                 return NOTIFY_OK;
1922
1923         if (entry->app.protocol == ETH_P_FIP ||
1924             entry->app.protocol == ETH_P_FCOE)
1925                 fcoe->ctlr.priority = prio;
1926
1927         if (entry->app.protocol == ETH_P_FCOE) {
1928                 port = lport_priv(fcoe->ctlr.lp);
1929                 port->priority = prio;
1930         }
1931
1932         return NOTIFY_OK;
1933 }
1934
1935 /**
1936  * fcoe_device_notification() - Handler for net device events
1937  * @notifier: The context of the notification
1938  * @event:    The type of event
1939  * @ptr:      The net device that the event was on
1940  *
1941  * This function is called by the Ethernet driver in case of link change event.
1942  *
1943  * Returns: 0 for success
1944  */
1945 static int fcoe_device_notification(struct notifier_block *notifier,
1946                                     ulong event, void *ptr)
1947 {
1948         struct fc_lport *lport = NULL;
1949         struct net_device *netdev = ptr;
1950         struct fcoe_interface *fcoe;
1951         struct fcoe_port *port;
1952         struct fcoe_dev_stats *stats;
1953         u32 link_possible = 1;
1954         u32 mfs;
1955         int rc = NOTIFY_OK;
1956
1957         list_for_each_entry(fcoe, &fcoe_hostlist, list) {
1958                 if (fcoe->netdev == netdev) {
1959                         lport = fcoe->ctlr.lp;
1960                         break;
1961                 }
1962         }
1963         if (!lport) {
1964                 rc = NOTIFY_DONE;
1965                 goto out;
1966         }
1967
1968         switch (event) {
1969         case NETDEV_DOWN:
1970         case NETDEV_GOING_DOWN:
1971                 link_possible = 0;
1972                 break;
1973         case NETDEV_UP:
1974         case NETDEV_CHANGE:
1975                 break;
1976         case NETDEV_CHANGEMTU:
1977                 if (netdev->features & NETIF_F_FCOE_MTU)
1978                         break;
1979                 mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
1980                                      sizeof(struct fcoe_crc_eof));
1981                 if (mfs >= FC_MIN_MAX_FRAME)
1982                         fc_set_mfs(lport, mfs);
1983                 break;
1984         case NETDEV_REGISTER:
1985                 break;
1986         case NETDEV_UNREGISTER:
1987                 list_del(&fcoe->list);
1988                 port = lport_priv(fcoe->ctlr.lp);
1989                 queue_work(fcoe_wq, &port->destroy_work);
1990                 goto out;
1991                 break;
1992         case NETDEV_FEAT_CHANGE:
1993                 fcoe_netdev_features_change(lport, netdev);
1994                 break;
1995         default:
1996                 FCOE_NETDEV_DBG(netdev, "Unknown event %ld "
1997                                 "from netdev netlink\n", event);
1998         }
1999
2000         fcoe_link_speed_update(lport);
2001
2002         if (link_possible && !fcoe_link_ok(lport))
2003                 fcoe_ctlr_link_up(&fcoe->ctlr);
2004         else if (fcoe_ctlr_link_down(&fcoe->ctlr)) {
2005                 stats = per_cpu_ptr(lport->dev_stats, get_cpu());
2006                 stats->LinkFailureCount++;
2007                 put_cpu();
2008                 fcoe_clean_pending_queue(lport);
2009         }
2010 out:
2011         return rc;
2012 }
2013
2014 /**
2015  * fcoe_disable() - Disables a FCoE interface
2016  * @netdev  : The net_device object the Ethernet interface to create on
2017  *
2018  * Called from fcoe transport.
2019  *
2020  * Returns: 0 for success
2021  */
2022 static int fcoe_disable(struct net_device *netdev)
2023 {
2024         struct fcoe_interface *fcoe;
2025         int rc = 0;
2026
2027         mutex_lock(&fcoe_config_mutex);
2028
2029         rtnl_lock();
2030         fcoe = fcoe_hostlist_lookup_port(netdev);
2031         rtnl_unlock();
2032
2033         if (fcoe) {
2034                 fcoe_ctlr_link_down(&fcoe->ctlr);
2035                 fcoe_clean_pending_queue(fcoe->ctlr.lp);
2036         } else
2037                 rc = -ENODEV;
2038
2039         mutex_unlock(&fcoe_config_mutex);
2040         return rc;
2041 }
2042
2043 /**
2044  * fcoe_enable() - Enables a FCoE interface
2045  * @netdev  : The net_device object the Ethernet interface to create on
2046  *
2047  * Called from fcoe transport.
2048  *
2049  * Returns: 0 for success
2050  */
2051 static int fcoe_enable(struct net_device *netdev)
2052 {
2053         struct fcoe_interface *fcoe;
2054         int rc = 0;
2055
2056         mutex_lock(&fcoe_config_mutex);
2057         rtnl_lock();
2058         fcoe = fcoe_hostlist_lookup_port(netdev);
2059         rtnl_unlock();
2060
2061         if (!fcoe)
2062                 rc = -ENODEV;
2063         else if (!fcoe_link_ok(fcoe->ctlr.lp))
2064                 fcoe_ctlr_link_up(&fcoe->ctlr);
2065
2066         mutex_unlock(&fcoe_config_mutex);
2067         return rc;
2068 }
2069
2070 /**
2071  * fcoe_destroy() - Destroy a FCoE interface
2072  * @netdev  : The net_device object the Ethernet interface to create on
2073  *
2074  * Called from fcoe transport
2075  *
2076  * Returns: 0 for success
2077  */
2078 static int fcoe_destroy(struct net_device *netdev)
2079 {
2080         struct fcoe_interface *fcoe;
2081         struct fc_lport *lport;
2082         struct fcoe_port *port;
2083         int rc = 0;
2084
2085         mutex_lock(&fcoe_config_mutex);
2086         rtnl_lock();
2087         fcoe = fcoe_hostlist_lookup_port(netdev);
2088         if (!fcoe) {
2089                 rc = -ENODEV;
2090                 goto out_nodev;
2091         }
2092         lport = fcoe->ctlr.lp;
2093         port = lport_priv(lport);
2094         list_del(&fcoe->list);
2095         queue_work(fcoe_wq, &port->destroy_work);
2096 out_nodev:
2097         rtnl_unlock();
2098         mutex_unlock(&fcoe_config_mutex);
2099         return rc;
2100 }
2101
2102 /**
2103  * fcoe_destroy_work() - Destroy a FCoE port in a deferred work context
2104  * @work: Handle to the FCoE port to be destroyed
2105  */
2106 static void fcoe_destroy_work(struct work_struct *work)
2107 {
2108         struct fcoe_port *port;
2109         struct fcoe_interface *fcoe;
2110         int npiv = 0;
2111
2112         port = container_of(work, struct fcoe_port, destroy_work);
2113         mutex_lock(&fcoe_config_mutex);
2114
2115         /* set if this is an NPIV port */
2116         npiv = port->lport->vport ? 1 : 0;
2117
2118         fcoe = port->priv;
2119         fcoe_if_destroy(port->lport);
2120
2121         /* Do not tear down the fcoe interface for NPIV port */
2122         if (!npiv)
2123                 fcoe_interface_cleanup(fcoe);
2124
2125         mutex_unlock(&fcoe_config_mutex);
2126 }
2127
2128 /**
2129  * fcoe_match() - Check if the FCoE is supported on the given netdevice
2130  * @netdev  : The net_device object the Ethernet interface to create on
2131  *
2132  * Called from fcoe transport.
2133  *
2134  * Returns: always returns true as this is the default FCoE transport,
2135  * i.e., support all netdevs.
2136  */
2137 static bool fcoe_match(struct net_device *netdev)
2138 {
2139         return true;
2140 }
2141
2142 /**
2143  * fcoe_dcb_create() - Initialize DCB attributes and hooks
2144  * @netdev: The net_device object of the L2 link that should be queried
2145  * @port: The fcoe_port to bind FCoE APP priority with
2146  * @
2147  */
2148 static void fcoe_dcb_create(struct fcoe_interface *fcoe)
2149 {
2150 #ifdef CONFIG_DCB
2151         int dcbx;
2152         u8 fup, up;
2153         struct net_device *netdev = fcoe->realdev;
2154         struct fcoe_port *port = lport_priv(fcoe->ctlr.lp);
2155         struct dcb_app app = {
2156                                 .priority = 0,
2157                                 .protocol = ETH_P_FCOE
2158                              };
2159
2160         /* setup DCB priority attributes. */
2161         if (netdev && netdev->dcbnl_ops && netdev->dcbnl_ops->getdcbx) {
2162                 dcbx = netdev->dcbnl_ops->getdcbx(netdev);
2163
2164                 if (dcbx & DCB_CAP_DCBX_VER_IEEE) {
2165                         app.selector = IEEE_8021QAZ_APP_SEL_ETHERTYPE;
2166                         up = dcb_ieee_getapp_mask(netdev, &app);
2167                         app.protocol = ETH_P_FIP;
2168                         fup = dcb_ieee_getapp_mask(netdev, &app);
2169                 } else {
2170                         app.selector = DCB_APP_IDTYPE_ETHTYPE;
2171                         up = dcb_getapp(netdev, &app);
2172                         app.protocol = ETH_P_FIP;
2173                         fup = dcb_getapp(netdev, &app);
2174                 }
2175
2176                 port->priority = ffs(up) ? ffs(up) - 1 : 0;
2177                 fcoe->ctlr.priority = ffs(fup) ? ffs(fup) - 1 : port->priority;
2178         }
2179 #endif
2180 }
2181
2182 /**
2183  * fcoe_create() - Create a fcoe interface
2184  * @netdev  : The net_device object the Ethernet interface to create on
2185  * @fip_mode: The FIP mode for this creation
2186  *
2187  * Called from fcoe transport
2188  *
2189  * Returns: 0 for success
2190  */
2191 static int fcoe_create(struct net_device *netdev, enum fip_state fip_mode)
2192 {
2193         int rc = 0;
2194         struct fcoe_interface *fcoe;
2195         struct fc_lport *lport;
2196
2197         mutex_lock(&fcoe_config_mutex);
2198         rtnl_lock();
2199
2200         /* look for existing lport */
2201         if (fcoe_hostlist_lookup(netdev)) {
2202                 rc = -EEXIST;
2203                 goto out_nodev;
2204         }
2205
2206         fcoe = fcoe_interface_create(netdev, fip_mode);
2207         if (IS_ERR(fcoe)) {
2208                 rc = PTR_ERR(fcoe);
2209                 goto out_nodev;
2210         }
2211
2212         lport = fcoe_if_create(fcoe, &netdev->dev, 0);
2213         if (IS_ERR(lport)) {
2214                 printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
2215                        netdev->name);
2216                 rc = -EIO;
2217                 rtnl_unlock();
2218                 fcoe_interface_cleanup(fcoe);
2219                 goto out_nortnl;
2220         }
2221
2222         /* Make this the "master" N_Port */
2223         fcoe->ctlr.lp = lport;
2224
2225         /* setup DCB priority attributes. */
2226         fcoe_dcb_create(fcoe);
2227
2228         /* add to lports list */
2229         fcoe_hostlist_add(lport);
2230
2231         /* start FIP Discovery and FLOGI */
2232         lport->boot_time = jiffies;
2233         fc_fabric_login(lport);
2234         if (!fcoe_link_ok(lport))
2235                 fcoe_ctlr_link_up(&fcoe->ctlr);
2236
2237 out_nodev:
2238         rtnl_unlock();
2239 out_nortnl:
2240         mutex_unlock(&fcoe_config_mutex);
2241         return rc;
2242 }
2243
2244 /**
2245  * fcoe_link_speed_update() - Update the supported and actual link speeds
2246  * @lport: The local port to update speeds for
2247  *
2248  * Returns: 0 if the ethtool query was successful
2249  *          -1 if the ethtool query failed
2250  */
2251 static int fcoe_link_speed_update(struct fc_lport *lport)
2252 {
2253         struct net_device *netdev = fcoe_netdev(lport);
2254         struct ethtool_cmd ecmd;
2255
2256         if (!__ethtool_get_settings(netdev, &ecmd)) {
2257                 lport->link_supported_speeds &=
2258                         ~(FC_PORTSPEED_1GBIT | FC_PORTSPEED_10GBIT);
2259                 if (ecmd.supported & (SUPPORTED_1000baseT_Half |
2260                                       SUPPORTED_1000baseT_Full))
2261                         lport->link_supported_speeds |= FC_PORTSPEED_1GBIT;
2262                 if (ecmd.supported & SUPPORTED_10000baseT_Full)
2263                         lport->link_supported_speeds |=
2264                                 FC_PORTSPEED_10GBIT;
2265                 switch (ethtool_cmd_speed(&ecmd)) {
2266                 case SPEED_1000:
2267                         lport->link_speed = FC_PORTSPEED_1GBIT;
2268                         break;
2269                 case SPEED_10000:
2270                         lport->link_speed = FC_PORTSPEED_10GBIT;
2271                         break;
2272                 }
2273                 return 0;
2274         }
2275         return -1;
2276 }
2277
2278 /**
2279  * fcoe_link_ok() - Check if the link is OK for a local port
2280  * @lport: The local port to check link on
2281  *
2282  * Returns: 0 if link is UP and OK, -1 if not
2283  *
2284  */
2285 static int fcoe_link_ok(struct fc_lport *lport)
2286 {
2287         struct net_device *netdev = fcoe_netdev(lport);
2288
2289         if (netif_oper_up(netdev))
2290                 return 0;
2291         return -1;
2292 }
2293
2294 /**
2295  * fcoe_percpu_clean() - Clear all pending skbs for an local port
2296  * @lport: The local port whose skbs are to be cleared
2297  *
2298  * Must be called with fcoe_create_mutex held to single-thread completion.
2299  *
2300  * This flushes the pending skbs by adding a new skb to each queue and
2301  * waiting until they are all freed.  This assures us that not only are
2302  * there no packets that will be handled by the lport, but also that any
2303  * threads already handling packet have returned.
2304  */
2305 static void fcoe_percpu_clean(struct fc_lport *lport)
2306 {
2307         struct fcoe_percpu_s *pp;
2308         struct fcoe_rcv_info *fr;
2309         struct sk_buff_head *list;
2310         struct sk_buff *skb, *next;
2311         struct sk_buff *head;
2312         unsigned int cpu;
2313
2314         for_each_possible_cpu(cpu) {
2315                 pp = &per_cpu(fcoe_percpu, cpu);
2316                 spin_lock_bh(&pp->fcoe_rx_list.lock);
2317                 list = &pp->fcoe_rx_list;
2318                 head = list->next;
2319                 for (skb = head; skb != (struct sk_buff *)list;
2320                      skb = next) {
2321                         next = skb->next;
2322                         fr = fcoe_dev_from_skb(skb);
2323                         if (fr->fr_dev == lport) {
2324                                 __skb_unlink(skb, list);
2325                                 kfree_skb(skb);
2326                         }
2327                 }
2328
2329                 if (!pp->thread || !cpu_online(cpu)) {
2330                         spin_unlock_bh(&pp->fcoe_rx_list.lock);
2331                         continue;
2332                 }
2333
2334                 skb = dev_alloc_skb(0);
2335                 if (!skb) {
2336                         spin_unlock_bh(&pp->fcoe_rx_list.lock);
2337                         continue;
2338                 }
2339                 skb->destructor = fcoe_percpu_flush_done;
2340
2341                 __skb_queue_tail(&pp->fcoe_rx_list, skb);
2342                 if (pp->fcoe_rx_list.qlen == 1)
2343                         wake_up_process(pp->thread);
2344                 spin_unlock_bh(&pp->fcoe_rx_list.lock);
2345
2346                 wait_for_completion(&fcoe_flush_completion);
2347         }
2348 }
2349
2350 /**
2351  * fcoe_reset() - Reset a local port
2352  * @shost: The SCSI host associated with the local port to be reset
2353  *
2354  * Returns: Always 0 (return value required by FC transport template)
2355  */
2356 static int fcoe_reset(struct Scsi_Host *shost)
2357 {
2358         struct fc_lport *lport = shost_priv(shost);
2359         struct fcoe_port *port = lport_priv(lport);
2360         struct fcoe_interface *fcoe = port->priv;
2361
2362         fcoe_ctlr_link_down(&fcoe->ctlr);
2363         fcoe_clean_pending_queue(fcoe->ctlr.lp);
2364         if (!fcoe_link_ok(fcoe->ctlr.lp))
2365                 fcoe_ctlr_link_up(&fcoe->ctlr);
2366         return 0;
2367 }
2368
2369 /**
2370  * fcoe_hostlist_lookup_port() - Find the FCoE interface associated with a net device
2371  * @netdev: The net device used as a key
2372  *
2373  * Locking: Must be called with the RNL mutex held.
2374  *
2375  * Returns: NULL or the FCoE interface
2376  */
2377 static struct fcoe_interface *
2378 fcoe_hostlist_lookup_port(const struct net_device *netdev)
2379 {
2380         struct fcoe_interface *fcoe;
2381
2382         list_for_each_entry(fcoe, &fcoe_hostlist, list) {
2383                 if (fcoe->netdev == netdev)
2384                         return fcoe;
2385         }
2386         return NULL;
2387 }
2388
2389 /**
2390  * fcoe_hostlist_lookup() - Find the local port associated with a
2391  *                          given net device
2392  * @netdev: The netdevice used as a key
2393  *
2394  * Locking: Must be called with the RTNL mutex held
2395  *
2396  * Returns: NULL or the local port
2397  */
2398 static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *netdev)
2399 {
2400         struct fcoe_interface *fcoe;
2401
2402         fcoe = fcoe_hostlist_lookup_port(netdev);
2403         return (fcoe) ? fcoe->ctlr.lp : NULL;
2404 }
2405
2406 /**
2407  * fcoe_hostlist_add() - Add the FCoE interface identified by a local
2408  *                       port to the hostlist
2409  * @lport: The local port that identifies the FCoE interface to be added
2410  *
2411  * Locking: must be called with the RTNL mutex held
2412  *
2413  * Returns: 0 for success
2414  */
2415 static int fcoe_hostlist_add(const struct fc_lport *lport)
2416 {
2417         struct fcoe_interface *fcoe;
2418         struct fcoe_port *port;
2419
2420         fcoe = fcoe_hostlist_lookup_port(fcoe_netdev(lport));
2421         if (!fcoe) {
2422                 port = lport_priv(lport);
2423                 fcoe = port->priv;
2424                 list_add_tail(&fcoe->list, &fcoe_hostlist);
2425         }
2426         return 0;
2427 }
2428
2429
2430 static struct fcoe_transport fcoe_sw_transport = {
2431         .name = {FCOE_TRANSPORT_DEFAULT},
2432         .attached = false,
2433         .list = LIST_HEAD_INIT(fcoe_sw_transport.list),
2434         .match = fcoe_match,
2435         .create = fcoe_create,
2436         .destroy = fcoe_destroy,
2437         .enable = fcoe_enable,
2438         .disable = fcoe_disable,
2439 };
2440
2441 /**
2442  * fcoe_init() - Initialize fcoe.ko
2443  *
2444  * Returns: 0 on success, or a negative value on failure
2445  */
2446 static int __init fcoe_init(void)
2447 {
2448         struct fcoe_percpu_s *p;
2449         unsigned int cpu;
2450         int rc = 0;
2451
2452         fcoe_wq = alloc_workqueue("fcoe", 0, 0);
2453         if (!fcoe_wq)
2454                 return -ENOMEM;
2455
2456         /* register as a fcoe transport */
2457         rc = fcoe_transport_attach(&fcoe_sw_transport);
2458         if (rc) {
2459                 printk(KERN_ERR "failed to register an fcoe transport, check "
2460                         "if libfcoe is loaded\n");
2461                 return rc;
2462         }
2463
2464         mutex_lock(&fcoe_config_mutex);
2465
2466         for_each_possible_cpu(cpu) {
2467                 p = &per_cpu(fcoe_percpu, cpu);
2468                 skb_queue_head_init(&p->fcoe_rx_list);
2469         }
2470
2471         for_each_online_cpu(cpu)
2472                 fcoe_percpu_thread_create(cpu);
2473
2474         /* Initialize per CPU interrupt thread */
2475         rc = register_hotcpu_notifier(&fcoe_cpu_notifier);
2476         if (rc)
2477                 goto out_free;
2478
2479         /* Setup link change notification */
2480         fcoe_dev_setup();
2481
2482         rc = fcoe_if_init();
2483         if (rc)
2484                 goto out_free;
2485
2486         mutex_unlock(&fcoe_config_mutex);
2487         return 0;
2488
2489 out_free:
2490         for_each_online_cpu(cpu) {
2491                 fcoe_percpu_thread_destroy(cpu);
2492         }
2493         mutex_unlock(&fcoe_config_mutex);
2494         destroy_workqueue(fcoe_wq);
2495         return rc;
2496 }
2497 module_init(fcoe_init);
2498
2499 /**
2500  * fcoe_exit() - Clean up fcoe.ko
2501  *
2502  * Returns: 0 on success or a  negative value on failure
2503  */
2504 static void __exit fcoe_exit(void)
2505 {
2506         struct fcoe_interface *fcoe, *tmp;
2507         struct fcoe_port *port;
2508         unsigned int cpu;
2509
2510         mutex_lock(&fcoe_config_mutex);
2511
2512         fcoe_dev_cleanup();
2513
2514         /* releases the associated fcoe hosts */
2515         rtnl_lock();
2516         list_for_each_entry_safe(fcoe, tmp, &fcoe_hostlist, list) {
2517                 list_del(&fcoe->list);
2518                 port = lport_priv(fcoe->ctlr.lp);
2519                 queue_work(fcoe_wq, &port->destroy_work);
2520         }
2521         rtnl_unlock();
2522
2523         unregister_hotcpu_notifier(&fcoe_cpu_notifier);
2524
2525         for_each_online_cpu(cpu)
2526                 fcoe_percpu_thread_destroy(cpu);
2527
2528         mutex_unlock(&fcoe_config_mutex);
2529
2530         /*
2531          * destroy_work's may be chained but destroy_workqueue()
2532          * can take care of them. Just kill the fcoe_wq.
2533          */
2534         destroy_workqueue(fcoe_wq);
2535
2536         /*
2537          * Detaching from the scsi transport must happen after all
2538          * destroys are done on the fcoe_wq. destroy_workqueue will
2539          * enusre the fcoe_wq is flushed.
2540          */
2541         fcoe_if_exit();
2542
2543         /* detach from fcoe transport */
2544         fcoe_transport_detach(&fcoe_sw_transport);
2545 }
2546 module_exit(fcoe_exit);
2547
2548 /**
2549  * fcoe_flogi_resp() - FCoE specific FLOGI and FDISC response handler
2550  * @seq: active sequence in the FLOGI or FDISC exchange
2551  * @fp: response frame, or error encoded in a pointer (timeout)
2552  * @arg: pointer the the fcoe_ctlr structure
2553  *
2554  * This handles MAC address management for FCoE, then passes control on to
2555  * the libfc FLOGI response handler.
2556  */
2557 static void fcoe_flogi_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
2558 {
2559         struct fcoe_ctlr *fip = arg;
2560         struct fc_exch *exch = fc_seq_exch(seq);
2561         struct fc_lport *lport = exch->lp;
2562         u8 *mac;
2563
2564         if (IS_ERR(fp))
2565                 goto done;
2566
2567         mac = fr_cb(fp)->granted_mac;
2568         /* pre-FIP */
2569         if (is_zero_ether_addr(mac))
2570                 fcoe_ctlr_recv_flogi(fip, lport, fp);
2571         if (!is_zero_ether_addr(mac))
2572                 fcoe_update_src_mac(lport, mac);
2573 done:
2574         fc_lport_flogi_resp(seq, fp, lport);
2575 }
2576
2577 /**
2578  * fcoe_logo_resp() - FCoE specific LOGO response handler
2579  * @seq: active sequence in the LOGO exchange
2580  * @fp: response frame, or error encoded in a pointer (timeout)
2581  * @arg: pointer the the fcoe_ctlr structure
2582  *
2583  * This handles MAC address management for FCoE, then passes control on to
2584  * the libfc LOGO response handler.
2585  */
2586 static void fcoe_logo_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
2587 {
2588         struct fc_lport *lport = arg;
2589         static u8 zero_mac[ETH_ALEN] = { 0 };
2590
2591         if (!IS_ERR(fp))
2592                 fcoe_update_src_mac(lport, zero_mac);
2593         fc_lport_logo_resp(seq, fp, lport);
2594 }
2595
2596 /**
2597  * fcoe_elsct_send - FCoE specific ELS handler
2598  *
2599  * This does special case handling of FIP encapsualted ELS exchanges for FCoE,
2600  * using FCoE specific response handlers and passing the FIP controller as
2601  * the argument (the lport is still available from the exchange).
2602  *
2603  * Most of the work here is just handed off to the libfc routine.
2604  */
2605 static struct fc_seq *fcoe_elsct_send(struct fc_lport *lport, u32 did,
2606                                       struct fc_frame *fp, unsigned int op,
2607                                       void (*resp)(struct fc_seq *,
2608                                                    struct fc_frame *,
2609                                                    void *),
2610                                       void *arg, u32 timeout)
2611 {
2612         struct fcoe_port *port = lport_priv(lport);
2613         struct fcoe_interface *fcoe = port->priv;
2614         struct fcoe_ctlr *fip = &fcoe->ctlr;
2615         struct fc_frame_header *fh = fc_frame_header_get(fp);
2616
2617         switch (op) {
2618         case ELS_FLOGI:
2619         case ELS_FDISC:
2620                 if (lport->point_to_multipoint)
2621                         break;
2622                 return fc_elsct_send(lport, did, fp, op, fcoe_flogi_resp,
2623                                      fip, timeout);
2624         case ELS_LOGO:
2625                 /* only hook onto fabric logouts, not port logouts */
2626                 if (ntoh24(fh->fh_d_id) != FC_FID_FLOGI)
2627                         break;
2628                 return fc_elsct_send(lport, did, fp, op, fcoe_logo_resp,
2629                                      lport, timeout);
2630         }
2631         return fc_elsct_send(lport, did, fp, op, resp, arg, timeout);
2632 }
2633
2634 /**
2635  * fcoe_vport_create() - create an fc_host/scsi_host for a vport
2636  * @vport: fc_vport object to create a new fc_host for
2637  * @disabled: start the new fc_host in a disabled state by default?
2638  *
2639  * Returns: 0 for success
2640  */
2641 static int fcoe_vport_create(struct fc_vport *vport, bool disabled)
2642 {
2643         struct Scsi_Host *shost = vport_to_shost(vport);
2644         struct fc_lport *n_port = shost_priv(shost);
2645         struct fcoe_port *port = lport_priv(n_port);
2646         struct fcoe_interface *fcoe = port->priv;
2647         struct net_device *netdev = fcoe->netdev;
2648         struct fc_lport *vn_port;
2649         int rc;
2650         char buf[32];
2651
2652         rc = fcoe_validate_vport_create(vport);
2653         if (rc) {
2654                 fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
2655                 printk(KERN_ERR "fcoe: Failed to create vport, "
2656                         "WWPN (0x%s) already exists\n",
2657                         buf);
2658                 return rc;
2659         }
2660
2661         mutex_lock(&fcoe_config_mutex);
2662         rtnl_lock();
2663         vn_port = fcoe_if_create(fcoe, &vport->dev, 1);
2664         rtnl_unlock();
2665         mutex_unlock(&fcoe_config_mutex);
2666
2667         if (IS_ERR(vn_port)) {
2668                 printk(KERN_ERR "fcoe: fcoe_vport_create(%s) failed\n",
2669                        netdev->name);
2670                 return -EIO;
2671         }
2672
2673         if (disabled) {
2674                 fc_vport_set_state(vport, FC_VPORT_DISABLED);
2675         } else {
2676                 vn_port->boot_time = jiffies;
2677                 fc_fabric_login(vn_port);
2678                 fc_vport_setlink(vn_port);
2679         }
2680         return 0;
2681 }
2682
2683 /**
2684  * fcoe_vport_destroy() - destroy the fc_host/scsi_host for a vport
2685  * @vport: fc_vport object that is being destroyed
2686  *
2687  * Returns: 0 for success
2688  */
2689 static int fcoe_vport_destroy(struct fc_vport *vport)
2690 {
2691         struct Scsi_Host *shost = vport_to_shost(vport);
2692         struct fc_lport *n_port = shost_priv(shost);
2693         struct fc_lport *vn_port = vport->dd_data;
2694         struct fcoe_port *port = lport_priv(vn_port);
2695
2696         mutex_lock(&n_port->lp_mutex);
2697         list_del(&vn_port->list);
2698         mutex_unlock(&n_port->lp_mutex);
2699         queue_work(fcoe_wq, &port->destroy_work);
2700         return 0;
2701 }
2702
2703 /**
2704  * fcoe_vport_disable() - change vport state
2705  * @vport: vport to bring online/offline
2706  * @disable: should the vport be disabled?
2707  */
2708 static int fcoe_vport_disable(struct fc_vport *vport, bool disable)
2709 {
2710         struct fc_lport *lport = vport->dd_data;
2711
2712         if (disable) {
2713                 fc_vport_set_state(vport, FC_VPORT_DISABLED);
2714                 fc_fabric_logoff(lport);
2715         } else {
2716                 lport->boot_time = jiffies;
2717                 fc_fabric_login(lport);
2718                 fc_vport_setlink(lport);
2719         }
2720
2721         return 0;
2722 }
2723
2724 /**
2725  * fcoe_vport_set_symbolic_name() - append vport string to symbolic name
2726  * @vport: fc_vport with a new symbolic name string
2727  *
2728  * After generating a new symbolic name string, a new RSPN_ID request is
2729  * sent to the name server.  There is no response handler, so if it fails
2730  * for some reason it will not be retried.
2731  */
2732 static void fcoe_set_vport_symbolic_name(struct fc_vport *vport)
2733 {
2734         struct fc_lport *lport = vport->dd_data;
2735         struct fc_frame *fp;
2736         size_t len;
2737
2738         snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
2739                  "%s v%s over %s : %s", FCOE_NAME, FCOE_VERSION,
2740                  fcoe_netdev(lport)->name, vport->symbolic_name);
2741
2742         if (lport->state != LPORT_ST_READY)
2743                 return;
2744
2745         len = strnlen(fc_host_symbolic_name(lport->host), 255);
2746         fp = fc_frame_alloc(lport,
2747                             sizeof(struct fc_ct_hdr) +
2748                             sizeof(struct fc_ns_rspn) + len);
2749         if (!fp)
2750                 return;
2751         lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RSPN_ID,
2752                              NULL, NULL, 3 * lport->r_a_tov);
2753 }
2754
2755 /**
2756  * fcoe_get_lesb() - Fill the FCoE Link Error Status Block
2757  * @lport: the local port
2758  * @fc_lesb: the link error status block
2759  */
2760 static void fcoe_get_lesb(struct fc_lport *lport,
2761                          struct fc_els_lesb *fc_lesb)
2762 {
2763         struct net_device *netdev = fcoe_netdev(lport);
2764
2765         __fcoe_get_lesb(lport, fc_lesb, netdev);
2766 }
2767
2768 /**
2769  * fcoe_set_port_id() - Callback from libfc when Port_ID is set.
2770  * @lport: the local port
2771  * @port_id: the port ID
2772  * @fp: the received frame, if any, that caused the port_id to be set.
2773  *
2774  * This routine handles the case where we received a FLOGI and are
2775  * entering point-to-point mode.  We need to call fcoe_ctlr_recv_flogi()
2776  * so it can set the non-mapped mode and gateway address.
2777  *
2778  * The FLOGI LS_ACC is handled by fcoe_flogi_resp().
2779  */
2780 static void fcoe_set_port_id(struct fc_lport *lport,
2781                              u32 port_id, struct fc_frame *fp)
2782 {
2783         struct fcoe_port *port = lport_priv(lport);
2784         struct fcoe_interface *fcoe = port->priv;
2785
2786         if (fp && fc_frame_payload_op(fp) == ELS_FLOGI)
2787                 fcoe_ctlr_recv_flogi(&fcoe->ctlr, lport, fp);
2788 }