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