drivers/scsi/fcoe/fcoe_transport.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
   4  *
   5  * Maintained at www.Open-FCoE.org
   6  */
   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
  20 MODULE_AUTHOR("Open-FCoE.org");
  21 MODULE_DESCRIPTION("FIP discovery protocol and FCoE transport for FCoE HBAs");
  22 MODULE_LICENSE("GPL v2");
  23
  24 static int fcoe_transport_create(const char *, const struct kernel_param *);
  25 static int fcoe_transport_destroy(const char *, const struct kernel_param *);
  26 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp);
  27 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *device);
  28 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *device);
  29 static int fcoe_transport_enable(const char *, const struct kernel_param *);
  30 static int fcoe_transport_disable(const char *, const struct kernel_param *);
  31 static int libfcoe_device_notification(struct notifier_block *notifier,
  32                                     ulong event, void *ptr);
  33
  34 static LIST_HEAD(fcoe_transports);
  35 static DEFINE_MUTEX(ft_mutex);
  36 static LIST_HEAD(fcoe_netdevs);
  37 static DEFINE_MUTEX(fn_mutex);
  38
  39 unsigned int libfcoe_debug_logging;
  40 module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO|S_IWUSR);
  41 MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
  42
  43 module_param_call(show, NULL, fcoe_transport_show, NULL, S_IRUSR);
  44 __MODULE_PARM_TYPE(show, "string");
  45 MODULE_PARM_DESC(show, " Show attached FCoE transports");
  46
  47 module_param_call(create, fcoe_transport_create, NULL,
  48                   (void *)FIP_MODE_FABRIC, S_IWUSR);
  49 __MODULE_PARM_TYPE(create, "string");
  50 MODULE_PARM_DESC(create, " Creates fcoe instance on an ethernet interface");
  51
  52 module_param_call(create_vn2vn, fcoe_transport_create, NULL,
  53                   (void *)FIP_MODE_VN2VN, S_IWUSR);
  54 __MODULE_PARM_TYPE(create_vn2vn, "string");
  55 MODULE_PARM_DESC(create_vn2vn, " Creates a VN_node to VN_node FCoE instance "
  56                  "on an Ethernet interface");
  57
  58 module_param_call(destroy, fcoe_transport_destroy, NULL, NULL, S_IWUSR);
  59 __MODULE_PARM_TYPE(destroy, "string");
  60 MODULE_PARM_DESC(destroy, " Destroys fcoe instance on an ethernet interface");
  61
  62 module_param_call(enable, fcoe_transport_enable, NULL, NULL, S_IWUSR);
  63 __MODULE_PARM_TYPE(enable, "string");
  64 MODULE_PARM_DESC(enable, " Enables fcoe on an ethernet interface.");
  65
  66 module_param_call(disable, fcoe_transport_disable, NULL, NULL, S_IWUSR);
  67 __MODULE_PARM_TYPE(disable, "string");
  68 MODULE_PARM_DESC(disable, " Disables fcoe on an ethernet interface.");
  69
  70 /* notification function for packets from net device */
  71 static struct notifier_block libfcoe_notifier = {
  72         .notifier_call = libfcoe_device_notification,
  73 };
  74
  75 static const struct {
  76         u32 fc_port_speed;
  77 #define SPEED_2000      2000
  78 #define SPEED_4000      4000
  79 #define SPEED_8000      8000
  80 #define SPEED_16000     16000
  81 #define SPEED_32000     32000
  82         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
  98 static 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 speeds
 112  * @lport: The local port to update speeds for
 113  *
 114  * Returns: 0 if the ethtool query was successful
 115  *          -1 if the ethtool query failed
 116  */
 117 int 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 }
 158 EXPORT_SYMBOL_GPL(fcoe_link_speed_update);
 159
 160 /**
 161  * __fcoe_get_lesb() - Get the Link Error Status Block (LESB) for a given lport
 162  * @lport: The local port to update speeds for
 163  * @fc_lesb: Pointer to the LESB to be filled up
 164  * @netdev: Pointer to the netdev that is associated with the lport
 165  *
 166  * Note, the Link Error Status Block (LESB) for FCoE is defined in FC-BB-6
 167  * Clause 7.11 in v1.04.
 168  */
 169 void __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 += stats->LinkFailureCount;
 187                 vlfc += stats->VLinkFailureCount;
 188                 mdac += 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 }
 196 EXPORT_SYMBOL_GPL(__fcoe_get_lesb);
 197
 198 /**
 199  * fcoe_get_lesb() - Fill the FCoE Link Error Status Block
 200  * @lport: the local port
 201  * @fc_lesb: the link error status block
 202  */
 203 void 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 }
 210 EXPORT_SYMBOL_GPL(fcoe_get_lesb);
 211
 212 /**
 213  * fcoe_ctlr_get_lesb() - Get the Link Error Status Block (LESB) for a given
 214  * fcoe controller device
 215  * @ctlr_dev: The given fcoe controller device
 216  *
 217  */
 218 void 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 }
 227 EXPORT_SYMBOL_GPL(fcoe_ctlr_get_lesb);
 228
 229 void 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 }
 238 EXPORT_SYMBOL_GPL(fcoe_wwn_to_str);
 239
 240 /**
 241  * fcoe_validate_vport_create() - Validate a vport before creating it
 242  * @vport: NPIV port to be created
 243  *
 244  * This routine is meant to add validation for a vport before creating it
 245  * via fcoe_vport_create().
 246  * Current validations are:
 247  *      - WWPN supplied is unique for given lport
 248  */
 249 int 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         }
 277 out:
 278         mutex_unlock(&n_port->lp_mutex);
 279         return rc;
 280 }
 281 EXPORT_SYMBOL_GPL(fcoe_validate_vport_create);
 282
 283 /**
 284  * fcoe_get_wwn() - Get the world wide name from LLD if it supports it
 285  * @netdev: the associated net device
 286  * @wwn: the output WWN
 287  * @type: the type of WWN (WWPN or WWNN)
 288  *
 289  * Returns: 0 for success
 290  */
 291 int 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 }
 299 EXPORT_SYMBOL_GPL(fcoe_get_wwn);
 300
 301 /**
 302  * fcoe_fc_crc() - Calculates the CRC for a given frame
 303  * @fp: The frame to be checksumed
 304  *
 305  * This uses crc32() routine to calculate the CRC for a frame
 306  *
 307  * Return: The 32 bit CRC value
 308  */
 309 u32 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 }
 336 EXPORT_SYMBOL_GPL(fcoe_fc_crc);
 337
 338 /**
 339  * fcoe_start_io() - Start FCoE I/O
 340  * @skb: The packet to be transmitted
 341  *
 342  * This routine is called from the net device to start transmitting
 343  * FCoE packets.
 344  *
 345  * Returns: 0 for success
 346  */
 347 int 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 }
 361 EXPORT_SYMBOL_GPL(fcoe_start_io);
 362
 363
 364 /**
 365  * fcoe_clean_pending_queue() - Dequeue a skb and free it
 366  * @lport: The local port to dequeue a skb on
 367  */
 368 void 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 }
 381 EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue);
 382
 383 /**
 384  * fcoe_check_wait_queue() - Attempt to clear the transmit backlog
 385  * @lport: The local port whose backlog is to be cleared
 386  * @skb: The received FIP packet
 387  *
 388  * This empties the wait_queue, dequeues the head of the wait_queue queue
 389  * and calls fcoe_start_io() for each packet. If all skb have been
 390  * transmitted it returns the qlen. If an error occurs it restores
 391  * wait_queue (to try again later) and returns -1.
 392  *
 393  * The wait_queue is used when the skb transmit fails. The failed skb
 394  * will go in the wait_queue which will be emptied by the timer function or
 395  * by the next skb transmit.
 396  */
 397 void 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;
 435 out:
 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 }
 440 EXPORT_SYMBOL_GPL(fcoe_check_wait_queue);
 441
 442 /**
 443  * fcoe_queue_timer() - The fcoe queue timer
 444  * @t: Timer context use to obtain the FCoE port
 445  *
 446  * Calls fcoe_check_wait_queue on timeout
 447  */
 448 void 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 }
 454 EXPORT_SYMBOL_GPL(fcoe_queue_timer);
 455
 456 /**
 457  * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC
 458  * @skb:  The packet to be transmitted
 459  * @tlen: The total length of the trailer
 460  * @fps:  The fcoe context
 461  *
 462  * This routine allocates a page for frame trailers. The page is re-used if
 463  * there is enough room left on it for the current trailer. If there isn't
 464  * enough buffer left a new page is allocated for the trailer. Reference to
 465  * the page from this function as well as the skbs using the page fragments
 466  * ensure that the page is freed at the appropriate time.
 467  *
 468  * Returns: 0 for success
 469  */
 470 int 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 }
 501 EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof);
 502
 503 /**
 504  * fcoe_transport_lookup - find an fcoe transport that matches a netdev
 505  * @netdev: The netdev to look for from all attached transports
 506  *
 507  * Returns : ptr to the fcoe transport that supports this netdev or NULL
 508  * if not found.
 509  *
 510  * The ft_mutex should be held when this is called
 511  */
 512 static 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 transport
 524  * @ft: The fcoe transport to be attached
 525  *
 526  * Returns : 0 for success
 527  */
 528 int 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         else
 544                 list_add_tail(&ft->list, &fcoe_transports);
 545
 546         ft->attached = true;
 547         LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name);
 548
 549 out_attach:
 550         mutex_unlock(&ft_mutex);
 551         return rc;
 552 }
 553 EXPORT_SYMBOL(fcoe_transport_attach);
 554
 555 /**
 556  * fcoe_transport_detach - Detaches an FCoE transport
 557  * @ft: The fcoe transport to be attached
 558  *
 559  * Returns : 0 for success
 560  */
 561 int 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
 591 out_attach:
 592         mutex_unlock(&ft_mutex);
 593         return rc;
 594
 595 }
 596 EXPORT_SYMBOL(fcoe_transport_detach);
 597
 598 static 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
 616 static int __init fcoe_transport_init(void)
 617 {
 618         register_netdevice_notifier(&libfcoe_notifier);
 619         return 0;
 620 }
 621
 622 static 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
 636 static 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
 657 static 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 which
 676  * it was created
 677  * @netdev: The net device that the FCoE interface is on
 678  *
 679  * Returns : ptr to the fcoe transport that supports this netdev or NULL
 680  * if not found.
 681  *
 682  * The ft_mutex should be held when this is called
 683  */
 684 static 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 device
 704  * @buffer: The name of the net device
 705  *
 706  * Returns: NULL or a ptr to net_device
 707  */
 708 static struct net_device *fcoe_if_to_netdev(const char *buffer)
 709 {
 710         char *cp;
 711         char ifname[IFNAMSIZ + 2];
 712
 713         if (buffer) {
 714                 strlcpy(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 events
 725  * @notifier: The context of the notification
 726  * @event:    The type of event
 727  * @ptr:      The net device that the event was on
 728  *
 729  * This function is called by the Ethernet driver in case of link change event.
 730  *
 731  * Returns: 0 for success
 732  */
 733 static 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
 748 ssize_t fcoe_ctlr_create_store(struct bus_type *bus,
 749                                const char *buf, size_t count)
 750 {
 751         struct net_device *netdev = NULL;
 752         struct fcoe_transport *ft = NULL;
 753         int rc = 0;
 754         int err;
 755
 756         mutex_lock(&ft_mutex);
 757
 758         netdev = fcoe_if_to_netdev(buf);
 759         if (!netdev) {
 760                 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buf);
 761                 rc = -ENODEV;
 762                 goto out_nodev;
 763         }
 764
 765         ft = fcoe_netdev_map_lookup(netdev);
 766         if (ft) {
 767                 LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
 768                                       "FCoE instance on %s.\n",
 769                                       ft->name, netdev->name);
 770                 rc = -EEXIST;
 771                 goto out_putdev;
 772         }
 773
 774         ft = fcoe_transport_lookup(netdev);
 775         if (!ft) {
 776                 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 777                                       netdev->name);
 778                 rc = -ENODEV;
 779                 goto out_putdev;
 780         }
 781
 782         /* pass to transport create */
 783         err = ft->alloc ? ft->alloc(netdev) : -ENODEV;
 784         if (err) {
 785                 fcoe_del_netdev_mapping(netdev);
 786                 rc = -ENOMEM;
 787                 goto out_putdev;
 788         }
 789
 790         err = fcoe_add_netdev_mapping(netdev, ft);
 791         if (err) {
 792                 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
 793                                       "for FCoE transport %s for %s.\n",
 794                                       ft->name, netdev->name);
 795                 rc = -ENODEV;
 796                 goto out_putdev;
 797         }
 798
 799         LIBFCOE_TRANSPORT_DBG("transport %s succeeded to create fcoe on %s.\n",
 800                               ft->name, netdev->name);
 801
 802 out_putdev:
 803         dev_put(netdev);
 804 out_nodev:
 805         mutex_unlock(&ft_mutex);
 806         if (rc)
 807                 return rc;
 808         return count;
 809 }
 810
 811 ssize_t fcoe_ctlr_destroy_store(struct bus_type *bus,
 812                                 const char *buf, size_t count)
 813 {
 814         int rc = -ENODEV;
 815         struct net_device *netdev = NULL;
 816         struct fcoe_transport *ft = NULL;
 817
 818         mutex_lock(&ft_mutex);
 819
 820         netdev = fcoe_if_to_netdev(buf);
 821         if (!netdev) {
 822                 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buf);
 823                 goto out_nodev;
 824         }
 825
 826         ft = fcoe_netdev_map_lookup(netdev);
 827         if (!ft) {
 828                 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 829                                       netdev->name);
 830                 goto out_putdev;
 831         }
 832
 833         /* pass to transport destroy */
 834         rc = ft->destroy(netdev);
 835         if (rc)
 836                 goto out_putdev;
 837
 838         fcoe_del_netdev_mapping(netdev);
 839         LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
 840                               ft->name, (rc) ? "failed" : "succeeded",
 841                               netdev->name);
 842         rc = count; /* required for successful return */
 843 out_putdev:
 844         dev_put(netdev);
 845 out_nodev:
 846         mutex_unlock(&ft_mutex);
 847         return rc;
 848 }
 849
 850 /**
 851  * fcoe_transport_create() - Create a fcoe interface
 852  * @buffer: The name of the Ethernet interface to create on
 853  * @kp:     The associated kernel param
 854  *
 855  * Called from sysfs. This holds the ft_mutex while calling the
 856  * registered fcoe transport's create function.
 857  *
 858  * Returns: 0 for success
 859  */
 860 static int fcoe_transport_create(const char *buffer,
 861                                  const struct kernel_param *kp)
 862 {
 863         int rc = -ENODEV;
 864         struct net_device *netdev = NULL;
 865         struct fcoe_transport *ft = NULL;
 866         enum fip_mode fip_mode = (enum fip_mode)(uintptr_t)kp->arg;
 867
 868         mutex_lock(&ft_mutex);
 869
 870         netdev = fcoe_if_to_netdev(buffer);
 871         if (!netdev) {
 872                 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
 873                 goto out_nodev;
 874         }
 875
 876         ft = fcoe_netdev_map_lookup(netdev);
 877         if (ft) {
 878                 LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
 879                                       "FCoE instance on %s.\n",
 880                                       ft->name, netdev->name);
 881                 rc = -EEXIST;
 882                 goto out_putdev;
 883         }
 884
 885         ft = fcoe_transport_lookup(netdev);
 886         if (!ft) {
 887                 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 888                                       netdev->name);
 889                 goto out_putdev;
 890         }
 891
 892         rc = fcoe_add_netdev_mapping(netdev, ft);
 893         if (rc) {
 894                 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
 895                                       "for FCoE transport %s for %s.\n",
 896                                       ft->name, netdev->name);
 897                 goto out_putdev;
 898         }
 899
 900         /* pass to transport create */
 901         rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV;
 902         if (rc)
 903                 fcoe_del_netdev_mapping(netdev);
 904
 905         LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n",
 906                               ft->name, (rc) ? "failed" : "succeeded",
 907                               netdev->name);
 908
 909 out_putdev:
 910         dev_put(netdev);
 911 out_nodev:
 912         mutex_unlock(&ft_mutex);
 913         return rc;
 914 }
 915
 916 /**
 917  * fcoe_transport_destroy() - Destroy a FCoE interface
 918  * @buffer: The name of the Ethernet interface to be destroyed
 919  * @kp:     The associated kernel parameter
 920  *
 921  * Called from sysfs. This holds the ft_mutex while calling the
 922  * registered fcoe transport's destroy function.
 923  *
 924  * Returns: 0 for success
 925  */
 926 static int fcoe_transport_destroy(const char *buffer,
 927                                   const struct kernel_param *kp)
 928 {
 929         int rc = -ENODEV;
 930         struct net_device *netdev = NULL;
 931         struct fcoe_transport *ft = NULL;
 932
 933         mutex_lock(&ft_mutex);
 934
 935         netdev = fcoe_if_to_netdev(buffer);
 936         if (!netdev) {
 937                 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
 938                 goto out_nodev;
 939         }
 940
 941         ft = fcoe_netdev_map_lookup(netdev);
 942         if (!ft) {
 943                 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 944                                       netdev->name);
 945                 goto out_putdev;
 946         }
 947
 948         /* pass to transport destroy */
 949         rc = ft->destroy ? ft->destroy(netdev) : -ENODEV;
 950         fcoe_del_netdev_mapping(netdev);
 951         LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
 952                               ft->name, (rc) ? "failed" : "succeeded",
 953                               netdev->name);
 954
 955 out_putdev:
 956         dev_put(netdev);
 957 out_nodev:
 958         mutex_unlock(&ft_mutex);
 959         return rc;
 960 }
 961
 962 /**
 963  * fcoe_transport_disable() - Disables a FCoE interface
 964  * @buffer: The name of the Ethernet interface to be disabled
 965  * @kp:     The associated kernel parameter
 966  *
 967  * Called from sysfs.
 968  *
 969  * Returns: 0 for success
 970  */
 971 static int fcoe_transport_disable(const char *buffer,
 972                                   const struct kernel_param *kp)
 973 {
 974         int rc = -ENODEV;
 975         struct net_device *netdev = NULL;
 976         struct fcoe_transport *ft = NULL;
 977
 978         mutex_lock(&ft_mutex);
 979
 980         netdev = fcoe_if_to_netdev(buffer);
 981         if (!netdev)
 982                 goto out_nodev;
 983
 984         ft = fcoe_netdev_map_lookup(netdev);
 985         if (!ft)
 986                 goto out_putdev;
 987
 988         rc = ft->disable ? ft->disable(netdev) : -ENODEV;
 989
 990 out_putdev:
 991         dev_put(netdev);
 992 out_nodev:
 993         mutex_unlock(&ft_mutex);
 994         return rc;
 995 }
 996
 997 /**
 998  * fcoe_transport_enable() - Enables a FCoE interface
 999  * @buffer: The name of the Ethernet interface to be enabled
1000  * @kp:     The associated kernel parameter
1001  *
1002  * Called from sysfs.
1003  *
1004  * Returns: 0 for success
1005  */
1006 static int fcoe_transport_enable(const char *buffer,
1007                                  const struct kernel_param *kp)
1008 {
1009         int rc = -ENODEV;
1010         struct net_device *netdev = NULL;
1011         struct fcoe_transport *ft = NULL;
1012
1013         mutex_lock(&ft_mutex);
1014
1015         netdev = fcoe_if_to_netdev(buffer);
1016         if (!netdev)
1017                 goto out_nodev;
1018
1019         ft = fcoe_netdev_map_lookup(netdev);
1020         if (!ft)
1021                 goto out_putdev;
1022
1023         rc = ft->enable ? ft->enable(netdev) : -ENODEV;
1024
1025 out_putdev:
1026         dev_put(netdev);
1027 out_nodev:
1028         mutex_unlock(&ft_mutex);
1029         return rc;
1030 }
1031
1032 /**
1033  * libfcoe_init() - Initialization routine for libfcoe.ko
1034  */
1035 static int __init libfcoe_init(void)
1036 {
1037         int rc = 0;
1038
1039         rc = fcoe_transport_init();
1040         if (rc)
1041                 return rc;
1042
1043         rc = fcoe_sysfs_setup();
1044         if (rc)
1045                 fcoe_transport_exit();
1046
1047         return rc;
1048 }
1049 module_init(libfcoe_init);
1050
1051 /**
1052  * libfcoe_exit() - Tear down libfcoe.ko
1053  */
1054 static void __exit libfcoe_exit(void)
1055 {
1056         fcoe_sysfs_teardown();
1057         fcoe_transport_exit();
1058 }
1059 module_exit(libfcoe_exit);