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 *, struct kernel_param *);
  36 static int fcoe_transport_destroy(const char *, 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 *, struct kernel_param *);
  41 static int fcoe_transport_disable(const char *, 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 a 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 a 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 a 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 a 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 void __fcoe_get_lesb(struct fc_lport *lport,
  87                      struct fc_els_lesb *fc_lesb,
  88                      struct net_device *netdev)
  89 {
  90         unsigned int cpu;
  91         u32 lfc, vlfc, mdac;
  92         struct fcoe_dev_stats *devst;
  93         struct fcoe_fc_els_lesb *lesb;
  94         struct rtnl_link_stats64 temp;
  95
  96         lfc = 0;
  97         vlfc = 0;
  98         mdac = 0;
  99         lesb = (struct fcoe_fc_els_lesb *)fc_lesb;
 100         memset(lesb, 0, sizeof(*lesb));
 101         for_each_possible_cpu(cpu) {
 102                 devst = per_cpu_ptr(lport->dev_stats, cpu);
 103                 lfc += devst->LinkFailureCount;
 104                 vlfc += devst->VLinkFailureCount;
 105                 mdac += devst->MissDiscAdvCount;
 106         }
 107         lesb->lesb_link_fail = htonl(lfc);
 108         lesb->lesb_vlink_fail = htonl(vlfc);
 109         lesb->lesb_miss_fka = htonl(mdac);
 110         lesb->lesb_fcs_error =
 111                         htonl(dev_get_stats(netdev, &temp)->rx_crc_errors);
 112 }
 113 EXPORT_SYMBOL_GPL(__fcoe_get_lesb);
 114
 115 void fcoe_wwn_to_str(u64 wwn, char *buf, int len)
 116 {
 117         u8 wwpn[8];
 118
 119         u64_to_wwn(wwn, wwpn);
 120         snprintf(buf, len, "%02x%02x%02x%02x%02x%02x%02x%02x",
 121                  wwpn[0], wwpn[1], wwpn[2], wwpn[3],
 122                  wwpn[4], wwpn[5], wwpn[6], wwpn[7]);
 123 }
 124 EXPORT_SYMBOL_GPL(fcoe_wwn_to_str);
 125
 126 /**
 127  * fcoe_validate_vport_create() - Validate a vport before creating it
 128  * @vport: NPIV port to be created
 129  *
 130  * This routine is meant to add validation for a vport before creating it
 131  * via fcoe_vport_create().
 132  * Current validations are:
 133  *      - WWPN supplied is unique for given lport
 134  */
 135 int fcoe_validate_vport_create(struct fc_vport *vport)
 136 {
 137         struct Scsi_Host *shost = vport_to_shost(vport);
 138         struct fc_lport *n_port = shost_priv(shost);
 139         struct fc_lport *vn_port;
 140         int rc = 0;
 141         char buf[32];
 142
 143         mutex_lock(&n_port->lp_mutex);
 144
 145         fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
 146         /* Check if the wwpn is not same as that of the lport */
 147         if (!memcmp(&n_port->wwpn, &vport->port_name, sizeof(u64))) {
 148                 LIBFCOE_TRANSPORT_DBG("vport WWPN 0x%s is same as that of the "
 149                                       "base port WWPN\n", buf);
 150                 rc = -EINVAL;
 151                 goto out;
 152         }
 153
 154         /* Check if there is any existing vport with same wwpn */
 155         list_for_each_entry(vn_port, &n_port->vports, list) {
 156                 if (!memcmp(&vn_port->wwpn, &vport->port_name, sizeof(u64))) {
 157                         LIBFCOE_TRANSPORT_DBG("vport with given WWPN 0x%s "
 158                                               "already exists\n", buf);
 159                         rc = -EINVAL;
 160                         break;
 161                 }
 162         }
 163 out:
 164         mutex_unlock(&n_port->lp_mutex);
 165         return rc;
 166 }
 167 EXPORT_SYMBOL_GPL(fcoe_validate_vport_create);
 168
 169 /**
 170  * fcoe_get_wwn() - Get the world wide name from LLD if it supports it
 171  * @netdev: the associated net device
 172  * @wwn: the output WWN
 173  * @type: the type of WWN (WWPN or WWNN)
 174  *
 175  * Returns: 0 for success
 176  */
 177 int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
 178 {
 179         const struct net_device_ops *ops = netdev->netdev_ops;
 180
 181         if (ops->ndo_fcoe_get_wwn)
 182                 return ops->ndo_fcoe_get_wwn(netdev, wwn, type);
 183         return -EINVAL;
 184 }
 185 EXPORT_SYMBOL_GPL(fcoe_get_wwn);
 186
 187 /**
 188  * fcoe_fc_crc() - Calculates the CRC for a given frame
 189  * @fp: The frame to be checksumed
 190  *
 191  * This uses crc32() routine to calculate the CRC for a frame
 192  *
 193  * Return: The 32 bit CRC value
 194  */
 195 u32 fcoe_fc_crc(struct fc_frame *fp)
 196 {
 197         struct sk_buff *skb = fp_skb(fp);
 198         struct skb_frag_struct *frag;
 199         unsigned char *data;
 200         unsigned long off, len, clen;
 201         u32 crc;
 202         unsigned i;
 203
 204         crc = crc32(~0, skb->data, skb_headlen(skb));
 205
 206         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 207                 frag = &skb_shinfo(skb)->frags[i];
 208                 off = frag->page_offset;
 209                 len = skb_frag_size(frag);
 210                 while (len > 0) {
 211                         clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
 212                         data = kmap_atomic(
 213                                 skb_frag_page(frag) + (off >> PAGE_SHIFT));
 214                         crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
 215                         kunmap_atomic(data);
 216                         off += clen;
 217                         len -= clen;
 218                 }
 219         }
 220         return crc;
 221 }
 222 EXPORT_SYMBOL_GPL(fcoe_fc_crc);
 223
 224 /**
 225  * fcoe_start_io() - Start FCoE I/O
 226  * @skb: The packet to be transmitted
 227  *
 228  * This routine is called from the net device to start transmitting
 229  * FCoE packets.
 230  *
 231  * Returns: 0 for success
 232  */
 233 int fcoe_start_io(struct sk_buff *skb)
 234 {
 235         struct sk_buff *nskb;
 236         int rc;
 237
 238         nskb = skb_clone(skb, GFP_ATOMIC);
 239         if (!nskb)
 240                 return -ENOMEM;
 241         rc = dev_queue_xmit(nskb);
 242         if (rc != 0)
 243                 return rc;
 244         kfree_skb(skb);
 245         return 0;
 246 }
 247 EXPORT_SYMBOL_GPL(fcoe_start_io);
 248
 249
 250 /**
 251  * fcoe_clean_pending_queue() - Dequeue a skb and free it
 252  * @lport: The local port to dequeue a skb on
 253  */
 254 void fcoe_clean_pending_queue(struct fc_lport *lport)
 255 {
 256         struct fcoe_port  *port = lport_priv(lport);
 257         struct sk_buff *skb;
 258
 259         spin_lock_bh(&port->fcoe_pending_queue.lock);
 260         while ((skb = __skb_dequeue(&port->fcoe_pending_queue)) != NULL) {
 261                 spin_unlock_bh(&port->fcoe_pending_queue.lock);
 262                 kfree_skb(skb);
 263                 spin_lock_bh(&port->fcoe_pending_queue.lock);
 264         }
 265         spin_unlock_bh(&port->fcoe_pending_queue.lock);
 266 }
 267 EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue);
 268
 269 /**
 270  * fcoe_check_wait_queue() - Attempt to clear the transmit backlog
 271  * @lport: The local port whose backlog is to be cleared
 272  *
 273  * This empties the wait_queue, dequeues the head of the wait_queue queue
 274  * and calls fcoe_start_io() for each packet. If all skb have been
 275  * transmitted it returns the qlen. If an error occurs it restores
 276  * wait_queue (to try again later) and returns -1.
 277  *
 278  * The wait_queue is used when the skb transmit fails. The failed skb
 279  * will go in the wait_queue which will be emptied by the timer function or
 280  * by the next skb transmit.
 281  */
 282 void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb)
 283 {
 284         struct fcoe_port *port = lport_priv(lport);
 285         int rc;
 286
 287         spin_lock_bh(&port->fcoe_pending_queue.lock);
 288
 289         if (skb)
 290                 __skb_queue_tail(&port->fcoe_pending_queue, skb);
 291
 292         if (port->fcoe_pending_queue_active)
 293                 goto out;
 294         port->fcoe_pending_queue_active = 1;
 295
 296         while (port->fcoe_pending_queue.qlen) {
 297                 /* keep qlen > 0 until fcoe_start_io succeeds */
 298                 port->fcoe_pending_queue.qlen++;
 299                 skb = __skb_dequeue(&port->fcoe_pending_queue);
 300
 301                 spin_unlock_bh(&port->fcoe_pending_queue.lock);
 302                 rc = fcoe_start_io(skb);
 303                 spin_lock_bh(&port->fcoe_pending_queue.lock);
 304
 305                 if (rc) {
 306                         __skb_queue_head(&port->fcoe_pending_queue, skb);
 307                         /* undo temporary increment above */
 308                         port->fcoe_pending_queue.qlen--;
 309                         break;
 310                 }
 311                 /* undo temporary increment above */
 312                 port->fcoe_pending_queue.qlen--;
 313         }
 314
 315         if (port->fcoe_pending_queue.qlen < port->min_queue_depth)
 316                 lport->qfull = 0;
 317         if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer))
 318                 mod_timer(&port->timer, jiffies + 2);
 319         port->fcoe_pending_queue_active = 0;
 320 out:
 321         if (port->fcoe_pending_queue.qlen > port->max_queue_depth)
 322                 lport->qfull = 1;
 323         spin_unlock_bh(&port->fcoe_pending_queue.lock);
 324 }
 325 EXPORT_SYMBOL_GPL(fcoe_check_wait_queue);
 326
 327 /**
 328  * fcoe_queue_timer() - The fcoe queue timer
 329  * @lport: The local port
 330  *
 331  * Calls fcoe_check_wait_queue on timeout
 332  */
 333 void fcoe_queue_timer(ulong lport)
 334 {
 335         fcoe_check_wait_queue((struct fc_lport *)lport, NULL);
 336 }
 337 EXPORT_SYMBOL_GPL(fcoe_queue_timer);
 338
 339 /**
 340  * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC
 341  * @skb:  The packet to be transmitted
 342  * @tlen: The total length of the trailer
 343  * @fps:  The fcoe context
 344  *
 345  * This routine allocates a page for frame trailers. The page is re-used if
 346  * there is enough room left on it for the current trailer. If there isn't
 347  * enough buffer left a new page is allocated for the trailer. Reference to
 348  * the page from this function as well as the skbs using the page fragments
 349  * ensure that the page is freed at the appropriate time.
 350  *
 351  * Returns: 0 for success
 352  */
 353 int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen,
 354                            struct fcoe_percpu_s *fps)
 355 {
 356         struct page *page;
 357
 358         page = fps->crc_eof_page;
 359         if (!page) {
 360                 page = alloc_page(GFP_ATOMIC);
 361                 if (!page)
 362                         return -ENOMEM;
 363
 364                 fps->crc_eof_page = page;
 365                 fps->crc_eof_offset = 0;
 366         }
 367
 368         get_page(page);
 369         skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page,
 370                            fps->crc_eof_offset, tlen);
 371         skb->len += tlen;
 372         skb->data_len += tlen;
 373         skb->truesize += tlen;
 374         fps->crc_eof_offset += sizeof(struct fcoe_crc_eof);
 375
 376         if (fps->crc_eof_offset >= PAGE_SIZE) {
 377                 fps->crc_eof_page = NULL;
 378                 fps->crc_eof_offset = 0;
 379                 put_page(page);
 380         }
 381
 382         return 0;
 383 }
 384 EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof);
 385
 386 /**
 387  * fcoe_transport_lookup - find an fcoe transport that matches a netdev
 388  * @netdev: The netdev to look for from all attached transports
 389  *
 390  * Returns : ptr to the fcoe transport that supports this netdev or NULL
 391  * if not found.
 392  *
 393  * The ft_mutex should be held when this is called
 394  */
 395 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *netdev)
 396 {
 397         struct fcoe_transport *ft = NULL;
 398
 399         list_for_each_entry(ft, &fcoe_transports, list)
 400                 if (ft->match && ft->match(netdev))
 401                         return ft;
 402         return NULL;
 403 }
 404
 405 /**
 406  * fcoe_transport_attach - Attaches an FCoE transport
 407  * @ft: The fcoe transport to be attached
 408  *
 409  * Returns : 0 for success
 410  */
 411 int fcoe_transport_attach(struct fcoe_transport *ft)
 412 {
 413         int rc = 0;
 414
 415         mutex_lock(&ft_mutex);
 416         if (ft->attached) {
 417                 LIBFCOE_TRANSPORT_DBG("transport %s already attached\n",
 418                                        ft->name);
 419                 rc = -EEXIST;
 420                 goto out_attach;
 421         }
 422
 423         /* Add default transport to the tail */
 424         if (strcmp(ft->name, FCOE_TRANSPORT_DEFAULT))
 425                 list_add(&ft->list, &fcoe_transports);
 426         else
 427                 list_add_tail(&ft->list, &fcoe_transports);
 428
 429         ft->attached = true;
 430         LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name);
 431
 432 out_attach:
 433         mutex_unlock(&ft_mutex);
 434         return rc;
 435 }
 436 EXPORT_SYMBOL(fcoe_transport_attach);
 437
 438 /**
 439  * fcoe_transport_detach - Detaches an FCoE transport
 440  * @ft: The fcoe transport to be attached
 441  *
 442  * Returns : 0 for success
 443  */
 444 int fcoe_transport_detach(struct fcoe_transport *ft)
 445 {
 446         int rc = 0;
 447         struct fcoe_netdev_mapping *nm = NULL, *tmp;
 448
 449         mutex_lock(&ft_mutex);
 450         if (!ft->attached) {
 451                 LIBFCOE_TRANSPORT_DBG("transport %s already detached\n",
 452                         ft->name);
 453                 rc = -ENODEV;
 454                 goto out_attach;
 455         }
 456
 457         /* remove netdev mapping for this transport as it is going away */
 458         mutex_lock(&fn_mutex);
 459         list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
 460                 if (nm->ft == ft) {
 461                         LIBFCOE_TRANSPORT_DBG("transport %s going away, "
 462                                 "remove its netdev mapping for %s\n",
 463                                 ft->name, nm->netdev->name);
 464                         list_del(&nm->list);
 465                         kfree(nm);
 466                 }
 467         }
 468         mutex_unlock(&fn_mutex);
 469
 470         list_del(&ft->list);
 471         ft->attached = false;
 472         LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name);
 473
 474 out_attach:
 475         mutex_unlock(&ft_mutex);
 476         return rc;
 477
 478 }
 479 EXPORT_SYMBOL(fcoe_transport_detach);
 480
 481 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp)
 482 {
 483         int i, j;
 484         struct fcoe_transport *ft = NULL;
 485
 486         i = j = sprintf(buffer, "Attached FCoE transports:");
 487         mutex_lock(&ft_mutex);
 488         list_for_each_entry(ft, &fcoe_transports, list) {
 489                 if (i >= PAGE_SIZE - IFNAMSIZ)
 490                         break;
 491                 i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
 492         }
 493         mutex_unlock(&ft_mutex);
 494         if (i == j)
 495                 i += snprintf(&buffer[i], IFNAMSIZ, "none");
 496         return i;
 497 }
 498
 499 static int __init fcoe_transport_init(void)
 500 {
 501         register_netdevice_notifier(&libfcoe_notifier);
 502         return 0;
 503 }
 504
 505 static int __exit fcoe_transport_exit(void)
 506 {
 507         struct fcoe_transport *ft;
 508
 509         unregister_netdevice_notifier(&libfcoe_notifier);
 510         mutex_lock(&ft_mutex);
 511         list_for_each_entry(ft, &fcoe_transports, list)
 512                 printk(KERN_ERR "FCoE transport %s is still attached!\n",
 513                       ft->name);
 514         mutex_unlock(&ft_mutex);
 515         return 0;
 516 }
 517
 518
 519 static int fcoe_add_netdev_mapping(struct net_device *netdev,
 520                                         struct fcoe_transport *ft)
 521 {
 522         struct fcoe_netdev_mapping *nm;
 523
 524         nm = kmalloc(sizeof(*nm), GFP_KERNEL);
 525         if (!nm) {
 526                 printk(KERN_ERR "Unable to allocate netdev_mapping");
 527                 return -ENOMEM;
 528         }
 529
 530         nm->netdev = netdev;
 531         nm->ft = ft;
 532
 533         mutex_lock(&fn_mutex);
 534         list_add(&nm->list, &fcoe_netdevs);
 535         mutex_unlock(&fn_mutex);
 536         return 0;
 537 }
 538
 539
 540 static void fcoe_del_netdev_mapping(struct net_device *netdev)
 541 {
 542         struct fcoe_netdev_mapping *nm = NULL, *tmp;
 543
 544         mutex_lock(&fn_mutex);
 545         list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
 546                 if (nm->netdev == netdev) {
 547                         list_del(&nm->list);
 548                         kfree(nm);
 549                         mutex_unlock(&fn_mutex);
 550                         return;
 551                 }
 552         }
 553         mutex_unlock(&fn_mutex);
 554 }
 555
 556
 557 /**
 558  * fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which
 559  * it was created
 560  *
 561  * Returns : ptr to the fcoe transport that supports this netdev or NULL
 562  * if not found.
 563  *
 564  * The ft_mutex should be held when this is called
 565  */
 566 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *netdev)
 567 {
 568         struct fcoe_transport *ft = NULL;
 569         struct fcoe_netdev_mapping *nm;
 570
 571         mutex_lock(&fn_mutex);
 572         list_for_each_entry(nm, &fcoe_netdevs, list) {
 573                 if (netdev == nm->netdev) {
 574                         ft = nm->ft;
 575                         mutex_unlock(&fn_mutex);
 576                         return ft;
 577                 }
 578         }
 579
 580         mutex_unlock(&fn_mutex);
 581         return NULL;
 582 }
 583
 584 /**
 585  * fcoe_if_to_netdev() - Parse a name buffer to get a net device
 586  * @buffer: The name of the net device
 587  *
 588  * Returns: NULL or a ptr to net_device
 589  */
 590 static struct net_device *fcoe_if_to_netdev(const char *buffer)
 591 {
 592         char *cp;
 593         char ifname[IFNAMSIZ + 2];
 594
 595         if (buffer) {
 596                 strlcpy(ifname, buffer, IFNAMSIZ);
 597                 cp = ifname + strlen(ifname);
 598                 while (--cp >= ifname && *cp == '\n')
 599                         *cp = '\0';
 600                 return dev_get_by_name(&init_net, ifname);
 601         }
 602         return NULL;
 603 }
 604
 605 /**
 606  * libfcoe_device_notification() - Handler for net device events
 607  * @notifier: The context of the notification
 608  * @event:    The type of event
 609  * @ptr:      The net device that the event was on
 610  *
 611  * This function is called by the Ethernet driver in case of link change event.
 612  *
 613  * Returns: 0 for success
 614  */
 615 static int libfcoe_device_notification(struct notifier_block *notifier,
 616                                     ulong event, void *ptr)
 617 {
 618         struct net_device *netdev = ptr;
 619
 620         switch (event) {
 621         case NETDEV_UNREGISTER:
 622                 LIBFCOE_TRANSPORT_DBG("NETDEV_UNREGISTER %s\n",
 623                                       netdev->name);
 624                 fcoe_del_netdev_mapping(netdev);
 625                 break;
 626         }
 627         return NOTIFY_OK;
 628 }
 629
 630
 631 /**
 632  * fcoe_transport_create() - Create a fcoe interface
 633  * @buffer: The name of the Ethernet interface to create on
 634  * @kp:     The associated kernel param
 635  *
 636  * Called from sysfs. This holds the ft_mutex while calling the
 637  * registered fcoe transport's create function.
 638  *
 639  * Returns: 0 for success
 640  */
 641 static int fcoe_transport_create(const char *buffer, struct kernel_param *kp)
 642 {
 643         int rc = -ENODEV;
 644         struct net_device *netdev = NULL;
 645         struct fcoe_transport *ft = NULL;
 646         enum fip_state fip_mode = (enum fip_state)(long)kp->arg;
 647
 648         mutex_lock(&ft_mutex);
 649
 650         netdev = fcoe_if_to_netdev(buffer);
 651         if (!netdev) {
 652                 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
 653                 goto out_nodev;
 654         }
 655
 656         ft = fcoe_netdev_map_lookup(netdev);
 657         if (ft) {
 658                 LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
 659                                       "FCoE instance on %s.\n",
 660                                       ft->name, netdev->name);
 661                 rc = -EEXIST;
 662                 goto out_putdev;
 663         }
 664
 665         ft = fcoe_transport_lookup(netdev);
 666         if (!ft) {
 667                 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 668                                       netdev->name);
 669                 goto out_putdev;
 670         }
 671
 672         rc = fcoe_add_netdev_mapping(netdev, ft);
 673         if (rc) {
 674                 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
 675                                       "for FCoE transport %s for %s.\n",
 676                                       ft->name, netdev->name);
 677                 goto out_putdev;
 678         }
 679
 680         /* pass to transport create */
 681         rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV;
 682         if (rc)
 683                 fcoe_del_netdev_mapping(netdev);
 684
 685         LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n",
 686                               ft->name, (rc) ? "failed" : "succeeded",
 687                               netdev->name);
 688
 689 out_putdev:
 690         dev_put(netdev);
 691 out_nodev:
 692         mutex_unlock(&ft_mutex);
 693         return rc;
 694 }
 695
 696 /**
 697  * fcoe_transport_destroy() - Destroy a FCoE interface
 698  * @buffer: The name of the Ethernet interface to be destroyed
 699  * @kp:     The associated kernel parameter
 700  *
 701  * Called from sysfs. This holds the ft_mutex while calling the
 702  * registered fcoe transport's destroy function.
 703  *
 704  * Returns: 0 for success
 705  */
 706 static int fcoe_transport_destroy(const char *buffer, struct kernel_param *kp)
 707 {
 708         int rc = -ENODEV;
 709         struct net_device *netdev = NULL;
 710         struct fcoe_transport *ft = NULL;
 711
 712         mutex_lock(&ft_mutex);
 713
 714         netdev = fcoe_if_to_netdev(buffer);
 715         if (!netdev) {
 716                 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
 717                 goto out_nodev;
 718         }
 719
 720         ft = fcoe_netdev_map_lookup(netdev);
 721         if (!ft) {
 722                 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
 723                                       netdev->name);
 724                 goto out_putdev;
 725         }
 726
 727         /* pass to transport destroy */
 728         rc = ft->destroy ? ft->destroy(netdev) : -ENODEV;
 729         fcoe_del_netdev_mapping(netdev);
 730         LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
 731                               ft->name, (rc) ? "failed" : "succeeded",
 732                               netdev->name);
 733
 734 out_putdev:
 735         dev_put(netdev);
 736 out_nodev:
 737         mutex_unlock(&ft_mutex);
 738         return rc;
 739 }
 740
 741 /**
 742  * fcoe_transport_disable() - Disables a FCoE interface
 743  * @buffer: The name of the Ethernet interface to be disabled
 744  * @kp:     The associated kernel parameter
 745  *
 746  * Called from sysfs.
 747  *
 748  * Returns: 0 for success
 749  */
 750 static int fcoe_transport_disable(const char *buffer, struct kernel_param *kp)
 751 {
 752         int rc = -ENODEV;
 753         struct net_device *netdev = NULL;
 754         struct fcoe_transport *ft = NULL;
 755
 756         mutex_lock(&ft_mutex);
 757
 758         netdev = fcoe_if_to_netdev(buffer);
 759         if (!netdev)
 760                 goto out_nodev;
 761
 762         ft = fcoe_netdev_map_lookup(netdev);
 763         if (!ft)
 764                 goto out_putdev;
 765
 766         rc = ft->disable ? ft->disable(netdev) : -ENODEV;
 767
 768 out_putdev:
 769         dev_put(netdev);
 770 out_nodev:
 771         mutex_unlock(&ft_mutex);
 772
 773         if (rc == -ERESTARTSYS)
 774                 return restart_syscall();
 775         else
 776                 return rc;
 777 }
 778
 779 /**
 780  * fcoe_transport_enable() - Enables a FCoE interface
 781  * @buffer: The name of the Ethernet interface to be enabled
 782  * @kp:     The associated kernel parameter
 783  *
 784  * Called from sysfs.
 785  *
 786  * Returns: 0 for success
 787  */
 788 static int fcoe_transport_enable(const char *buffer, struct kernel_param *kp)
 789 {
 790         int rc = -ENODEV;
 791         struct net_device *netdev = NULL;
 792         struct fcoe_transport *ft = NULL;
 793
 794         mutex_lock(&ft_mutex);
 795
 796         netdev = fcoe_if_to_netdev(buffer);
 797         if (!netdev)
 798                 goto out_nodev;
 799
 800         ft = fcoe_netdev_map_lookup(netdev);
 801         if (!ft)
 802                 goto out_putdev;
 803
 804         rc = ft->enable ? ft->enable(netdev) : -ENODEV;
 805
 806 out_putdev:
 807         dev_put(netdev);
 808 out_nodev:
 809         mutex_unlock(&ft_mutex);
 810         return rc;
 811 }
 812
 813 /**
 814  * libfcoe_init() - Initialization routine for libfcoe.ko
 815  */
 816 static int __init libfcoe_init(void)
 817 {
 818         int rc = 0;
 819
 820         rc = fcoe_transport_init();
 821         if (rc)
 822                 return rc;
 823
 824         rc = fcoe_sysfs_setup();
 825         if (rc)
 826                 fcoe_transport_exit();
 827
 828         return rc;
 829 }
 830 module_init(libfcoe_init);
 831
 832 /**
 833  * libfcoe_exit() - Tear down libfcoe.ko
 834  */
 835 static void __exit libfcoe_exit(void)
 836 {
 837         fcoe_sysfs_teardown();
 838         fcoe_transport_exit();
 839 }
 840 module_exit(libfcoe_exit);