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