1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
5 * Maintained at www.Open-FCoE.org
8 #include <linux/types.h>
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/list.h>
12 #include <linux/netdevice.h>
13 #include <linux/ethtool.h>
14 #include <linux/errno.h>
15 #include <linux/crc32.h>
16 #include <scsi/libfcoe.h>
20 MODULE_AUTHOR("Open-FCoE.org");
21 MODULE_DESCRIPTION("FIP discovery protocol and FCoE transport for FCoE HBAs");
22 MODULE_LICENSE("GPL v2");
24 static int fcoe_transport_create(const char *, const struct kernel_param *);
25 static int fcoe_transport_destroy(const char *, const struct kernel_param *);
26 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp);
27 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *device);
28 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *device);
29 static int fcoe_transport_enable(const char *, const struct kernel_param *);
30 static int fcoe_transport_disable(const char *, const struct kernel_param *);
31 static int libfcoe_device_notification(struct notifier_block *notifier,
32 ulong event, void *ptr);
34 static LIST_HEAD(fcoe_transports);
35 static DEFINE_MUTEX(ft_mutex);
36 static LIST_HEAD(fcoe_netdevs);
37 static DEFINE_MUTEX(fn_mutex);
39 unsigned int libfcoe_debug_logging;
40 module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO|S_IWUSR);
41 MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
43 module_param_call(show, NULL, fcoe_transport_show, NULL, S_IRUSR);
44 __MODULE_PARM_TYPE(show, "string");
45 MODULE_PARM_DESC(show, " Show attached FCoE transports");
47 module_param_call(create, fcoe_transport_create, NULL,
48 (void *)FIP_MODE_FABRIC, S_IWUSR);
49 __MODULE_PARM_TYPE(create, "string");
50 MODULE_PARM_DESC(create, " Creates fcoe instance on an ethernet interface");
52 module_param_call(create_vn2vn, fcoe_transport_create, NULL,
53 (void *)FIP_MODE_VN2VN, S_IWUSR);
54 __MODULE_PARM_TYPE(create_vn2vn, "string");
55 MODULE_PARM_DESC(create_vn2vn, " Creates a VN_node to VN_node FCoE instance "
56 "on an Ethernet interface");
58 module_param_call(destroy, fcoe_transport_destroy, NULL, NULL, S_IWUSR);
59 __MODULE_PARM_TYPE(destroy, "string");
60 MODULE_PARM_DESC(destroy, " Destroys fcoe instance on an ethernet interface");
62 module_param_call(enable, fcoe_transport_enable, NULL, NULL, S_IWUSR);
63 __MODULE_PARM_TYPE(enable, "string");
64 MODULE_PARM_DESC(enable, " Enables fcoe on an ethernet interface.");
66 module_param_call(disable, fcoe_transport_disable, NULL, NULL, S_IWUSR);
67 __MODULE_PARM_TYPE(disable, "string");
68 MODULE_PARM_DESC(disable, " Disables fcoe on an ethernet interface.");
70 /* notification function for packets from net device */
71 static struct notifier_block libfcoe_notifier = {
72 .notifier_call = libfcoe_device_notification,
77 #define SPEED_2000 2000
78 #define SPEED_4000 4000
79 #define SPEED_8000 8000
80 #define SPEED_16000 16000
81 #define SPEED_32000 32000
83 } fcoe_port_speed_mapping[] = {
84 { FC_PORTSPEED_1GBIT, SPEED_1000 },
85 { FC_PORTSPEED_2GBIT, SPEED_2000 },
86 { FC_PORTSPEED_4GBIT, SPEED_4000 },
87 { FC_PORTSPEED_8GBIT, SPEED_8000 },
88 { FC_PORTSPEED_10GBIT, SPEED_10000 },
89 { FC_PORTSPEED_16GBIT, SPEED_16000 },
90 { FC_PORTSPEED_20GBIT, SPEED_20000 },
91 { FC_PORTSPEED_25GBIT, SPEED_25000 },
92 { FC_PORTSPEED_32GBIT, SPEED_32000 },
93 { FC_PORTSPEED_40GBIT, SPEED_40000 },
94 { FC_PORTSPEED_50GBIT, SPEED_50000 },
95 { FC_PORTSPEED_100GBIT, SPEED_100000 },
98 static inline u32 eth2fc_speed(u32 eth_port_speed)
102 for (i = 0; i < ARRAY_SIZE(fcoe_port_speed_mapping); i++) {
103 if (fcoe_port_speed_mapping[i].eth_port_speed == eth_port_speed)
104 return fcoe_port_speed_mapping[i].fc_port_speed;
107 return FC_PORTSPEED_UNKNOWN;
111 * fcoe_link_speed_update() - Update the supported and actual link speeds
112 * @lport: The local port to update speeds for
114 * Returns: 0 if the ethtool query was successful
115 * -1 if the ethtool query failed
117 int fcoe_link_speed_update(struct fc_lport *lport)
119 struct net_device *netdev = fcoe_get_netdev(lport);
120 struct ethtool_link_ksettings ecmd;
122 if (!__ethtool_get_link_ksettings(netdev, &ecmd)) {
123 lport->link_supported_speeds &= ~(FC_PORTSPEED_1GBIT |
124 FC_PORTSPEED_10GBIT |
125 FC_PORTSPEED_20GBIT |
126 FC_PORTSPEED_40GBIT);
128 if (ecmd.link_modes.supported[0] & (
129 SUPPORTED_1000baseT_Half |
130 SUPPORTED_1000baseT_Full |
131 SUPPORTED_1000baseKX_Full))
132 lport->link_supported_speeds |= FC_PORTSPEED_1GBIT;
134 if (ecmd.link_modes.supported[0] & (
135 SUPPORTED_10000baseT_Full |
136 SUPPORTED_10000baseKX4_Full |
137 SUPPORTED_10000baseKR_Full |
138 SUPPORTED_10000baseR_FEC))
139 lport->link_supported_speeds |= FC_PORTSPEED_10GBIT;
141 if (ecmd.link_modes.supported[0] & (
142 SUPPORTED_20000baseMLD2_Full |
143 SUPPORTED_20000baseKR2_Full))
144 lport->link_supported_speeds |= FC_PORTSPEED_20GBIT;
146 if (ecmd.link_modes.supported[0] & (
147 SUPPORTED_40000baseKR4_Full |
148 SUPPORTED_40000baseCR4_Full |
149 SUPPORTED_40000baseSR4_Full |
150 SUPPORTED_40000baseLR4_Full))
151 lport->link_supported_speeds |= FC_PORTSPEED_40GBIT;
153 lport->link_speed = eth2fc_speed(ecmd.base.speed);
158 EXPORT_SYMBOL_GPL(fcoe_link_speed_update);
161 * __fcoe_get_lesb() - Get the Link Error Status Block (LESB) for a given lport
162 * @lport: The local port to update speeds for
163 * @fc_lesb: Pointer to the LESB to be filled up
164 * @netdev: Pointer to the netdev that is associated with the lport
166 * Note, the Link Error Status Block (LESB) for FCoE is defined in FC-BB-6
167 * Clause 7.11 in v1.04.
169 void __fcoe_get_lesb(struct fc_lport *lport,
170 struct fc_els_lesb *fc_lesb,
171 struct net_device *netdev)
175 struct fc_stats *stats;
176 struct fcoe_fc_els_lesb *lesb;
177 struct rtnl_link_stats64 temp;
182 lesb = (struct fcoe_fc_els_lesb *)fc_lesb;
183 memset(lesb, 0, sizeof(*lesb));
184 for_each_possible_cpu(cpu) {
185 stats = per_cpu_ptr(lport->stats, cpu);
186 lfc += READ_ONCE(stats->LinkFailureCount);
187 vlfc += READ_ONCE(stats->VLinkFailureCount);
188 mdac += READ_ONCE(stats->MissDiscAdvCount);
190 lesb->lesb_link_fail = htonl(lfc);
191 lesb->lesb_vlink_fail = htonl(vlfc);
192 lesb->lesb_miss_fka = htonl(mdac);
193 lesb->lesb_fcs_error =
194 htonl(dev_get_stats(netdev, &temp)->rx_crc_errors);
196 EXPORT_SYMBOL_GPL(__fcoe_get_lesb);
199 * fcoe_get_lesb() - Fill the FCoE Link Error Status Block
200 * @lport: the local port
201 * @fc_lesb: the link error status block
203 void fcoe_get_lesb(struct fc_lport *lport,
204 struct fc_els_lesb *fc_lesb)
206 struct net_device *netdev = fcoe_get_netdev(lport);
208 __fcoe_get_lesb(lport, fc_lesb, netdev);
210 EXPORT_SYMBOL_GPL(fcoe_get_lesb);
213 * fcoe_ctlr_get_lesb() - Get the Link Error Status Block (LESB) for a given
214 * fcoe controller device
215 * @ctlr_dev: The given fcoe controller device
218 void fcoe_ctlr_get_lesb(struct fcoe_ctlr_device *ctlr_dev)
220 struct fcoe_ctlr *fip = fcoe_ctlr_device_priv(ctlr_dev);
221 struct net_device *netdev = fcoe_get_netdev(fip->lp);
222 struct fc_els_lesb *fc_lesb;
224 fc_lesb = (struct fc_els_lesb *)(&ctlr_dev->lesb);
225 __fcoe_get_lesb(fip->lp, fc_lesb, netdev);
227 EXPORT_SYMBOL_GPL(fcoe_ctlr_get_lesb);
229 void fcoe_wwn_to_str(u64 wwn, char *buf, int len)
233 u64_to_wwn(wwn, wwpn);
234 snprintf(buf, len, "%02x%02x%02x%02x%02x%02x%02x%02x",
235 wwpn[0], wwpn[1], wwpn[2], wwpn[3],
236 wwpn[4], wwpn[5], wwpn[6], wwpn[7]);
238 EXPORT_SYMBOL_GPL(fcoe_wwn_to_str);
241 * fcoe_validate_vport_create() - Validate a vport before creating it
242 * @vport: NPIV port to be created
244 * This routine is meant to add validation for a vport before creating it
245 * via fcoe_vport_create().
246 * Current validations are:
247 * - WWPN supplied is unique for given lport
249 int fcoe_validate_vport_create(struct fc_vport *vport)
251 struct Scsi_Host *shost = vport_to_shost(vport);
252 struct fc_lport *n_port = shost_priv(shost);
253 struct fc_lport *vn_port;
257 mutex_lock(&n_port->lp_mutex);
259 fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
260 /* Check if the wwpn is not same as that of the lport */
261 if (!memcmp(&n_port->wwpn, &vport->port_name, sizeof(u64))) {
262 LIBFCOE_TRANSPORT_DBG("vport WWPN 0x%s is same as that of the "
263 "base port WWPN\n", buf);
268 /* Check if there is any existing vport with same wwpn */
269 list_for_each_entry(vn_port, &n_port->vports, list) {
270 if (!memcmp(&vn_port->wwpn, &vport->port_name, sizeof(u64))) {
271 LIBFCOE_TRANSPORT_DBG("vport with given WWPN 0x%s "
272 "already exists\n", buf);
278 mutex_unlock(&n_port->lp_mutex);
281 EXPORT_SYMBOL_GPL(fcoe_validate_vport_create);
284 * fcoe_get_wwn() - Get the world wide name from LLD if it supports it
285 * @netdev: the associated net device
286 * @wwn: the output WWN
287 * @type: the type of WWN (WWPN or WWNN)
289 * Returns: 0 for success
291 int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
293 const struct net_device_ops *ops = netdev->netdev_ops;
295 if (ops->ndo_fcoe_get_wwn)
296 return ops->ndo_fcoe_get_wwn(netdev, wwn, type);
299 EXPORT_SYMBOL_GPL(fcoe_get_wwn);
302 * fcoe_fc_crc() - Calculates the CRC for a given frame
303 * @fp: The frame to be checksumed
305 * This uses crc32() routine to calculate the CRC for a frame
307 * Return: The 32 bit CRC value
309 u32 fcoe_fc_crc(struct fc_frame *fp)
311 struct sk_buff *skb = fp_skb(fp);
314 unsigned long off, len, clen;
318 crc = crc32(~0, skb->data, skb_headlen(skb));
320 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
321 frag = &skb_shinfo(skb)->frags[i];
322 off = skb_frag_off(frag);
323 len = skb_frag_size(frag);
325 clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
327 skb_frag_page(frag) + (off >> PAGE_SHIFT));
328 crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
336 EXPORT_SYMBOL_GPL(fcoe_fc_crc);
339 * fcoe_start_io() - Start FCoE I/O
340 * @skb: The packet to be transmitted
342 * This routine is called from the net device to start transmitting
345 * Returns: 0 for success
347 int fcoe_start_io(struct sk_buff *skb)
349 struct sk_buff *nskb;
352 nskb = skb_clone(skb, GFP_ATOMIC);
355 rc = dev_queue_xmit(nskb);
361 EXPORT_SYMBOL_GPL(fcoe_start_io);
365 * fcoe_clean_pending_queue() - Dequeue a skb and free it
366 * @lport: The local port to dequeue a skb on
368 void fcoe_clean_pending_queue(struct fc_lport *lport)
370 struct fcoe_port *port = lport_priv(lport);
373 spin_lock_bh(&port->fcoe_pending_queue.lock);
374 while ((skb = __skb_dequeue(&port->fcoe_pending_queue)) != NULL) {
375 spin_unlock_bh(&port->fcoe_pending_queue.lock);
377 spin_lock_bh(&port->fcoe_pending_queue.lock);
379 spin_unlock_bh(&port->fcoe_pending_queue.lock);
381 EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue);
384 * fcoe_check_wait_queue() - Attempt to clear the transmit backlog
385 * @lport: The local port whose backlog is to be cleared
386 * @skb: The received FIP packet
388 * This empties the wait_queue, dequeues the head of the wait_queue queue
389 * and calls fcoe_start_io() for each packet. If all skb have been
390 * transmitted it returns the qlen. If an error occurs it restores
391 * wait_queue (to try again later) and returns -1.
393 * The wait_queue is used when the skb transmit fails. The failed skb
394 * will go in the wait_queue which will be emptied by the timer function or
395 * by the next skb transmit.
397 void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb)
399 struct fcoe_port *port = lport_priv(lport);
402 spin_lock_bh(&port->fcoe_pending_queue.lock);
405 __skb_queue_tail(&port->fcoe_pending_queue, skb);
407 if (port->fcoe_pending_queue_active)
409 port->fcoe_pending_queue_active = 1;
411 while (port->fcoe_pending_queue.qlen) {
412 /* keep qlen > 0 until fcoe_start_io succeeds */
413 port->fcoe_pending_queue.qlen++;
414 skb = __skb_dequeue(&port->fcoe_pending_queue);
416 spin_unlock_bh(&port->fcoe_pending_queue.lock);
417 rc = fcoe_start_io(skb);
418 spin_lock_bh(&port->fcoe_pending_queue.lock);
421 __skb_queue_head(&port->fcoe_pending_queue, skb);
422 /* undo temporary increment above */
423 port->fcoe_pending_queue.qlen--;
426 /* undo temporary increment above */
427 port->fcoe_pending_queue.qlen--;
430 if (port->fcoe_pending_queue.qlen < port->min_queue_depth)
432 if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer))
433 mod_timer(&port->timer, jiffies + 2);
434 port->fcoe_pending_queue_active = 0;
436 if (port->fcoe_pending_queue.qlen > port->max_queue_depth)
438 spin_unlock_bh(&port->fcoe_pending_queue.lock);
440 EXPORT_SYMBOL_GPL(fcoe_check_wait_queue);
443 * fcoe_queue_timer() - The fcoe queue timer
444 * @t: Timer context use to obtain the FCoE port
446 * Calls fcoe_check_wait_queue on timeout
448 void fcoe_queue_timer(struct timer_list *t)
450 struct fcoe_port *port = from_timer(port, t, timer);
452 fcoe_check_wait_queue(port->lport, NULL);
454 EXPORT_SYMBOL_GPL(fcoe_queue_timer);
457 * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC
458 * @skb: The packet to be transmitted
459 * @tlen: The total length of the trailer
460 * @fps: The fcoe context
462 * This routine allocates a page for frame trailers. The page is re-used if
463 * there is enough room left on it for the current trailer. If there isn't
464 * enough buffer left a new page is allocated for the trailer. Reference to
465 * the page from this function as well as the skbs using the page fragments
466 * ensure that the page is freed at the appropriate time.
468 * Returns: 0 for success
470 int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen,
471 struct fcoe_percpu_s *fps)
475 page = fps->crc_eof_page;
477 page = alloc_page(GFP_ATOMIC);
481 fps->crc_eof_page = page;
482 fps->crc_eof_offset = 0;
486 skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page,
487 fps->crc_eof_offset, tlen);
489 skb->data_len += tlen;
490 skb->truesize += tlen;
491 fps->crc_eof_offset += sizeof(struct fcoe_crc_eof);
493 if (fps->crc_eof_offset >= PAGE_SIZE) {
494 fps->crc_eof_page = NULL;
495 fps->crc_eof_offset = 0;
501 EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof);
504 * fcoe_transport_lookup - find an fcoe transport that matches a netdev
505 * @netdev: The netdev to look for from all attached transports
507 * Returns : ptr to the fcoe transport that supports this netdev or NULL
510 * The ft_mutex should be held when this is called
512 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *netdev)
514 struct fcoe_transport *ft = NULL;
516 list_for_each_entry(ft, &fcoe_transports, list)
517 if (ft->match && ft->match(netdev))
523 * fcoe_transport_attach - Attaches an FCoE transport
524 * @ft: The fcoe transport to be attached
526 * Returns : 0 for success
528 int fcoe_transport_attach(struct fcoe_transport *ft)
532 mutex_lock(&ft_mutex);
534 LIBFCOE_TRANSPORT_DBG("transport %s already attached\n",
540 /* Add default transport to the tail */
541 if (strcmp(ft->name, FCOE_TRANSPORT_DEFAULT))
542 list_add(&ft->list, &fcoe_transports);
544 list_add_tail(&ft->list, &fcoe_transports);
547 LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name);
550 mutex_unlock(&ft_mutex);
553 EXPORT_SYMBOL(fcoe_transport_attach);
556 * fcoe_transport_detach - Detaches an FCoE transport
557 * @ft: The fcoe transport to be attached
559 * Returns : 0 for success
561 int fcoe_transport_detach(struct fcoe_transport *ft)
564 struct fcoe_netdev_mapping *nm = NULL, *tmp;
566 mutex_lock(&ft_mutex);
568 LIBFCOE_TRANSPORT_DBG("transport %s already detached\n",
574 /* remove netdev mapping for this transport as it is going away */
575 mutex_lock(&fn_mutex);
576 list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
578 LIBFCOE_TRANSPORT_DBG("transport %s going away, "
579 "remove its netdev mapping for %s\n",
580 ft->name, nm->netdev->name);
585 mutex_unlock(&fn_mutex);
588 ft->attached = false;
589 LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name);
592 mutex_unlock(&ft_mutex);
596 EXPORT_SYMBOL(fcoe_transport_detach);
598 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp)
601 struct fcoe_transport *ft = NULL;
603 i = j = sprintf(buffer, "Attached FCoE transports:");
604 mutex_lock(&ft_mutex);
605 list_for_each_entry(ft, &fcoe_transports, list) {
606 if (i >= PAGE_SIZE - IFNAMSIZ)
608 i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
610 mutex_unlock(&ft_mutex);
612 i += snprintf(&buffer[i], IFNAMSIZ, "none");
616 static int __init fcoe_transport_init(void)
618 register_netdevice_notifier(&libfcoe_notifier);
622 static int fcoe_transport_exit(void)
624 struct fcoe_transport *ft;
626 unregister_netdevice_notifier(&libfcoe_notifier);
627 mutex_lock(&ft_mutex);
628 list_for_each_entry(ft, &fcoe_transports, list)
629 printk(KERN_ERR "FCoE transport %s is still attached!\n",
631 mutex_unlock(&ft_mutex);
636 static int fcoe_add_netdev_mapping(struct net_device *netdev,
637 struct fcoe_transport *ft)
639 struct fcoe_netdev_mapping *nm;
641 nm = kmalloc(sizeof(*nm), GFP_KERNEL);
643 printk(KERN_ERR "Unable to allocate netdev_mapping");
650 mutex_lock(&fn_mutex);
651 list_add(&nm->list, &fcoe_netdevs);
652 mutex_unlock(&fn_mutex);
657 static void fcoe_del_netdev_mapping(struct net_device *netdev)
659 struct fcoe_netdev_mapping *nm = NULL, *tmp;
661 mutex_lock(&fn_mutex);
662 list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
663 if (nm->netdev == netdev) {
666 mutex_unlock(&fn_mutex);
670 mutex_unlock(&fn_mutex);
675 * fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which
677 * @netdev: The net device that the FCoE interface is on
679 * Returns : ptr to the fcoe transport that supports this netdev or NULL
682 * The ft_mutex should be held when this is called
684 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *netdev)
686 struct fcoe_transport *ft = NULL;
687 struct fcoe_netdev_mapping *nm;
689 mutex_lock(&fn_mutex);
690 list_for_each_entry(nm, &fcoe_netdevs, list) {
691 if (netdev == nm->netdev) {
693 mutex_unlock(&fn_mutex);
698 mutex_unlock(&fn_mutex);
703 * fcoe_if_to_netdev() - Parse a name buffer to get a net device
704 * @buffer: The name of the net device
706 * Returns: NULL or a ptr to net_device
708 static struct net_device *fcoe_if_to_netdev(const char *buffer)
711 char ifname[IFNAMSIZ + 2];
714 strscpy(ifname, buffer, IFNAMSIZ);
715 cp = ifname + strlen(ifname);
716 while (--cp >= ifname && *cp == '\n')
718 return dev_get_by_name(&init_net, ifname);
724 * libfcoe_device_notification() - Handler for net device events
725 * @notifier: The context of the notification
726 * @event: The type of event
727 * @ptr: The net device that the event was on
729 * This function is called by the Ethernet driver in case of link change event.
731 * Returns: 0 for success
733 static int libfcoe_device_notification(struct notifier_block *notifier,
734 ulong event, void *ptr)
736 struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
739 case NETDEV_UNREGISTER:
740 LIBFCOE_TRANSPORT_DBG("NETDEV_UNREGISTER %s\n",
742 fcoe_del_netdev_mapping(netdev);
748 ssize_t fcoe_ctlr_create_store(const char *buf, size_t count)
750 struct net_device *netdev = NULL;
751 struct fcoe_transport *ft = NULL;
755 mutex_lock(&ft_mutex);
757 netdev = fcoe_if_to_netdev(buf);
759 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buf);
764 ft = fcoe_netdev_map_lookup(netdev);
766 LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
767 "FCoE instance on %s.\n",
768 ft->name, netdev->name);
773 ft = fcoe_transport_lookup(netdev);
775 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
781 /* pass to transport create */
782 err = ft->alloc ? ft->alloc(netdev) : -ENODEV;
784 fcoe_del_netdev_mapping(netdev);
789 err = fcoe_add_netdev_mapping(netdev, ft);
791 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
792 "for FCoE transport %s for %s.\n",
793 ft->name, netdev->name);
798 LIBFCOE_TRANSPORT_DBG("transport %s succeeded to create fcoe on %s.\n",
799 ft->name, netdev->name);
804 mutex_unlock(&ft_mutex);
810 ssize_t fcoe_ctlr_destroy_store(const char *buf, size_t count)
813 struct net_device *netdev = NULL;
814 struct fcoe_transport *ft = NULL;
816 mutex_lock(&ft_mutex);
818 netdev = fcoe_if_to_netdev(buf);
820 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buf);
824 ft = fcoe_netdev_map_lookup(netdev);
826 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
831 /* pass to transport destroy */
832 rc = ft->destroy(netdev);
836 fcoe_del_netdev_mapping(netdev);
837 LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
838 ft->name, (rc) ? "failed" : "succeeded",
840 rc = count; /* required for successful return */
844 mutex_unlock(&ft_mutex);
849 * fcoe_transport_create() - Create a fcoe interface
850 * @buffer: The name of the Ethernet interface to create on
851 * @kp: The associated kernel param
853 * Called from sysfs. This holds the ft_mutex while calling the
854 * registered fcoe transport's create function.
856 * Returns: 0 for success
858 static int fcoe_transport_create(const char *buffer,
859 const struct kernel_param *kp)
862 struct net_device *netdev = NULL;
863 struct fcoe_transport *ft = NULL;
864 enum fip_mode fip_mode = (enum fip_mode)(uintptr_t)kp->arg;
866 mutex_lock(&ft_mutex);
868 netdev = fcoe_if_to_netdev(buffer);
870 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
874 ft = fcoe_netdev_map_lookup(netdev);
876 LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
877 "FCoE instance on %s.\n",
878 ft->name, netdev->name);
883 ft = fcoe_transport_lookup(netdev);
885 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
890 rc = fcoe_add_netdev_mapping(netdev, ft);
892 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
893 "for FCoE transport %s for %s.\n",
894 ft->name, netdev->name);
898 /* pass to transport create */
899 rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV;
901 fcoe_del_netdev_mapping(netdev);
903 LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n",
904 ft->name, (rc) ? "failed" : "succeeded",
910 mutex_unlock(&ft_mutex);
915 * fcoe_transport_destroy() - Destroy a FCoE interface
916 * @buffer: The name of the Ethernet interface to be destroyed
917 * @kp: The associated kernel parameter
919 * Called from sysfs. This holds the ft_mutex while calling the
920 * registered fcoe transport's destroy function.
922 * Returns: 0 for success
924 static int fcoe_transport_destroy(const char *buffer,
925 const struct kernel_param *kp)
928 struct net_device *netdev = NULL;
929 struct fcoe_transport *ft = NULL;
931 mutex_lock(&ft_mutex);
933 netdev = fcoe_if_to_netdev(buffer);
935 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
939 ft = fcoe_netdev_map_lookup(netdev);
941 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
946 /* pass to transport destroy */
947 rc = ft->destroy ? ft->destroy(netdev) : -ENODEV;
948 fcoe_del_netdev_mapping(netdev);
949 LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
950 ft->name, (rc) ? "failed" : "succeeded",
956 mutex_unlock(&ft_mutex);
961 * fcoe_transport_disable() - Disables a FCoE interface
962 * @buffer: The name of the Ethernet interface to be disabled
963 * @kp: The associated kernel parameter
967 * Returns: 0 for success
969 static int fcoe_transport_disable(const char *buffer,
970 const struct kernel_param *kp)
973 struct net_device *netdev = NULL;
974 struct fcoe_transport *ft = NULL;
976 mutex_lock(&ft_mutex);
978 netdev = fcoe_if_to_netdev(buffer);
982 ft = fcoe_netdev_map_lookup(netdev);
986 rc = ft->disable ? ft->disable(netdev) : -ENODEV;
991 mutex_unlock(&ft_mutex);
996 * fcoe_transport_enable() - Enables a FCoE interface
997 * @buffer: The name of the Ethernet interface to be enabled
998 * @kp: The associated kernel parameter
1000 * Called from sysfs.
1002 * Returns: 0 for success
1004 static int fcoe_transport_enable(const char *buffer,
1005 const struct kernel_param *kp)
1008 struct net_device *netdev = NULL;
1009 struct fcoe_transport *ft = NULL;
1011 mutex_lock(&ft_mutex);
1013 netdev = fcoe_if_to_netdev(buffer);
1017 ft = fcoe_netdev_map_lookup(netdev);
1021 rc = ft->enable ? ft->enable(netdev) : -ENODEV;
1026 mutex_unlock(&ft_mutex);
1031 * libfcoe_init() - Initialization routine for libfcoe.ko
1033 static int __init libfcoe_init(void)
1037 rc = fcoe_transport_init();
1041 rc = fcoe_sysfs_setup();
1043 fcoe_transport_exit();
1047 module_init(libfcoe_init);
1050 * libfcoe_exit() - Tear down libfcoe.ko
1052 static void __exit libfcoe_exit(void)
1054 fcoe_sysfs_teardown();
1055 fcoe_transport_exit();
1057 module_exit(libfcoe_exit);