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