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