7264d0d5d737e8aa353d04081c1e0023c508980c
[linux-2.6.git] / 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 = frag->size;
210                 while (len > 0) {
211                         clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
212                         data = kmap_atomic(frag->page + (off >> PAGE_SHIFT),
213                                            KM_SKB_DATA_SOFTIRQ);
214                         crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
215                         kunmap_atomic(data, KM_SKB_DATA_SOFTIRQ);
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                 printk(KERN_ERR "libfcoe_device_notification: 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         fcoe_transport_init();
819
820         return 0;
821 }
822 module_init(libfcoe_init);
823
824 /**
825  * libfcoe_exit() - Tear down libfcoe.ko
826  */
827 static void __exit libfcoe_exit(void)
828 {
829         fcoe_transport_exit();
830 }
831 module_exit(libfcoe_exit);