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