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