1 /* 2 * Copyright(c) 2008 - 2011 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/types.h> 21 #include <linux/module.h> 22 #include <linux/kernel.h> 23 #include <linux/list.h> 24 #include <linux/netdevice.h> 25 #include <linux/errno.h> 26 #include <linux/crc32.h> 27 #include <scsi/libfcoe.h> 28 29 #include "libfcoe.h" 30 31 MODULE_AUTHOR("Open-FCoE.org"); 32 MODULE_DESCRIPTION("FIP discovery protocol and FCoE transport for FCoE HBAs"); 33 MODULE_LICENSE("GPL v2"); 34 35 static int fcoe_transport_create(const char *, const struct kernel_param *); 36 static int fcoe_transport_destroy(const char *, const struct kernel_param *); 37 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp); 38 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *device); 39 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *device); 40 static int fcoe_transport_enable(const char *, const struct kernel_param *); 41 static int fcoe_transport_disable(const char *, const struct kernel_param *); 42 static int libfcoe_device_notification(struct notifier_block *notifier, 43 ulong event, void *ptr); 44 45 static LIST_HEAD(fcoe_transports); 46 static DEFINE_MUTEX(ft_mutex); 47 static LIST_HEAD(fcoe_netdevs); 48 static DEFINE_MUTEX(fn_mutex); 49 50 unsigned int libfcoe_debug_logging; 51 module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO|S_IWUSR); 52 MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels"); 53 54 module_param_call(show, NULL, fcoe_transport_show, NULL, S_IRUSR); 55 __MODULE_PARM_TYPE(show, "string"); 56 MODULE_PARM_DESC(show, " Show attached FCoE transports"); 57 58 module_param_call(create, fcoe_transport_create, NULL, 59 (void *)FIP_MODE_FABRIC, S_IWUSR); 60 __MODULE_PARM_TYPE(create, "string"); 61 MODULE_PARM_DESC(create, " Creates fcoe instance on an ethernet interface"); 62 63 module_param_call(create_vn2vn, fcoe_transport_create, NULL, 64 (void *)FIP_MODE_VN2VN, S_IWUSR); 65 __MODULE_PARM_TYPE(create_vn2vn, "string"); 66 MODULE_PARM_DESC(create_vn2vn, " Creates a VN_node to VN_node FCoE instance " 67 "on an Ethernet interface"); 68 69 module_param_call(destroy, fcoe_transport_destroy, NULL, NULL, S_IWUSR); 70 __MODULE_PARM_TYPE(destroy, "string"); 71 MODULE_PARM_DESC(destroy, " Destroys fcoe instance on an ethernet interface"); 72 73 module_param_call(enable, fcoe_transport_enable, NULL, NULL, S_IWUSR); 74 __MODULE_PARM_TYPE(enable, "string"); 75 MODULE_PARM_DESC(enable, " Enables fcoe on an ethernet interface."); 76 77 module_param_call(disable, fcoe_transport_disable, NULL, NULL, S_IWUSR); 78 __MODULE_PARM_TYPE(disable, "string"); 79 MODULE_PARM_DESC(disable, " Disables fcoe on an ethernet interface."); 80 81 /* notification function for packets from net device */ 82 static struct notifier_block libfcoe_notifier = { 83 .notifier_call = libfcoe_device_notification, 84 }; 85 86 static const struct { 87 u32 fc_port_speed; 88 #define SPEED_2000 2000 89 #define SPEED_4000 4000 90 #define SPEED_8000 8000 91 #define SPEED_16000 16000 92 #define SPEED_32000 32000 93 u32 eth_port_speed; 94 } fcoe_port_speed_mapping[] = { 95 { FC_PORTSPEED_1GBIT, SPEED_1000 }, 96 { FC_PORTSPEED_2GBIT, SPEED_2000 }, 97 { FC_PORTSPEED_4GBIT, SPEED_4000 }, 98 { FC_PORTSPEED_8GBIT, SPEED_8000 }, 99 { FC_PORTSPEED_10GBIT, SPEED_10000 }, 100 { FC_PORTSPEED_16GBIT, SPEED_16000 }, 101 { FC_PORTSPEED_20GBIT, SPEED_20000 }, 102 { FC_PORTSPEED_25GBIT, SPEED_25000 }, 103 { FC_PORTSPEED_32GBIT, SPEED_32000 }, 104 { FC_PORTSPEED_40GBIT, SPEED_40000 }, 105 { FC_PORTSPEED_50GBIT, SPEED_50000 }, 106 { FC_PORTSPEED_100GBIT, SPEED_100000 }, 107 }; 108 109 static inline u32 eth2fc_speed(u32 eth_port_speed) 110 { 111 int i; 112 113 for (i = 0; i < ARRAY_SIZE(fcoe_port_speed_mapping); i++) { 114 if (fcoe_port_speed_mapping[i].eth_port_speed == eth_port_speed) 115 return fcoe_port_speed_mapping[i].fc_port_speed; 116 } 117 118 return FC_PORTSPEED_UNKNOWN; 119 } 120 121 /** 122 * fcoe_link_speed_update() - Update the supported and actual link speeds 123 * @lport: The local port to update speeds for 124 * 125 * Returns: 0 if the ethtool query was successful 126 * -1 if the ethtool query failed 127 */ 128 int fcoe_link_speed_update(struct fc_lport *lport) 129 { 130 struct net_device *netdev = fcoe_get_netdev(lport); 131 struct ethtool_link_ksettings ecmd; 132 133 if (!__ethtool_get_link_ksettings(netdev, &ecmd)) { 134 lport->link_supported_speeds &= ~(FC_PORTSPEED_1GBIT | 135 FC_PORTSPEED_10GBIT | 136 FC_PORTSPEED_20GBIT | 137 FC_PORTSPEED_40GBIT); 138 139 if (ecmd.link_modes.supported[0] & ( 140 SUPPORTED_1000baseT_Half | 141 SUPPORTED_1000baseT_Full | 142 SUPPORTED_1000baseKX_Full)) 143 lport->link_supported_speeds |= FC_PORTSPEED_1GBIT; 144 145 if (ecmd.link_modes.supported[0] & ( 146 SUPPORTED_10000baseT_Full | 147 SUPPORTED_10000baseKX4_Full | 148 SUPPORTED_10000baseKR_Full | 149 SUPPORTED_10000baseR_FEC)) 150 lport->link_supported_speeds |= FC_PORTSPEED_10GBIT; 151 152 if (ecmd.link_modes.supported[0] & ( 153 SUPPORTED_20000baseMLD2_Full | 154 SUPPORTED_20000baseKR2_Full)) 155 lport->link_supported_speeds |= FC_PORTSPEED_20GBIT; 156 157 if (ecmd.link_modes.supported[0] & ( 158 SUPPORTED_40000baseKR4_Full | 159 SUPPORTED_40000baseCR4_Full | 160 SUPPORTED_40000baseSR4_Full | 161 SUPPORTED_40000baseLR4_Full)) 162 lport->link_supported_speeds |= FC_PORTSPEED_40GBIT; 163 164 lport->link_speed = eth2fc_speed(ecmd.base.speed); 165 return 0; 166 } 167 return -1; 168 } 169 EXPORT_SYMBOL_GPL(fcoe_link_speed_update); 170 171 /** 172 * __fcoe_get_lesb() - Get the Link Error Status Block (LESB) for a given lport 173 * @lport: The local port to update speeds for 174 * @fc_lesb: Pointer to the LESB to be filled up 175 * @netdev: Pointer to the netdev that is associated with the lport 176 * 177 * Note, the Link Error Status Block (LESB) for FCoE is defined in FC-BB-6 178 * Clause 7.11 in v1.04. 179 */ 180 void __fcoe_get_lesb(struct fc_lport *lport, 181 struct fc_els_lesb *fc_lesb, 182 struct net_device *netdev) 183 { 184 unsigned int cpu; 185 u32 lfc, vlfc, mdac; 186 struct fc_stats *stats; 187 struct fcoe_fc_els_lesb *lesb; 188 struct rtnl_link_stats64 temp; 189 190 lfc = 0; 191 vlfc = 0; 192 mdac = 0; 193 lesb = (struct fcoe_fc_els_lesb *)fc_lesb; 194 memset(lesb, 0, sizeof(*lesb)); 195 for_each_possible_cpu(cpu) { 196 stats = per_cpu_ptr(lport->stats, cpu); 197 lfc += stats->LinkFailureCount; 198 vlfc += stats->VLinkFailureCount; 199 mdac += stats->MissDiscAdvCount; 200 } 201 lesb->lesb_link_fail = htonl(lfc); 202 lesb->lesb_vlink_fail = htonl(vlfc); 203 lesb->lesb_miss_fka = htonl(mdac); 204 lesb->lesb_fcs_error = 205 htonl(dev_get_stats(netdev, &temp)->rx_crc_errors); 206 } 207 EXPORT_SYMBOL_GPL(__fcoe_get_lesb); 208 209 /** 210 * fcoe_get_lesb() - Fill the FCoE Link Error Status Block 211 * @lport: the local port 212 * @fc_lesb: the link error status block 213 */ 214 void fcoe_get_lesb(struct fc_lport *lport, 215 struct fc_els_lesb *fc_lesb) 216 { 217 struct net_device *netdev = fcoe_get_netdev(lport); 218 219 __fcoe_get_lesb(lport, fc_lesb, netdev); 220 } 221 EXPORT_SYMBOL_GPL(fcoe_get_lesb); 222 223 /** 224 * fcoe_ctlr_get_lesb() - Get the Link Error Status Block (LESB) for a given 225 * fcoe controller device 226 * @ctlr_dev: The given fcoe controller device 227 * 228 */ 229 void fcoe_ctlr_get_lesb(struct fcoe_ctlr_device *ctlr_dev) 230 { 231 struct fcoe_ctlr *fip = fcoe_ctlr_device_priv(ctlr_dev); 232 struct net_device *netdev = fcoe_get_netdev(fip->lp); 233 struct fc_els_lesb *fc_lesb; 234 235 fc_lesb = (struct fc_els_lesb *)(&ctlr_dev->lesb); 236 __fcoe_get_lesb(fip->lp, fc_lesb, netdev); 237 } 238 EXPORT_SYMBOL_GPL(fcoe_ctlr_get_lesb); 239 240 void fcoe_wwn_to_str(u64 wwn, char *buf, int len) 241 { 242 u8 wwpn[8]; 243 244 u64_to_wwn(wwn, wwpn); 245 snprintf(buf, len, "%02x%02x%02x%02x%02x%02x%02x%02x", 246 wwpn[0], wwpn[1], wwpn[2], wwpn[3], 247 wwpn[4], wwpn[5], wwpn[6], wwpn[7]); 248 } 249 EXPORT_SYMBOL_GPL(fcoe_wwn_to_str); 250 251 /** 252 * fcoe_validate_vport_create() - Validate a vport before creating it 253 * @vport: NPIV port to be created 254 * 255 * This routine is meant to add validation for a vport before creating it 256 * via fcoe_vport_create(). 257 * Current validations are: 258 * - WWPN supplied is unique for given lport 259 */ 260 int fcoe_validate_vport_create(struct fc_vport *vport) 261 { 262 struct Scsi_Host *shost = vport_to_shost(vport); 263 struct fc_lport *n_port = shost_priv(shost); 264 struct fc_lport *vn_port; 265 int rc = 0; 266 char buf[32]; 267 268 mutex_lock(&n_port->lp_mutex); 269 270 fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf)); 271 /* Check if the wwpn is not same as that of the lport */ 272 if (!memcmp(&n_port->wwpn, &vport->port_name, sizeof(u64))) { 273 LIBFCOE_TRANSPORT_DBG("vport WWPN 0x%s is same as that of the " 274 "base port WWPN\n", buf); 275 rc = -EINVAL; 276 goto out; 277 } 278 279 /* Check if there is any existing vport with same wwpn */ 280 list_for_each_entry(vn_port, &n_port->vports, list) { 281 if (!memcmp(&vn_port->wwpn, &vport->port_name, sizeof(u64))) { 282 LIBFCOE_TRANSPORT_DBG("vport with given WWPN 0x%s " 283 "already exists\n", buf); 284 rc = -EINVAL; 285 break; 286 } 287 } 288 out: 289 mutex_unlock(&n_port->lp_mutex); 290 return rc; 291 } 292 EXPORT_SYMBOL_GPL(fcoe_validate_vport_create); 293 294 /** 295 * fcoe_get_wwn() - Get the world wide name from LLD if it supports it 296 * @netdev: the associated net device 297 * @wwn: the output WWN 298 * @type: the type of WWN (WWPN or WWNN) 299 * 300 * Returns: 0 for success 301 */ 302 int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type) 303 { 304 const struct net_device_ops *ops = netdev->netdev_ops; 305 306 if (ops->ndo_fcoe_get_wwn) 307 return ops->ndo_fcoe_get_wwn(netdev, wwn, type); 308 return -EINVAL; 309 } 310 EXPORT_SYMBOL_GPL(fcoe_get_wwn); 311 312 /** 313 * fcoe_fc_crc() - Calculates the CRC for a given frame 314 * @fp: The frame to be checksumed 315 * 316 * This uses crc32() routine to calculate the CRC for a frame 317 * 318 * Return: The 32 bit CRC value 319 */ 320 u32 fcoe_fc_crc(struct fc_frame *fp) 321 { 322 struct sk_buff *skb = fp_skb(fp); 323 struct skb_frag_struct *frag; 324 unsigned char *data; 325 unsigned long off, len, clen; 326 u32 crc; 327 unsigned i; 328 329 crc = crc32(~0, skb->data, skb_headlen(skb)); 330 331 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 332 frag = &skb_shinfo(skb)->frags[i]; 333 off = frag->page_offset; 334 len = skb_frag_size(frag); 335 while (len > 0) { 336 clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK)); 337 data = kmap_atomic( 338 skb_frag_page(frag) + (off >> PAGE_SHIFT)); 339 crc = crc32(crc, data + (off & ~PAGE_MASK), clen); 340 kunmap_atomic(data); 341 off += clen; 342 len -= clen; 343 } 344 } 345 return crc; 346 } 347 EXPORT_SYMBOL_GPL(fcoe_fc_crc); 348 349 /** 350 * fcoe_start_io() - Start FCoE I/O 351 * @skb: The packet to be transmitted 352 * 353 * This routine is called from the net device to start transmitting 354 * FCoE packets. 355 * 356 * Returns: 0 for success 357 */ 358 int fcoe_start_io(struct sk_buff *skb) 359 { 360 struct sk_buff *nskb; 361 int rc; 362 363 nskb = skb_clone(skb, GFP_ATOMIC); 364 if (!nskb) 365 return -ENOMEM; 366 rc = dev_queue_xmit(nskb); 367 if (rc != 0) 368 return rc; 369 kfree_skb(skb); 370 return 0; 371 } 372 EXPORT_SYMBOL_GPL(fcoe_start_io); 373 374 375 /** 376 * fcoe_clean_pending_queue() - Dequeue a skb and free it 377 * @lport: The local port to dequeue a skb on 378 */ 379 void fcoe_clean_pending_queue(struct fc_lport *lport) 380 { 381 struct fcoe_port *port = lport_priv(lport); 382 struct sk_buff *skb; 383 384 spin_lock_bh(&port->fcoe_pending_queue.lock); 385 while ((skb = __skb_dequeue(&port->fcoe_pending_queue)) != NULL) { 386 spin_unlock_bh(&port->fcoe_pending_queue.lock); 387 kfree_skb(skb); 388 spin_lock_bh(&port->fcoe_pending_queue.lock); 389 } 390 spin_unlock_bh(&port->fcoe_pending_queue.lock); 391 } 392 EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue); 393 394 /** 395 * fcoe_check_wait_queue() - Attempt to clear the transmit backlog 396 * @lport: The local port whose backlog is to be cleared 397 * 398 * This empties the wait_queue, dequeues the head of the wait_queue queue 399 * and calls fcoe_start_io() for each packet. If all skb have been 400 * transmitted it returns the qlen. If an error occurs it restores 401 * wait_queue (to try again later) and returns -1. 402 * 403 * The wait_queue is used when the skb transmit fails. The failed skb 404 * will go in the wait_queue which will be emptied by the timer function or 405 * by the next skb transmit. 406 */ 407 void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb) 408 { 409 struct fcoe_port *port = lport_priv(lport); 410 int rc; 411 412 spin_lock_bh(&port->fcoe_pending_queue.lock); 413 414 if (skb) 415 __skb_queue_tail(&port->fcoe_pending_queue, skb); 416 417 if (port->fcoe_pending_queue_active) 418 goto out; 419 port->fcoe_pending_queue_active = 1; 420 421 while (port->fcoe_pending_queue.qlen) { 422 /* keep qlen > 0 until fcoe_start_io succeeds */ 423 port->fcoe_pending_queue.qlen++; 424 skb = __skb_dequeue(&port->fcoe_pending_queue); 425 426 spin_unlock_bh(&port->fcoe_pending_queue.lock); 427 rc = fcoe_start_io(skb); 428 spin_lock_bh(&port->fcoe_pending_queue.lock); 429 430 if (rc) { 431 __skb_queue_head(&port->fcoe_pending_queue, skb); 432 /* undo temporary increment above */ 433 port->fcoe_pending_queue.qlen--; 434 break; 435 } 436 /* undo temporary increment above */ 437 port->fcoe_pending_queue.qlen--; 438 } 439 440 if (port->fcoe_pending_queue.qlen < port->min_queue_depth) 441 lport->qfull = 0; 442 if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer)) 443 mod_timer(&port->timer, jiffies + 2); 444 port->fcoe_pending_queue_active = 0; 445 out: 446 if (port->fcoe_pending_queue.qlen > port->max_queue_depth) 447 lport->qfull = 1; 448 spin_unlock_bh(&port->fcoe_pending_queue.lock); 449 } 450 EXPORT_SYMBOL_GPL(fcoe_check_wait_queue); 451 452 /** 453 * fcoe_queue_timer() - The fcoe queue timer 454 * @lport: The local port 455 * 456 * Calls fcoe_check_wait_queue on timeout 457 */ 458 void fcoe_queue_timer(struct timer_list *t) 459 { 460 struct fcoe_port *port = from_timer(port, t, timer); 461 462 fcoe_check_wait_queue(port->lport, NULL); 463 } 464 EXPORT_SYMBOL_GPL(fcoe_queue_timer); 465 466 /** 467 * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC 468 * @skb: The packet to be transmitted 469 * @tlen: The total length of the trailer 470 * @fps: The fcoe context 471 * 472 * This routine allocates a page for frame trailers. The page is re-used if 473 * there is enough room left on it for the current trailer. If there isn't 474 * enough buffer left a new page is allocated for the trailer. Reference to 475 * the page from this function as well as the skbs using the page fragments 476 * ensure that the page is freed at the appropriate time. 477 * 478 * Returns: 0 for success 479 */ 480 int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen, 481 struct fcoe_percpu_s *fps) 482 { 483 struct page *page; 484 485 page = fps->crc_eof_page; 486 if (!page) { 487 page = alloc_page(GFP_ATOMIC); 488 if (!page) 489 return -ENOMEM; 490 491 fps->crc_eof_page = page; 492 fps->crc_eof_offset = 0; 493 } 494 495 get_page(page); 496 skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page, 497 fps->crc_eof_offset, tlen); 498 skb->len += tlen; 499 skb->data_len += tlen; 500 skb->truesize += tlen; 501 fps->crc_eof_offset += sizeof(struct fcoe_crc_eof); 502 503 if (fps->crc_eof_offset >= PAGE_SIZE) { 504 fps->crc_eof_page = NULL; 505 fps->crc_eof_offset = 0; 506 put_page(page); 507 } 508 509 return 0; 510 } 511 EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof); 512 513 /** 514 * fcoe_transport_lookup - find an fcoe transport that matches a netdev 515 * @netdev: The netdev to look for from all attached transports 516 * 517 * Returns : ptr to the fcoe transport that supports this netdev or NULL 518 * if not found. 519 * 520 * The ft_mutex should be held when this is called 521 */ 522 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *netdev) 523 { 524 struct fcoe_transport *ft = NULL; 525 526 list_for_each_entry(ft, &fcoe_transports, list) 527 if (ft->match && ft->match(netdev)) 528 return ft; 529 return NULL; 530 } 531 532 /** 533 * fcoe_transport_attach - Attaches an FCoE transport 534 * @ft: The fcoe transport to be attached 535 * 536 * Returns : 0 for success 537 */ 538 int fcoe_transport_attach(struct fcoe_transport *ft) 539 { 540 int rc = 0; 541 542 mutex_lock(&ft_mutex); 543 if (ft->attached) { 544 LIBFCOE_TRANSPORT_DBG("transport %s already attached\n", 545 ft->name); 546 rc = -EEXIST; 547 goto out_attach; 548 } 549 550 /* Add default transport to the tail */ 551 if (strcmp(ft->name, FCOE_TRANSPORT_DEFAULT)) 552 list_add(&ft->list, &fcoe_transports); 553 else 554 list_add_tail(&ft->list, &fcoe_transports); 555 556 ft->attached = true; 557 LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name); 558 559 out_attach: 560 mutex_unlock(&ft_mutex); 561 return rc; 562 } 563 EXPORT_SYMBOL(fcoe_transport_attach); 564 565 /** 566 * fcoe_transport_detach - Detaches an FCoE transport 567 * @ft: The fcoe transport to be attached 568 * 569 * Returns : 0 for success 570 */ 571 int fcoe_transport_detach(struct fcoe_transport *ft) 572 { 573 int rc = 0; 574 struct fcoe_netdev_mapping *nm = NULL, *tmp; 575 576 mutex_lock(&ft_mutex); 577 if (!ft->attached) { 578 LIBFCOE_TRANSPORT_DBG("transport %s already detached\n", 579 ft->name); 580 rc = -ENODEV; 581 goto out_attach; 582 } 583 584 /* remove netdev mapping for this transport as it is going away */ 585 mutex_lock(&fn_mutex); 586 list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) { 587 if (nm->ft == ft) { 588 LIBFCOE_TRANSPORT_DBG("transport %s going away, " 589 "remove its netdev mapping for %s\n", 590 ft->name, nm->netdev->name); 591 list_del(&nm->list); 592 kfree(nm); 593 } 594 } 595 mutex_unlock(&fn_mutex); 596 597 list_del(&ft->list); 598 ft->attached = false; 599 LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name); 600 601 out_attach: 602 mutex_unlock(&ft_mutex); 603 return rc; 604 605 } 606 EXPORT_SYMBOL(fcoe_transport_detach); 607 608 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp) 609 { 610 int i, j; 611 struct fcoe_transport *ft = NULL; 612 613 i = j = sprintf(buffer, "Attached FCoE transports:"); 614 mutex_lock(&ft_mutex); 615 list_for_each_entry(ft, &fcoe_transports, list) { 616 if (i >= PAGE_SIZE - IFNAMSIZ) 617 break; 618 i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name); 619 } 620 mutex_unlock(&ft_mutex); 621 if (i == j) 622 i += snprintf(&buffer[i], IFNAMSIZ, "none"); 623 return i; 624 } 625 626 static int __init fcoe_transport_init(void) 627 { 628 register_netdevice_notifier(&libfcoe_notifier); 629 return 0; 630 } 631 632 static int fcoe_transport_exit(void) 633 { 634 struct fcoe_transport *ft; 635 636 unregister_netdevice_notifier(&libfcoe_notifier); 637 mutex_lock(&ft_mutex); 638 list_for_each_entry(ft, &fcoe_transports, list) 639 printk(KERN_ERR "FCoE transport %s is still attached!\n", 640 ft->name); 641 mutex_unlock(&ft_mutex); 642 return 0; 643 } 644 645 646 static int fcoe_add_netdev_mapping(struct net_device *netdev, 647 struct fcoe_transport *ft) 648 { 649 struct fcoe_netdev_mapping *nm; 650 651 nm = kmalloc(sizeof(*nm), GFP_KERNEL); 652 if (!nm) { 653 printk(KERN_ERR "Unable to allocate netdev_mapping"); 654 return -ENOMEM; 655 } 656 657 nm->netdev = netdev; 658 nm->ft = ft; 659 660 mutex_lock(&fn_mutex); 661 list_add(&nm->list, &fcoe_netdevs); 662 mutex_unlock(&fn_mutex); 663 return 0; 664 } 665 666 667 static void fcoe_del_netdev_mapping(struct net_device *netdev) 668 { 669 struct fcoe_netdev_mapping *nm = NULL, *tmp; 670 671 mutex_lock(&fn_mutex); 672 list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) { 673 if (nm->netdev == netdev) { 674 list_del(&nm->list); 675 kfree(nm); 676 mutex_unlock(&fn_mutex); 677 return; 678 } 679 } 680 mutex_unlock(&fn_mutex); 681 } 682 683 684 /** 685 * fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which 686 * it was created 687 * 688 * Returns : ptr to the fcoe transport that supports this netdev or NULL 689 * if not found. 690 * 691 * The ft_mutex should be held when this is called 692 */ 693 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *netdev) 694 { 695 struct fcoe_transport *ft = NULL; 696 struct fcoe_netdev_mapping *nm; 697 698 mutex_lock(&fn_mutex); 699 list_for_each_entry(nm, &fcoe_netdevs, list) { 700 if (netdev == nm->netdev) { 701 ft = nm->ft; 702 mutex_unlock(&fn_mutex); 703 return ft; 704 } 705 } 706 707 mutex_unlock(&fn_mutex); 708 return NULL; 709 } 710 711 /** 712 * fcoe_if_to_netdev() - Parse a name buffer to get a net device 713 * @buffer: The name of the net device 714 * 715 * Returns: NULL or a ptr to net_device 716 */ 717 static struct net_device *fcoe_if_to_netdev(const char *buffer) 718 { 719 char *cp; 720 char ifname[IFNAMSIZ + 2]; 721 722 if (buffer) { 723 strlcpy(ifname, buffer, IFNAMSIZ); 724 cp = ifname + strlen(ifname); 725 while (--cp >= ifname && *cp == '\n') 726 *cp = '\0'; 727 return dev_get_by_name(&init_net, ifname); 728 } 729 return NULL; 730 } 731 732 /** 733 * libfcoe_device_notification() - Handler for net device events 734 * @notifier: The context of the notification 735 * @event: The type of event 736 * @ptr: The net device that the event was on 737 * 738 * This function is called by the Ethernet driver in case of link change event. 739 * 740 * Returns: 0 for success 741 */ 742 static int libfcoe_device_notification(struct notifier_block *notifier, 743 ulong event, void *ptr) 744 { 745 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 746 747 switch (event) { 748 case NETDEV_UNREGISTER: 749 LIBFCOE_TRANSPORT_DBG("NETDEV_UNREGISTER %s\n", 750 netdev->name); 751 fcoe_del_netdev_mapping(netdev); 752 break; 753 } 754 return NOTIFY_OK; 755 } 756 757 ssize_t fcoe_ctlr_create_store(struct bus_type *bus, 758 const char *buf, size_t count) 759 { 760 struct net_device *netdev = NULL; 761 struct fcoe_transport *ft = NULL; 762 int rc = 0; 763 int err; 764 765 mutex_lock(&ft_mutex); 766 767 netdev = fcoe_if_to_netdev(buf); 768 if (!netdev) { 769 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buf); 770 rc = -ENODEV; 771 goto out_nodev; 772 } 773 774 ft = fcoe_netdev_map_lookup(netdev); 775 if (ft) { 776 LIBFCOE_TRANSPORT_DBG("transport %s already has existing " 777 "FCoE instance on %s.\n", 778 ft->name, netdev->name); 779 rc = -EEXIST; 780 goto out_putdev; 781 } 782 783 ft = fcoe_transport_lookup(netdev); 784 if (!ft) { 785 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n", 786 netdev->name); 787 rc = -ENODEV; 788 goto out_putdev; 789 } 790 791 /* pass to transport create */ 792 err = ft->alloc ? ft->alloc(netdev) : -ENODEV; 793 if (err) { 794 fcoe_del_netdev_mapping(netdev); 795 rc = -ENOMEM; 796 goto out_putdev; 797 } 798 799 err = fcoe_add_netdev_mapping(netdev, ft); 800 if (err) { 801 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping " 802 "for FCoE transport %s for %s.\n", 803 ft->name, netdev->name); 804 rc = -ENODEV; 805 goto out_putdev; 806 } 807 808 LIBFCOE_TRANSPORT_DBG("transport %s succeeded to create fcoe on %s.\n", 809 ft->name, netdev->name); 810 811 out_putdev: 812 dev_put(netdev); 813 out_nodev: 814 mutex_unlock(&ft_mutex); 815 if (rc) 816 return rc; 817 return count; 818 } 819 820 ssize_t fcoe_ctlr_destroy_store(struct bus_type *bus, 821 const char *buf, size_t count) 822 { 823 int rc = -ENODEV; 824 struct net_device *netdev = NULL; 825 struct fcoe_transport *ft = NULL; 826 827 mutex_lock(&ft_mutex); 828 829 netdev = fcoe_if_to_netdev(buf); 830 if (!netdev) { 831 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buf); 832 goto out_nodev; 833 } 834 835 ft = fcoe_netdev_map_lookup(netdev); 836 if (!ft) { 837 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n", 838 netdev->name); 839 goto out_putdev; 840 } 841 842 /* pass to transport destroy */ 843 rc = ft->destroy(netdev); 844 if (rc) 845 goto out_putdev; 846 847 fcoe_del_netdev_mapping(netdev); 848 LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n", 849 ft->name, (rc) ? "failed" : "succeeded", 850 netdev->name); 851 rc = count; /* required for successful return */ 852 out_putdev: 853 dev_put(netdev); 854 out_nodev: 855 mutex_unlock(&ft_mutex); 856 return rc; 857 } 858 EXPORT_SYMBOL(fcoe_ctlr_destroy_store); 859 860 /** 861 * fcoe_transport_create() - Create a fcoe interface 862 * @buffer: The name of the Ethernet interface to create on 863 * @kp: The associated kernel param 864 * 865 * Called from sysfs. This holds the ft_mutex while calling the 866 * registered fcoe transport's create function. 867 * 868 * Returns: 0 for success 869 */ 870 static int fcoe_transport_create(const char *buffer, 871 const struct kernel_param *kp) 872 { 873 int rc = -ENODEV; 874 struct net_device *netdev = NULL; 875 struct fcoe_transport *ft = NULL; 876 enum fip_state fip_mode = (enum fip_state)(long)kp->arg; 877 878 mutex_lock(&ft_mutex); 879 880 netdev = fcoe_if_to_netdev(buffer); 881 if (!netdev) { 882 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer); 883 goto out_nodev; 884 } 885 886 ft = fcoe_netdev_map_lookup(netdev); 887 if (ft) { 888 LIBFCOE_TRANSPORT_DBG("transport %s already has existing " 889 "FCoE instance on %s.\n", 890 ft->name, netdev->name); 891 rc = -EEXIST; 892 goto out_putdev; 893 } 894 895 ft = fcoe_transport_lookup(netdev); 896 if (!ft) { 897 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n", 898 netdev->name); 899 goto out_putdev; 900 } 901 902 rc = fcoe_add_netdev_mapping(netdev, ft); 903 if (rc) { 904 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping " 905 "for FCoE transport %s for %s.\n", 906 ft->name, netdev->name); 907 goto out_putdev; 908 } 909 910 /* pass to transport create */ 911 rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV; 912 if (rc) 913 fcoe_del_netdev_mapping(netdev); 914 915 LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n", 916 ft->name, (rc) ? "failed" : "succeeded", 917 netdev->name); 918 919 out_putdev: 920 dev_put(netdev); 921 out_nodev: 922 mutex_unlock(&ft_mutex); 923 return rc; 924 } 925 926 /** 927 * fcoe_transport_destroy() - Destroy a FCoE interface 928 * @buffer: The name of the Ethernet interface to be destroyed 929 * @kp: The associated kernel parameter 930 * 931 * Called from sysfs. This holds the ft_mutex while calling the 932 * registered fcoe transport's destroy function. 933 * 934 * Returns: 0 for success 935 */ 936 static int fcoe_transport_destroy(const char *buffer, 937 const struct kernel_param *kp) 938 { 939 int rc = -ENODEV; 940 struct net_device *netdev = NULL; 941 struct fcoe_transport *ft = NULL; 942 943 mutex_lock(&ft_mutex); 944 945 netdev = fcoe_if_to_netdev(buffer); 946 if (!netdev) { 947 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer); 948 goto out_nodev; 949 } 950 951 ft = fcoe_netdev_map_lookup(netdev); 952 if (!ft) { 953 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n", 954 netdev->name); 955 goto out_putdev; 956 } 957 958 /* pass to transport destroy */ 959 rc = ft->destroy ? ft->destroy(netdev) : -ENODEV; 960 fcoe_del_netdev_mapping(netdev); 961 LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n", 962 ft->name, (rc) ? "failed" : "succeeded", 963 netdev->name); 964 965 out_putdev: 966 dev_put(netdev); 967 out_nodev: 968 mutex_unlock(&ft_mutex); 969 return rc; 970 } 971 972 /** 973 * fcoe_transport_disable() - Disables a FCoE interface 974 * @buffer: The name of the Ethernet interface to be disabled 975 * @kp: The associated kernel parameter 976 * 977 * Called from sysfs. 978 * 979 * Returns: 0 for success 980 */ 981 static int fcoe_transport_disable(const char *buffer, 982 const struct kernel_param *kp) 983 { 984 int rc = -ENODEV; 985 struct net_device *netdev = NULL; 986 struct fcoe_transport *ft = NULL; 987 988 mutex_lock(&ft_mutex); 989 990 netdev = fcoe_if_to_netdev(buffer); 991 if (!netdev) 992 goto out_nodev; 993 994 ft = fcoe_netdev_map_lookup(netdev); 995 if (!ft) 996 goto out_putdev; 997 998 rc = ft->disable ? ft->disable(netdev) : -ENODEV; 999 1000 out_putdev: 1001 dev_put(netdev); 1002 out_nodev: 1003 mutex_unlock(&ft_mutex); 1004 return rc; 1005 } 1006 1007 /** 1008 * fcoe_transport_enable() - Enables a FCoE interface 1009 * @buffer: The name of the Ethernet interface to be enabled 1010 * @kp: The associated kernel parameter 1011 * 1012 * Called from sysfs. 1013 * 1014 * Returns: 0 for success 1015 */ 1016 static int fcoe_transport_enable(const char *buffer, 1017 const struct kernel_param *kp) 1018 { 1019 int rc = -ENODEV; 1020 struct net_device *netdev = NULL; 1021 struct fcoe_transport *ft = NULL; 1022 1023 mutex_lock(&ft_mutex); 1024 1025 netdev = fcoe_if_to_netdev(buffer); 1026 if (!netdev) 1027 goto out_nodev; 1028 1029 ft = fcoe_netdev_map_lookup(netdev); 1030 if (!ft) 1031 goto out_putdev; 1032 1033 rc = ft->enable ? ft->enable(netdev) : -ENODEV; 1034 1035 out_putdev: 1036 dev_put(netdev); 1037 out_nodev: 1038 mutex_unlock(&ft_mutex); 1039 return rc; 1040 } 1041 1042 /** 1043 * libfcoe_init() - Initialization routine for libfcoe.ko 1044 */ 1045 static int __init libfcoe_init(void) 1046 { 1047 int rc = 0; 1048 1049 rc = fcoe_transport_init(); 1050 if (rc) 1051 return rc; 1052 1053 rc = fcoe_sysfs_setup(); 1054 if (rc) 1055 fcoe_transport_exit(); 1056 1057 return rc; 1058 } 1059 module_init(libfcoe_init); 1060 1061 /** 1062 * libfcoe_exit() - Tear down libfcoe.ko 1063 */ 1064 static void __exit libfcoe_exit(void) 1065 { 1066 fcoe_sysfs_teardown(); 1067 fcoe_transport_exit(); 1068 } 1069 module_exit(libfcoe_exit); 1070