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