drivers/scsi/fcoe/fcoe_transport.c

   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
 859 /**
 860  * fcoe_transport_create() - Create a fcoe interface
 861  * @buffer: The name of the Ethernet interface to create on
 862  * @kp:     The associated kernel param
 863  *
 864  * Called from sysfs. This holds the ft_mutex while calling the
 865  * registered fcoe transport's create function.
 866  *
 867  * Returns: 0 for success
 868  */
 869 static int fcoe_transport_create(const char *buffer,
 870                                  const struct kernel_param *kp)
 871 {
 872         int rc = -ENODEV;
 873         struct net_device *netdev = NULL;
 874         struct fcoe_transport *ft = NULL;
 875         enum fip_mode fip_mode = (enum fip_mode)kp->arg;
 876
 877         mutex_lock(&ft_mutex);
 878
 879         netdev = fcoe_if_to_netdev(buffer);
 880         if (!netdev) {
 881                 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
 882                 goto out_nodev;
 883         }
 884
 885         ft = fcoe_netdev_map_lookup(netdev);
 886         if (ft) {
 887                 LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
 888                                       "FCoE instance on %s.\n",
 889                                       ft->name, netdev->name);
 890                 rc = -EEXIST;
 891                 goto out_putdev;
 892         }
 893
 894         ft = fcoe_transport_lookup(netdev);
 895         if (!ft) {
 896                 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 897                                       netdev->name);
 898                 goto out_putdev;
 899         }
 900
 901         rc = fcoe_add_netdev_mapping(netdev, ft);
 902         if (rc) {
 903                 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
 904                                       "for FCoE transport %s for %s.\n",
 905                                       ft->name, netdev->name);
 906                 goto out_putdev;
 907         }
 908
 909         /* pass to transport create */
 910         rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV;
 911         if (rc)
 912                 fcoe_del_netdev_mapping(netdev);
 913
 914         LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n",
 915                               ft->name, (rc) ? "failed" : "succeeded",
 916                               netdev->name);
 917
 918 out_putdev:
 919         dev_put(netdev);
 920 out_nodev:
 921         mutex_unlock(&ft_mutex);
 922         return rc;
 923 }
 924
 925 /**
 926  * fcoe_transport_destroy() - Destroy a FCoE interface
 927  * @buffer: The name of the Ethernet interface to be destroyed
 928  * @kp:     The associated kernel parameter
 929  *
 930  * Called from sysfs. This holds the ft_mutex while calling the
 931  * registered fcoe transport's destroy function.
 932  *
 933  * Returns: 0 for success
 934  */
 935 static int fcoe_transport_destroy(const char *buffer,
 936                                   const struct kernel_param *kp)
 937 {
 938         int rc = -ENODEV;
 939         struct net_device *netdev = NULL;
 940         struct fcoe_transport *ft = NULL;
 941
 942         mutex_lock(&ft_mutex);
 943
 944         netdev = fcoe_if_to_netdev(buffer);
 945         if (!netdev) {
 946                 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
 947                 goto out_nodev;
 948         }
 949
 950         ft = fcoe_netdev_map_lookup(netdev);
 951         if (!ft) {
 952                 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 953                                       netdev->name);
 954                 goto out_putdev;
 955         }
 956
 957         /* pass to transport destroy */
 958         rc = ft->destroy ? ft->destroy(netdev) : -ENODEV;
 959         fcoe_del_netdev_mapping(netdev);
 960         LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
 961                               ft->name, (rc) ? "failed" : "succeeded",
 962                               netdev->name);
 963
 964 out_putdev:
 965         dev_put(netdev);
 966 out_nodev:
 967         mutex_unlock(&ft_mutex);
 968         return rc;
 969 }
 970
 971 /**
 972  * fcoe_transport_disable() - Disables a FCoE interface
 973  * @buffer: The name of the Ethernet interface to be disabled
 974  * @kp:     The associated kernel parameter
 975  *
 976  * Called from sysfs.
 977  *
 978  * Returns: 0 for success
 979  */
 980 static int fcoe_transport_disable(const char *buffer,
 981                                   const struct kernel_param *kp)
 982 {
 983         int rc = -ENODEV;
 984         struct net_device *netdev = NULL;
 985         struct fcoe_transport *ft = NULL;
 986
 987         mutex_lock(&ft_mutex);
 988
 989         netdev = fcoe_if_to_netdev(buffer);
 990         if (!netdev)
 991                 goto out_nodev;
 992
 993         ft = fcoe_netdev_map_lookup(netdev);
 994         if (!ft)
 995                 goto out_putdev;
 996
 997         rc = ft->disable ? ft->disable(netdev) : -ENODEV;
 998
 999 out_putdev:
1000         dev_put(netdev);
1001 out_nodev:
1002         mutex_unlock(&ft_mutex);
1003         return rc;
1004 }
1005
1006 /**
1007  * fcoe_transport_enable() - Enables a FCoE interface
1008  * @buffer: The name of the Ethernet interface to be enabled
1009  * @kp:     The associated kernel parameter
1010  *
1011  * Called from sysfs.
1012  *
1013  * Returns: 0 for success
1014  */
1015 static int fcoe_transport_enable(const char *buffer,
1016                                  const struct kernel_param *kp)
1017 {
1018         int rc = -ENODEV;
1019         struct net_device *netdev = NULL;
1020         struct fcoe_transport *ft = NULL;
1021
1022         mutex_lock(&ft_mutex);
1023
1024         netdev = fcoe_if_to_netdev(buffer);
1025         if (!netdev)
1026                 goto out_nodev;
1027
1028         ft = fcoe_netdev_map_lookup(netdev);
1029         if (!ft)
1030                 goto out_putdev;
1031
1032         rc = ft->enable ? ft->enable(netdev) : -ENODEV;
1033
1034 out_putdev:
1035         dev_put(netdev);
1036 out_nodev:
1037         mutex_unlock(&ft_mutex);
1038         return rc;
1039 }
1040
1041 /**
1042  * libfcoe_init() - Initialization routine for libfcoe.ko
1043  */
1044 static int __init libfcoe_init(void)
1045 {
1046         int rc = 0;
1047
1048         rc = fcoe_transport_init();
1049         if (rc)
1050                 return rc;
1051
1052         rc = fcoe_sysfs_setup();
1053         if (rc)
1054                 fcoe_transport_exit();
1055
1056         return rc;
1057 }
1058 module_init(libfcoe_init);
1059
1060 /**
1061  * libfcoe_exit() - Tear down libfcoe.ko
1062  */
1063 static void __exit libfcoe_exit(void)
1064 {
1065         fcoe_sysfs_teardown();
1066         fcoe_transport_exit();
1067 }
1068 module_exit(libfcoe_exit);